WingAIDiagnosisService/Manage/CarotidDiagnosis.cs

using System.Collections.Generic;
using System.Linq;
using WingInterfaceLibrary.Enum;

namespace WingAIDiagnosisService.Manage
{
    public class CarotidDiagnosis : BaseDiagnosis
    {
        private AICarotidLabelEnum? _mimanLabel;
        private DiagnosisPerImageModel _mimanDiagnosisImage = null;
        public CarotidDiagnosis(List<DiagnosisPerImageModel> recordResult, DiagnosisOrganEnum organ) : base(recordResult, organ)
        {
        }

        #region Private 

        private AIDetectedObject CheckFocus(AIDetectedObject message)
        {
            return message;
        }

        private bool IsMiMan(int label)
        {
            return false;
        }

        private bool IsMalignant(int label)
        {
            return false;
        }

        private List<int> ExistingLabels(List<DiagnosisPerImageModel> results)
        {
            var existingLabels = new List<int> { (int)AICarotidLabelEnum.BIRads1 };
            existingLabels.AddRange(results.SelectMany(x => x.GetLabels()));
            return existingLabels.Distinct().ToList();
        }

        /// <summary>根据诊断结果返回弥漫病灶类型</summary>
        /// <param name="results"></param>
        /// <returns></returns>
        private void GetMiManLabel(List<DiagnosisPerImageModel> results)
        {
        }

        /// <summary>确定病例弥漫性病灶类型</summary>
        private void ConfirmMiManLabel()
        {
            var imageResults = RecordDiagnosisResult.Where(x => x.DataType == DataType.VinnoVidSingle || x.DataType == DataType.ThirdVidSingle)?.ToList() ?? new List<DiagnosisPerImageModel>();
            var movieResults = RecordDiagnosisResult.Where(x => x.DataType == DataType.VinnoVidMovie || x.DataType == DataType.ThirdVidMovie)?.ToList() ?? new List<DiagnosisPerImageModel>();
            if (movieResults.Any())
            {
                GetMiManLabel(movieResults);
            }
            else
            {
                GetMiManLabel(imageResults);
            }
        }

        /// <summary>查询横截面最大的图</summary>
        /// <param name="label"></param>
        /// <returns></returns>
        private DiagnosisPerImageModel GetMaxLesionSizeImage(AICarotidLabelEnum label)
        {
            double maxLesionSize = 0;
            DiagnosisPerImageModel resultData = null;
            foreach (var diagResult in RecordDiagnosisResult)
            {
                //result 这张图要不要
                if (!diagResult.GetLabels().Contains((int)label))
                {
                    continue;
                }
                var isChosed = false;
                foreach (var organResult in diagResult.DiagResultsForEachOrgan)
                {
                    if (isChosed)
                    {
                        break;
                    }
                    foreach (var detectedObjectInfo in organResult.DetectedObjects)
                    {
                        if (detectedObjectInfo.Label == (int)label)
                        {
                            var currLesionSize = GetMaxLesionSize(detectedObjectInfo);
                            if (currLesionSize > maxLesionSize)
                            {
                                //要
                                isChosed = true;
                                maxLesionSize = currLesionSize;
                                resultData = diagResult;
                                break;
                            }
                        }
                    }
                }
            }
            return resultData;
        }

        /// <summary>局灶性选图</summary>
        /// <returns></returns>
        private List<DiagnosisPerImageModel> GetFocusImages()
        {
            var labels = new List<AICarotidLabelEnum>
            {
                AICarotidLabelEnum.Plaque,
            };
            var focusImages = new List<AICarotidFocusImageModel>();
            foreach (var label in labels)
            {
                var diagnosisImage = GetMaxLesionSizeImage(label);
                if (diagnosisImage != null)//!focusImages.Any(x => x.DiagnosisImage.TerminalDataId == diagnosisImage.TerminalDataId && x.DiagnosisImage.AIDiagResult.Index == diagnosisImage.AIDiagResult.Index)
                {
                    focusImages.Add(new AICarotidFocusImageModel { Label = label, DiagnosisImage = diagnosisImage });
                }
            }

            var resultData = new List<DiagnosisPerImageModel>();
            var mimanChosed = false;
            foreach (var diagResult in focusImages)
            {
                if (resultData.Any(x => x.RemedicalCode == diagResult.DiagnosisImage.RemedicalCode && x.Index == diagResult.DiagnosisImage.Index))
                {
                    continue;
                }
                var otherLabels = focusImages.Where(x => x.DiagnosisImage.RemedicalCode != diagResult.DiagnosisImage.RemedicalCode || x.DiagnosisImage.Index != diagResult.DiagnosisImage.Index)
                    .Select(x => x.Label).ToList();
                var organResultList = new List<AIDiagnosisResultPerOrgan>();
                foreach (var organResult in diagResult.DiagnosisImage.DiagResultsForEachOrgan)
                {
                    var detectedObjects = organResult.DetectedObjects.Where(x => !otherLabels.Contains((AICarotidLabelEnum)x.Label))?.ToList() ?? new List<AIDetectedObject>();
                    if (mimanChosed)
                    {
                        detectedObjects = detectedObjects.Where(x => !IsMiMan(x.Label))?.ToList() ?? new List<AIDetectedObject>();
                    }
                    if (detectedObjects != null && detectedObjects.Any())
                    {
                        organResult.DetectedObjects = detectedObjects.ToList();
                        organResultList.Add(organResult);
                        if (detectedObjects.Any(x => IsMiMan(x.Label)))
                        {
                            mimanChosed = true;
                        }
                    }
                }
                diagResult.DiagnosisImage.DiagResultsForEachOrgan = organResultList;
                resultData.Add(diagResult.DiagnosisImage);
            }
            return resultData;
        }

