WingAIDiagnosisService/Service/AIDiagnosisService.cs

using WingServerCommon.Service;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.Enum;
using WingServerCommon.Config;
using WingServerCommon.Config.Parameters;
using WingAIDiagnosisService.Carotid.Utilities;
using Vinno.vCloud.Common.Vid2;
using WingAIDiagnosisService.Manage;
using WingAIDiagnosisService.Carotid;
using Newtonsoft.Json;
using AI.DiagSystem;
using WingServerCommon.Log;
using System.IO;
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
using AI.Common;
using System.Threading;
using AI.Common.Log;
using SkiaSharp;
using System.Net.Http;
using System.Net;
using WingInterfaceLibrary.Request.Storage;
using WingInterfaceLibrary.Result.AIDiagnosis;
using WingInterfaceLibrary.Request.AIDiagnosis;
using WingInterfaceLibrary.DTO.Record;
using WingInterfaceLibrary.DTO.Comment;
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;
using System.Net.Http.Headers;
using WingAIDiagnosisService.Common;
using WingInterfaceLibrary.Interface.DBInterface;
using WingInterfaceLibrary.Request.DBRequest;
using WingInterfaceLibrary.DTO.DiagnosisResult;
using WingInterfaceLibrary.Request.RemedicalAISelected;
using ContourModifyUtils;
using WingInterfaceLibrary.Request.DBCopy;
using Newtonsoft.Json.Linq;

namespace WingAIDiagnosisService.Service
{
    /// <summary>
    /// AI诊断服务
    /// </summary>
    public partial class AIDiagnosisService : JsonRpcService, IAIDiagnosisService
    {
        private EnumPerformance _workerLevel = EnumPerformance.Medium;
        private int _batchImageSize = 16;
        private int _sleepTime = 400;
        private readonly string _tempFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DiagnosisTemp");
        private AIDiagSystem _diagSystem;
        private AILesionCompareUtils _lesionCompareUtil;
        private RecognizeCarotidType _recognizeCarotidType = new RecognizeCarotidType();
        //识别左右颈是否初始化成功
        private static bool _recognizeCarotidTypeCanBeUse = false;
        static HttpClient _httpClient = new HttpClient();
        private IAuthenticationService _authenticationService;
        private IStorageService _storageService;
        private readonly string _carotidName = "CarotidPlaqueDetect";
        private int _contourInterval = 10;
        private IDiagnosisResultDBService _diagnosisResultDBService;

        /// <summary>
        /// Init service
        /// </summary>
        public override void Load(JsonRpcClientPool jsonRpcClientPool)
        {
            base.Load(jsonRpcClientPool);
            _authenticationService = GetProxy<IAuthenticationService>();
            _storageService = GetProxy<IStorageService>();
            _workerLevel = (EnumPerformance)ConfigurationManager.GetParammeter<IntParameter>("AI", "WorkerLevel").Value;
            _batchImageSize = ConfigurationManager.GetParammeter<IntParameter>("AI", "BatchImageSize").Value;
            _contourInterval = ConfigurationManager.GetParammeter<IntParameter>("AI", "ContourInterval").Value;
            _httpClient.Timeout = TimeSpan.FromMinutes(15);
            _diagnosisResultDBService = GetProxy<IDiagnosisResultDBService>();
            InitAISystem();
            //初始化识别左右颈 
            _recognizeCarotidTypeCanBeUse = _recognizeCarotidType.Initialization();
            var keyPointDistanceThreshold = ConfigurationManager.GetParammeter<IntParameter>("AI", "KeyPointDistanceThreshold").Value;
            var dragStartPointCatchDistanceThreshold = ConfigurationManager.GetParammeter<IntParameter>("AI", "DragStartPointCatchDistanceThreshold").Value;
            ContourModifyHelper.KeyPointDistanceThreshold = keyPointDistanceThreshold;
            ContourModifyHelper.DragStartPointCatchDistanceThreshold = dragStartPointCatchDistanceThreshold;
        }

        private void InitAISystem()
        {
            var modeFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "AIDiagnosis\\Networks");
            _diagSystem = new AIDiagSystem(_workerLevel, modeFilePath, EnumInferWorkName.Default, false, true, true);
            if (_diagSystem != null)
            {
                _diagSystem.NotifyError += AIdiagSystem_NotifyError;
                _diagSystem.NotifyLog += AIdiagSystem_NotifyLog;
            }
            _lesionCompareUtil = new AILesionCompareUtils();
        }

        /// <summary>
        /// 查询杏聆荟支持的AI模块
        /// </summary>
        /// <param name="request">查询杏聆荟支持的AI模块请求实体</param>
        /// <returns></returns>
        /// <show>false</show>
        public async Task<IList<string>> FindDiagnosisModulesAsync(TokenRequest request)
        {
            try
            {
                var moduleNames = AIDiagSystem.GetValidModuleNamesForVclound() ?? new List<EnumAIModuleNames>();
                var resultData = moduleNames.Select(x => x.ToString()).ToList();
                if (!resultData.Contains(_carotidName))
                {
                    resultData.Remove("CarotidArtery");
                    resultData.Add(_carotidName);
                }
                return await Task.FromResult(resultData.Distinct().ToList());
            }
            catch (Exception)
            {
                return new List<string>();
            }
        }

        /// <summary>
        /// 图像诊断
        /// </summary>
        /// <param name="request">图像诊断请求实体</param>
        /// <returns>图像诊断结果</returns>
        /// <show>false</show>
        public async Task<DiagnosisImageResult> DiagnosisImageAsync(DiagnosisImageRequest request)
        {
            try
            {
                var relationCode = request.RelationCode;
                var fileUrl = request.FileToken;
                var localFile = "";
                if (!string.IsNullOrWhiteSpace(request.DiskPath))
                {
                    localFile = request.DiskPath;
                }
                else
                {
                    localFile = await DownloadAsync(fileUrl);
                }
                if (File.Exists(localFile))
                {
                    if (_diagSystem == null)
                    {
                        InitAISystem();
                    }
                    using (var imageData = new VinnoImageData(localFile, OperationMode.Open))
                    {
                        if (DiagnosisHelper.IsCarotid(imageData))
                        {
                            if (imageData.ImageCount > DiagnosisHelper.CarotidMinImageCounts)
                            {
                                //颈动脉
                                var result = await CarotidDiagnosis(imageData);
                                var resultData = new DiagnosisImageResult()
                                {
                                    DiagnosisOrgans = new List<DiagnosisOrganEnum>() { DiagnosisOrganEnum.CarotidArtery },
                                    CarotidResult = result
                                };
                                return resultData;
                            }
                        }
                        else
                        {
                            //乳腺、肝脏
                            var results = NormalDiagnosis(relationCode, fileUrl, imageData);
                            //AI实体有很多参数仅支持get，为了方便后续反序列化，db入库前先做个转换
                            var diagnosisPerImages = results.Select(x => new AIDiagnosisPerImageModel(x.Key, x.Value, 1)).ToList();
                            var organs = GetDiagnosisOrgans(diagnosisPerImages);
                            if (organs.Contains(DiagnosisOrganEnum.Breast))
                            {
                                var breastCount = diagnosisPerImages.Where(a => a.PriorityScore > 0).Count();
                                var totalCount = results.Count;
                                var breastRate = breastCount * 1.0 / totalCount * 1.0;
                                if (breastRate <= 1 / 3.0)
                                {
                                    return new DiagnosisImageResult
                                    {
                                        DiagnosisConclusion = DiagnosisConclusionEnum.Unrecognized,
                                        DiagnosisResult = null,
                                        DiagnosisOrgans = new List<DiagnosisOrganEnum>(),
                                    };
                                }
                            }
                            await AddDiagnosisResultInfosAsync(relationCode, fileUrl, diagnosisPerImages);
                            //轮廓线分隔处理
                            diagnosisPerImages = results.Select(x => new AIDiagnosisPerImageModel(x.Key, x.Value, _contourInterval)).ToList();
                            var diagnosisResult = Newtonsoft.Json.JsonConvert.DeserializeObject<List<AIDiagnosisPerImageDTO>>(Newtonsoft.Json.JsonConvert.SerializeObject(diagnosisPerImages));
                            var resultData = new DiagnosisImageResult()
                            {
                                DiagnosisConclusion = (DiagnosisConclusionEnum)GetDiagnosisConclusion(diagnosisPerImages),
                                DiagnosisResult = diagnosisResult,
                                DiagnosisOrgans = organs,
                            };
                            return resultData;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"DiagnosisImageAsync err {ex}");
            }
            return new DiagnosisImageResult();
        }

        private class TempAIResult
        {
            public int Index { get; set; }

            public AIDiagnosisPerImageModel ImageDiagResult { get; set; }

        }

        private class Description : AI.Common.IDescription
        {


            public EnumDescriptionType Type { get; set; }

            // 其他必要的实现，根据您的接口定义
        }

        private class DescriptionConverter : JsonConverter
        {
            public override bool CanConvert(Type objectType)
            {
                return (objectType == typeof(AI.Common.IDescription));
            }

            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                throw new NotImplementedException();
            }

            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                var jsonObject = JObject.Load(reader);
                var description = new Description();
                serializer.Populate(jsonObject.CreateReader(), description);
                return description;
            }
        }

