AISDK/AIDiagnosisSystem/Vinno.AIService/Vinno.AI.HepatoRenalRatioDiagnosisService/HepatoRenalRatioDiagnosisService.cs

using AI.Common;
using AI.Common.Log;
using AIDiagnosis.Common.Enums;
using AIDiagnosis.Common.Models;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using UsHepatoRenalRatioDetectLib;
using Vinno.AI.CommonSDK.Enums;
using Vinno.AI.CommonSDK.Models;
using Vinno.AI.CommonSDK.Tools;
using Vinno.AI.HepatoRenalRatioDiagnosisSDK.Enums;
using Vinno.AI.HepatoRenalRatioDiagnosisSDK.Interfaces;
using Vinno.AI.HepatoRenalRatioDiagnosisSDK.Models;
using Vinno.AI.HepatoRenalRatioDiagnosisService.Tools;
using Vinno.AI.Service.Common.Interfaces;
using Vinno.AI.Service.Common.Models;
using Vinno.AI.Service.Common.Tools;
using HepatoRenalRatioDiagnosis = HepatoRenalRatioDiagnosisSDK.HepatoRenalRatioDiagnosis;

namespace Vinno.AI.HepatoRenalRatioDiagnosisService
{
    public class HepatoRenalRatioDiagnosisService : IHepatoRenalRatioDiagnosisService, IDisposable, IEngine
    {
        private readonly string _modelFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Networks");
        private readonly ConcurrentStack<byte[]> _singleImageCache;

        private PipeServer _singleImagePipeServer;
        private ImageProvider _imageProvider;
        private HepatoRenalRatioDiagnosis _hepatoRenalRatioDiagnosis;
        private bool _disposed;

        public static List<FunctionInfo> AllFunctions { get; }

        static HepatoRenalRatioDiagnosisService()
        {
            AllFunctions = HepatoRenalRatioDiagnosis.AllFunctions;
        }

        public static void Init(FunctionInfo enableFunction, FunctionInfo currentUsedFunction)
        {
            HepatoRenalRatioDiagnosis.Init(enableFunction, currentUsedFunction);
        }

        public HepatoRenalRatioDiagnosisService()
        {
            try
            {
                _singleImageCache = new ConcurrentStack<byte[]>();
                _singleImagePipeServer = new PipeServer(AIDiagnosisSystemConsts.PipeForHepatoRenalRatioDiagnosisSingleImage);
                _singleImagePipeServer.LogMsgThrow += OnLogMsgThrow;
                _singleImagePipeServer.DataReceived += OnDataReceived;
                _singleImagePipeServer.StartAndReceive();
                _imageProvider = new ImageProvider(AIEnumType.HepatoRenalRatioDiagnosis);
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-Constructor error:{ex}");
            }
        }

        public void Initialize(HepatoRenalRatioDiagnosisParameter hepatoRenalRatioDiagnosisParameter, bool hasImageProvider)
        {
            try
            {
                CloseDiagnosis();
                var detectMode = (EnumDetectMode)hepatoRenalRatioDiagnosisParameter.DetectMode;
                var detectTps = hepatoRenalRatioDiagnosisParameter.DetectTps;
                var intervalTime = hepatoRenalRatioDiagnosisParameter.IntervalTime;
                var isCropped = hepatoRenalRatioDiagnosisParameter.IsCropped;
                _hepatoRenalRatioDiagnosis = new HepatoRenalRatioDiagnosis();
                _hepatoRenalRatioDiagnosis.StartEvaluation += OnStartEvaluation;
                _hepatoRenalRatioDiagnosis.FinishEvaluation += OnFinishEvaluation;
                _hepatoRenalRatioDiagnosis.NotifyError += OnNotifyError;
                _hepatoRenalRatioDiagnosis.NotifyLog += OnNotifyLog;
                _hepatoRenalRatioDiagnosis.Initialize(Setting.Instance.IsSaveDetectImage, Setting.Instance.IsSaveAllImage, Logger.LogDir, hasImageProvider ? _imageProvider : null, detectMode, isCropped, detectTps, intervalTime, _modelFolder);
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-Initialize error:{ex}");
            }
        }

