fis_lib_measure/lib/view/measure/measure_main_view.dart

import 'dart:ui';

import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/interfaces/date_types/int_size.dart';
import 'package:fis_measure/interfaces/enums/operate.dart';
import 'package:fis_measure/interfaces/process/player/play_controller.dart';
import 'package:fis_measure/interfaces/process/standard_line/calibration.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/interfaces/process/workspace/measure_3d_view_controller.dart';
import 'package:fis_measure/process/workspace/measure_3d_view_controller.dart';
import 'package:fis_measure/process/workspace/measure_data_controller.dart';
import 'package:fis_measure/process/workspace/measure_handler.dart';
import 'package:fis_measure/process/workspace/third_part/application.dart';
import 'package:fis_measure/process/workspace/third_part/calibration_controller.dart';
import 'package:fis_measure/utils/canvas.dart';
import 'package:fis_measure/values/colors.dart';
import 'package:fis_measure/view/button_group/button_group.dart';
import 'package:fis_measure/view/3d_view/carotid_player.dart';
import 'package:fis_measure/view/gesture/annotation/annotation_gesture.dart';
import 'package:fis_measure/view/measure/capture_image.dart';
import 'package:fis_measure/view/paint/ai_patint.dart';
import 'package:fis_measure/view/paint/ai_patint_result.dart';
import 'package:fis_measure/view/result/results_panel.dart';
import 'package:fis_measure/view/standard_line/calibration_canvas.dart';
import 'package:fis_measure/view/standard_line/calibration_gesture.dart';
import 'package:fis_ui/index.dart';
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:get/get.dart';

import 'package:fis_measure/view/canvas/active_canvas.dart';
import 'package:fis_measure/view/canvas/annotation_canvas.dart';
import 'package:fis_measure/view/canvas/records_canvas.dart';
import 'package:fis_measure/view/gesture/mouse_gesture.dart';
import 'package:fis_measure/view/pause/pause_panel.dart';
import 'package:fis_measure/view/player/controller.dart';
import 'package:fis_measure/view/player/player.dart';

class MeasureMainView extends StatefulWidget implements FWidget {
  const MeasureMainView({Key? key}) : super(key: key);

  @override
  State<StatefulWidget> createState() => _MeasureMainViewState();
}

class _MeasureMainViewState extends State<MeasureMainView> {
  late final application = Get.find<IApplication>();

  late final playerController = Get.find<IPlayerController>();
  late final measure3DViewController = Get.find<Measure3DViewController>();
  late final measureHandler = Get.find<MeasureHandler>();

  /// 测量数据
  final measureData = Get.find<MeasureDataController>();

  late bool canMeasure = application.canMeasure;

  late bool enableCarotid2DMeasure = false;
  bool isCaptureState = false;
  late double calibrationLine = 4;

  /// 是否显示进度条
  bool ifShowProgressBar = true;

  /// 参考校准线控制器
  IStandardLineCalibrationController? standardLineCalibrationController;

  final playerKey = GlobalKey();
  final _key = GlobalKey();

  bool get inAnnotation =>
      application.currentOperateType == MeasureOperateType.annotation;

  @override
  void initState() {
    super.initState();
    installStandardLine();

    VidPlayerController vidPlayerController =
        playerController as VidPlayerController;
    WidgetsBinding.instance!.addPostFrameCallback((timeStamp) {
      onCanMeasureChanged(this, application.canMeasure);
      application.canMeasureChanged.addListener(onCanMeasureChanged);
      application.operateTypeChanged.addListener(onOperateTypeChanged);
      measure3DViewController.updatePlayerMode.addListener(_onModeChanged);

      /// [Carotid] ✅在此判断是否为颈动脉2D图像，如果是，则不显示进度条且读取设置播放器单帧缓存
      if (measure3DViewController.curMeasureMode == MeasureMode.carotid2DMode) {
        vidPlayerController.pause();
        vidPlayerController
            .set2DMeasureFrame(measure3DViewController.image4Measure!);
        setState(() {
          enableCarotid2DMeasure = true;
          ifShowProgressBar = false;
        });
        application.clearRecords();
      }
    });
  }