        public async Task<DiagnosisImageResult> GetDiagnosisImageResultByAIResultAsync(GetDiagnosisImageResultByAIResultRequest request)
        {
            try
            {
                var aiResult = request.AiResult;
                var relationCode = request.RelationCode;
                var fileUrl = request.FileUrl;
                var createTime = request.CreateTime;
                var upateTime = request.UpdateTime;
                //乳腺、肝脏
                // var settings = new JsonSerializerSettings
                // {
                //     Converters = new List<JsonConverter> { new DescriptionConverter() }
                // };
                var aiDiagResultPerImgList = JsonConvert.DeserializeObject<List<TempAIResult>>(aiResult);
                foreach (var item in aiDiagResultPerImgList)
                {
                    item.ImageDiagResult.Index = item.Index;
                }
                var diagnosisPerImages = aiDiagResultPerImgList.Select(x => x.ImageDiagResult)?.ToList() ?? new List<AIDiagnosisPerImageModel>();
                foreach (var perImage in diagnosisPerImages)
                {
                    foreach (var perOrgan in perImage.DiagResultsForEachOrgan)
                    {
                        var detectedObjects = new List<WingAIDiagnosisService.Manage.AIDetectedObject>();
                        foreach (var perDetectedObject in perOrgan.DetectedObjects)
                        {
                            if (perDetectedObject.Descriptions != null && perDetectedObject.Descriptions.Any())
                            {
                                foreach (var item in perDetectedObject.Descriptions)
                                {
                                    item.Type = item.DescriptionType;
                                    item.Value = item.DescriptionValue;
                                }
                            }

                            detectedObjects.Add(perDetectedObject);
                        }
                        perOrgan.DetectedObjects = detectedObjects;
                    }
                }
                var organs = GetDiagnosisOrgans(diagnosisPerImages);
                await AddDiagnosisResultInfosAsync(relationCode, fileUrl, diagnosisPerImages, createTime, upateTime, false);
                //轮廓线分隔处理
                foreach (var perImage in diagnosisPerImages)
                {
                    foreach (var perOrgan in perImage.DiagResultsForEachOrgan)
                    {
                        var organContours = new List<WingAIDiagnosisService.Manage.AIDiagnosisPoint2D>();
                        if (perOrgan.OrganContour != null && perOrgan.OrganContour.Count > 0)
                        {
                            var coutours = perOrgan.OrganContour;
                            if (coutours != null && coutours.Count > 0)
                            {
                                for (var i = 0; i < coutours.Count; i++)
                                {
                                    if (i % _contourInterval == 0)
                                    {
                                        organContours.Add(coutours[i]);
                                    }
                                }
                            }
                        }
                        perOrgan.OrganContours = organContours;
                        perOrgan.OrganContour = new List<Manage.AIDiagnosisPoint2D>();
                        var detectedObjects = new List<WingAIDiagnosisService.Manage.AIDetectedObject>();
                        foreach (var perDetectedObject in perOrgan.DetectedObjects)
                        {
                            var contours = new List<WingAIDiagnosisService.Manage.AIDiagnosisPoint2D>();
                            if (perDetectedObject.Contour != null && perDetectedObject.Contour.Count > 0)
                            {
                                var coutours = perDetectedObject.Contour;
                                if (coutours != null && coutours.Count > 0)
                                {
                                    for (var i = 0; i < coutours.Count; i++)
                                    {
                                        if (i % _contourInterval == 0)
                                        {
                                            contours.Add(coutours[i]);
                                        }
                                    }
                                }
                            }
                            perDetectedObject.Contours = contours;
                            perDetectedObject.Contour = new List<Manage.AIDiagnosisPoint2D>();

                            detectedObjects.Add(perDetectedObject);
                        }
                        perOrgan.DetectedObjects = detectedObjects;
                    }
                }
                var diagnosisResult = Newtonsoft.Json.JsonConvert.DeserializeObject<List<AIDiagnosisPerImageDTO>>(Newtonsoft.Json.JsonConvert.SerializeObject(diagnosisPerImages));
                var resultData = new DiagnosisImageResult()
                {
                    DiagnosisConclusion = (DiagnosisConclusionEnum)GetDiagnosisConclusion(diagnosisPerImages),
                    DiagnosisResult = diagnosisResult,
                    DiagnosisOrgans = organs,
                };
                return resultData;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn("GetDiagnosisImageResultByAIResultAsync" + ex);
                return null;
            }
        }