        /// <summary>
        /// 切换引擎
        /// </summary>
        /// <param name="functionInfo"></param>
        public void SwitchEngines(FunctionInfo functionInfo)
        {
            try
            {
                HepatoRenalRatioDiagnosis.SwitchAIEngines(functionInfo);
                if (_hepatoRenalRatioDiagnosis != null)
                {
                    _hepatoRenalRatioDiagnosis.SwitchAIEngines2(functionInfo);
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-SwitchEngines error:{ex}");
            }
        }

        public void Start()
        {
            try
            {
                if (_hepatoRenalRatioDiagnosis != null)
                {
                    _hepatoRenalRatioDiagnosis.Start();
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-Start error:{ex}");
            }
        }

        public void Stop()
        {
            try
            {
                if (_hepatoRenalRatioDiagnosis != null)
                {
                    _hepatoRenalRatioDiagnosis.Stop();
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-Stop error:{ex}");
            }
        }

        public void SetDetectTps(int detectTps)
        {
            try
            {
                if (_hepatoRenalRatioDiagnosis != null)
                {
                    _hepatoRenalRatioDiagnosis.DetectTps = detectTps;
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-SetDetectTps error:{ex}");
            }
        }

        public void SetIntervalTime(int intervalTime)
        {
            try
            {
                if (_hepatoRenalRatioDiagnosis != null)
                {
                    _hepatoRenalRatioDiagnosis.IntervalTime = intervalTime;
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-SetIntervalTime error:{ex}");
            }
        }

        public void SetDetectMode(AIEnumDetectMode detectMode)
        {
            try
            {
                if (_hepatoRenalRatioDiagnosis != null)
                {
                    _hepatoRenalRatioDiagnosis.DetectMode = (EnumDetectMode)detectMode;
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-SetDetectMode error:{ex}");
            }
        }

        public void SetIsCropped(bool isCropped)
        {
            try
            {
                if (_hepatoRenalRatioDiagnosis != null)
                {
                    _hepatoRenalRatioDiagnosis.IsCropped = isCropped;
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-SetDetectMode error:{ex}");
            }
        }

        /// <summary>
        /// 检测单张Byte Image
        /// </summary>
        /// <returns></returns>
        public AIHRRDetectResultPerImg DetectOneByteImage()
        {
            try
            {
                byte[] byteImage = null;
                int retryCount = 0;
                while (!_singleImageCache.TryPop(out byteImage) && retryCount < 50)
                {
                    Thread.Sleep(10);
                    retryCount++;
                }
                if (byteImage == null)
                {
                    Logger.Error($"HepatoRenalRatioDiagnosisService-DetectOneByteImage Get Image Cache Fail");
                    return null;
                }
                var result = _hepatoRenalRatioDiagnosis.DetectOneImage(byteImage);
                var aiHRRDetectResultPerImg = AIConvertHelper.ConvertHRRDetectResultPerImgToAIHRRDetectResultPerImg(result);
                return aiHRRDetectResultPerImg;
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-DetectOneByteImage error:{ex}");
                return null;
            }
        }

        /// <summary>
        /// 检测单张Byte Image,其中IsCropped参数仅本次有效
        /// </summary>
        /// <returns></returns>
        public AIHRRDetectResultPerImg DetectOneByteImageWithTempSetting(bool isCropped)
        {
            try
            {
                byte[] byteImage = null;
                int retryCount = 0;
                while (!_singleImageCache.TryPop(out byteImage) && retryCount < 50)
                {
                    Thread.Sleep(10);
                    retryCount++;
                }
                if (byteImage == null)
                {
                    Logger.Error($"HepatoRenalRatioDiagnosisService-DetectOneByteImage Get Image Cache Fail");
                    return null;
                }
                var result = _hepatoRenalRatioDiagnosis.DetectOneImage(byteImage, isCropped);
                var aiHRRDetectResultPerImg = AIConvertHelper.ConvertHRRDetectResultPerImgToAIHRRDetectResultPerImg(result);
                return aiHRRDetectResultPerImg;
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-DetectOneByteImage error:{ex}");
                return null;
            }
        }

        public AIHRRDetectResultPerImg DetectOneRawImage(int height, int width, AIEnumColorType colorType)
        {
            try
            {
                byte[] byteImage = null;
                int retryCount = 0;
                while (!_singleImageCache.TryPop(out byteImage) && retryCount < 50)
                {
                    Thread.Sleep(10);
                    retryCount++;
                }
                if (byteImage == null)
                {
                    Logger.Error($"HepatoRenalRatioDiagnosisService-DetectOneRawImage Get Image Cache Fail");
                    return null;
                }
                var rawImage = new RawImage(byteImage, width, height, (EnumColorType)colorType);
                var result = _hepatoRenalRatioDiagnosis.DetectOneImage(rawImage);
                var aiHRRDetectResultPerImg = AIConvertHelper.ConvertHRRDetectResultPerImgToAIHRRDetectResultPerImg(result);
                return aiHRRDetectResultPerImg;
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-DetectOneRawImage error:{ex}");
                return null;
            }
        }

        public AIHRRDetectResultPerImg DetectOneRawImageWithTempSetting(int height, int width, AIEnumColorType colorType, bool isCropped)
        {
            try
            {
                byte[] byteImage = null;
                int retryCount = 0;
                while (!_singleImageCache.TryPop(out byteImage) && retryCount < 50)
                {
                    Thread.Sleep(10);
                    retryCount++;
                }
                if (byteImage == null)
                {
                    Logger.Error($"HepatoRenalRatioDiagnosisService-DetectOneRawImage Get Image Cache Fail");
                    return null;
                }
                var rawImage = new RawImage(byteImage, width, height, (EnumColorType)colorType);
                var result = _hepatoRenalRatioDiagnosis.DetectOneImage(rawImage, isCropped);
                var aiHRRDetectResultPerImg = AIConvertHelper.ConvertHRRDetectResultPerImgToAIHRRDetectResultPerImg(result);
                return aiHRRDetectResultPerImg;
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-DetectOneRawImage error:{ex}");
                return null;
            }
        }

        public AIHepatoRenalRatioInfo GetHepatoRenalRatioByByteImage(AIRect rcLiver, AIRect rcKidney)
        {
            try
            {
                byte[] byteImage = null;
                int retryCount = 0;
                while (!_singleImageCache.TryPop(out byteImage) && retryCount < 50)
                {
                    Thread.Sleep(10);
                    retryCount++;
                }
                if (byteImage == null)
                {
                    Logger.Error($"HepatoRenalRatioDiagnosisService-GetHepatoRenalRatioByByteImage Get Image Cache Fail");
                    return null;
                }
                var liverRect = AICommonServiceConvertHelper.ConvertAIRectToRect(rcLiver);
                var kidneyRect = AICommonServiceConvertHelper.ConvertAIRectToRect(rcKidney);
                var result = _hepatoRenalRatioDiagnosis.GetHepatoRenalRatio(byteImage, liverRect, kidneyRect, out var meanGrayLiverROI, out var meanGrayKidneyROI, out var hrrRatio);
                return new AIHepatoRenalRatioInfo(meanGrayLiverROI, meanGrayKidneyROI, hrrRatio, (AIEnumHRRStatus)result);
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-GetHepatoRenalRatioByRawImage error:{ex}");
                return null;
            }
        }

        public AIHepatoRenalRatioInfo GetHepatoRenalRatioByRawImage(int height, int width, AIEnumColorType colorType, AIRect rcLiver, AIRect rcKidney)
        {
            try
            {
                byte[] byteImage = null;
                int retryCount = 0;
                while (!_singleImageCache.TryPop(out byteImage) && retryCount < 50)
                {
                    Thread.Sleep(10);
                    retryCount++;
                }
                if (byteImage == null)
                {
                    Logger.Error($"HepatoRenalRatioDiagnosisService-GetHepatoRenalRatioByRawImage Get Image Cache Fail");
                    return null;
                }
                var rawImage = new RawImage(byteImage, width, height, (EnumColorType)colorType);
                var liverRect = AICommonServiceConvertHelper.ConvertAIRectToRect(rcLiver);
                var kidneyRect = AICommonServiceConvertHelper.ConvertAIRectToRect(rcKidney);
                var result = _hepatoRenalRatioDiagnosis.GetHepatoRenalRatio(rawImage, liverRect, kidneyRect, out var meanGrayLiverROI, out var meanGrayKidneyROI, out var hrrRatio);
                return new AIHepatoRenalRatioInfo(meanGrayLiverROI, meanGrayKidneyROI, hrrRatio, (AIEnumHRRStatus)result);
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-GetHepatoRenalRatioByRawImage error:{ex}");
                return null;
            }
        }

        /// <summary>
        /// Send Raw Image Data For Pipe
        /// </summary>
        /// <param name="height"></param>
        /// <param name="width"></param>
        /// <param name="colorType"></param>
        public void SendRawImageData(int height, int width, AIEnumColorType colorType)
        {
            try
            {
                _imageProvider?.ReceiveRawImageData(height, width, (EnumColorType)colorType);
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-SendRawImageData error:{ex}");
            }
        }

        /// <summary>
        /// Send Byte Image Data For Pipe
        /// </summary>
        public void SendByteImageData()
        {
            try
            {
                _imageProvider?.ReceiveByteImageData();
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-SendByteImageData error:{ex}");
            }
        }

        public void Close()
        {
            try
            {
                Logger.Info($"HepatoRenalRatioDiagnosisService-Close Invoke");
                CloseDiagnosis();
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-Close error:{ex}");
            }
        }

        private void CloseDiagnosis()
        {
            if (_hepatoRenalRatioDiagnosis != null)
            {
                _hepatoRenalRatioDiagnosis.StartEvaluation -= OnStartEvaluation;
                _hepatoRenalRatioDiagnosis.FinishEvaluation -= OnFinishEvaluation;
                _hepatoRenalRatioDiagnosis.NotifyError -= OnNotifyError;
                _hepatoRenalRatioDiagnosis.NotifyLog -= OnNotifyLog;
                _hepatoRenalRatioDiagnosis.Close();
                _hepatoRenalRatioDiagnosis = null;
            }
        }

        public void Dispose()
        {
            try
            {
                if (!_disposed)
                {
                    Logger.Info($"HepatoRenalRatioDiagnosisService-Start Dispose");
                    CloseDiagnosis();
                    if (_singleImagePipeServer != null)
                    {
                        _singleImagePipeServer.DataReceived -= OnDataReceived;
                        _singleImagePipeServer.Dispose();
                        _singleImagePipeServer.LogMsgThrow -= OnLogMsgThrow;
                        _singleImagePipeServer = null;
                    }
                    _imageProvider.Dispose();
                    _imageProvider = null;
                    _disposed = true;
                    Logger.Info($"HepatoRenalRatioDiagnosisService Dispose End");
                }
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-Dispose error:{ex}");
            }
        }

        private void OnStartEvaluation(object sender, EventArgs e)
        {
            NotificationSender.SendNotification(new AINotificationArgs() { NotificationType = AIEnumNotificationType.HepatoRenalRatioDiagnosisStartEvaluationRaised, Params = e });
        }

        private void OnFinishEvaluation(object sender, HRRDetectResultPerImg e)
        {
            var aiHRRDetectResultPerImg = AIConvertHelper.ConvertHRRDetectResultPerImgToAIHRRDetectResultPerImg(e);
            NotificationSender.SendNotification(new AINotificationArgs() { NotificationType = AIEnumNotificationType.HepatoRenalRatioDiagnosisFinishEvaluationRaised, Params = aiHRRDetectResultPerImg });
        }

        private void OnNotifyLog(object sender, LogEventArgs e)
        {
            if (e == null)
            {
                return;
            }
            switch (e.LogType)
            {
                case EnumLogType.InfoLog:
                    Logger.Info($"HepatoRenalRatioDiagnosisService OnNotifyLog:{e.Msg}");
                    break;

                case EnumLogType.WarnLog:
                    Logger.Warning($"HepatoRenalRatioDiagnosisService OnNotifyLog:{e.Msg}");
                    break;

                case EnumLogType.ErrorLog:
                case EnumLogType.FatalLog:
                default:
                    Logger.Error($"HepatoRenalRatioDiagnosisService OnNotifyLog:{e.Msg}");
                    break;
            }
            var logEventArgs = AICommonServiceConvertHelper.ConvertLogEventArgsToAILogEventArgs(e);
            NotificationSender.SendNotification(new AINotificationArgs() { NotificationType = AIEnumNotificationType.HepatoRenalRatioDiagnosisNotifyLogRaised, Params = logEventArgs });
        }

        private void OnNotifyError(object sender, ErrorEventArgs e)
        {
            Logger.Error($"HepatoRenalRatioDiagnosisService OnNotifyError:{e.GetException()}");
            var logEventArgs = AICommonServiceConvertHelper.ConvertErrorEventArgsToAILogEventArgs(e);
            NotificationSender.SendNotification(new AINotificationArgs() { NotificationType = AIEnumNotificationType.HepatoRenalRatioDiagnosisNotifyLogRaised, Params = logEventArgs });
        }

        private void OnLogMsgThrow(object sender, AILogEventArgs e)
        {
            if (e == null)
            {
                return;
            }
            switch (e.LogType)
            {
                case AIEnumLogType.ErrorLog:
                case AIEnumLogType.FatalLog:
                    Logger.Error(e.Msg);
                    break;

                case AIEnumLogType.WarnLog:
                    Logger.Warning(e.Msg);
                    break;

                case AIEnumLogType.InfoLog:
                default:
                    Logger.Info(e.Msg);
                    break;
            }
        }

        private void OnDataReceived(object sender, byte[] e)
        {
            try
            {
                _singleImageCache.Push(e);
            }
            catch (Exception ex)
            {
                Logger.Error($"HepatoRenalRatioDiagnosisService-OnDataReceived error:{ex}");
            }
        }
    }
}