WingAIDiagnosisService/Service/AIDiagnosisService.URM.cs

using WingServerCommon.Service;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.Request.RemedicalAISelected;
using System.Threading.Tasks;
using System.Linq;
using WingServerCommon.Log;
using System.IO;
using System;
using System.Net.Http;
using System.Net;
using WingAIDiagnosisService.URMManage;
using System.Collections.Generic;
using WingInterfaceLibrary.Request.Examine;
using System.Drawing;
using Vinno.IUS.Common.Media.FFmpeg.Video;
using Vinno.IUS.Common.Media.FFmpeg.Video.Codecs;
using SkiaSharp;
using Vinno.IUS.Common.Media.FFmpeg.Settings;

namespace WingAIDiagnosisService.Service
{
    /// <summary>
    /// URM分析服务
    /// </summary>
    public partial class AIDiagnosisService : JsonRpcService, IAIDiagnosisService
    {
        private static object _urmProcessLocker = new object();
        private readonly string _urmTempFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "URMTemp");

        /// <summary>
        /// URM分析
        /// </summary>
        /// <param name="request">URM分析请求实体</param>
        /// <returns>URM分析分析结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMAnalysisResult> URMAnalysisAsync(URMAnalysisRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            var pos = $"{request.X},{request.Y},{request.Width},{request.Height}";
            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisAsync start, remedicalCode:{remedicalCode}, Pos:{pos}");