  @override
  void dispose() {
    application.canMeasureChanged.removeListener(onCanMeasureChanged);
    application.operateTypeChanged.removeListener(onOperateTypeChanged);
    measure3DViewController.updatePlayerMode.removeListener(_onModeChanged);
    uninstallStandardLine();
    super.dispose();
  }

  /// 装载参考校准线
  void installStandardLine() {
    if (application.isThirdPart) {
      final standradLine = (application as ThirdPartApplication).standardLine;
      standardLineCalibrationController =
          StandardLineCalibrationController(application, standradLine);
      standardLineCalibrationController!.editStateChanged
          .addListener(onStandardLineCalibrationStateChanged);
      Get.put<IStandardLineCalibrationController>(
          standardLineCalibrationController!);
    }
  }

  /// 卸载参考校准线
  void uninstallStandardLine() {
    standardLineCalibrationController?.editStateChanged
        .removeListener(onStandardLineCalibrationStateChanged);
    Get.delete<IStandardLineCalibrationController>();
  }

  /// 模式改变触发更新
  /// [Carotid] 🚧预留消息通知，虽然目前不会触发到，但是为了以后组件不销毁的情况下，切换模式的时候，可以触发
  void _onModeChanged(Object s, MeasureMode mode) {
    print("measure main view 测量模式更新: ${mode.toString()}");
    switch (mode) {
      case MeasureMode.vidMode:
        setState(() {
          ifShowProgressBar = true;
          enableCarotid2DMeasure = false;
        });
        break;
      case MeasureMode.carotid2DMode:
        setState(() {
          ifShowProgressBar = false;
          enableCarotid2DMeasure = true;
        });
        application.clearRecords();
        break;
      case MeasureMode.carotid3DMode:
        break;
    }
  }

  /// 保存图片
  void capturePng() async {
    isCaptureState = true;
    setState(() {});
    await Future.delayed(const Duration(milliseconds: 10), () async {
      final RenderRepaintBoundary? boundary =
          _key.currentContext?.findRenderObject() as RenderRepaintBoundary?;

      if (boundary != null) {
        final image = await boundary.toImage();
        final byteData = await image.toByteData(format: ImageByteFormat.png);
        final pngBytes = byteData!.buffer.asUint8List();
        Get.dialog(
          CaptureImage(
            bytes: pngBytes,
          ),
          transitionCurve: Curves.bounceInOut,
        );
        await measureData.saveImage.call(
          pngBytes,
          measureData.measureImageData.patientCode ?? '',
          measureData.measureImageData.recordCode ?? '',
          measureData.measureImageData.remedicalCode ?? '',
        );
        isCaptureState = false;
        Future.delayed(
          const Duration(
            milliseconds: 600,
          ),
          () {
            Get.back();
          },
        );
        setState(() {});
      }
    });
  }

  void onCanMeasureChanged(Object sender, bool e) {
    if (e != canMeasure) {
      setState(() {
        canMeasure = e;
      });
    }
  }

  void onOperateTypeChanged(Object sender, MeasureOperateType e) {
    setState(() {});
  }

  void onStandardLineCalibrationStateChanged(
      Object sender, StandardLineCalibrationEditState e) {
    setState(() {
      if (e == StandardLineCalibrationEditState.drawn) {
        Get.dialog(buildCalibrationLine());
      }
    });
  }

