fis_lib_measure/lib/view/paint/ai_patint_controller.dart

import 'dart:convert';

import 'package:fis_measure/interfaces/process/player/play_controller.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/process/workspace/measure_data_controller.dart';
import 'package:fis_measure/view/paint/ai_patint_state.dart';
import 'package:fis_measure/view/paint/date_structure.dart';
import 'package:fis_measure/view/player/controller.dart';
import 'package:fis_measure/view/player/enums.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';

class AiPatintController extends GetxController {
  static const _HAS_VIEW_STATUS_ARR = [VidPlayStatus.play, VidPlayStatus.pause];

  /// 播放器控制器
  final VidPlayerController controller;
  final state = AiPatintState();

  late final application = Get.find<IApplication>();

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

  /// 播放控制器
  final playerController = Get.find<IPlayerController>();

  /// ai结果图展示
  late List<Offset> aiResultsList = [];

  /// 获取病灶大小
  late String description;

  /// ai结果点集
  late AiDotsResults aiDotsResults;

  /// ai结果点集List
  late List<AiDotsResults> aiDotsResultsList;

  /// ai结果数据
  late List<AIDetectedObject> aiDetectedObject = [];

  /// ai部位
  late DiagnosisOrganEnum diagnosisOrgan = DiagnosisOrganEnum.Null;

  // late double unitsPhysicalPixels =
  //     application.currentViewPort.region.width / application.frameData!.width;

  /// 是否是播放状态
  get isPlay => playerController.status == VidPlayStatus.play;

  /// ai json 数据
  late String? aiResults = '';

  /// ai的横纵坐标 四个点
  late Offset p1 = Offset.zero;
  late Offset p2 = Offset.zero;
  late Offset p3 = Offset.zero;
  late Offset p4 = Offset.zero;

  /// 视频时的画面
  double left = -1;
  double top = -1;
  double width = -1;
  double height = -1;

  /// 当前帧数
  int? frameIndex;

  AiPatintController(this.controller);

  @override
  void onInit() {
    _addListenrs();

    super.onInit();
  }

  @override
  void dispose() {
    super.dispose();
    _removeListenrs();
  }

  void onMeasuredAIResultsInfoChanged(Object sender, String e) {
    try {
      if (e.isNotEmpty && e != "[]") {
        aiResults = e;
        final measureDataAIResults = jsonDecode(
          aiResults ?? '',
        );
        state.aiResult.clear();
        for (var element in (measureDataAIResults as List)) {
          if (element != null) {
            state.aiResult.add(
              AIDiagnosisPerImageDTO.fromJson(
                element,
              ),
            );
          } else {
            state.aiResult.add(AIDiagnosisPerImageDTO());
          }
        }
      } else {
        aiResults = '';
        state.aiResult.clear();
      }
    } catch (e) {
      print(e);
    }
  }

  /// 单帧图处理
  void onSingleFrameImage(
    List<AIDetectedObject>? detectedObjects,
    double widthScale,
  ) {
    aiDetectedObject = detectedObjects ?? [];

    for (int m = 0; m < detectedObjects!.length; m++) {
      final List<AIDiagnosisPoint2D>? contours = detectedObjects[m].contours;
      if (contours!.isNotEmpty && detectedObjects[m].descriptions!.isNotEmpty) {
        description = detectedObjects[m]
            .descriptions![detectedObjects[m].descriptions!.length - 1]
            .value!;

        final descriptions = jsonDecode(description);
        if (_HAS_VIEW_STATUS_ARR.contains(state.vidStatus)) {
          aiResultsList = [];
          for (int i = 0; i < contours.length; i++) {
            if (i % 9 == 0) {
              aiResultsList.add(Offset(
                contours[i].x * widthScale,
                contours[i].y * widthScale,
              ));
            }
            p1 = Offset(descriptions['HorizontalPoint1']['X'] * widthScale,
                descriptions['HorizontalPoint1']['Y'] * widthScale);
            p2 = Offset(descriptions['HorizontalPoint2']['X'] * widthScale,
                descriptions['HorizontalPoint2']['Y'] * widthScale);
            p3 = Offset(descriptions['VerticalPoint1']['X'] * widthScale,
                descriptions['VerticalPoint1']['Y'] * widthScale);
            p4 = Offset(descriptions['VerticalPoint2']['X'] * widthScale,
                descriptions['VerticalPoint2']['Y'] * widthScale);
            aiDotsResults = AiDotsResults(
              aiResultsIndex: m,
              aiResultsList: aiResultsList,
              p1: p1,
              p2: p2,
              p3: p3,
              p4: p4,
            );
          }
          aiDotsResultsList.add(aiDotsResults);
        }
      }
    }
  }