            var currentFolder = string.Empty;
            var resultData = new URMAnalysisResult { URMAnalysisDetails = new List<ImgItem>() };
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == 0);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");

                            bool success = false;
                            lock (_urmProcessLocker)
                            {
                                Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisAsync URMAnalysisProcess start, remedicalCode:{remedicalCode}");
                                URMAnalysisProcess _urmAnalysisProcess = null;
                                try
                                {
                                    // 开始URM分析
                                    _urmAnalysisProcess = new URMAnalysisProcess();
                                    success = _urmAnalysisProcess.URMAnalysis($"\"UrmDatapath\":\"{origialFile}\",\"VecLens\":\"474\",\"Mlas\":\"128\",\"VectorStartForMid\":\"9\",\"FramesGot\":\"1200\",\"CenterFrequencyMHz\":\"3.8\",\"Prf\":\"10313\",\"Angles\":\"29\",\"SupersonicSpeed\":\"1540\",\"PulseNum\":\"3\",\"FrequencyMin\":\"5\",\"FMUint\":\"MHz\",\"FrameRateDisplay\":\"101.9\",\"FDUnit\":\"Hz\",\"ScaleOfPixel_x\":\"0.212260852677748\",\"ScaleOfPixel_y\":\"0.493506493506494\",\"ULMCount\":\"400\",\"PacketsNum\":\"200\",\"Res\":\"2.5\",\"MaxLinkingDistance\":\"2\",\"MinLength\":\"5\",\"MaxGapClosing\":\"2\",\"LocMethod\":\"radial\",\"ButterCuttofFreqLow\":\"30\",\"NLocalMax\":\"3\",\"SVDCutoffLow\":\"30\",\"Fwhm\":\"3\",\"MOCOYN\":\"0\",\"MOCOLevel\":\"4\",\"MOCOThresh1\":\"0.05\",\"MOCOThresh2\":\"0.05\",\"MOCOThresh3\":\"5\",\"LocaFixmethod\":\"fixgray\",\"LocFixThresh\":\"25\",\"RefNum\":\"1\",\"MotionCorrThresh\":\"0.5\",\"Pos\":\" {pos} \",\"FilterDeci\":\"1\",\"PSFNum\":\"10\",\"PSFCorr\":\"0.5\",\"Depth\":\"0\",\"X0\":\"0\",\"Z0\":\"0\",\"ProbeType\":\"1\",\"Decifactorx\":\"1\",\"Decifactory\":\"1\",\"SizeScan\":\"474\",\"MotionAngleThresh\":\"2\",\"TrackInterpFactor\":\"0.8\"", currentFolder);

                                }
                                catch (Exception ex)
                                {
                                    Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync URMAnalysisProcess error, remedicalCode:{remedicalCode}, ex:{ex}");
                                }
                                finally
                                {
                                    _urmAnalysisProcess?.Release();
                                    Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisAsync URMAnalysisProcess end, remedicalCode:{remedicalCode}");
                                }
                            }
                            if (success)
                            {
                                resultData.IsSuccess = true;
                                await InitURMAnalysisDetails(resultData, fileToken, currentFolder, origialRemedicalInfo);
                                await InitURMVideo(resultData, currentFolder);
                            }
                            // else
                            // {
                            //     Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync URMAnalysisProcess failed test, remedicalCode:{remedicalCode}");
                            //     resultData.IsSuccess = true;
                            //     await InitURMAnalysisDetails(resultData, fileToken, currentFolder, origialRemedicalInfo);
                            //     await InitURMVideo(resultData, currentFolder);
                            // }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                if (Directory.Exists(currentFolder))
                {
                    // Directory.Delete(currentFolder, true);
                }
            }
            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisAsync finished, remedicalCode:{remedicalCode}, result:{resultData.IsSuccess}");
            return resultData;
        }

        private async Task InitURMAnalysisDetails(URMAnalysisResult resultData, string originalUrl, string currentFolder, ImgItem originalRemedicalInfo)
        {
            resultData.URMAnalysisDetails.Add(new ImgItem
            {
                ImgType = 0,
                FileToken = originalUrl,
                FileSize = originalRemedicalInfo.FileSize,
                CoverImgUrl = originalRemedicalInfo.CoverImgUrl,
                PreviewFileUrl = originalRemedicalInfo.PreviewFileUrl,
            });
            var files = Directory.GetFiles(currentFolder);
            foreach (var file in files)
            {
                var fileName = Path.GetFileName(file);
                if (fileName.Contains("den"))
                {
                    var fileInfo = await UploadFileWithSizeAsync(file, fileName);
                    resultData.URMAnalysisDetails.Add(new ImgItem
                    {
                        ImgType = 1,
                        FileToken = fileInfo.Item1,
                        FileSize = fileInfo.Item2,
                    });
                }
                if (fileName.Contains("dir"))
                {
                    var fileInfo = await UploadFileWithSizeAsync(file, fileName);
                    resultData.URMAnalysisDetails.Add(new ImgItem
                    {
                        ImgType = 2,
                        FileToken = fileInfo.Item1,
                        FileSize = fileInfo.Item2,
                    });
                }
                if (fileName.Contains("vel"))
                {
                    var fileInfo = await UploadFileWithSizeAsync(file, fileName);
                    resultData.URMAnalysisDetails.Add(new ImgItem
                    {
                        ImgType = 3,
                        FileToken = fileInfo.Item1,
                        FileSize = fileInfo.Item2,
                    });
                }
            }
        }

        private async Task InitURMVideo(URMAnalysisResult resultData, string currentFolder)
        {
            var mp4FileInfos = ImagesToMP4(currentFolder);
            if (!string.IsNullOrWhiteSpace(mp4FileInfos.Item1))
            {
                if (File.Exists(mp4FileInfos.Item1))
                {
                    var mp4ImgItem = new ImgItem
                    {
                        ImgType = 4,
                    };
                    var converImageUrl = await UploadFileAsync(mp4FileInfos.Item1, Path.GetFileName(mp4FileInfos.Item1));
                    mp4ImgItem.CoverImgUrl = converImageUrl;
                    mp4ImgItem.PreviewFileUrl = converImageUrl;
                    if (File.Exists(mp4FileInfos.Item2))
                    {
                        var mp4Info = await UploadFileWithSizeAsync(mp4FileInfos.Item2, Path.GetFileName(mp4FileInfos.Item2));
                        mp4ImgItem.FileToken = mp4Info.Item1;
                        mp4ImgItem.FileSize = mp4Info.Item2;
                        resultData.URMAnalysisDetails.Add(mp4ImgItem);
                    }
                }
            }
        }

        private Tuple<string, string> ImagesToMP4(string currentFolder)
        {
            try
            {
                var files = Directory.GetFiles(Path.Combine(currentFolder, "avi"))?.OrderBy(x => x);
                if (files?.Any() ?? false)
                {
                    var mp4Path = Path.Combine(currentFolder, $"{Guid.NewGuid():N}.mp4");
                    var firstFile = files.FirstOrDefault();

                    var width = 0;
                    var height = 0;
                    using (SKBitmap bitmap = SKBitmap.Decode(firstFile))
                    {
                        width = bitmap.Width;
                        height = bitmap.Height;
                    }

                    var frameRate = 10;
                    var setting = new FFmpegSettings();
                    var writeArgs = new FFmpegVideoWriterArgs(mp4Path, width, height)
                    {
                        FrameRate = frameRate,
                        VideoCodec = FFmpegVideoCodec.X264
                    };
                    using (var videoWriter = new FFmpegVideoWriter(writeArgs, setting, null))
                    {
                        foreach (var avi in files)
                        {
                            using (SKBitmap bitmap = SKBitmap.Decode(avi))
                            {
                                if (bitmap != null)
                                {
                                    try
                                    {
                                        if (bitmap.Bytes != null && bitmap.Bytes.Length > 0 && bitmap.Width > 0 && bitmap.Height > 0)
                                        {
                                            var frame = new BitmapFrame(bitmap.Width, bitmap.Height, bitmap.Bytes);
                                            videoWriter.WriteFrame(frame);
                                        }
                                    }
                                    catch (Exception exception)
                                    {
                                    }
                                }
                            }
                        }
                    }
                    return new Tuple<string, string>(firstFile, mp4Path);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync ImagesToMP4 ex:{ex}");
            }
            return new Tuple<string, string>("", "");
        }

        private async Task<bool> DownloadToLocalAsync(string fileUrl, string localFile)
        {
            try
            {
                if (fileUrl.Contains("FlyinsonoStorage"))
                {
                    // 自建存储
                    var infos = fileUrl.Split("FlyinsonoStorage");
                    var sourceFilePath = Path.Combine(_storageDirectory, infos[1].Trim('/'));
                    if (File.Exists(sourceFilePath))
                    {
                        File.Copy(sourceFilePath, localFile);
                        return true;
                    }
                }
                else
                {
                    long fileSize = 0;
                    using (var request = new HttpRequestMessage())
                    {
                        request.RequestUri = new Uri(fileUrl);
                        request.Method = HttpMethod.Get;
                        var response = await _httpClient.SendAsync(request);

                        if (response != null && response.StatusCode == HttpStatusCode.OK)
                        {
                            var contentLength = response.Content.Headers.ContentLength;
                            fileSize = contentLength == null ? 0 : contentLength.Value;
                        }
                    }
                    if (fileSize > 0)
                    {
                        byte[] bytes = await _httpClient.GetByteArrayAsync(fileUrl);
                        File.WriteAllBytes(localFile, bytes);
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync, fileToken:{fileUrl}, ex:{ex}");
            }
            return false;
        }
    }
}