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;

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;

        private URMAnalysisManager URMAnalysisManager
        {
            get
            {
                if (_urmAnalysisManager == null)
                {
                    _urmAnalysisManager = new URMAnalysisManager();
                }
                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 pos = $"{x},{y},{width},{height},{customizedStartFrame},{customizedEndFrame}";
            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async start, remedicalCode:{remedicalCode}, Pos:{pos}");

            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);
                        }
                        var converName = Path.GetFileName(converImageUrl);
                        var converFile = Path.Combine(currentFolder, converName);
                        if (!File.Exists(converFile))
                        {
                            await DownloadToLocalAsync(converImageUrl, converFile);
                        }
                        DeleteTempFiles(currentFolder, new List<string> { origialFile, converFile });
                        if (File.Exists(origialFile))
                        {
                            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);
                                if (result != null)
                                {
                                    resultData.IsSuccess = true;
                                    resultData.UrmPosition = pos;
                                    resultData.URMSrcWidth = result.URMSrcWidth;
                                    resultData.URMSrcHeight = result.URMSrcHeight;
                                    resultData.URMRes = result.URMRes;
                                    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<URMProcessResult> URMProcessAsync(URMProcessRequest request)
        {
            // DeleteExpiredFolders(DateTime.Now.AddHours(-6));
            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);
                        var urmProcessRequest = ConvertToUrmRequest<URMProcessRequest, UrmProcessRequest>(request, remedical, currentFolder);
                        var base64String = URMAnalysisManager.DoUrmProcess(urmProcessRequest);
                        Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync end, remedicalCode:{remedicalCode}, base64String-Length:{base64String.Length}");
                        return new URMProcessResult
                        {
                            Base64String = base64String,
                        };
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService URMProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return new URMProcessResult();
        }

        private async Task DownloadUrmBinFiles(string currentFolder, List<ImgItem> imgList)
        {
            // 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);
                    }
                }
            }
        }

        /// <summary>
        /// URM视频后处理
        /// </summary>
        /// <param name="request">URM视频后处理请求实体</param>
        /// <returns>URM视频后处理结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMVideoProcessResult> URMVideoProcessAsync(URMVideoProcessRequest request)
        {
            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);
                        var urmProcessRequest = ConvertToUrmRequest<URMVideoProcessRequest, DoUrmVideoProcessRequest>(request, remedical, currentFolder);
                        urmProcessRequest.GUID = request.RemedicalCode;
                        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;

                        var base64String = URMAnalysisManager.DoUrmVideoProcess(urmProcessRequest);
                        Logger.WriteLineInfo($"AIDiagnosisService URMVideoProcessAsync end, remedicalCode:{remedicalCode}, base64String-Length:{base64String.Length}");
                        return new URMVideoProcessResult
                        {
                            Base64String = base64String,
                        };
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMVideoProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService URMVideoProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return new URMVideoProcessResult();
        }

        /// <summary>
        /// URM测量
        /// </summary>
        /// <param name="request">URM测量后处理测量请求实体</param>
        /// <returns>URM测量后处理结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMMeasureProcessResult> URMMeasureProcessAsync(URMMeasureProcessRequest request)
        {
            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);
                        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;

                        var output = URMAnalysisManager.MeasureProcess(urmProcessRequest);
                        Logger.WriteLineInfo($"AIDiagnosisService URMMeasureProcessAsync end, remedicalCode:{remedicalCode}, ResultFlag: {output?.ResultFlag}");
                        if (output != null)
                        {
                            return JsonConvert.DeserializeObject<URMMeasureProcessResult>(JsonConvert.SerializeObject(output));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMMeasureProcessAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService URMMeasureProcessAsync finally, remedicalCode:{remedicalCode}");
            }
            return new URMMeasureProcessResult();
        }

        private URMAnalysisV2Result DoURMAnalysisV2(string remedicalCode, string origialFile, string converFile, string outputFolder, Dictionary<string, string> urmParamers)
        {
            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(arguments, outputFolder, converFile);
            }
            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 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)
        {
            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)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync, fileToken:{fileUrl}, ex:{ex}");
            }
            return false;
        }

        private void DeleteExpiredFolders(DateTime time)
        {
            if (Directory.Exists(_urmTempFolder))
            {
                DirectoryInfo theFolder = new DirectoryInfo(_urmTempFolder);
                DirectoryInfo[] dics = theFolder.GetDirectories();
                foreach (var item in dics)
                {
                    if (item.CreationTime < time)
                    {
                        Directory.Delete(item.FullName, true);
                    }
                }
            }
        }

        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,
            };
            return urmProcessRequest;
        }

    }
}