  /// TODO 翻译
  FWidget buildCalibrationLine() {
    return FSimpleDialog(
      title: const FText(
        '参考线校准',
        style: TextStyle(
          color: Colors.white,
          fontSize: 18,
        ),
      ),
      isDefault: true,
      onOk: () {
        standardLineCalibrationController!.confirmEdit(calibrationLine);
        Get.back();
      },
      onCancel: () {
        standardLineCalibrationController!.cancelEdit();
        Get.back();
      },
      children: [
        buildCalibrationLineItem(
          '长度',
          FTextField(
            decoration: InputDecoration(
              hintText: '请输入',
              hintStyle: const TextStyle(
                fontSize: 16,
              ),
              enabledBorder: OutlineInputBorder(
                borderSide: BorderSide(
                  color: Colors.white.withOpacity(0.5),
                  width: 0.5,
                  style: BorderStyle.solid,
                ),
              ),
              focusedBorder: const OutlineInputBorder(
                borderSide: BorderSide(
                  color: Colors.blue,
                  width: 0.5,
                  style: BorderStyle.solid,
                ),
              ),
              filled: true,
            ),
            onChanged: (val) => calibrationLine = double.parse(val),
          ),
        ),
        buildCalibrationLineItem(
          '单位',
          const FText('cm'),
        ),
      ],
    );
  }

  FWidget buildCalibrationLineItem(String name, FWidget itemWidget) {
    return FContainer(
      padding: const EdgeInsets.symmetric(vertical: 15, horizontal: 25),
      child: FRow(
        children: [
          FContainer(
            width: 60,
            child: FText(name),
          ),
          FExpanded(
            child: itemWidget,
          ),
        ],
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    MeasureCanvasExt.setFontFamily(
        Theme.of(context).textTheme.button?.fontFamily);
    bool canShowAI = [
      DiagnosisConclusionEnum.Benign,
      DiagnosisConclusionEnum.Malignant,
      DiagnosisConclusionEnum.BenignAndMalignant
    ].contains(measureData.diagnosisConclusion);
    return Container(
      color: MeasureColors.Background,
      child: RepaintBoundary(
        child: Column(
          children: [
            Expanded(
              child: Row(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Expanded(
                    child: RepaintBoundary(
                      key: _key,
                      child: CustomMultiChildLayout(
                        delegate: _LayerLayoutDelegate(),
                        children: [
                          LayoutId(
                            id: _LayerLayoutIds.player,
                            child: enableCarotid2DMeasure
                                ? CarotidPlayer(
                                    measure3DViewController,
                                    playerController as VidPlayerController,
                                  )
                                : VidPlayer(
                                    playerController as VidPlayerController,
                                  ),
                          ),
                          if (canMeasure) ...[
                            LayoutId(
                              id: _LayerLayoutIds.recordsCanvas,
                              child: const MeasureRecordsCanvasPanel(),
                            ),
                            LayoutId(
                              id: _LayerLayoutIds.activeMeasure,
                              child: const MeasureActiveCanvasPanel(),
                            ),
                            LayoutId(
                              id: _LayerLayoutIds.activeAnnotation,
                              child: const AnnotationCanvas(),
                            ),
                            if (application.isThirdPart)
                              LayoutId(
                                id: _LayerLayoutIds.standardLineCalibration,
                                child: StandardLineCalibrationCanvas(
                                    standardLineCalibrationController!),
                              ),
                            LayoutId(
                              id: _LayerLayoutIds.gesture,
                              child: _buildGestureLayer(),
                            ),
                            LayoutId(
                              id: _LayerLayoutIds.result,
                              child: const MeasureResultPanel(),
                            ),
                            if (!isCaptureState)
                              LayoutId(
                                id: _LayerLayoutIds.buttonGroups,
                                child: ButtonGroup(
                                  capturePng: () => capturePng(),
                                ),
                              )
                          ],
                          if (canShowAI) ...[
                            LayoutId(
                              id: _LayerLayoutIds.paintAI,
                              child: AIPaintInfo(
                                playerController as VidPlayerController,
                              ),
                            )
                          ],
                        ],
                      ),
                    ),
                  ),
                  if (canShowAI && !measureHandler.fullScreenState) ...[
                    SizedBox(
                      width: 200,
                      child: AIPaintInfoReslut(
                        playerController as VidPlayerController,
                      ),
                    ),
                  ],
                ],
              ),
            ),
            ifShowProgressBar ? const MeasurePausePanel() : Container(),
          ],
        ),
      ),
    );
  }

  Widget _buildGestureLayer() {
    if (application.isThirdPart) {
      if (standardLineCalibrationController!.isEditing) {
        return StandardLineCalibrationGesture(
            standardLineCalibrationController!);
      }
    }
    return inAnnotation
        ? const AnnotationGestureLayer()
        : const MeasureMouseGesturePanel();
  }
}

class _LayerLayoutDelegate extends MultiChildLayoutDelegate {
  Offset? layoutOffset;
  Size? layoutSize;