        #endregion

        /// <summary>筛选有效的AI诊断记录</summary>
        /// <param name="allResult"></param>
        /// <returns></returns>
        public override void CheckDiagResultIndex()
        {
            var validResult = new List<DiagnosisPerImageModel>();
            foreach (var diagResult in RecordDiagnosisResult)
            {
                var organResultList = new List<AIDiagnosisResultPerOrgan>();
                foreach (var organResult in diagResult.DiagResultsForEachOrgan)
                {
                    var valid = CheckResultValid(organResult);
                    if (valid != null)
                    {
                        organResultList.Add(valid);
                    }
                }
                if (organResultList.Any())
                {
                    diagResult.DiagResultsForEachOrgan = organResultList;
                    validResult.Add(diagResult);
                }
            }
            RecordDiagnosisResult = validResult;
        }

        /// <summary>筛选报告可用诊断结果</summary>
        /// <param name="validResults"></param>
        /// <returns></returns>
        public override List<DiagnosisPerImageModel> GetReportResults()
        {
            if (!RecordDiagnosisResult.Any())
            {
                return RecordDiagnosisResult;
            }

            if (!HasSick())
            {
                //未见异常
                RecordDiagnosisResult = new List<DiagnosisPerImageModel> { RecordDiagnosisResult.FirstOrDefault() };
            }
            else
            {
                var reportResults = GetFocusImages();
                if (!reportResults.Any() && _mimanDiagnosisImage != null)
                {
                    //只有弥漫的情况
                    reportResults = new List<DiagnosisPerImageModel> { _mimanDiagnosisImage };
                }
                RecordDiagnosisResult = reportResults;
            }
            InitialAIImage();
            return RecordDiagnosisResult;
        }

        /// <summary>判断并返回有效的诊断描述</summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public override AIDiagnosisResultPerOrgan CheckResultValid(AIDiagnosisResultPerOrgan message)
        {
            if (message.Organ != DiagnosisOrganEnum.CarotidArtery)
            {
                return null;
            }
            var result = message;
            var validDetectedObjects = message.DetectedObjects;
            // foreach (var obj in message.DetectedObjects)
            // {
            //     var obj_new = CheckFocus(obj);
            //     if (obj_new != null)
            //     {
            //         validDetectedObjects.Add(obj_new);
            //     }
            // }
            result.DetectedObjects = validDetectedObjects;
            return result;
        }

        /// <summary>判断AI诊断结果</summary>
        /// <returns></returns>
        public override DiagnosisConclusion GetAIStatus()
        {
            var status = DiagnosisConclusion.Unrecognized;
            bool existMalignant = false;
            bool existBenign = false;
            if (RecordDiagnosisResult != null && RecordDiagnosisResult.Any())
            {
                foreach (var diagResult in RecordDiagnosisResult)
                {
                    if (existMalignant && existBenign)
                        break;
                    if (diagResult.PriorityScore > 0 && diagResult.DiagResultsForEachOrgan != null)
                    {
                        foreach (var organ in diagResult.DiagResultsForEachOrgan)
                        {
                            if (organ.DetectedObjects != null)
                            {
                                if (!existMalignant)
                                {
                                    if (organ.DetectedObjects.Any(a => IsMalignant(a.Label)))
                                    {
                                        existMalignant = true;
                                    }
                                }

                                if (!existBenign)
                                {
                                    if (organ.DetectedObjects.Any(a => a.Label >= 1))
                                    {
                                        existBenign = true;
                                    }
                                }
                            }
                        }

                        if (existMalignant)
                        {
                            status = existBenign ? DiagnosisConclusion.BenignAndMalignant : DiagnosisConclusion.Malignant;
                        }
                        else
                        {
                            status = existBenign ? DiagnosisConclusion.Benign : DiagnosisConclusion.NoObviousLesion;
                        }
                    }
                }
            }
            return status;
        }

        /// <summary>
        /// 是否恶性病灶
        /// </summary>
        /// <param name="label"></param>
        /// <returns></returns>
        protected override bool IsMalignant(AIDetectedObject detectedObject)
        {
            return false;
        }


    }

    public class AICarotidFocusImageModel
    {
        public AICarotidLabelEnum Label { get; set; }
        public DiagnosisPerImageModel DiagnosisImage { get; set; }
    }
}