  /// ai处理图片结果
  bool onGetAIResultsInfo(double widthScale) {
    if (state.aiResult.isEmpty) {
      return false;
    } else if (state.aiResult.length == 1) {
      final diagResultsForEachOrgan =
          state.aiResult[0].diagResultsForEachOrgan?[state.aiResultIndex];
      final detectedObjects = diagResultsForEachOrgan!.detectedObjects;
      diagnosisOrgan = diagResultsForEachOrgan.organ;
      updateFeatures();
      if (detectedObjects!.isNotEmpty) {
        onSingleFrameImage(
          detectedObjects,
          widthScale,
        );
        return true;
      } else {
        return false;
      }
    } else {
      updateFeatures();
      final diagResultsForEachOrgan = state.aiResult[state.frameIndex]
          .diagResultsForEachOrgan?[state.aiResultIndex];
      diagnosisOrgan =
          diagResultsForEachOrgan?.organ ?? DiagnosisOrganEnum.Null;
      final detectedObjects = diagResultsForEachOrgan?.detectedObjects;
      if (state.vidStatus == VidPlayStatus.pause) {
        if (detectedObjects!.isNotEmpty) {
          onSingleFrameImage(
            detectedObjects,
            widthScale,
          );
        }
        return true;
      } else if (state.vidStatus == VidPlayStatus.play) {
        if (detectedObjects?.isNotEmpty ?? false) {
          for (int m = 0; m < detectedObjects!.length; m++) {
            final organBoundBox =
                detectedObjects[m].boundingBox ?? AIDiagnosisRect();
            bool isLiver = diagnosisOrgan == DiagnosisOrganEnum.Liver;
            // 判断病灶是否是肝脏的弥漫性
            if (detectedObjects[m].label != 0) {
              if (isLiver) {
                if (detectedObjects[m].label < 5) {
                  left = organBoundBox.left * widthScale;
                  top = organBoundBox.top * widthScale;
                  width = organBoundBox.width * widthScale;
                  height = organBoundBox.height * widthScale;
                }
              } else {
                left = organBoundBox.left * widthScale;
                top = organBoundBox.top * widthScale;
                width = organBoundBox.width * widthScale;
                height = organBoundBox.height * widthScale;
              }
            }
          }
          return true;
        } else {
          return false;
        }
      }
      return false;
    }
  }

  void updateFeatures() {
    aiDotsResults = AiDotsResults(
      aiResultsIndex: 0,
      aiResultsList: [],
      p1: Offset.zero,
      p2: Offset.zero,
      p3: Offset.zero,
      p4: Offset.zero,
    );
    state.aiResultIndex = 0;
    aiDotsResultsList = [];
    left = 0;
    top = 0;
    width = 0;
    height = 0;
  }

  void _addListenrs() async {
    measureData.aiResultsInfoChanged
        .addListener(onMeasuredAIResultsInfoChanged);
    if (measureData.aiResults.isNotEmpty) {
      onMeasuredAIResultsInfoChanged(this, measureData.aiResults);
    }
  }

  void _removeListenrs() {
    measureData.aiResultsInfoChanged
        .removeListener(onMeasuredAIResultsInfoChanged);
  }
}