  _LayerLayoutDelegate();

  @override
  void performLayout(Size size) {
    if (!hasChild(_LayerLayoutIds.player)) return;

    final application = Get.find<IApplication>();
    final vidFrame = application.frameData;
    final imageSize = IntSize.fill(vidFrame?.width ?? 0, vidFrame?.height ?? 0);

    /// 以Contain方式填充布局，计算定位偏移量
    calcSize(size, imageSize);
    final offset = layoutOffset!;
    final renderSize = layoutSize!;

    /// 同步图像显示尺寸
    application.displaySize = renderSize;

    layoutLayer(_LayerLayoutIds.player, offset, renderSize);

    /// 其他层按播放器尺寸位置层叠布局
    layoutLayer(_LayerLayoutIds.recordsCanvas, offset, renderSize);
    layoutLayer(_LayerLayoutIds.activeMeasure, offset, renderSize);
    layoutLayer(_LayerLayoutIds.activeAnnotation, offset, renderSize);
    layoutLayer(_LayerLayoutIds.standardLineCalibration, offset, renderSize);
    layoutLayer(_LayerLayoutIds.gesture, offset, renderSize);
    layoutLayer(
      _LayerLayoutIds.result,
      offset + const Offset(2, 2),
      renderSize,
    );
    layoutLayer(_LayerLayoutIds.pause, offset, renderSize);
    layoutLayer(_LayerLayoutIds.paintAI, offset, renderSize);
    layoutLayer(_LayerLayoutIds.buttonGroups, offset, renderSize);
  }

  void layoutLayer(_LayerLayoutIds layoutId, Offset offset, Size size) {
    if (hasChild(layoutId)) {
      layoutChild(
        layoutId,
        BoxConstraints.loose(size),
      );
      positionChild(layoutId, offset);
    }
  }

  void calcSize(Size size, IntSize imageSize) {
    final parentWHRatio = size.width / size.height;
    final imageWHRatio = imageSize.width / imageSize.height;
    if (imageWHRatio < parentWHRatio) {
      // 高度撑满
      final layoutWidth = size.height * imageWHRatio;
      final layoutHeight = size.height;
      final offsetX = (size.width - layoutWidth) / 2;
      layoutOffset = Offset(offsetX, 0);
      layoutSize = Size(layoutWidth, layoutHeight);
    } else if (imageWHRatio > parentWHRatio) {
      // 宽度撑满
      final layoutWidth = size.width;
      final layoutHeight = size.width / imageWHRatio;
      final offsetY = (size.height - layoutHeight) / 2;
      layoutOffset = Offset(0, offsetY);
      layoutSize = Size(layoutWidth, layoutHeight);
    } else {
      layoutOffset = Offset.zero;
      layoutSize = size;
    }
  }

  @override
  bool shouldRelayout(covariant MultiChildLayoutDelegate oldDelegate) {
    return false;
  }
}

enum _LayerLayoutIds {
  /// 播放器
  player,

  /// 测量记录画板
  recordsCanvas,

  /// 活动测量画板
  activeMeasure,

  /// 活动注释画板
  activeAnnotation,

  /// 结果面板
  result,

  /// 手势面板
  gesture,

  /// 暂停画板 后面需要优化命名
  pause,

  /// AI画板
  paintAI,

  /// 按钮组
  buttonGroups,

  /// 参考校准线画板
  standardLineCalibration,
}