        public async Task<CarotidResultDTO> GetCarotidResultAsync(GetCarotidResultRequest request)
        {
            try
            {
                var surfaceToken = request.SurfaceToken;
                var mdlToken = request.MdlToken;
                CarotidScanTypeEnum carotidScanType = request.CarotidScanType;
                CarotidScanDirectionEnum carotidScanDirection = request.CarotidScanDirection;
                var measureImageFiles = request.MeasureImageFiles;
                var measureResult = request.MeasureResult;
                var surfaceImageList = await SurfaceFileByUrl(surfaceToken);
                var result = new CarotidResultDTO
                {
                    CarotidScanType = carotidScanType,
                    CarotidScanDirection = carotidScanDirection,
                    SurfaceFile = surfaceToken,
                    SurfaceFileSize = 0,
                    CDNSurfaceFile = surfaceToken,//源站地址
                    MdlFileSize = 0,
                    MdlFile = mdlToken,//源站地址
                    CDNMdlFile = mdlToken,
                    MeasureImageFiles = measureImageFiles,
                    MeasureResult = measureResult,
                    SurfaceImageList = surfaceImageList,
                };
                return result;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn("GetCarotidResultAsync" + ex);
                return null;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="baseUrl"></param>
        private async Task<List<string>> SurfaceFileByUrl(string baseUrl)
        {
            var fileUrls = new List<string>();
            //todo 自建存储
            try
            {
                using (var httpClient = new HttpClient())
                {
                    using (var stream = await httpClient.GetStreamAsync(baseUrl))
                    {
                        var reader = new Carotid3DStreamReader(stream);
                        var width = reader.ReadInt();
                        var height = reader.ReadInt();
                        var depth = reader.ReadInt();
                        var physicalData = VinnoCarotid3DPhysicalData.FromBytes(reader.ReadBytes());
                        var imageCount = reader.ReadInt();
                        var fileName = $"{Guid.NewGuid():N}";
                        for (var i = 0; i < imageCount; i++)
                        {
                            var readBytes = reader.ReadBytes();
                            if (readBytes.Any())
                            {
                                using var img = new Mat();
                                CvInvoke.Imdecode(readBytes, ImreadModes.Color, img);
                                var buf = new Emgu.CV.Util.VectorOfByte();
                                using var image = img.ToImage<Gray, byte>();
                                CvInvoke.Imencode(".jpg", image, buf, new KeyValuePair<ImwriteFlags, int>(ImwriteFlags.JpegQuality, 80));
                                var jpgByte = buf.ToArray();
                                var localPath = Path.Combine(_tempFolder, $"{fileName}_{i + 1}.jpg");
                                File.WriteAllBytes(localPath, jpgByte);
                                var fileUrl = await UploadFileAsync(localPath, Path.GetFileName(localPath));
                                fileUrls.Add(fileUrl);
                                File.Delete(localPath);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn("SurfaceFileByUrl" + ex);
                fileUrls = new List<string>();
            }
            return fileUrls;
        }


        /// <summary>
        /// 生成AI报告
        /// </summary>
        /// <param name="request">生成AI报告请求实体</param>
        /// <returns></returns>
        /// <show>false</show>
        public async Task<DiagnosisReportResult> DiagnosisReportAsync(DiagnosisReportRequest request)
        {
            try
            {
                if (request.Organ == DiagnosisOrganEnum.CarotidArtery)
                {
                    var result = await GetCarotidAIMeasureResult(request);
                    return result;
                }
                else
                {
                    var manager = await CreateDiagnosisManagerAsync(request);
                    var reportPerImages = manager.GetReportResults();
                    var diagnosisConclusion = GetDiagnosisConclusion(reportPerImages);
                    var diagnosisOrgans = GetDiagnosisOrgans(reportPerImages);

                    var diagnosisResult = new List<DiagnosisPerImageDTO>();
                    foreach (var item in reportPerImages)
                    {
                        var aiFileToken = await UploadFileAsync(item.AILocalImagePath, Path.GetFileName(item.AILocalImagePath));
                        var previewPath = Path.Combine(_tempFolder, $"{Guid.NewGuid():N}.jpg");
                        CreateThumbnailFile(item.AILocalImagePath, 100, 30, previewPath);
                        var previewUrl = await UploadFileAsync(previewPath, Path.GetFileName(previewPath));

                        var perImageJson = Newtonsoft.Json.JsonConvert.SerializeObject(item);
                        var perImageResult = Newtonsoft.Json.JsonConvert.DeserializeObject<DiagnosisPerImageDTO>(perImageJson);
                        perImageResult.RemedicalCode = item.RemedicalCode;
                        perImageResult.DataType = (RemedicalFileDataTypeEnum)item.DataType;
                        perImageResult.Pixel = item.Pixel;
                        perImageResult.AIFileToken = aiFileToken;
                        perImageResult.AIPreviewFileToken = previewUrl;
                        perImageResult.PerImageJson = perImageJson;
                        var conclusion = GetDiagnosisConclusion(new List<DiagnosisPerImageModel> { item });
                        var organs = GetDiagnosisOrgans(new List<DiagnosisPerImageModel> { item });
                        perImageResult.DiagnosisConclusion = (DiagnosisConclusionEnum)conclusion;
                        perImageResult.DiagnosisOrgans = organs;
                        diagnosisResult.Add(perImageResult);
                    }
                    return new DiagnosisReportResult
                    {
                        DiagnosisConclusion = (DiagnosisConclusionEnum)diagnosisConclusion,
                        DiagnosisResult = diagnosisResult,
                    };
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIService DiagnosisReport err, {ex}");
            }
            return new DiagnosisReportResult();
        }

        /// <summary>
        /// 查询AI诊断结论
        /// </summary>
        /// <param name="request">查询AI诊断结论请求实体</param>
        /// <returns></returns>
        /// <show>false</show>
        public async Task<GetDiagnosisConclusionResult> GetDiagnosisConclusionAsync(GetDiagnosisConclusionRequest request)
        {
            var preImage = Newtonsoft.Json.JsonConvert.DeserializeObject<DiagnosisPerImageModel>(request.PerImageJson);
            var conclusion = GetDiagnosisConclusion(new List<DiagnosisPerImageModel> { preImage });
            var organs = GetDiagnosisOrgans(new List<DiagnosisPerImageModel> { preImage });
            var resultData = new GetDiagnosisConclusionResult
            {
                DiagnosisConclusion = (DiagnosisConclusionEnum)conclusion,
                DiagnosisOrgans = organs,
            };
            return await Task.FromResult(resultData);
        }

        /// <summary>
        /// 查询AI相关枚举集合
        /// </summary>
        /// <param name="request">查询AI相关枚举集合请求实体</param>
        /// <returns>AI相关枚举集合</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<GetDiagnosisEnumItemsResult> GetDiagnosisEnumItemsAsync(GetDiagnosisEnumItemsRequest request)
        {
            var diagnosisItems = new List<EnumItemDTO>();
            //病灶
            diagnosisItems.Add(GetEnumItem(typeof(DiagnosisBreastLabelEnum), "Breast", new List<string> { "BIRads1" }));
            diagnosisItems.Add(GetEnumItem(typeof(DiagnosisLiverLabelEnum), "Liver", new List<string> { "BIRads1" }));
            diagnosisItems.Add(GetEnumItem(typeof(AIThyroidLabelEnum), "Thyroid", new List<string> { "TIRADS0" }));
            //病灶特性描述
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesShapeValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesOrientationValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesEchoPatternValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesLesionBoundaryValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesMarginValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumCalcificationsValue), "Calcification"));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesLiverShapeValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesLiverBoundaryValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesLiverEchoTextureValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesThyroidEchoPatternValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesThyroidShapeValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesThyroidMarginValue)));
            diagnosisItems.Add(GetEnumItem(typeof(EnumDesThyroidEchogenicFociValue)));
            //局灶和弥漫区分
            diagnosisItems.Add(GetEnumItem(typeof(DiagnosisBreastLabelEnum), "BreastLocalLesion", includeFields: new List<string> { "Lipomyoma", "BIRads2", "BIRads3" }));
            diagnosisItems.Add(GetEnumItem(typeof(DiagnosisBreastLabelEnum), "BreastDiffuseLesion", includeFields: new List<string> { "BIRads4A", "BIRads4B", "BIRads4C", "BIRads5" }));
            diagnosisItems.Add(GetEnumItem(typeof(DiagnosisLiverLabelEnum), "LiverLocalLesion", includeFields: new List<string> { "Hyperechoic", "HHE", "CYST", "PossibleCancer" }));
            diagnosisItems.Add(GetEnumItem(typeof(DiagnosisLiverLabelEnum), "LiverDiffuseLesion", includeFields: new List<string> { "FattyLiver", "DiffuseLesions", "Cirrhosis", "PCLD" }));
            diagnosisItems.Add(GetEnumItem(typeof(AIThyroidLabelEnum), "ThyroidLocalLesion", includeFields: new List<string> { "TIRADS2", "TIRADS3", "TIRADS4a", "TIRADS4b", "TIRADS4c", "TIRADS5" }));
            diagnosisItems.Add(GetEnumItem(typeof(AIThyroidLabelEnum), "ThyroidDiffuseLesion", includeFields: new List<string> { "DiffuseDisease" }));

            var resultData = new GetDiagnosisEnumItemsResult { Source = diagnosisItems };
            return await Task.FromResult(resultData);
        }

        private EnumItemDTO GetEnumItem(Type enumType, string keyCode = "", List<string> excludeFields = null, List<string> includeFields = null)
        {
            keyCode = !string.IsNullOrWhiteSpace(keyCode) ? keyCode : enumType.Name.ToString().Replace("EnumDes", "").Replace("Enum", "").Replace("Value", "");
            var enumNames = Enum.GetNames(enumType).ToList();
            if (excludeFields != null && excludeFields.Any())
            {
                enumNames = enumNames.Except(excludeFields).ToList();
            }
            if (includeFields != null && includeFields.Any())
            {
                enumNames = enumNames.Intersect(includeFields).ToList();
            }
            var children = new List<EnumFieldDTO>();
            foreach (var val in enumNames)
            {
                var id = (int)enumType.GetField(val).GetValue(val);
                var fieldValue = val.ToString();
                if (enumType == typeof(DiagnosisLiverLabelEnum) && fieldValue == "Hyperechoic")
                {
                    fieldValue = "LiverHyperechoic";
                }
                children.Add(new EnumFieldDTO
                {
                    Id = id,
                    Value = fieldValue,
                });
            }
            return new EnumItemDTO
            {
                Code = keyCode,
                Children = children,
            };
        }

        /// <summary>
        /// 查询病灶轮廓的关键点 
        /// </summary>
        /// <param name="request">查询病灶轮廓的关键点请求实体</param>
        /// <returns>关键点集合</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<List<DiagnosisKeyPointDTO>> GetKeyPointsOfContourAsync(GetKeyPointsOfContourRequest request)
        {
            var contourPoints = request.Contours.Select(c => new Point2D
            {
                X = c.X,
                Y = c.Y
            }).ToArray();
            var ls = request.LesionSize;
            var horizontalP1 = new Point2D(ls.HorizontalPoint1.X, ls.HorizontalPoint1.Y);
            var horizontalP2 = new Point2D(ls.HorizontalPoint2.X, ls.HorizontalPoint2.Y);
            var verticalP1 = new Point2D(ls.VerticalPoint1.X, ls.VerticalPoint1.Y);
            var verticalP2 = new Point2D(ls.VerticalPoint2.X, ls.VerticalPoint2.Y);
            var lesionSize = new LesionSize(horizontalP1, horizontalP2, verticalP1, verticalP2);
            // lesionSize.HorizontalLengthInPixel = ls.HorizontalLengthInPixel;
            // lesionSize.VerticalLengthInPixel = ls.VerticalLengthInPixel;
            var aiResult = ContourModifyHelper.KeyPointsOfContour(contourPoints, lesionSize);
            var resultData = KeyPointToDto(aiResult);
            return await Task.FromResult(resultData);
        }

        /// <summary>
        /// 移动光标，查询受影响关键点 
        /// </summary>
        /// <param name="request">移动光标，查询受影响关键点请求实体</param>
        /// <returns>受影响关键点下标</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<List<int>> AffectedKeyPointsByDragActionAsync(AffectedKeyPointsByDragActionRequest request)
        {
            var origKeyPoints = request.KeyPoints.Select(c => new KeyPointInfo
            {
                Type = (EnumKeyPointType)c.Type,
                IndexInContour = c.IndexInContour,
                Point = new Point2D(c.Point.X, c.Point.Y)
            }).ToArray();
            var mousePoint = new Point2D(request.MousePoint.X, request.MousePoint.Y);
            var resultData = ContourModifyHelper.AffectedKeyPointsByDragAction(origKeyPoints, mousePoint).ToList();
            return await Task.FromResult(resultData);
        }

        /// <summary>
        /// 拖动光标，查询所有轮廓点和关键点
        /// </summary>
        /// <param name="request">拖动光标，查询所有轮廓点和关键点请求实体</param>
        /// <returns>所有轮廓点和关键点</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<ContourAndKeyPointsAfterDragResult> ContourAndKeyPointsAfterDragAsync(ContourAndKeyPointsAfterDragRequest request)
        {
            var origContourPoints = request.Contours.Select(c => new Point2D
            {
                X = c.X,
                Y = c.Y
            }).ToArray();
            var origKeyPoints = request.KeyPoints.Select(c => new KeyPointInfo
            {
                Type = (EnumKeyPointType)c.Type,
                IndexInContour = c.IndexInContour,
                Point = new Point2D(c.Point.X, c.Point.Y)
            }).ToArray();
            var dragStartPoint = new Point2D(request.StartPoint.X, request.StartPoint.Y);
            var dragEndPoint = new Point2D(request.EndPoint.X, request.EndPoint.Y);
            ContourModifyHelper.ContourAndKeyPointsAfterDrag(origContourPoints, origKeyPoints, dragStartPoint, dragEndPoint
                , out Point2D[] dstContourPoints, out KeyPointInfo[] dstKeyPoints, out int[] affectedKeyPointIndexes);

            var dstContours = PointToDto(dstContourPoints);
            var dstKeys = KeyPointToDto(dstKeyPoints);
            var resultData = new ContourAndKeyPointsAfterDragResult
            {
                DstContours = dstContours,
                DstKeyPoints = dstKeys,
                AffectedKeyPointIndexes = affectedKeyPointIndexes.ToList(),
            };
            return await Task.FromResult(resultData);
        }

        /// <summary>
        /// 画轮廓模式，查询鼠标位置到轮廓线的最短距离
        /// </summary>
        /// <param name="request">画轮廓模式，查询鼠标位置到轮廓线的最短距离请求实体</param>
        /// <returns>鼠标离轮廓线的距离，高亮点的下标</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<MinimumDistanceToContourPointsResult> MinimumDistanceToContourPointsAsync(MinimumDistanceToContourPointsRequest request)
        {
            var origContourPoints = request.ContourPoints.Select(c => new Point2D
            {
                X = c.X,
                Y = c.Y
            }).ToArray();
            var mousePoint = new Point2D(request.MousePoint.X, request.MousePoint.Y);
            var distance = ContourModifyHelper.MinimumDistanceToContourPoints(origContourPoints, mousePoint, out int closestPointIndex);
            var resultData = new MinimumDistanceToContourPointsResult
            {
                DistanceCaught = distance,
                ClosestPointIndex = closestPointIndex,
            };
            return await Task.FromResult(resultData);
        }

        /// <summary>
        /// 画轮廓模式，合并新旧轮廓
        /// </summary>
        /// <param name="request">画轮廓模式，查询鼠标位置到轮廓线的最短距离请求实体</param>
        /// <returns>合并后的完整轮廓线，合并后的横纵径尺寸结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<ContourMergeResult> ContourMergeAsync(ContourMergeRequest request)
        {
            var origContourPoints = request.ContourPoints.Select(c => new Point2D
            {
                X = c.X,
                Y = c.Y
            }).ToArray();
            var ls = request.LesionSize;
            var horizontalP1 = new Point2D(ls.HorizontalPoint1.X, ls.HorizontalPoint1.Y);
            var horizontalP2 = new Point2D(ls.HorizontalPoint2.X, ls.HorizontalPoint2.Y);
            var verticalP1 = new Point2D(ls.VerticalPoint1.X, ls.VerticalPoint1.Y);
            var verticalP2 = new Point2D(ls.VerticalPoint2.X, ls.VerticalPoint2.Y);
            var lesionSize = new LesionSize(horizontalP1, horizontalP2, verticalP1, verticalP2);
            // lesionSize.HorizontalLengthInPixel = ls.HorizontalLengthInPixel;
            // lesionSize.VerticalLengthInPixel = ls.VerticalLengthInPixel;
            var drawingNewContourPoints = request.DrawingNewContourPoints.Select(c => new Point2D
            {
                X = c.X,
                Y = c.Y
            }).ToArray();
            var aiResult = ContourModifyHelper.ContourMerge(origContourPoints, lesionSize, drawingNewContourPoints, out Point2D[] dstContourPoints, out LesionSize dstLesionSize);
            var dstContours = PointToDto(dstContourPoints);
            var resultData = new ContourMergeResult
            {
                DstContours = dstContours,
                DstLesionSize = new WingInterfaceLibrary.DTO.Comment.AIDiagnosisLesionSize
                {
                    HorizontalPoint1 = new WingInterfaceLibrary.DTO.Comment.AIDiagnosisPoint2D { X = dstLesionSize.HorizontalPoint1.X, Y = dstLesionSize.HorizontalPoint1.Y },
                    HorizontalPoint2 = new WingInterfaceLibrary.DTO.Comment.AIDiagnosisPoint2D { X = dstLesionSize.HorizontalPoint2.X, Y = dstLesionSize.HorizontalPoint2.Y },
                    VerticalPoint1 = new WingInterfaceLibrary.DTO.Comment.AIDiagnosisPoint2D { X = dstLesionSize.VerticalPoint1.X, Y = dstLesionSize.VerticalPoint1.Y },
                    VerticalPoint2 = new WingInterfaceLibrary.DTO.Comment.AIDiagnosisPoint2D { X = dstLesionSize.VerticalPoint2.X, Y = dstLesionSize.VerticalPoint2.Y },
                    HorizontalLengthInPixel = dstLesionSize.HorizontalLengthInPixel,
                    VerticalLengthInPixel = dstLesionSize.VerticalLengthInPixel,
                },
            };
            return await Task.FromResult(resultData);
        }

        /// <summary>
        /// 获取颈动脉ai报告数据
        /// </summary>
        /// <param name="request">生成AI报告请求实体</param>
        /// <returns></returns>
        private async Task<DiagnosisReportResult> GetCarotidAIMeasureResult(DiagnosisReportRequest request)
        {
            var result = new DiagnosisReportResult()
            {
                DiagnosisConclusion = DiagnosisConclusionEnum.NoObviousLesion
            };
            var orderedExamDatas = request.RemedicalList.OrderByDescending(m => m.CarotidResult?.CarotidScanType).Where(m => m.CarotidResult?.MeasureImageFiles != null && m.CarotidResult.MeasureImageFiles.Count > 0);
            if (orderedExamDatas?.Count() > 0)
            {
                DiagnosisRemicalDTO leftData = null;
                //left
                var leftExamDatas = orderedExamDatas.Where(m => m.CarotidResult.CarotidScanType == CarotidScanTypeEnum.CarotidLeft);
                if (leftExamDatas.Any())
                {
                    foreach (var leftItem in leftExamDatas)
                    {
                        if (string.IsNullOrEmpty(leftItem.CarotidResult.MeasureResult))
                        {
                            result.DiagnosisConclusion = DiagnosisConclusionEnum.Unrecognized;
                            continue;
                        }
                        //leftItem.CarotidResult.MeasureResult = "{\"IntimaResult\":{\"IsSuccess\":true,\"AntIntima\":{\"IntimaThick\":0.0,\"IsSuccess\":false},\"PostIntima\":{\"IntimaThick\":0.75,\"IsSuccess\":true}},\"IsYImageSuccess\":false,\"PlaqueResult\":{\"PlaquePostion\":0,\"PlaqueCountType\":2,\"PlaqueType\":0,\"PlaqueWidth\":1.75,\"PlaqueHeight\":3.76,\"Stenosis\":10.37,\"IsSuccess\":true}}";
                        var measureResult = JsonConvert.DeserializeObject<CarotidAIMeasureResult>(leftItem.CarotidResult.MeasureResult) ?? new CarotidAIMeasureResult();
                        if (measureResult.PlaqueResult?.PlaqueCountType != Carotid.Utilities.DetectPlaque.PlaqueCountType.NoPlaque)
                        {
                            leftData = leftItem;
                            result.DiagnosisConclusion = DiagnosisConclusionEnum.Other;
                            break;
                        }
                    }
                    if (leftData == null)
                    {
                        leftData = leftExamDatas.First();
                    }
                }
                if (leftData != null)
                {
                    result.CarotidResult.Add(leftData);
                }
                //right
                float intimaThickStandard = 1.0f;
                DiagnosisRemicalDTO rightData = null;
                var rightExamDatas = orderedExamDatas.Where(m => m.CarotidResult.CarotidScanType == CarotidScanTypeEnum.CarotidRight);
                if (rightExamDatas.Any())
                {
                    foreach (var rightItem in rightExamDatas)
                    {
                        if (string.IsNullOrEmpty(rightItem.CarotidResult.MeasureResult))
                        {
                            result.DiagnosisConclusion = DiagnosisConclusionEnum.Unrecognized;
                            continue;
                        }
                        //rightItem.CarotidResult.MeasureResult = "{\"IntimaResult\":{\"IsSuccess\":true,\"AntIntima\":{\"IntimaThick\":0.0,\"IsSuccess\":false},\"PostIntima\":{\"IntimaThick\":0.75,\"IsSuccess\":true}},\"IsYImageSuccess\":false,\"PlaqueResult\":{\"PlaquePostion\":0,\"PlaqueCountType\":2,\"PlaqueType\":0,\"PlaqueWidth\":1.75,\"PlaqueHeight\":3.76,\"Stenosis\":10.37,\"IsSuccess\":true}}";
                        var measureResult = JsonConvert.DeserializeObject<CarotidAIMeasureResult>(rightItem.CarotidResult.MeasureResult) ?? new CarotidAIMeasureResult();
                        if (measureResult.IntimaResult?.PostIntima?.IntimaThick > intimaThickStandard)
                        {
                            rightData = rightItem;
                            result.DiagnosisConclusion = DiagnosisConclusionEnum.Other;
                            break;
                        }
                    }
                    if (rightData == null)
                    {
                        rightData = rightExamDatas.First();
                    }
                }
                if (rightData != null)
                {
                    result.CarotidResult.Add(rightData);
                }
                Logger.WriteLineInfo($"AIDiagnosisService package carotidAIMeasureResult finished, CarotidLeftRemedicalCode:{leftData?.RemedicalCode}, CarotidLeft:{leftData?.CarotidResult?.MeasureResult}, CarotidRightRemedicalCode:{rightData?.RemedicalCode}, CarotidRight:" + rightData?.CarotidResult?.MeasureResult);
            }
            return result;
        }

        private async Task<BaseDiagnosis> CreateDiagnosisManagerAsync(DiagnosisReportRequest request)
        {
            var recordResults = new List<DiagnosisPerImageModel>();
            foreach (var remedical in request.RemedicalList)
            {
                foreach (var perImage in remedical.DiagnosisResult)
                {
                    var localFile = await DownloadAsync(remedical.FileToken);
                    if (File.Exists((localFile)))
                    {
                        var diagnosisPerImage = new DiagnosisPerImageModel();
                        diagnosisPerImage.RemedicalCode = remedical.RemedicalCode;
                        diagnosisPerImage.DataType = (WingAIDiagnosisService.Manage.DataType)remedical.DataType;
                        diagnosisPerImage.LocalVidPath = localFile;
                        diagnosisPerImage.Index = perImage.Index;
                        diagnosisPerImage.PriorityScore = perImage.PriorityScore;
                        var diagnosisResults = Newtonsoft.Json.JsonConvert.DeserializeObject<List<WingAIDiagnosisService.Manage.AIDiagnosisResultPerOrgan>>(Newtonsoft.Json.JsonConvert.SerializeObject(perImage.DiagResultsForEachOrgan));
                        diagnosisPerImage.DiagResultsForEachOrgan = diagnosisResults;
                        recordResults.Add(diagnosisPerImage);
                    }
                }
            }
            switch (request.Organ)
            {
                case DiagnosisOrganEnum.Breast:
                    return new BreastDiagnosis(recordResults, request.Organ);
                case DiagnosisOrganEnum.Liver:
                    return new LiverDiagnosis(recordResults, request.Organ);
                case DiagnosisOrganEnum.Thyroid://甲状腺
                    return new ThyroidDiagnosis(recordResults, request.Organ);
                default:
                    throw new Exception($"not support organ type:{request.Organ.ToString()}");
            }
        }

        private async Task<CarotidResultDTO> CarotidDiagnosis(VinnoImageData imageData)
        {
            var resampleInputData = new ResampleInputData();
            resampleInputData.SurfaceFilePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.SurfaceFileSuffix);
            resampleInputData.MdlFilePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.ModelFileSuffix);
            resampleInputData.MdlZipFilePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.ZipFileSuffix);
            resampleInputData.BaseAIImagePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.JPGFileSuffix);
            resampleInputData.PlaqueAIImagePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.JPGFileSuffix);
            resampleInputData.YShapeAIImagePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.JPGFileSuffix);
            var resampleResult = TryResample(imageData, resampleInputData);
            if (resampleResult.ResampleErrorCode == ResampleErrorCode.Success)
            {
                var carotidAIImageTokens = new List<CarotidAIImage>();

                if (resampleResult.CarotidAIMeasureResult.IsYImageSuccess)
                {
                    var fileUrl = await UploadFileAsync(resampleInputData.YShapeAIImagePath, Path.GetFileName(resampleInputData.YShapeAIImagePath));
                    if (!string.IsNullOrWhiteSpace(fileUrl))
                    {
                        carotidAIImageTokens.Add(new CarotidAIImage() { AIImageToken = fileUrl, AIImageType = CarotidAIImageType.YShape });
                    }
                    File.Delete(resampleInputData.YShapeAIImagePath);
                }

                if (resampleResult.CarotidAIMeasureResult.IntimaResult.IsSuccess)
                {
                    var fileUrl = await UploadFileAsync(resampleInputData.BaseAIImagePath, Path.GetFileName(resampleInputData.BaseAIImagePath));
                    if (!string.IsNullOrWhiteSpace(fileUrl))
                    {
                        carotidAIImageTokens.Add(new CarotidAIImage() { AIImageToken = fileUrl, AIImageType = CarotidAIImageType.Base });
                    }
                    File.Delete(resampleInputData.BaseAIImagePath);
                }

                if (resampleResult.CarotidAIMeasureResult.PlaqueResult.IsSuccess && resampleResult.CarotidAIMeasureResult.PlaqueResult.PlaqueCountType != WingAIDiagnosisService.Carotid.Utilities.DetectPlaque.PlaqueCountType.NoPlaque)
                {
                    var fileUrl = await UploadFileAsync(resampleInputData.PlaqueAIImagePath, Path.GetFileName(resampleInputData.PlaqueAIImagePath));
                    if (!string.IsNullOrWhiteSpace(fileUrl))
                    {
                        carotidAIImageTokens.Add(new CarotidAIImage() { AIImageToken = fileUrl, AIImageType = CarotidAIImageType.Plaque });
                    }
                    File.Delete(resampleInputData.PlaqueAIImagePath);
                }
                var surfaceImageList = new List<string>();
                long surfaceFileSize = 0;
                var cdnSurfaceFile = "";
                if (!string.IsNullOrWhiteSpace(resampleInputData.SurfaceFilePath) && File.Exists(resampleInputData.SurfaceFilePath))
                {
                    surfaceImageList = await SurfaceFile(resampleInputData.SurfaceFilePath);
                    var surfaceFileTuple = await UploadFileTupleAsync(resampleInputData.SurfaceFilePath, Path.GetFileName(resampleInputData.SurfaceFilePath));
                    surfaceFileSize = surfaceFileTuple.Item2;
                    File.Delete(resampleInputData.SurfaceFilePath);
                    resampleInputData.SurfaceFilePath = surfaceFileTuple.Item1;
                    cdnSurfaceFile = surfaceFileTuple.Item1.ToUrlToken();//ToCDN
                }
                long mdlFileFileSize = 0;
                var cdnMdlFile = "";
                if (!string.IsNullOrWhiteSpace(resampleInputData.MdlFilePath) && File.Exists(resampleInputData.MdlFilePath))
                {
                    var mdlFileTuple = await UploadFileTupleAsync(resampleInputData.MdlFilePath, Path.GetFileName(resampleInputData.MdlFilePath));
                    mdlFileFileSize = mdlFileTuple.Item2;
                    File.Delete(resampleInputData.MdlFilePath);
                    resampleInputData.MdlFilePath = mdlFileTuple.Item1;
                    cdnMdlFile = mdlFileTuple.Item1.ToUrlToken();//ToCDN
                }

                var result = new CarotidResultDTO
                {
                    CarotidScanType = (CarotidScanTypeEnum)resampleInputData.ScanType,
                    CarotidScanDirection = (CarotidScanDirectionEnum)resampleInputData.CarotidScanDirection,
                    SurfaceFile = resampleInputData.SurfaceFilePath,
                    SurfaceFileSize = surfaceFileSize,
                    CDNSurfaceFile = cdnSurfaceFile,
                    MdlFileSize = mdlFileFileSize,
                    MdlFile = resampleInputData.MdlFilePath,
                    CDNMdlFile = cdnMdlFile,
                    MeasureImageFiles = carotidAIImageTokens.Select(x => new MeasureImageFileDTO { ImageType = (CarotidAIImageTypeEnum)x.AIImageType, ImageFile = x.AIImageToken }).ToList(),
                    MeasureResult = JsonConvert.SerializeObject(resampleResult.CarotidAIMeasureResult),
                    SurfaceImageList = surfaceImageList,

                };
                return result;
            }
            return null;
        }

        private ResampleResult TryResample(VinnoImageData vinnoImageData, ResampleInputData resampleInputData)
        {
            float scanDistance = 7;
            ResampleResult resampleResult = new ResampleResult(ResampleErrorCode.Fail);
            var vinnoExtendedData = VinnoCarotidExtendedData.FromBytes(vinnoImageData.ExtendedData);
            CarotidScanType scanType = CarotidScanType.CarotidLeft;
            CarotidScanDirection direction = CarotidScanDirection.TopToBottom;
            if (vinnoExtendedData != null)
            {
                // Should be 6~9cm normally.
                //scanDistance = vinnoExtendedData.ScanDistance;
                scanType = vinnoExtendedData.CarotidType == CarotidType.Left ? CarotidScanType.CarotidLeft : CarotidScanType.CarotidRight;
                direction = vinnoExtendedData.CarotidDirection == CarotidDirection.BottomToTop ? CarotidScanDirection.BottomToTop
                    : CarotidScanDirection.TopToBottom;
            }
            else
            {
                //This is a walkaround : vid's first frame is black image or depth coordinate is not in the right place.
                var middleCount = vinnoImageData.ImageCount / 2;
                var vinnoImage = vinnoImageData.GetImage(middleCount);
                var imageBuffer = vinnoImage.ImageData;
                if (_recognizeCarotidTypeCanBeUse)
                {
                    //转成彩色图像
                    using var img = new Mat();
                    CvInvoke.Imdecode(imageBuffer, ImreadModes.Color, img);
                    using var image = img.ToImage<Bgr, byte>();
                    //识别左右颈信息
                    scanType = _recognizeCarotidType.RecognizeType(image);
                }
            }
            resampleInputData.ScanDistance = scanDistance;
            resampleInputData.ScanType = scanType;
            resampleInputData.CarotidScanDirection = direction;
            resampleResult = ResampleModel.Instance.Resample(vinnoImageData, resampleInputData, _workerLevel);
            return resampleResult;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="filePath"></param>
        private async Task<List<string>> SurfaceFile(string filePath)
        {
            var fileUrls = new List<string>();
            using (var stream = new FileStream(filePath, FileMode.Open))
            {
                var reader = new Carotid3DStreamReader(stream);
                var width = reader.ReadInt();
                var height = reader.ReadInt();
                var depth = reader.ReadInt();
                var physicalData = VinnoCarotid3DPhysicalData.FromBytes(reader.ReadBytes());
                var imageCount = reader.ReadInt();
                var fileName = $"{Guid.NewGuid():N}";
                for (var i = 0; i < imageCount; i++)
                {
                    var readBytes = reader.ReadBytes();
                    if (readBytes.Any())
                    {
                        using var img = new Mat();
                        CvInvoke.Imdecode(readBytes, ImreadModes.Color, img);
                        var buf = new Emgu.CV.Util.VectorOfByte();
                        using var image = img.ToImage<Gray, byte>();
                        CvInvoke.Imencode(".jpg", image, buf, new KeyValuePair<ImwriteFlags, int>(ImwriteFlags.JpegQuality, 80));
                        var jpgByte = buf.ToArray();
                        var localPath = Path.Combine(_tempFolder, $"{fileName}_{i + 1}.jpg");
                        File.WriteAllBytes(localPath, jpgByte);
                        var fileUrl = await UploadFileAsync(localPath, Path.GetFileName(localPath));
                        fileUrls.Add(fileUrl);
                        File.Delete(localPath);
                    }
                }
            }
            return fileUrls;
        }

        private SKBitmap CreateBitmap(VinnoImage vinnoImage)
        {
            try
            {
                return SKBitmap.Decode(vinnoImage.ImageData);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Create skbitmap by VinnoImage error:{ex}");
            }

            return null;
        }

        private EnumColorType MapTo(SKColorType sKColor)
        {
            switch (sKColor)
            {
                case SKColorType.Rgba8888:
                    return EnumColorType.Rgba;
                case SKColorType.Rgb888x:
                    return EnumColorType.Rgba;
                case SKColorType.Bgra8888:
                    return EnumColorType.Bgra;
                case SKColorType.Gray8:
                    return EnumColorType.Gray8;

            }
            throw new Exception($"AIService not support color type:{sKColor}");
        }

        private void AIdiagSystem_NotifyError(object sender, ErrorEventArgs e)
        {
            Logger.WriteLineError("AIdiagSystem_NotifyError:" + e.GetException());
        }

        private void AIdiagSystem_NotifyLog(object sender, LogEventArgs e)
        {
            if (e != null && !string.IsNullOrEmpty(e.Msg))
            {
                switch (e.LogType)
                {
                    case EnumLogType.InfoLog:
                        Logger.WriteLineInfo($"AIdiagSystem_NotifyLog:{e.Msg}");
                        break;
                    case EnumLogType.ErrorLog:
                        Logger.WriteLineError($"AIdiagSystem_NotifyLog:{e.Msg}");
                        break;
                    case EnumLogType.WarnLog:
                        Logger.WriteLineWarn($"AIdiagSystem_NotifyLog:{e.Msg}");
                        break;
                    case EnumLogType.FatalLog:
                        Logger.WriteLineError($"AIdiagSystem_NotifyLog:{e.Msg}");
                        break;
                    default:
                        Logger.WriteLineInfo(e.Msg);
                        break;
                }
            }
        }

        private DiagnosisConclusion GetDiagnosisConclusion<T>(List<T> results) where T : AIDiagnosisPerImageModel
        {
            var diagnosisConclusions = new List<DiagnosisConclusion>();
            foreach (var imageResult in results)
            {
                foreach (var diagnosisResult in imageResult.DiagResultsForEachOrgan)
                {
                    var benignLabels = new List<int>();
                    var malignantLabels = new List<int>();
                    if (diagnosisResult.Organ == DiagnosisOrganEnum.Breast)
                    {
                        benignLabels = new List<int> { 1, 2, 3 };
                        malignantLabels = new List<int> { 4, 5, 6, 7 };
                    }
                    else if (diagnosisResult.Organ == DiagnosisOrganEnum.Liver)
                    {
                        benignLabels = new List<int> { 1, 2, 3, 5, 6, 7, 8 };
                        malignantLabels = new List<int> { 4 };
                    }
                    else if (diagnosisResult.Organ == DiagnosisOrganEnum.Thyroid)
                    {
                        benignLabels = new List<int> { 1, 2, 7 };
                        malignantLabels = new List<int> { 3, 4, 5, 6 };
                    }
                    var labels = diagnosisResult.DetectedObjects.Select(x => x.Label);
                    if (labels.Contains(0))
                    {
                        diagnosisConclusions.Add(DiagnosisConclusion.NoObviousLesion);
                    }
                    if (labels.Intersect(benignLabels).Any())
                    {
                        diagnosisConclusions.Add(DiagnosisConclusion.Benign);
                    }
                    if (labels.Intersect(malignantLabels).Any())
                    {
                        diagnosisConclusions.Add(DiagnosisConclusion.Malignant);
                    }
                }
            }
            var containsBenign = diagnosisConclusions.Contains(DiagnosisConclusion.Benign);
            var containsMalignant = diagnosisConclusions.Contains(DiagnosisConclusion.Malignant);
            var containsNoObviousLesion = diagnosisConclusions.Contains(DiagnosisConclusion.NoObviousLesion);
            if (containsBenign && containsMalignant)
            {
                return DiagnosisConclusion.BenignAndMalignant;
            }
            else if (containsBenign)
            {
                return DiagnosisConclusion.Benign;
            }
            else if (containsMalignant)
            {
                return DiagnosisConclusion.Malignant;
            }
            else if (containsNoObviousLesion)
            {
                return DiagnosisConclusion.NoObviousLesion;
            }
            else
            {
                return DiagnosisConclusion.Unrecognized;
            }
        }

        private List<DiagnosisOrganEnum> GetDiagnosisOrgans(List<AIDiagnosisPerImageModel> results)
        {
            var diagnosisOrgans = new List<DiagnosisOrganEnum>();
            foreach (var imageResult in results)
            {
                foreach (var diagnosisResult in imageResult.DiagResultsForEachOrgan)
                {
                    var organName = Enum.GetName(typeof(DiagnosisOrganEnum), (int)diagnosisResult.Organ);
                    if (!string.IsNullOrWhiteSpace(organName) && diagnosisResult.Organ != DiagnosisOrganEnum.Null && diagnosisResult.DetectedObjects?.Any() == true)
                    {
                        diagnosisOrgans.Add((DiagnosisOrganEnum)diagnosisResult.Organ);
                    }
                }
            }
            return diagnosisOrgans.Distinct().ToList();
        }

        private List<DiagnosisOrganEnum> GetDiagnosisOrgans(List<DiagnosisPerImageModel> results)
        {
            var diagnosisOrgans = new List<DiagnosisOrganEnum>();
            foreach (var imageResult in results)
            {
                foreach (var diagnosisResult in imageResult.DiagResultsForEachOrgan)
                {
                    var organName = Enum.GetName(typeof(DiagnosisOrganEnum), (int)diagnosisResult.Organ);
                    if (!string.IsNullOrWhiteSpace(organName) && diagnosisResult.Organ != DiagnosisOrganEnum.Null && diagnosisResult.DetectedObjects?.Any() == true)
                    {
                        diagnosisOrgans.Add((DiagnosisOrganEnum)diagnosisResult.Organ);
                    }
                }
            }
            return diagnosisOrgans.Distinct().ToList();
        }

        private Dictionary<int, AIDiagResultPerImg> NormalDiagnosis(string relationCode, string fileUrl, VinnoImageData imageData)
        {
            var results = new Dictionary<int, AIDiagResultPerImg>();
            try
            {
                var imageCount = imageData.ImageCount;
                Logger.WriteLineInfo($"AIDiagnosisService diagnosis start, relationCode:{relationCode}, fileUrl:{fileUrl}, imageCount:{imageCount}");
                if (imageCount > 0)
                {
                    var diagId = _diagSystem.StartEvalutationOfMultipleImageBatches(imageCount);
                    for (var i = 0; i < imageCount; i++)
                    {
                        var image = imageData.GetImage(i);
                        using (var bitmap = CreateBitmap(image))
                        {
                            var rawImage = new RawImage(bitmap.Bytes, bitmap.Width, bitmap.Height, MapTo(bitmap.ColorType));
                            _diagSystem.PushOneBatchOfImagesAsync(diagId, new List<RawImage> { rawImage });
                        }
                    }
                    results = _diagSystem.GetEvaluationsOfPushedMultipleImageBatches(diagId);
                    Logger.WriteLineInfo($"AIDiagnosisService diagnosis successfully");
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService NormalDiagnosis err, {ex}");
            }
            return results;
        }

        /// <summary>
        /// 保存AI诊断结果
        /// </summary>
        /// <param name="relationCode"></param>
        /// <param name="fileUrl"></param>
        /// <param name="diagnosisResultInfos"></param>
        /// <returns></returns>
        private async Task<bool> AddDiagnosisResultInfosAsync(string relationCode, string fileUrl, List<AIDiagnosisPerImageModel> diagnosisResultInfos
        , DateTime? createTime = null, DateTime? updateTime = null, bool syncOthers = true)
        {
            try
            {
                var resultInfos = new List<DiagnosisResultDTO>();
                for (var i = 0; i < diagnosisResultInfos.Count; i++)
                {
                    resultInfos.Add(new DiagnosisResultDTO
                    {
                        Index = i,
                        DiagnosisResult = Newtonsoft.Json.JsonConvert.SerializeObject(diagnosisResultInfos[i]),
                    });
                }
                var addRequest = new AddDiagnosisResultInfosDBRequest
                {
                    RelationCode = relationCode,
                    FileUrl = fileUrl,
                    DiagnosisResultInfos = resultInfos,
                    CreateTime = createTime,
                    UpdateTime = updateTime,
                    SyncOthers = syncOthers,
                };
                if (syncOthers)
                {
                    _diagnosisResultDBService.AddDiagnosisResultInfosAsync(addRequest);
                }
                else
                {
                    await _diagnosisResultDBService.AddDiagnosisResultInfosAsync(addRequest);
                }
                return true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService AddDiagnosisResultInfosAsync err, ex:{ex}");
                return false;
            }
        }

        /// <summary>下载文件</summary>
        /// <param name="fileUrl"></param>
        /// <returns></returns>
        private async Task<string> DownloadAsync(string fileUrl)
        {
            try
            {
                if (string.IsNullOrEmpty(fileUrl))
                {
                    return string.Empty;
                }
                if (!Directory.Exists(_tempFolder))
                {
                    Directory.CreateDirectory(_tempFolder);
                }
                var fileName = Path.GetFileName(fileUrl);
                var tempFile = Path.Combine(_tempFolder, fileName);
                if (File.Exists(tempFile))
                {
                    return tempFile;
                }
                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)
                {
                    throw new NotSupportedException($"fileSize is {fileSize}");
                }
                byte[] bytes = await _httpClient.GetByteArrayAsync(fileUrl);
                File.WriteAllBytes(tempFile, bytes);
                return tempFile;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"DiagnosisService download file err, url: {fileUrl}, {ex}");
            }
            finally
            {
                //Logger.WriteLineInfo($"download file:{fileUrl}");
            }
            return string.Empty;
        }

        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="fileName"></param>
        /// <returns></returns>
        private async Task<string> UploadFileAsync(string filePath, string fileName)
        {
            var fileToken = "";
            using (var fileStream = new FileStream(filePath, FileMode.Open))
            {
                var size = fileStream.Length;

                byte[] buffer = new byte[fileStream.Length];
                fileStream.Read(buffer, 0, buffer.Length);
                fileToken = await DoUploadFile(fileName, buffer);
            }
            return fileToken;
        }


        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="fileName"></param>
        /// <returns></returns>
        private async Task<Tuple<string, long>> UploadFileTupleAsync(string filePath, string fileName)
        {
            var fileToken = "";
            long size = 0;
            using (var fileStream = new FileStream(filePath, FileMode.Open))
            {
                size = fileStream.Length;
                byte[] buffer = new byte[fileStream.Length];
                fileStream.Read(buffer, 0, buffer.Length);
                fileToken = await DoUploadFile(fileName, buffer);
            }
            return new Tuple<string, long>(fileToken, size);
        }
        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="fileData"></param>
        /// <returns></returns>
        async Task<string> DoUploadFile(string fileName, byte[] fileData)
        {
            var requestHeads = new Dictionary<string, string>();
            var defaultToken = await _authenticationService.GetServerDefaultTokenAsync();
            var authorizationRet = await _storageService.GetAuthorizationAsync(
                new FileServiceRequest
                {
                    Token = defaultToken,
                    FileName = fileName,
                });
            requestHeads.Add("Authorization", authorizationRet.Authorization);
            var fileUrl = authorizationRet.StorageUrl;
            Logger.WriteLineInfo($"DoUploadFile fileUrl:{fileUrl}");
            using (var request = new HttpRequestMessage())
            {
                var fileExtension = Path.GetExtension(fileName);
                var mimeType = FileHelper.GetMimeType(fileExtension);
                var contentType = MediaTypeHeaderValue.Parse(mimeType);
                using (UploadContent content = new UploadContent(fileData, contentType))
                {
                    request.RequestUri = new Uri(fileUrl);
                    request.Method = HttpMethod.Put;
                    request.Content = content;
                    foreach (var head in requestHeads)
                    {
                        request.Headers.TryAddWithoutValidation(head.Key, head.Value);
                    }
                    var result = await ExecuteRequest(request);
                    if (!result)
                    {
                        throw new Exception("Upload file failed!");
                    }
                }
            }
            return fileUrl;
        }

        private UploadFileTypeEnum GetUploadFileType(string fileName)
        {
            if (fileName.EndsWith(".vid"))
            {
                return UploadFileTypeEnum.VID;
            }
            else if (fileName.EndsWith(".jpg"))
            {
                return UploadFileTypeEnum.JPG;
            }
            else
            {
                return UploadFileTypeEnum.MP4;
            }
        }

        /// <summary>
        /// 执行请求
        /// </summary>
        /// <param name="httpRequestMessage"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public async Task<bool> ExecuteRequest(HttpRequestMessage httpRequestMessage)
        {
            try
            {
                var response = await _httpClient.SendAsync(httpRequestMessage);
                if (response != null && response.StatusCode == HttpStatusCode.OK)
                {
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        private List<WingInterfaceLibrary.DTO.Comment.AIDiagnosisPoint2D> PointToDto(Point2D[] points)
        {
            var dstContours = new List<WingInterfaceLibrary.DTO.Comment.AIDiagnosisPoint2D>();
            foreach (var p in points)
            {
                dstContours.Add(new WingInterfaceLibrary.DTO.Comment.AIDiagnosisPoint2D
                {
                    X = p.X,
                    Y = p.Y
                });
            }
            return dstContours;
        }

        private List<DiagnosisKeyPointDTO> KeyPointToDto(KeyPointInfo[] points)
        {
            var dstKeys = new List<DiagnosisKeyPointDTO>();
            foreach (var point in points)
            {
                dstKeys.Add(new DiagnosisKeyPointDTO
                {
                    Type = (DiagnosisKeyPointType)point.Type,
                    IndexInContour = point.IndexInContour,
                    Point = new WingInterfaceLibrary.DTO.Comment.AIDiagnosisPoint2D
                    {
                        X = point.Point.X,
                        Y = point.Point.Y,
                    },
                });
            }
            return dstKeys;
        }

        /// <summary>
        /// 创建缩略图文件
        /// </summary>
        /// <param name="vinnoImage"></param>
        /// <param name="requestHeight"></param>
        /// <param name="quality"></param>
        /// <param name="fullPath"></param>
        private void CreateThumbnailFile(string filePath, int requestHeight, int quality, string fullPath)
        {
            using (var fileStream = new FileStream(filePath, FileMode.Open))
            {
                var size = fileStream.Length;

                byte[] buffer = new byte[fileStream.Length];
                fileStream.Read(buffer, 0, buffer.Length);

                byte[] compressedData = buffer;
                using (var ms = new MemoryStream(compressedData))
                {
                    using (var image = SKBitmap.Decode(ms))
                    {
                        var ratio = (double)requestHeight / image.Height;
                        if (ratio < 1)
                        {
                            var width = (int)(image.Width * ratio);
                            var height = (int)(image.Height * ratio);
                            SKBitmap tempImage = image;
                            if (image.Width != width || image.Height != height)
                            {
                                tempImage = image.Resize(new SKImageInfo(width, height), SKFilterQuality.High);
                            }
                            try
                            {
                                using (var map = new SKPixmap(new SKImageInfo(tempImage.Width, tempImage.Height, tempImage.ColorType), tempImage.GetPixels()))
                                {
                                    using (var stream = new SKDynamicMemoryWStream())
                                    {
                                        SKPixmap.Encode(stream, map, SKEncodedImageFormat.Jpeg, quality);
                                        compressedData = stream.CopyToData().ToArray();
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                throw ex;
                            }
                            finally
                            {
                                tempImage.Dispose();
                            }
                        }
                    }
                }
                using (var fs = File.Create(fullPath))
                {
                    fs.Write(compressedData, 0, compressedData.Length);
                }
            }
        }
    }
}