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 System.Collections.Generic;
using WingInterfaceLibrary.Request.Examine;
using Vinno.IUS.Common.Media.FFmpeg.Video;
using Vinno.IUS.Common.Media.FFmpeg.Video.Codecs;
using SkiaSharp;
using Vinno.IUS.Common.Media.FFmpeg.Settings;
using System.Diagnostics;
using Logger = WingServerCommon.Log.Logger;
using System.Text;
using Newtonsoft.Json;
using WingAIDiagnosisService.URMManage;
using WingInterfaceLibrary.Result.Record;
using Vinno.DataTypes;
using WingInterfaceLibrary.DTO.Record;
using static WingAIDiagnosisService.URMManage.UrmProcessRequest;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using Microsoft.VisualBasic;
using WingInterfaceLibrary.Request.AIDiagnosis;
using Vinno.Enums;
using Vinno.vCloud.Common.Vid2;
using WingInterfaceLibrary.Notifications;

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

        private URMAnalysisManager _urmAnalysisManager;

        //银杏叶logo
        private static string _logoBase64 = "iVBORw0KGgoAAAANSUhEUgAAAGQAAABTCAYAAABpnaJBAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAABn9JREFUeF7tnXtsU1UYwEk0JhoTE2M0GBMTYkxM0PgH+8tEYQKbbDym2YCNYQJOgQxFdOEVpxgR1Cl06x5l6TY2NscY27pABgzW59qyB+vK3iQGEk0M+IfBRxSJ9TvzK9luv66P++i53fklvz92ex7fOd/uPee2690CgSBqKuyrSmo9uYEy6/LAsZ7XQiy3pweqHKsDtZ6N7OeSE95NJVhVoDQm59qQBERjqfX1gNG2sgKbESgBNdGxanKuC9R781/EJgXxYHKuqaYmN14NPcsC1a6sF7B5QbTAOmGBy8yf1KTKla0x2I1ASo17/S6YpO5q15uB4651gTLbCnISlRY2B0swhKi4NPH1kovjh7vRD/FwclFqTX2fmiwtbOzb6sMwwgIT/yxc4nxUfSa7/MFZ7MLi+ifc1lUrMYywGKM8W+EXi22338Jq+qTeu/k2NTgttU4dW4ThhNA8sO06VWcu230fj2F1/oG1IguCvsEssyX2zAh6sm8LudvqGj34OFU+Gi3+fbewGX6pdW/4lQqeA8mEwPEnJOViEi5hqdgUH/RMfvt8U1/BHQjujgGur9KAOTJMQpZSZWMSdmWvYHOJA3Yd/1DBcWxIQkzOtY8Q5WLW3Jt9D5vUngtjh8mgdGBIQnomj1Ll4rJtaHdM9zqKUOvJ+4MKRieGJESJy1XQTv9+bd8RMNrSfqEC0ZFEQshycYvNqk9j3zs/UgHoyRr3xuRISGPf1ueozvVmh2/PrIScGdpNlpMjNq0u0NEP0o71aPf4kVkJocrIFZtWjzbfRy9THetRHNJ9qDJyZO9gY9PqAR31SzvWqzik+1Bl5Ph9/3vqJ6TCsYrsXG+yt85xSNO0+4oyqXJyrPfma3KGkJ3rTfZBGA5pmkpH5u9UObli8+pBdapHpdd3uCH8iyonV3Nv9gHsQh2oTvWo9HN1qoxSGqypn3QMFz2MXSlHy2ChnepQr+Kw2LhuUa8rKVuz4Gwpwi7lcX7si+wT3vzrrFGqM70K4ymtcGQUK/n+VSThplr+umJyrj1DNS6Mz1Jr6l2c2vjo9O8XCVFYA5yVlydKPsUpjh2qUaFcl/6G0xsbdZ48cYaoZLktbRynOTKVjox3y6zLb1INCZUTp3tuoGCBtKJQHWGRH8BpD49Wf2MrnP7+yh2c9vBQFYXqidMeHqqSUD1x2sNDVRKqI/tIA6c9PFRFoWpGXtTZt1mJikJ1jJwQQ8+yMqKiUCVbhz7oxqkPD1VRqJ7s/S2cehqLf684SxJgtSvrIUwBjcm55m+qolAda9wbIu+6Gvu2noR1RZXPnYWhnhrcbsKpnxtYfNqgwpS0AaGy1ns3Rz5LpLQMFtqg8rC0MaF8jba02BMyk0sT33ihIS9c1oYS/XXnZBGnVjlaBndaoWFrlXM12aFwbnEa1cM6dSy9zpN7DjqbttKRQQYi/F+ctsTQOby/tdye3mruzb6dbH9uFI8RbxK1ptaT26Dl30vxptmdM4VTwQ8W/94j7DeFCngeGN19iNbAmnOICHY+yGdCGEbbyrtEwEmtybnmCg6fP7pGD+6jgk52cfh8QgWc7MKO8ygOnz+ogOeB/CZknt5E8puQ7vEjVMDJLr8JuTz5HXsiHRV00lrjzuE3IQwq6GS10pHJ9y6LQQUeq+wJosddWTBgvtckuA/h98YwCBV4ONmjBZv6CyrKbWkp58cOpWATJGW2FSntviJVnqIdj+beHP7PjrPXiq9RwUttHth+uuHK24uxWswYepYtbriyhWxbCyvsq9gXQ5/BcPildWgXOYCgVY7VF+o8uU9icdm0DBYuOn11J9mXyj6FIfBNuM9I2P8GMbtzFmIxxTk3UrzQaEtbR/WttM3926zYLf9QA4CFL2Dx730Ui6hKtSvrQXNv9iYqDiWs8+S5sSt9IB0A7JYm8CVNOTfy2QMdw3t2SOOR46mBHVexeX1wYexL6ZN6buJLCcdoW3lPEltMYjP6Yub6AdvZf/EwV3QMFxnY987BqB4mDfdBN7CqvoDr9qxH0eJh7oHNgKXcns4eajNL9qAbLKI/6r35T7MkBO0a/Twh64YAgST8FEwGe6sDDwsSQb1386xH0eJhQSJoHtj+0sxkXBz/yosvCRIBJGEymIyovjIsUI86z6aRYDKYTf0Fj+FLAq2BhfvVmcno9B84iy8JEgXs3X9mySi3vyEuVbxQ415/C3ZZIf9KQiAQCKQsWPAfVXjcqZiVuhgAAAAASUVORK5CYII=";
        //视频默认urm colorbar
        private static string _urmColorbarBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAoAAACACAIAAAC9e29UAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAH/SURBVFhHpZchSJwBGIa/9z8GQ4tFGFiuDAQZCCLI0pWBmCyCmK4MjMZFm3FJhJVLY2AxiWC5NAYWkwxWrpgsK7qwhc8vvOE///feC3v4wId7uONHXg5F5iRm0/DnDOrdP6mKyj+oispXVEXlb1RF5TOqovIJVVH5E1VR+ZCqqLxPVVTepioqb1EVlVepispvqIrKr6kK5F+aBPmbJkHe0yTIXzQJ8pYmQX6nSZDXNAnygiZBfqVJkF9okiaewlwTf8Lc/70b+ZFPIUEe0CTIXZoE+YEmQb6nSZDrNAnyLU2CXKFJkEs0CfIVTQI784CdecDOPGBnHrAzD9iZB+zMA3bmATvzgJ15NJ1xTl3TGefU9epb7d/s6210Xmpf713npfb16jvxxUvtg515wM48YGcesDMP2JkH7MwDdubzQMQiVVF5maqo3KcqKq9RFZU3qYrKA6qi8g5VUXmPqqg8pCrq75YFc5Xrtzbz5ueXH9i+erRTPoai8oiqqHxOVVS+pCoqj6mKyjdUReU7qqLyhKqo/EBVVH6kKionVYFY9HnZ577Paz5v+jzwecfnPZ+HLjed9U1d09nu1M3NnQ9sH+LUP/nI53OfL30e+3zj853PE58ffH70OW1e8rnv87rPA593fR76fOTzsc+ffR75fOHz2Odbnyc2z/kX2eaIZwFK+NjQuHI3AAAAAElFTkSuQmCC";
        //灌注colorbar
        private static string _perfusionColorbarBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAoAAACACAIAAAC9e29UAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAFRSURBVFhHzZWhrsJQEERnmiYgkEgkshKJRPJXfBISiaxEVlZWYiCIfWYNZHPsu5MVkxyzSe/Z+iJKt5Zg/hP7mjvW8S1LHd+z1PGYpY4fWep4ylLHc5Y6XrLU8TNLHX+y1HH02co4NtnKOLbZyjh22co49tnKOIZsZRyHbGUcx2xlHKdsZRznbGW638f3PU3jlWAa3tyBgjtQcAcK7kDBHSi4AwV3oOAOFNyBgjtQcH9QcD9RcC8ouGcU3BMK7gcK7hEF9x0F9w0F9xUF715aw7SM31rBNLy5zyi4Tyi4jyi4Dyi4BxTcexTcOxTcWxTcGxTcPQpufSJrFevJeGE8M54YPxiPjO+Mb4yvhDu9BNM0fgum4c2tM3+xE+Mj4wPjgfGe8Y7xlvGGcc9YrL/weEh4eiQ8XBKePQmPpoQnV8KDLeG5l+hn0f0+vu9pFuv1B8jHoVpzbDgNAAAAAElFTkSuQmCC";
        //angle colorbar
        private static string _angleColorbarBase64 = "iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAIAAAADnC86AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAATySURBVFhHxZfBap1VEMfnyC0k0IIpJBAX9QGy6MKFQgVdKCjowr5BdaePoAtfoIu6U/AF9AEUzCILAy51kYUFA43QQgJmodALDRx/Z/7nzDf35t6mu/4ZTub77sz8zpzvfOfe2MtS6X9fQHeq3bDJrq/y33rheq/0v+u1Xe1Wtb1qFzZZ1szsmo/Yn9UeV/un9o+eoyvAs2pzJz1bRHIpAZOCjW2a1avY68F11+rWhc1gBFVOUKXgZTbzradWHylkhdaA657PmwqbdCwL9mUFj5yWRtxTjwb/e49Z0ipwvWO2MYrgbFAEnkplC56MUI0tlJkyulN/Ud0FXQLXT3x7Np47DQ8jOpZlscJhRLePRf3XHR/rD4qdtAiunzqP9GD3GWj2WDxvKZ5rhDaSNxrU3ve3yuha6rgxRqNiy99gl6kUJrYU1LYyXEcQyKCGn5TA9evADHywm5GrTkRlpF0EWDnMrjOCFI7j65ee4Brg+mAwdApp3DK7mc6lDVWQSepVo6o3O0/jf2lkwT9X3tTx1JkbSDlQg71FrqcvPGNltnYv8+IyjGRXgAPTAGMM2zF71WfQ2VAwPWBlNgB2NpwwojXGVFwOrj8tUnEyddtHsbfntqEKbLGgzrgGGdQlPAmMg13fC/BElWUqPMC7bq+5v3PqRdQxadxqpMc+PnHDISizScjWvxbbsaanpiWMd5Xdov2kJilAyb/MHt6ys3fNPjBj3IV0ZHYyGiWQ8EjN9TCHlKMOpta415QD8TNbrcE55ITjuPmIkANmMjoOqpC5DMLxsZx0MOviN7oiSneiBlXFpruDN+zwe7Pb+8xhtKvPFUsSko9UEvllOe9gRYUiCikPqYYWgPKg7tf9Q/vGXW5wmw8VJa0s4yo03f4+W/zWzkF5pjImCeZvswfWwHY/kflYcCkclGcBde5g/VRZio8K0QrFeX48Fqi/tkVmqVlwf8hXrrVG1GZQ7MzBj/wHFYpRJBkVtLqY9hZb6cA+vrB7Zmwxf8hsNzY3k9IeVE6ugqFGxS927OCjOu4MUwq5maq3id6O2ivEi/Sh2TtmvFo+l+Px8mY2Y66INUyxPxz8m3ec54cfVEZKUZCyIKh/bLfbItubPuLP2nR4AHql9C7n/CjanWKHfnKpIU0UIzGMOhgFVdNPJY4qDiyOLWoQzu1xwHG06YzDx/IJmE9GTEfm+2Via7pL7HBO27GsVIE1Ww7wQWIGMYYRrhG7XuznAUYCy2BoBtkGXtn6hcXaYUpKmOdRfWwaYJ6FCqgFGOHH5Xn70iWP7mhXoulIdQClsUzSzaC2XwxogL/gnR4FwgavXz6dfmwwSrGFsPGbIHiBD9ssnDuuAUZfldaiyoCRL6Qb7YqqdvWMESOBik2MPAlN9UYxftZ1JTAiW8urRnC4VDvzlq0CIGOp9YqMEHw+0fSCja9F5nLSIvi70ngUEFWO+yTJKKydJUHVFlMgNhhYb1ROsc88o2sRjH50tqiM+N4IqeJh0a4EO8xjEeFqtLOL3fXYSZfAaN83mubvjhrVmC0jMVG9aWIxUdlQb3vdBa0CI47SUYZ//TT/4F2WwFpw8rCRAZV/PFdoDRid+HfXfOJpkVcutR6z8LpklxW7WdohulrrwV0l9wpVCjYYKVPp+Jp+YqzXlWDOj/LEykMrgQ+qlHvds/K6lZ2rqC9PZv8D5k++tFb2OZQAAAAASUVORK5CYII=";

        private URMAnalysisManager URMAnalysisManager
        {
            get
            {
                if (_urmAnalysisManager == null)
                {
                    _urmAnalysisManager = new URMAnalysisManager(SendDiskSpaceFullNotification);
                }
                return _urmAnalysisManager;
            }
        }

        /// <summary>
        /// URM分析
        /// </summary>
        /// <param name="request">URM分析请求实体</param>
        /// <returns>URM分析分析结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMAnalysisResult> URMAnalysisAsync(URMAnalysisRequest request)
        {
            return null;
        }

        /// <summary>
        /// URM分析V2
        /// </summary>
        /// <param name="request">URM分析V2请求实体</param>
        /// <returns>URM分析分析结果V2</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMAnalysisV2Result> URMAnalysisV2Async(URMAnalysisV2Request request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            var customizedStartFrame = request.CustomizedStartFrame != null ? request.CustomizedStartFrame.ToString() : string.Empty;
            var customizedEndFrame = request.CustomizedEndFrame != null ? request.CustomizedEndFrame.ToString() : string.Empty;

            var x = (int)request.X;
            var y = (int)request.Y;
            var width = (int)request.Width;
            var height = (int)request.Height;

            var currentFolder = string.Empty;
            var resultData = new URMAnalysisV2Result { 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;
                    var converImageUrl = remedical?.TerminalImages?.CoverImageUrl;
                    if (!string.IsNullOrWhiteSpace(fileToken) && !string.IsNullOrWhiteSpace(converImageUrl))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async, remedicalCode:{remedicalCode}, fileToken:{fileToken}, converImageUrl:{converImageUrl}");
                        currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialName = Path.GetFileName(fileToken);
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile, request.NotifyUserCode, remedicalCode);
                        }
                        var coverInfo = await SaveCoverImageInfo(remedical, request.CustomizedStartFrame ?? 0, currentFolder, request.NotifyUserCode);
                        var coverVidFile = coverInfo.Item1;
                        var converFile = coverInfo.Item2;
                        var vidImageCount = coverInfo.Item3;
                        DeleteTempFiles(currentFolder, new List<string> { origialFile, coverVidFile, converFile });
                        var readmePath = Path.Combine(currentFolder, "readme.txt");
                        try
                        {
                            File.WriteAllText(readmePath, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        }
                        catch { }
                        if (File.Exists(origialFile) && File.Exists(coverVidFile) && File.Exists(converFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var urmParamers = remedical.UrmParameters;
                            if (urmParamers != null && urmParamers.Any())
                            {
                                Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async URMAnalysisProcess start, remedicalCode:{remedicalCode}");
                                urmParamers.TryAdd("startX", x.ToString());
                                urmParamers.TryAdd("startY", y.ToString());
                                urmParamers.TryAdd("width", width.ToString());
                                urmParamers.TryAdd("height", height.ToString());
                                urmParamers.TryAdd("CustomizedStartFrame", request.CustomizedStartFrame == null ? "" : request.CustomizedStartFrame.ToString());
                                urmParamers.TryAdd("CustomizedEndFrame", request.CustomizedEndFrame == null ? "" : request.CustomizedEndFrame.ToString());
                                urmParamers.TryAdd("RoiXPercent", request.RoiXPercent.ToString());
                                urmParamers.TryAdd("RoiYPercent", request.RoiYPercent.ToString());
                                urmParamers.TryAdd("RoiWPercent", request.RoiWPercent.ToString());
                                urmParamers.TryAdd("RoiHPercent", request.RoiHPercent.ToString());
                                foreach (var k in urmParamers.Keys)
                                {
                                    if (k.ToLower() == "section")
                                    {
                                        var section = urmParamers[k];
                                        if (!string.IsNullOrWhiteSpace(section) && !section.Contains("URMAnalysisParam:Level"))
                                        {
                                            urmParamers[k] = $"URMAnalysisParam:Level{section}";
                                        }
                                    }
                                }
                                // 开始URM分析
                                var result = DoURMAnalysisV2(remedicalCode, origialFile, converFile, currentFolder, urmParamers, request.NotifyUserCode);
                                if (result != null)
                                {
                                    var pos = $"{x},{y},{width},{height},{customizedStartFrame},{customizedEndFrame},{vidImageCount}";
                                    Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async start, remedicalCode:{remedicalCode}, Pos:{pos}");
                                    resultData.IsSuccess = true;
                                    resultData.UrmPosition = pos;
                                    resultData.URMSrcWidth = result.URMSrcWidth;
                                    resultData.URMSrcHeight = result.URMSrcHeight;
                                    resultData.URMRes = result.URMRes;
                                    resultData.URMScaleOfPixel_x = result.URMScaleOfPixel_x;
                                    resultData.URMScaleOfPixel_y = result.URMScaleOfPixel_y;
                                    await InitUrmVidDetails(resultData, coverVidFile, converFile);
                                    await InitURMAnalysisDetails(resultData, fileToken, currentFolder, origialRemedicalInfo, result.ConverImageUrl);
                                }
                            }
                        }
                        else
                        {
                            Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisV2Async failed, remedicalCode:{remedicalCode}, origialFile not existed");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisV2Async error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                try
                {
                    if (Directory.Exists(currentFolder))
                    {
                        Directory.Delete(currentFolder, true);
                    }
                }
                catch { }
            }
            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async finished, remedicalCode:{remedicalCode}, result:{resultData.IsSuccess}");
            return resultData;
        }

        /// <summary>
        /// URM后处理-预加载
        /// </summary>
        /// <param name="request">URM后处理请求实体</param>
        /// <returns>URM后处理结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<bool> LoadURMProcessAsync(URMProcessRequest request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
                    if (remedical != null && remedical.ImgList != null && remedical.ImgList.Any() && remedical.ImgList.Any(x => x.ImgType != 0)
                        && remedical.UrmParameters != null && remedical.UrmParameters.Any())
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMProcessAsync start, remedicalCode:{remedicalCode}");
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        await DownloadUrmBinFiles(currentFolder, remedical.ImgList, "", remedicalCode);
                        try
                        {
                            File.WriteAllText(Path.Combine(currentFolder, "readme.txt"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        }
                        catch
                        {

                        }
                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMProcessAsync InitURMProcessor start, remedicalCode:{remedicalCode}");
                        var urmProcessRequest = ConvertToUrmRequest<URMProcessRequest, UrmProcessRequest>(request, remedical, currentFolder);
                        urmProcessRequest.RemedicalCode = remedicalCode;
                        urmProcessRequest.Token = request.Token;
                        urmProcessRequest.GUID = urmProcessRequest.GetUniqueCode();
                        URMAnalysisManager.InitURMProcessor(urmProcessRequest);
                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMProcessAsync InitURMProcessor end, remedicalCode:{remedicalCode}");
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService LoadURMProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService LoadURMProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return false;
        }

        /// <summary>
        /// URM后处理
        /// </summary>
        /// <param name="request">URM后处理请求实体</param>
        /// <returns>URM后处理结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMProcessResult> URMProcessAsync(URMProcessRequest request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
                    if (remedical != null && remedical.ImgList != null && remedical.ImgList.Any() && remedical.ImgList.Any(x => x.ImgType != 0)
                        && remedical.UrmParameters != null && remedical.UrmParameters.Any())
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync start, remedicalCode:{remedicalCode}");
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        await DownloadUrmBinFiles(currentFolder, remedical.ImgList, "", remedicalCode);
                        try
                        {
                            File.WriteAllText(Path.Combine(currentFolder, "readme.txt"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        }
                        catch
                        {

                        }
                        Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync DoUrmProcess start, remedicalCode:{remedicalCode}");
                        var urmProcessRequest = ConvertToUrmRequest<URMProcessRequest, UrmProcessRequest>(request, remedical, currentFolder);

                        urmProcessRequest.RemedicalCode = remedicalCode;
                        urmProcessRequest.Token = request.Token;
                        if (request.ZoomOn)
                        {
                            urmProcessRequest.ProcessType = 2;
                        }
                        urmProcessRequest.GUID = urmProcessRequest.GetUniqueCode();

                        double urmMinVal = 0;
                        double urmMaxVal = 0;
                        var base64String = URMAnalysisManager.DoUrmProcess(urmProcessRequest, ref urmMinVal, ref urmMaxVal);
                        Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync DoUrmProcess end, remedicalCode:{remedicalCode}, base64String-Length:{base64String.Length}");
                        return new URMProcessResult
                        {
                            Base64String = base64String,
                            UrmMinVal = urmMinVal,
                            UrmMaxVal = urmMaxVal,
                        };
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return new URMProcessResult();
        }

        /// <summary>
        /// 获取URMColorbar
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<URMColorbarResult> GetURMColorbarAsync(URMColorbarRequest request)
        {
            var result = new URMColorbarResult();
            result.LogoBase64 = _logoBase64;
            if (request.ProcessType == 0)
            {
                result.ColorbarBase64 = _urmColorbarBase64;
            }
            else if (request.ProcessType == 1)//URM后处理
            {
                if (request.UrmImageType == URMType.Angle.ToString("D"))
                {
                    result.ColorbarBase64 = _angleColorbarBase64;
                }
                else
                {
                    DeleteExpiredFolders(DateTime.Now.AddDays(-1));
                    var remedicalCode = request.RemedicalCode;
                    try
                    {
                        if (!string.IsNullOrWhiteSpace(remedicalCode))
                        {
                            var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                            // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
                            if (remedical != null && remedical.ImgList != null && remedical.ImgList.Any() && remedical.ImgList.Any(x => x.ImgType != 0)
                                && remedical.UrmParameters != null && remedical.UrmParameters.Any())
                            {
                                Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync start, remedicalCode:{remedicalCode}");
                                var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                                if (!Directory.Exists(currentFolder))
                                {
                                    Directory.CreateDirectory(currentFolder);
                                }
                                await DownloadUrmBinFiles(currentFolder, remedical.ImgList, "", remedicalCode);
                                try
                                {
                                    File.WriteAllText(Path.Combine(currentFolder, "readme.txt"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                }
                                catch
                                {

                                }
                                Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync DoUrmProcess start, remedicalCode:{remedicalCode}");
                                var urmProcessRequest = ConvertToUrmRequest<URMProcessRequest, UrmProcessRequest>(request, remedical, currentFolder);
                                urmProcessRequest.RemedicalCode = remedicalCode;
                                urmProcessRequest.Token = request.Token;
                                urmProcessRequest.ProcessType = 1;
                                urmProcessRequest.GUID = urmProcessRequest.GetUniqueCode();
                                var base64String = URMAnalysisManager.CreateUrmColorbarImage(urmProcessRequest);
                                Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync DoUrmProcess end, remedicalCode:{remedicalCode}, base64String-Length:{base64String.Length}");
                                result.ColorbarBase64 = base64String;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Logger.WriteLineWarn($"AIDiagnosisService URMProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
                    }
                    finally
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync finally, remedicalCode:{remedicalCode}");
                    }
                }
            }
            else if (request.ProcessType == 2)//灌注图
            {
                result.ColorbarBase64 = _perfusionColorbarBase64;
            }
            return result;
        }

        private async Task DownloadUrmBinFiles(string currentFolder, List<ImgItem> imgList, string userCode, string remedicalCode)
        {
            // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
            foreach (var imgItem in imgList)
            {
                if (imgItem.ImgType != 0 && !string.IsNullOrWhiteSpace(imgItem.FileToken))
                {
                    var fileName = Path.GetFileName(imgItem.FileToken);
                    if (imgItem.ImgType == 10)
                    {
                        fileName = "srcDenArray.bin";
                    }
                    else if (imgItem.ImgType == 11)
                    {
                        fileName = "srcDirArray.bin";
                    }
                    else if (imgItem.ImgType == 12)
                    {
                        fileName = "srcVelArray.bin";
                    }
                    else if (imgItem.ImgType == 13)
                    {
                        fileName = "srcAngleArray.bin";
                    }
                    else if (imgItem.ImgType == 14)
                    {
                        fileName = "srcMaskArray.bin";
                    }
                    else if (imgItem.ImgType == 15)
                    {
                        fileName = "URMPoints.bin";
                    }
                    else if (imgItem.ImgType == 16)
                    {
                        fileName = "URMPointNums.bin";
                    }
                    var localFilePath = Path.Combine(currentFolder, fileName);
                    if (!File.Exists(localFilePath))
                    {
                        await DownloadToLocalAsync(imgItem.FileToken, localFilePath, userCode, remedicalCode);
                    }
                }
            }
        }

        /// <summary>
        /// URM视频后处理-预加载
        /// </summary>
        /// <param name="request">URM视频后处理请求实体</param>
        /// <returns>URM视频后处理结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<bool> LoadURMVideoProcessAsync(URMVideoProcessRequest request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
                    if (remedical != null && remedical.ImgList != null && remedical.ImgList.Any() && remedical.ImgList.Any(x => x.ImgType != 0)
                        && remedical.UrmParameters != null && remedical.UrmParameters.Any())
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMVideoProcessAsync start, remedicalCode:{remedicalCode}");
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        await DownloadUrmBinFiles(currentFolder, remedical.ImgList, request.NotifyUserCode, remedicalCode);
                        try
                        {
                            File.WriteAllText(Path.Combine(currentFolder, "readme.txt"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        }
                        catch { }
                        var urmProcessRequest = ConvertToUrmRequest<URMVideoProcessRequest, DoUrmVideoProcessRequest>(request, remedical, currentFolder);
                        urmProcessRequest.VideoFrame = request.VideoFrame;
                        urmProcessRequest.URMVideoScaler = request.URMVideoScaler;
                        urmProcessRequest.URMVideoParameter = request.URMVideoParameter;
                        urmProcessRequest.URMVideoType = request.URMVideoType;
                        var pointsPath = Path.Combine(currentFolder, "URMPoints.bin");
                        var pointNumsPath = Path.Combine(currentFolder, "URMPointNums.bin");
                        urmProcessRequest.PointsDataPath = File.Exists(pointsPath) ? pointsPath : string.Empty;
                        urmProcessRequest.PointNumsDataPath = File.Exists(pointNumsPath) ? pointNumsPath : string.Empty;
                        urmProcessRequest.GUID = urmProcessRequest.GetUniqueCode();

                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMVideoProcessAsync InitVideoProcessor start, remedicalCode:{remedicalCode}");
                        URMAnalysisManager.InitVideoProcessor(urmProcessRequest);
                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMVideoProcessAsync InitVideoProcessor end, remedicalCode:{remedicalCode}");
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService LoadURMVideoProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService LoadURMVideoProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return false;
        }

        /// <summary>
        /// URM视频后处理
        /// </summary>
        /// <param name="request">URM视频后处理请求实体</param>
        /// <returns>URM视频后处理结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMVideoProcessResult> URMVideoProcessAsync(URMVideoProcessRequest request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
                    if (remedical != null && remedical.ImgList != null && remedical.ImgList.Any() && remedical.ImgList.Any(x => x.ImgType != 0)
                        && remedical.UrmParameters != null && remedical.UrmParameters.Any())
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService URMVideoProcessAsync start, remedicalCode:{remedicalCode}");
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        await DownloadUrmBinFiles(currentFolder, remedical.ImgList, request.NotifyUserCode, remedicalCode);
                        try
                        {
                            File.WriteAllText(Path.Combine(currentFolder, "readme.txt"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        }
                        catch { }
                        var urmProcessRequest = ConvertToUrmRequest<URMVideoProcessRequest, DoUrmVideoProcessRequest>(request, remedical, currentFolder);
                        urmProcessRequest.VideoFrame = request.VideoFrame;
                        urmProcessRequest.URMVideoScaler = request.URMVideoScaler;
                        urmProcessRequest.URMVideoParameter = request.URMVideoParameter;
                        urmProcessRequest.URMVideoType = request.URMVideoType;
                        var pointsPath = Path.Combine(currentFolder, "URMPoints.bin");
                        var pointNumsPath = Path.Combine(currentFolder, "URMPointNums.bin");
                        urmProcessRequest.PointsDataPath = File.Exists(pointsPath) ? pointsPath : string.Empty;
                        urmProcessRequest.PointNumsDataPath = File.Exists(pointNumsPath) ? pointNumsPath : string.Empty;
                        urmProcessRequest.GUID = urmProcessRequest.GetUniqueCode();
                        // 预加载其它Process
                        // LoadVideoProcessInfos(urmProcessRequest);

                        Logger.WriteLineInfo($"AIDiagnosisService URMVideoProcessAsync DoUrmVideoProcess start, remedicalCode:{remedicalCode}");
                        Logger.WriteLineInfo($"urmProcessRequest:{JsonConvert.SerializeObject(urmProcessRequest)}");
                        double urmMinVal = 0;
                        double urmMaxVal = 0;
                        var base64String = URMAnalysisManager.DoUrmVideoProcess(urmProcessRequest, ref urmMinVal, ref urmMaxVal);
                        Logger.WriteLineInfo($"AIDiagnosisService URMVideoProcessAsync DoUrmVideoProcess end, remedicalCode:{remedicalCode}, base64String-Length:{base64String.Length}");
                        return new URMVideoProcessResult
                        {
                            Base64String = base64String,
                            UrmMinVal = urmMinVal,
                            UrmMaxVal = urmMaxVal,
                        };
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMVideoProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService URMVideoProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return new URMVideoProcessResult();
        }

        private void LoadVideoProcessInfos(DoUrmVideoProcessRequest videoProcessProcess)
        {
            try
            {
                var videoParameterInfos = new List<float> { 1, 2, 3 };
                var videoTypeInfos = new List<float> { 0, 1, 2 };

                var videoProcessProcessNew = JsonConvert.DeserializeObject<DoUrmVideoProcessRequest>(JsonConvert.SerializeObject(videoProcessProcess));
                foreach (var videoParameter in videoParameterInfos)
                {
                    foreach (var videoType in videoTypeInfos)
                    {
                        if (videoParameter != videoProcessProcess.URMVideoParameter || videoType != videoProcessProcess.URMVideoType)
                        {
                            videoProcessProcessNew.URMVideoParameter = videoParameter;
                            videoProcessProcessNew.URMVideoType = videoType;
                            videoProcessProcessNew.GUID = videoProcessProcessNew.GetUniqueCode();
                            var process = URMAnalysisManager.VideoProcessorList.FirstOrDefault(x => x.GUID == videoProcessProcessNew.GUID);
                            if (process == null)
                            {
                                URMAnalysisManager.InitVideoProcessor(videoProcessProcessNew);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService LoadVideoProcessInfos error, remedicalCode:{videoProcessProcess.RemedicalCode}, ex:{ex}");
            }
        }

        /// <summary>
        /// URM测量-预加载
        /// </summary>
        /// <param name="request">URM测量后处理测量请求实体</param>
        /// <returns>URM测量后处理结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<bool> LoadURMMeasureProcessAsync(URMMeasureProcessRequest request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
                    if (remedical != null && remedical.ImgList != null && remedical.ImgList.Any() && remedical.ImgList.Any(x => x.ImgType != 0)
                        && remedical.UrmParameters != null && remedical.UrmParameters.Any())
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMMeasureProcessAsync start, remedicalCode:{remedicalCode}");
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        await DownloadUrmBinFiles(currentFolder, remedical.ImgList, "", remedicalCode);
                        try
                        {
                            File.WriteAllText(Path.Combine(currentFolder, "readme.txt"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        }
                        catch { }
                        var urmProcessRequest = ConvertToUrmRequest<URMMeasureProcessRequest, UrmMeasureProcessRequest>(request, remedical, currentFolder);
                        urmProcessRequest.UrmMeasureType = (URMMeasureType)request.UrmMeasureType;
                        if (request.SrcDPoints?.Any() ?? false)
                        {
                            urmProcessRequest.SrcDPoints = request.SrcDPoints?.Select(p => new DPoint { X = p.X, Y = p.Y })?.ToList() ?? new List<DPoint>();
                        }
                        else
                        {
                            urmProcessRequest.SrcDPoints = new List<DPoint>
                            {
                                new DPoint { X = 0, Y = 0 },
                                new DPoint { X = 0, Y = 0 },
                            };
                        }
                        urmProcessRequest.CMlength = request.CMlength;
                        urmProcessRequest.Phywidth = request.Phywidth;
                        urmProcessRequest.ROIType = (URMROIType)request.ROIType;
                        urmProcessRequest.ShellWidth = request.ShellWidth;
                        urmProcessRequest.GUID = urmProcessRequest.GetUniqueCode();

                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMMeasureProcessAsync InitURMMeasureProcessor start, remedicalCode:{remedicalCode}, Guid:{urmProcessRequest.GUID}");
                        double urmMinVal = 0;
                        double urmMaxVal = 0;
                        var output = URMAnalysisManager.MeasureProcess(remedicalCode, urmProcessRequest, out string perfusionImgBase64, ref urmMinVal, ref urmMaxVal);
                        Logger.WriteLineInfo($"AIDiagnosisService LoadURMMeasureProcessAsync InitURMMeasureProcessor end, remedicalCode:{remedicalCode}");
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService LoadURMMeasureProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService LoadURMMeasureProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return false;
        }

        /// <summary>
        /// URM测量
        /// </summary>
        /// <param name="request">URM测量后处理测量请求实体</param>
        /// <returns>URM测量后处理结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMMeasureProcessResult> URMMeasureProcessAsync(URMMeasureProcessRequest request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
                    if (remedical != null && remedical.ImgList != null && remedical.ImgList.Any() && remedical.ImgList.Any(x => x.ImgType != 0)
                        && remedical.UrmParameters != null && remedical.UrmParameters.Any())
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService URMMeasureProcessAsync start, remedicalCode:{remedicalCode}");
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        await DownloadUrmBinFiles(currentFolder, remedical.ImgList, "", remedicalCode);
                        try
                        {
                            File.WriteAllText(Path.Combine(currentFolder, "readme.txt"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        }
                        catch { }
                        var urmProcessRequest = ConvertToUrmRequest<URMMeasureProcessRequest, UrmMeasureProcessRequest>(request, remedical, currentFolder);
                        urmProcessRequest.UrmMeasureType = (URMMeasureType)request.UrmMeasureType;
                        urmProcessRequest.SrcDPoints = request.SrcDPoints?.Select(p => new DPoint { X = p.X, Y = p.Y })?.ToList() ?? new List<DPoint>();
                        urmProcessRequest.CMlength = request.CMlength;
                        urmProcessRequest.Phywidth = request.Phywidth;
                        urmProcessRequest.ROIType = (URMROIType)request.ROIType;
                        urmProcessRequest.ShellWidth = request.ShellWidth;
                        urmProcessRequest.GUID = urmProcessRequest.GetUniqueCode();

                        Logger.WriteLineInfo($"AIDiagnosisService URMMeasureProcessAsync MeasureProcess start, remedicalCode:{remedicalCode}, Guid:{urmProcessRequest.GUID}");
                        double urmMinVal = 0;
                        double urmMaxVal = 0;
                        var output = URMAnalysisManager.MeasureProcess(remedicalCode, urmProcessRequest, out string perfusionImgBase64, ref urmMinVal, ref urmMaxVal);
                        Logger.WriteLineInfo($"AIDiagnosisService URMMeasureProcessAsync MeasureProcess end, remedicalCode:{remedicalCode}, ResultFlag: {output?.ResultFlag}");
                        if (output != null)
                        {
                            var result = JsonConvert.DeserializeObject<URMMeasureProcessResult>(JsonConvert.SerializeObject(output));
                            result.PerfusionImgBase64 = perfusionImgBase64;
                            result.UrmMinVal = urmMinVal;
                            result.UrmMaxVal = urmMaxVal;
                            return result;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMMeasureProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService URMMeasureProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return new URMMeasureProcessResult();
        }

        /// <summary>
        /// URM生成后处理视频
        /// </summary>
        /// <param name="request">URM生成后处理视频请求实体</param>
        /// <returns>URM生成后处理视频结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMGenerateVideoResult> URMGenerateVideoAsync(URMGenerateVideoRequest request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    // 10-srcDenArray.bin，11-srcDirArray.bin，12-srcVelArray.bin，13-srcAngleArray.bin，14-srcMaskArray.bin，15-URMPoints.bin，16-URMPointNums.bin
                    if (remedical != null && remedical.ImgList != null && remedical.ImgList.Any() && remedical.ImgList.Any(x => x.ImgType != 0)
                        && remedical.UrmParameters != null && remedical.UrmParameters.Any())
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService URMGenerateVideoAsync start, remedicalCode:{remedicalCode}");
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        await DownloadUrmBinFiles(currentFolder, remedical.ImgList, request.NotifyUserCode, remedicalCode);
                        try
                        {
                            File.WriteAllText(Path.Combine(currentFolder, "readme.txt"), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        }
                        catch { }
                        var urmProcessRequest = ConvertToUrmRequest<URMVideoProcessRequest, DoUrmVideoProcessRequest>(request, remedical, currentFolder);
                        urmProcessRequest.URMVideoScaler = request.URMVideoScaler;
                        urmProcessRequest.URMVideoParameter = request.URMVideoParameter;
                        urmProcessRequest.URMVideoType = request.URMVideoType;
                        var pointsPath = Path.Combine(currentFolder, "URMPoints.bin");
                        var pointNumsPath = Path.Combine(currentFolder, "URMPointNums.bin");
                        urmProcessRequest.PointsDataPath = File.Exists(pointsPath) ? pointsPath : string.Empty;
                        urmProcessRequest.PointNumsDataPath = File.Exists(pointNumsPath) ? pointNumsPath : string.Empty;

                        if (!string.IsNullOrWhiteSpace(request.BackgroundImage))
                        {
                            var bgImgPath = Path.Combine(currentFolder, $"{Guid.NewGuid()}.png");
                            var coverImageWidth = 0;
                            var coverImageHeight = 0;
                            byte[] bgImageBytes = Convert.FromBase64String(request.BackgroundImage);
                            using (FileStream fs = new FileStream(bgImgPath, FileMode.Create))
                            {
                                fs.Write(bgImageBytes, 0, bgImageBytes.Length);
                            }
                            using (var image = Image.Load(bgImgPath))
                            {
                                coverImageWidth = image.Width;
                                coverImageHeight = image.Height;
                            }
                            urmProcessRequest.Roix = (int)(coverImageWidth * request.RoiXPercent);
                            urmProcessRequest.Roiy = (int)(coverImageHeight * request.RoiYPercent);
                            urmProcessRequest.Roiwidth = (int)(coverImageWidth * request.RoiWPercent);
                            urmProcessRequest.Roiheight = (int)(coverImageHeight * request.RoiHPercent);
                            urmProcessRequest.ScreenWidth = coverImageWidth;
                            urmProcessRequest.ScreenHeight = coverImageHeight;
                        }
                        urmProcessRequest.GUID = urmProcessRequest.GetUniqueCode();

                        var imgList = MergeUrmImages(remedicalCode, currentFolder, request.BackgroundImage, urmProcessRequest, request);
                        Logger.WriteLineInfo($"AIDiagnosisService URMGenerateVideoAsync DoUrmVideoProcess, remedicalCode:{remedicalCode}, imgCount:{imgList.Count}");
                        if (imgList.Count >= 150)
                        {
                            var videoInfo = ImagesToMp4(remedicalCode, currentFolder, imgList);
                            var coverImgUrl = string.Empty;
                            var videoUrl = string.Empty;
                            long videoSize = 0;
                            await Task.Delay(1000 * 2);
                            if (!string.IsNullOrWhiteSpace(videoInfo.Item1))
                            {
                                var fileName = Path.GetFileName(videoInfo.Item1);
                                var fileInfo = await UploadFileWithSizeAsync(videoInfo.Item1, fileName);
                                coverImgUrl = fileInfo.Item1;
                            }
                            if (!string.IsNullOrWhiteSpace(videoInfo.Item2))
                            {
                                var fileName = Path.GetFileName(videoInfo.Item2);
                                var fileInfo = await UploadFileWithSizeAsync(videoInfo.Item2, fileName);
                                videoUrl = fileInfo.Item1;
                                videoSize = fileInfo.Item2;
                            }
                            var resultData = new URMGenerateVideoResult
                            {
                                VideoUrl = videoUrl,
                                CoverImgUrl = coverImgUrl,
                                VideoSize = videoSize,
                            };
                            Logger.WriteLineInfo($"AIDiagnosisService URMGenerateVideoAsync end, remedicalCode:{remedicalCode}, resultData:{JsonConvert.SerializeObject(resultData)}");
                            return resultData;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMVideoProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService URMVideoProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return new URMGenerateVideoResult();
        }

        private List<string> MergeUrmImages(string remedicalCode, string currentFolder, string backgroundImageBase64, DoUrmVideoProcessRequest urmProcessRequest, URMGenerateVideoRequest request)
        {
            var leftLogoX = (int)(request.LeftImgTopLeftCornerXPercent * urmProcessRequest.ScreenWidth) - 30;
            var leftLogoY = (int)(request.LeftImgTopLeftCornerYPercent * urmProcessRequest.ScreenHeight);
            var rightLogoX = (int)(request.RightImgTopLeftCornerXPercent * urmProcessRequest.ScreenWidth) - 30;
            var rightLogoY = (int)(request.RightImgTopLeftCornerYPercent * urmProcessRequest.ScreenHeight);
            var colorBarX = (int)(request.ColorBarXPercent * urmProcessRequest.ScreenWidth);
            var colorBarY = (int)(request.ColorBarYPercent * urmProcessRequest.ScreenHeight);
            // var leftLogoX = (int)(0.15 * urmProcessRequest.ScreenWidth) - 30;
            // var leftLogoY = (int)(0.15 * urmProcessRequest.ScreenHeight) - 20;
            // var rightLogoX = (int)(0.55 * urmProcessRequest.ScreenWidth) - 30;
            // var rightLogoY = (int)(0.15 * urmProcessRequest.ScreenHeight) - 20;
            // var colorBarX = (int)(0.95 * urmProcessRequest.ScreenWidth);
            // var colorBarY = (int)(0.15 * urmProcessRequest.ScreenHeight);
            //colorbar的数值和单位
            var unit = "mm/s";
            var top = "36.0";
            var bottom = "-36.0";
            var imgList = new List<string>();
            for (var i = 0; i < 200; i++)
            {
                try
                {
                    urmProcessRequest.VideoFrame = i;
                    double urmMinVal = 0;
                    double urmMaxVal = 0;
                    var base64String = URMAnalysisManager.DoUrmVideoProcess(urmProcessRequest, ref urmMinVal, ref urmMaxVal);
                    if (!string.IsNullOrWhiteSpace(base64String))
                    {
                        if (string.IsNullOrWhiteSpace(backgroundImageBase64))
                        {
                            base64String = AddLogAndColorBar(base64String);
                            imgList.Add(base64String);
                        }
                        else
                        {
                            byte[] bgImageBytes = Convert.FromBase64String(backgroundImageBase64);
                            byte[] currImageBytes = Convert.FromBase64String(base64String);
                            byte[] logoImageBytes = Convert.FromBase64String(_logoBase64);
                            byte[] colorbarImageBytes = Convert.FromBase64String(_urmColorbarBase64);
                            using (MemoryStream streamBg = new MemoryStream(bgImageBytes))
                            using (SKBitmap bitmapBg = SKBitmap.Decode(streamBg))
                            using (MemoryStream stream2 = new MemoryStream(currImageBytes))
                            using (SKBitmap bitmap2 = SKBitmap.Decode(stream2))
                            using (MemoryStream streamLogo = new MemoryStream(logoImageBytes))
                            using (SKBitmap bitmapLogo = SKBitmap.Decode(streamLogo))
                            using (MemoryStream streamColorbar = new MemoryStream(colorbarImageBytes))
                            using (SKBitmap bitmapColorbar = SKBitmap.Decode(streamColorbar))
                            {
                                // 设置额外图片的目标大小
                                int targetWidth = 30;
                                int targetHeight = 20;
                                var bitmapLogoSmall = bitmapLogo.Resize(new SKImageInfo(targetWidth, targetHeight), SKFilterQuality.High);
                                using (var canvas = new SKCanvas(bitmapBg))
                                {
                                    canvas.DrawBitmap(bitmap2, new SKPoint(0, 0));
                                    canvas.DrawBitmap(bitmapLogoSmall, new SKPoint(leftLogoX, leftLogoY));
                                    canvas.DrawBitmap(bitmapLogoSmall, new SKPoint(rightLogoX, rightLogoY));
                                    canvas.DrawBitmap(bitmapColorbar, new SKPoint(colorBarX, colorBarY + 10));
                                    // 添加上方的黄色文字
                                    using (var paint = new SKPaint())
                                    {
                                        paint.Color = SKColors.Yellow;
                                        paint.TextSize = 14;
                                        canvas.DrawText(top, colorBarX - 8, colorBarY, paint);
                                    }
                                    // 添加下方的黄色文字
                                    using (var paint = new SKPaint())
                                    {
                                        paint.Color = SKColors.Yellow;
                                        paint.TextSize = 14;
                                        canvas.DrawText(bottom, colorBarX - 11, colorBarY + 15 + bitmapColorbar.Height + 25, paint);
                                        canvas.DrawText(unit, colorBarX - 11, colorBarY + 15 + bitmapColorbar.Height + 42, paint);
                                    }
                                    canvas.ResetMatrix(); // 重置变换矩
                                }
                                if (bitmapBg.Width % 2 == 0 && bitmapBg.Height % 2 == 0)
                                {
                                    using (MemoryStream ms = new MemoryStream())
                                    {
                                        bitmapBg.Encode(SKEncodedImageFormat.Png, 100).SaveTo(ms);
                                        byte[] imageBytes = ms.ToArray();
                                        var newPng = Convert.ToBase64String(imageBytes);
                                        if (!string.IsNullOrWhiteSpace(newPng))
                                        {
                                            imgList.Add(newPng);
                                        }
                                    }
                                }
                                else
                                {
                                    int newWidth = bitmapBg.Width % 2 == 0 ? bitmapBg.Width : bitmapBg.Width + 1;
                                    int newHeight = bitmapBg.Height % 2 == 0 ? bitmapBg.Height : bitmapBg.Height + 1;
                                    var bitmapBgSmall = bitmapBg.Resize(new SKImageInfo(newWidth, newHeight), SKFilterQuality.High);
                                    // 保存处理后的图像为PNG格式并转换为base64字符串
                                    using (MemoryStream ms = new MemoryStream())
                                    {
                                        bitmapBgSmall.Encode(SKEncodedImageFormat.Png, 100).SaveTo(ms);
                                        byte[] imageBytes = ms.ToArray();
                                        var newPng = Convert.ToBase64String(imageBytes);
                                        if (!string.IsNullOrWhiteSpace(newPng))
                                        {
                                            imgList.Add(newPng);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Logger.WriteLineInfo($"AIDiagnosisService URMGenerateVideoAsync DoUrmVideoProcess fail, remedicalCode:{remedicalCode}, frameRate:{i}, ex:{ex}");
                }
            }
            return imgList;
        }


        private string AddLogAndColorBar(string base64String)
        {
            try
            {
                //银杏叶logo
                var logoBase64 = "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";
                //colorbar
                var colorbarbase64 = "iVBORw0KGgoAAAANSUhEUgAAAAoAAACACAIAAAC9e29UAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAH/SURBVFhHpZchSJwBGIa/9z8GQ4tFGFiuDAQZCCLI0pWBmCyCmK4MjMZFm3FJhJVLY2AxiWC5NAYWkwxWrpgsK7qwhc8vvOE///feC3v4wId7uONHXg5F5iRm0/DnDOrdP6mKyj+oispXVEXlb1RF5TOqovIJVVH5E1VR+ZCqqLxPVVTepioqb1EVlVepispvqIrKr6kK5F+aBPmbJkHe0yTIXzQJ8pYmQX6nSZDXNAnygiZBfqVJkF9okiaewlwTf8Lc/70b+ZFPIUEe0CTIXZoE+YEmQb6nSZDrNAnyLU2CXKFJkEs0CfIVTQI784CdecDOPGBnHrAzD9iZB+zMA3bmATvzgJ15NJ1xTl3TGefU9epb7d/s6210Xmpf713npfb16jvxxUvtg515wM48YGcesDMP2JkH7MwDdubzQMQiVVF5maqo3KcqKq9RFZU3qYrKA6qi8g5VUXmPqqg8pCrq75YFc5Xrtzbz5ueXH9i+erRTPoai8oiqqHxOVVS+pCoqj6mKyjdUReU7qqLyhKqo/EBVVH6kKionVYFY9HnZ577Paz5v+jzwecfnPZ+HLjed9U1d09nu1M3NnQ9sH+LUP/nI53OfL30e+3zj853PE58ffH70OW1e8rnv87rPA593fR76fOTzsc+ffR75fOHz2Odbnyc2z/kX2eaIZwFK+NjQuHI3AAAAAElFTkSuQmCC";
                //colorbar的数值和单位
                var unit = "mm/s";
                var top = "36.0";
                var bottom = "-36.0";
                byte[] bytes1 = Convert.FromBase64String(base64String);
                byte[] bytes2 = Convert.FromBase64String(colorbarbase64);
                byte[] bytesExtra = Convert.FromBase64String(logoBase64);
                using (MemoryStream stream1 = new MemoryStream(bytes1))
                using (SKBitmap bitmap1 = SKBitmap.Decode(stream1))
                using (MemoryStream stream2 = new MemoryStream(bytes2))
                using (SKBitmap bitmap2 = SKBitmap.Decode(stream2))
                using (MemoryStream streamExtra = new MemoryStream(bytesExtra))
                using (SKBitmap originalBitmapExtra = SKBitmap.Decode(streamExtra))
                {
                    // 设置额外图片的目标大小
                    int targetWidth = 30;
                    int targetHeight = 20;
                    SKBitmap bitmapExtra = new SKBitmap(targetWidth, targetHeight);
                    using (SKCanvas canvasExtra = new SKCanvas(bitmapExtra))
                    {
                        // 缩放额外图片到目标大小
                        canvasExtra.DrawBitmap(originalBitmapExtra, new SKRect(0, 0, targetWidth, targetHeight));
                    }
                    int spacing = 20; // 设置间距
                    int downShift = 35; // 往下移动的距离
                    int width = bitmap1.Width + bitmap2.Width + spacing + 100;
                    int height = Math.Max(bitmap1.Height, bitmap2.Height);

                    using (SKBitmap resultBitmap = new SKBitmap(width, height))
                    {
                        using (SKCanvas canvas = new SKCanvas(resultBitmap))
                        {
                            //logo
                            canvas.DrawBitmap(bitmapExtra, 0, 0);
                            //原图
                            canvas.DrawBitmap(bitmap1, bitmapExtra.Width, 0);
                            //colorbar
                            canvas.DrawBitmap(bitmap2, bitmapExtra.Width + bitmap1.Width + spacing, downShift);
                            // 添加上方的黄色文字
                            using (var paint = new SKPaint())
                            {
                                paint.Color = SKColors.Yellow;
                                paint.TextSize = 18;
                                canvas.DrawText(top, bitmapExtra.Width + bitmap1.Width + spacing - 8, downShift - 5, paint);
                            }
                            // 添加下方的黄色文字
                            using (var paint = new SKPaint())
                            {
                                paint.Color = SKColors.Yellow;
                                paint.TextSize = 18;
                                canvas.DrawText(bottom, bitmapExtra.Width + bitmap1.Width + spacing - 9, downShift + bitmap2.Height + 15, paint);
                                canvas.DrawText(unit, bitmapExtra.Width + bitmap1.Width + spacing - 9, downShift + bitmap2.Height + 33, paint);
                            }
                        }
                        if (resultBitmap.Width % 2 == 0 && resultBitmap.Height % 2 == 0)
                        {
                            // 将拼接后的图片转换为 base64 编码字符串
                            using (SKImage image = SKImage.FromBitmap(resultBitmap))
                            using (MemoryStream outputStream = new MemoryStream())
                            {
                                image.Encode(SKEncodedImageFormat.Png, 100).SaveTo(outputStream);
                                byte[] resultBytes = outputStream.ToArray();
                                string base64ResultImage = Convert.ToBase64String(resultBytes);
                                return base64ResultImage;
                            }
                        }
                        else
                        {
                            int newWidth = resultBitmap.Width % 2 == 0 ? resultBitmap.Width : resultBitmap.Width - 1;
                            int newHeight = resultBitmap.Height % 2 == 0 ? resultBitmap.Height : resultBitmap.Height - 1;
                            var resultBitmapSmall = resultBitmap.Resize(new SKImageInfo(newWidth, newHeight), SKFilterQuality.High);
                            // 将拼接后的图片转换为 base64 编码字符串
                            using (SKImage image = SKImage.FromBitmap(resultBitmapSmall))
                            using (MemoryStream outputStream = new MemoryStream())
                            {
                                image.Encode(SKEncodedImageFormat.Png, 100).SaveTo(outputStream);
                                byte[] resultBytes = outputStream.ToArray();
                                string base64ResultImage = Convert.ToBase64String(resultBytes);
                                return base64ResultImage;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"AddLogAndColorBar error:{ex}");
                return base64String;
            }
        }

        private Tuple<string, string> ImagesToMp4(string remedicalCode, string currentFolder, List<string> imgList)
        {
            try
            {

                var mp4Path = Path.Combine(currentFolder, $"{Guid.NewGuid()}.mp4");
                var firstFrame = imgList.FirstOrDefault();
                var width = 0;
                var height = 0;
                var coverImgPath = Path.Combine(currentFolder, $"{Guid.NewGuid()}.png");
                byte[] coverImageBytes = Convert.FromBase64String(firstFrame);
                using (FileStream fs = new FileStream(coverImgPath, FileMode.Create))
                {
                    fs.Write(coverImageBytes, 0, coverImageBytes.Length);
                }
                using (var image = Image.Load(coverImgPath))
                {
                    width = image.Width;
                    height = image.Height;
                }
                var frameRate = 30;
                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 base64String in imgList)
                    {
                        byte[] imageBytes = Convert.FromBase64String(base64String);
                        using (var stream = new MemoryStream(imageBytes))
                        {
                            using (SKBitmap bitmap = SKBitmap.Decode(stream))
                            {
                                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)
                                    {
                                        Logger.WriteLineWarn($"AIDiagnosisService ImagesToMP4 WriteFrame ex:{exception}");
                                    }
                                }
                            }
                        }
                    }
                }
                return new Tuple<string, string>(coverImgPath, mp4Path);
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService ImagesToMP4 ex:{ex}");
            }
            return new Tuple<string, string>("", "");
        }

        private URMAnalysisV2Result DoURMAnalysisV2(string remedicalCode, string origialFile, string converFile, string outputFolder, Dictionary<string, string> urmParamers, string userCode)
        {
            try
            {
                var arguments = new List<string>();
                arguments.Add($"{origialFile}");
                arguments.Add($"{GetValue(urmParamers, "familyName")}");
                arguments.Add($"{GetValue(urmParamers, "typeInfo")}");
                arguments.Add($"{GetValue(urmParamers, "nativeId")}");
                arguments.Add($"{GetValue(urmParamers, "VecLens")}");
                arguments.Add($"{GetValue(urmParamers, "Mlas")}");
                arguments.Add($"{GetValue(urmParamers, "FramesGot")}");
                arguments.Add($"{GetValue(urmParamers, "CenterFrequencyMhz")}");
                arguments.Add($"{GetValue(urmParamers, "SupersonicSpeed")}");
                arguments.Add($"{GetValue(urmParamers, "FrequencyMin")}");
                arguments.Add($"{GetValue(urmParamers, "FrameRateDisplay")}");
                arguments.Add($"{GetValue(urmParamers, "Depth")}");
                arguments.Add($"{GetValue(urmParamers, "X0")}");
                arguments.Add($"{GetValue(urmParamers, "Z0")}");
                arguments.Add($"{GetValue(urmParamers, "ProbeType")}");
                arguments.Add($"{GetValue(urmParamers, "ScaleOfPixel_x")}");
                arguments.Add($"{GetValue(urmParamers, "ScaleOfPixel_y")}");
                arguments.Add($"{GetValue(urmParamers, "section")}");
                arguments.Add($"{GetValue(urmParamers, "MOCOYN")}");
                arguments.Add($"{GetValue(urmParamers, "MidProc_DeciFactor")}");
                arguments.Add($"{GetValue(urmParamers, "VectorStartForMid")}");
                arguments.Add($"{GetValue(urmParamers, "isliner")}");

                arguments.Add($"{GetValue(urmParamers, "startX")}");
                arguments.Add($"{GetValue(urmParamers, "startY")}");
                arguments.Add($"{GetValue(urmParamers, "width")}");
                arguments.Add($"{GetValue(urmParamers, "height")}");
                arguments.Add($"{GetValue(urmParamers, "CustomizedStartFrame")}");
                arguments.Add($"{GetValue(urmParamers, "CustomizedEndFrame")}");
                arguments.Add($"{GetValue(urmParamers, "RoiXPercent")}");
                arguments.Add($"{GetValue(urmParamers, "RoiYPercent")}");
                arguments.Add($"{GetValue(urmParamers, "RoiWPercent")}");
                arguments.Add($"{GetValue(urmParamers, "RoiHPercent")}");

                Logger.WriteLineInfo($"AIDiagnosisService DoURMAnalysisV2 arguments:{string.Join(";", arguments)}");
                return URMAnalysisManager.DoURMAnalysis(remedicalCode, arguments, outputFolder, converFile, userCode);
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService DoURMAnalysisV2 error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return default;
        }

        private string GetValue(Dictionary<string, string> urmParamers, string key)
        {
            foreach (var k in urmParamers.Keys)
            {
                if (k.ToLower() == key.ToLower())
                {
                    var value = urmParamers[k];
                    return string.IsNullOrWhiteSpace(value) ? "" : value;
                }
            }
            return "";
        }

        private async Task<Tuple<string, string, int>> SaveCoverImageInfo(RemedicalInfoDTO remedical, int frameIndex, string currentFolder, string userCode)
        {
            var width = 0;
            var height = 0;
            var coverImageFile = Path.Combine(currentFolder, $"{Guid.NewGuid():N}.png");
            var coverVidFile = Path.Combine(currentFolder, $"{Guid.NewGuid():N}.vid");
            var vidImageCount = 0;
            try
            {
                var vidImageUrl = remedical.TerminalImages.OriginImageUrl;
                var vidImageName = Path.GetFileName(vidImageUrl);
                var vidImageFile = Path.Combine(currentFolder, vidImageName);
                if (!File.Exists(vidImageFile))
                {
                    await DownloadToLocalAsync(vidImageUrl, vidImageFile, userCode, remedical.RemedicalCode);
                    await Task.Delay(1000 * 2);
                }

                using (var imageData = new VinnoImageData(vidImageFile, OperationMode.Open))
                {
                    vidImageCount = imageData.ImageCount;
                    if (imageData.ImageCount <= frameIndex)
                    {
                        frameIndex = 0;
                    }
                    var frameImage = imageData.GetImage(frameIndex);
                    var isCbiImage = frameImage?.Visuals?.SelectMany(x => x.Modes)?.Any(x => x.Name?.ToUpper() == "URMCBI") ?? false;
                    if (isCbiImage)
                    {
                        using (var image = Image.Load(frameImage.ImageData))
                        {
                            int imgWidth = image.Width / 2; // 获取图片宽度的一半
                                                            // 将图像左右等分
                            using (Image leftImage = image.Clone(x => x.Crop(imgWidth, image.Height)))
                            {
                                // 复制左边的部分并粘贴到右边
                                image.Mutate(x => x.DrawImage(leftImage, new Point(imgWidth, 0), 1f));
                            }
                            image.Save(coverImageFile); // 保存生成的新图片
                            width = image.Width;
                            height = image.Height;
                            if (File.Exists(coverImageFile))
                            {
                                var imageBytes = File.ReadAllBytes(coverImageFile);
                                var vinnoImageTemp = new VinnoImage(0, width, height, imageBytes);
                                vinnoImageTemp.Visuals = frameImage.Visuals;
                                var vinnoImageData = new VinnoImageData(coverVidFile, OperationMode.Create);
                                vinnoImageData.AddImage(vinnoImageTemp);
                                vinnoImageData.AddProbe(imageData.Probe);
                                vinnoImageData.AddExtendedData(imageData.ExtendedData);
                                vinnoImageData.Dispose();
                            }
                        }
                    }
                    else
                    {
                        using (var image = Image.Load(frameImage.ImageData))
                        {
                            image.Save(coverImageFile); // 保存生成的新图片
                        }
                        var vinnoImageTemp = frameImage;
                        vinnoImageTemp.Visuals = frameImage.Visuals;
                        var vinnoImageData = new VinnoImageData(coverVidFile, OperationMode.Create);
                        vinnoImageData.AddImage(vinnoImageTemp);
                        vinnoImageData.AddProbe(imageData.Probe);
                        vinnoImageData.AddExtendedData(imageData.ExtendedData);
                        vinnoImageData.Dispose();
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService SaveCoverImageInfo error, remedicalCode:{remedical?.RemedicalCode}, ex:{ex}");
            }
            return new Tuple<string, string, int>(coverVidFile, coverImageFile, vidImageCount);
        }

        private async Task InitUrmVidDetails(URMAnalysisV2Result resultData, string coverVidFile, string converFile)
        {
            if (File.Exists(coverVidFile))
            {
                var coverVid = new ImgItem
                {
                    ImgType = 5,
                };
                var fileName = Path.GetFileName(coverVidFile);
                var fileInfo = await UploadFileWithSizeAsync(coverVidFile, fileName);
                coverVid.FileToken = fileInfo.Item1;
                coverVid.FileSize = fileInfo.Item2;
                if (File.Exists(converFile))
                {
                    var fileName2 = Path.GetFileName(converFile);
                    var fileInfo2 = await UploadFileWithSizeAsync(converFile, fileName2);
                    coverVid.CoverImgUrl = fileInfo2.Item1;
                    coverVid.PreviewFileUrl = fileInfo2.Item1;
                }
                resultData.URMAnalysisDetails.Add(coverVid);
            }
        }

        private async Task InitURMAnalysisDetails(URMAnalysisV2Result resultData, string originalUrl, string currentFolder, ImgItem originalRemedicalInfo, string converImagePath)
        {
            var orginal = new ImgItem
            {
                ImgType = 0,
                FileToken = originalUrl,
                FileSize = originalRemedicalInfo.FileSize,
                CoverImgUrl = originalRemedicalInfo.CoverImgUrl,
                PreviewFileUrl = originalRemedicalInfo.PreviewFileUrl,
            };
            if (File.Exists(converImagePath))
            {
                var fileName = Path.GetFileName(converImagePath);
                var fileInfo = await UploadFileWithSizeAsync(converImagePath, fileName);
                orginal.CoverImgUrl = fileInfo.Item1;
                orginal.PreviewFileUrl = fileInfo.Item1;
            }
            resultData.URMAnalysisDetails.Add(orginal);
            var files = Directory.GetFiles(currentFolder);
            foreach (var file in files)
            {
                var fileName = Path.GetFileName(file);
                if (fileName.Contains(".bin"))
                {
                    var imgType = 0;
                    if (fileName.Contains("srcDenArray.bin"))
                    {
                        imgType = 10;
                    }
                    else if (fileName.Contains("srcDirArray.bin"))
                    {
                        imgType = 11;
                    }
                    else if (fileName.Contains("srcVelArray.bin"))
                    {
                        imgType = 12;
                    }
                    else if (fileName.Contains("srcAngleArray.bin"))
                    {
                        imgType = 13;
                    }
                    else if (fileName.Contains("srcMaskArray.bin"))
                    {
                        imgType = 14;
                    }
                    else if (fileName.Contains("URMPoints.bin"))
                    {
                        imgType = 15;
                    }
                    else if (fileName.Contains("URMPointNums.bin"))
                    {
                        imgType = 16;
                    }
                    else
                    {
                        continue;
                    }
                    var fileInfo = await UploadFileWithSizeAsync(file, fileName);
                    resultData.URMAnalysisDetails.Add(new ImgItem
                    {
                        ImgType = imgType,
                        FileToken = fileInfo.Item1,
                        FileSize = fileInfo.Item2,
                    });
                }
            }
        }

        private async Task<bool> DownloadToLocalAsync(string fileUrl, string localFile, string userCode, string remedicalCode)
        {
            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;
                    }
                }
                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)
            {
                if (ex.Message.Contains("磁盘空间不足"))
                {
                    Logger.WriteLineError($"AIDiagnosisService URMAnalysisAsync, fileToken:{fileUrl}, ex:{ex}");
                    SendDiskSpaceFullNotification(userCode, remedicalCode, ex.Message);
                }
                else
                {
                    Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync, fileToken:{fileUrl}, ex:{ex}");
                }
            }
            return false;
        }

        private void SendDiskSpaceFullNotification(string userCode, string remedicalCode, string exMessage)
        {
            try
            {
                var diskName = "";
                var currentPath = AppDomain.CurrentDomain.BaseDirectory;
                if (!string.IsNullOrWhiteSpace(currentPath))
                {
                    var pathParts = currentPath.Split('\\');
                    if (pathParts.Length >= 2)
                    {
                        diskName = pathParts[0];
                    }
                }
                var message = new DiskSpaceFullNotification
                {
                    DiskName = diskName,
                };
                var result = SendNotification(message, userCode, remedicalCode).Result;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService SendDiskSpaceFullNotification failed, ex:{ex}");
            }
        }

        private void DeleteExpiredFolders(DateTime time)
        {
            try
            {
                if (Directory.Exists(_urmTempFolder))
                {
                    DirectoryInfo theFolder = new DirectoryInfo(_urmTempFolder);
                    DirectoryInfo[] dics = theFolder.GetDirectories();
                    foreach (var item in dics)
                    {
                        var readmePath = Path.Combine(item.FullName, "readme.txt");
                        if (File.Exists(readmePath))
                        {
                            if (File.GetLastWriteTime(readmePath) < time)
                            {
                                try
                                {
                                    Directory.Delete(item.FullName, true);
                                }
                                catch { }
                            }
                        }
                        else if (item.CreationTime < time)
                        {
                            try
                            {
                                Directory.Delete(item.FullName, true);
                            }
                            catch { }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService DeleteExpiredFolders failed, ex:{ex}");
            }
        }

        private void DeleteTempFiles(string currentFolder, List<string> expectFiles)
        {
            try
            {
                var files = Directory.GetFiles(currentFolder);
                if (files?.Any() ?? false)
                {
                    foreach (var file in files)
                    {
                        if (expectFiles == null || !expectFiles.Any(x => x == file))
                        {
                            File.Delete(file);
                        }
                    }
                }
                var aviFolder = Path.Combine(currentFolder, "avi");
                if (Directory.Exists(aviFolder))
                {
                    Directory.Delete(aviFolder, true);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService DeleteTempFiles failed, currentFolder:{currentFolder}, ex:{ex}");
            }
        }

        private double ConvertToDouble(string value)
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                return 0;
            }
            if (double.TryParse(value, out double x))
            {
                return x;
            }
            return 0;
        }

        private URMRequest ConvertToUrmRequest<WingRequest, URMRequest>(WingRequest request, RemedicalInfoDTO remedical, string currentFolder)
            where WingRequest : URMProcessRequest, new()
            where URMRequest : UrmProcessRequest, new()
        {
            var denPath = Path.Combine(currentFolder, "srcDenArray.bin");
            var dirPath = Path.Combine(currentFolder, "srcDirArray.bin");
            var velPath = Path.Combine(currentFolder, "srcVelArray.bin");
            var angelPath = Path.Combine(currentFolder, "srcAngleArray.bin");
            var maskPath = Path.Combine(currentFolder, "srcMaskArray.bin");

            var urmProcessRequest = new URMRequest
            {
                FamilyName = GetValue(remedical.UrmParameters, "familyName"),
                TypeInfo = GetValue(remedical.UrmParameters, "typeInfo"),
                NativeId = GetValue(remedical.UrmParameters, "nativeId"),
                Isliner = GetValue(remedical.UrmParameters, "isliner").ToLower() == "true",
                ScaleOfPixel_x = ConvertToDouble(GetValue(remedical.UrmParameters, "ScaleOfPixel_x")),
                ScaleOfPixel_y = ConvertToDouble(GetValue(remedical.UrmParameters, "ScaleOfPixel_y")),
                Urmsrcwidth = remedical.URMSrcWidth,
                Urmsrcheight = remedical.URMSrcHeight,
                DenDataPath = File.Exists(denPath) ? denPath : string.Empty,
                DirDataPath = File.Exists(dirPath) ? dirPath : string.Empty,
                VelDataPath = File.Exists(velPath) ? velPath : string.Empty,
                AngleDataPath = File.Exists(angelPath) ? angelPath : string.Empty,
                MaskDataPath = File.Exists(maskPath) ? maskPath : string.Empty,
                Res = remedical.URMRes,

                UrmImageType = request.UrmImageType,
                UrmBlend = request.UrmBlend,
                DownsampleIndex = request.DownsampleIndex,
                IntPowerDen = request.IntPowerDen,
                IntPowerDir = request.IntPowerDir,
                SigmaGauss = request.SigmaGauss,
                VessScale = request.VessScale,
                VelMaxScaler = request.VelMaxScaler,
                VelMinScaler = request.VelMinScaler,
                Iterations = request.Iterations,
                ImgProcessVer = request.ImgProcessVer,
                ZoomOn = request.ZoomOn,
                ZoomRoix = request.ZoomRoix,
                ZoomRoiy = request.ZoomRoiy,
                ZoomRoiwidth = request.ZoomRoiwidth,
                ZoomRoiheight = request.ZoomRoiheight,
                LeftRight = request.LeftRight,
                UpDown = request.UpDown,
                UrmTraceDPoints = request.UrmTraceDPoints?.Select(p => new DPoint { X = p.X, Y = p.Y })?.ToArray(),
                Roix = request.Roix,
                Roiy = request.Roiy,
                Roiwidth = request.Roiwidth,
                Roiheight = request.Roiheight,
                ScreenWidth = request.ScreenWidth,
                ScreenHeight = request.ScreenHeight,
            };
            var scaleOfPixel_x = GetValue(remedical.UrmParameters, "URMScaleOfPixel_x");
            if (!string.IsNullOrWhiteSpace(scaleOfPixel_x))
            {
                urmProcessRequest.ScaleOfPixel_x = ConvertToDouble(scaleOfPixel_x);
            }
            var scaleOfPixel_y = GetValue(remedical.UrmParameters, "URMScaleOfPixel_y");
            if (!string.IsNullOrWhiteSpace(scaleOfPixel_y))
            {
                urmProcessRequest.ScaleOfPixel_y = ConvertToDouble(scaleOfPixel_y);
            }
            return urmProcessRequest;
        }

        /// <summary>
        /// 发送通知
        /// </summary>
        private async Task<bool> SendNotification(DiskSpaceFullNotification notification, string userCode, string remedicalCode)
        {
            if (!string.IsNullOrWhiteSpace(userCode))
            {
                var broadcastNotificationRequest = new WingInterfaceLibrary.Internal.Request.BroadcastNotificationRequest()
                {
                    ClientIds = new List<string> { userCode },
                    Message = notification,
                    JsonMessage = JsonConvert.SerializeObject(notification),
                    NotificationType = notification.NotificationType,
                    TransactionType = WingInterfaceLibrary.Enum.TransactionTypeEnum.Lab,
                    ReceiverType = WingInterfaceLibrary.Enum.ApplicantTypeEnum.Client,
                    RelevanceCode = remedicalCode
                };

                return await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);
            }
            return false;
        }

    }
}