WingAIDiagnosisService/URMManage/URMAnalysisManager.cs

using System;
using System.IO;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using Vinno.DataTypes;
using Vinno.Infrastructure;
using WingInterfaceLibrary.Request.RemedicalAISelected;

namespace WingAIDiagnosisService.URMManage
{
    public class URMAnalysisManager
    {
        public URMAnalysisV2Result DoURMAnalysis(string[] args)
        {
            AppendEnvironmentPath();
            var arg2Params = args[3].Split(";");
            var familyName = "Linear";
            var typeInfo = "Linear_U5-15LE";
            var nativeId = "Breast";
            var VecLens = 568;
            var Mlas = 128;
            var FramesGot = 2200;
            var CenterFrequencyMhz = 4.7;
            var SupersonicSpeed = 1540;
            var FrequencyMin = 6.5;
            var FrameRateDisplay = 101.9;
            var Depth = 0;
            var X0 = 0;
            var Z0 = 0;
            var ProbeType = "1";
            var ScaleOfPixel_x = 0.214925914347303;
            var ScaleOfPixel_y = 0.61038961038961;
            var section = "URMAnalysisParam:Level4";
            var MOCOYN = "0";
            var MidProc_DeciFactor = 1;
            var VectorStartForMid = 11;
            var isliner = false;
            // 前端调用时传入
            var startX = 47;
            var startY = 14;
            var width = 74;
            var height = 492;
            int? CustomizedStartFrame = null;
            int? CustomizedEndFrame = null;

            var UrmDatapath = arg2Params[0];
            // var familyName = arg2Params[1];
            // var typeInfo = arg2Params[2];
            // var nativeId = arg2Params[3];
            // var VecLens = ConvertToInt(arg2Params[4]);
            // var Mlas = ConvertToInt(arg2Params[5]);
            // var FramesGot = ConvertToInt(arg2Params[6]);
            // var CenterFrequencyMhz = ConvertToDouble(arg2Params[7]);
            // var SupersonicSpeed = ConvertToInt(arg2Params[8]);
            // var FrequencyMin = ConvertToDouble(arg2Params[9]);
            // var FrameRateDisplay = ConvertToDouble(arg2Params[10]);
            // var Depth = ConvertToInt(arg2Params[11]);
            // var X0 = ConvertToInt(arg2Params[12]);
            // var Z0 = ConvertToInt(arg2Params[13]);
            // var ProbeType = arg2Params[14];
            // var ScaleOfPixel_x = ConvertToDouble(arg2Params[15]);
            // var ScaleOfPixel_y = ConvertToDouble(arg2Params[16]);
            // var section = arg2Params[17];
            // var MOCOYN = arg2Params[18];
            // var MidProc_DeciFactor = ConvertToInt(arg2Params[19]);
            // var VectorStartForMid = ConvertToInt(arg2Params[20]);
            // var isliner = arg2Params[21]?.ToLower() == "true";
            // // 前端调用时传入
            // var startX = ConvertToInt(arg2Params[22]);
            // var startY = ConvertToInt(arg2Params[23]);
            // var width = ConvertToInt(arg2Params[24]);
            // var height = ConvertToInt(arg2Params[25]);
            // int? CustomizedStartFrame = ConvertToIntCanNull(arg2Params[26]);
            // int? CustomizedEndFrame = ConvertToIntCanNull(arg2Params[27]);
            var roiXPercent = ConvertToDouble(arg2Params[28]);
            var roiYPercent = ConvertToDouble(arg2Params[29]);
            var roiWPercent = ConvertToDouble(arg2Params[30]);
            var roiHPercent = ConvertToDouble(arg2Params[31]);
            // 开始执行分析
            URMFileIO urmFileIO = new URMFileIO(familyName: familyName, typeInfo: typeInfo, nativeId: nativeId);
            urmFileIO.UpdateParamJson(UrmDatapath, VecLens, Mlas, FramesGot, CenterFrequencyMhz, SupersonicSpeed, FrequencyMin, FrameRateDisplay, Depth, X0, Z0, ProbeType, ScaleOfPixel_x, ScaleOfPixel_y, section, MOCOYN, MidProc_DeciFactor, VectorStartForMid, startX, startY, width, height, CustomizedStartFrame, CustomizedEndFrame, out string urmParams);

            var modeRecord = new URMAnalysisModeRecord();
            try
            {
                var outputFolder = args[1];
                if (!Directory.Exists(outputFolder))
                {
                    Directory.CreateDirectory(outputFolder);
                }
                bool success = URMAnalysisProcess.GetInstance().URMAnalysis(urmParams, modeRecord);
                // 读取输出
                var SrcWidth = modeRecord.URMSrcWidth;
                var SrcHeight = modeRecord.URMSrcHeight;
                var denPath = Path.Combine(outputFolder, "srcDenArray.bin");
                var dirPath = Path.Combine(outputFolder, "srcDirArray.bin");
                var velPath = Path.Combine(outputFolder, "srcVelArray.bin");
                var angelPath = Path.Combine(outputFolder, "srcAngleArray.bin");
                var maskPath = Path.Combine(outputFolder, "srcMaskArray.bin");
                var pointsPath = Path.Combine(outputFolder, "URMPoints.bin");
                var pointNumsPath = Path.Combine(outputFolder, "URMPointNums.bin");
                ResultDataIOHelper.WriteArrayToFile(denPath, modeRecord.URMDenArray, SrcWidth * SrcHeight);
                ResultDataIOHelper.WriteArrayToFile(dirPath, modeRecord.URMDirArray, SrcWidth * SrcHeight);
                ResultDataIOHelper.WriteArrayToFile(velPath, modeRecord.URMVelArray, SrcWidth * SrcHeight);
                ResultDataIOHelper.WriteArrayToFile(angelPath, modeRecord.URMAngleImgArray, SrcWidth * SrcHeight);
                ResultDataIOHelper.WriteByteArrayToFile(maskPath, modeRecord.URMMask, SrcWidth * SrcHeight);
                ResultDataIOHelper.WriteURMPointsToFile(pointsPath, modeRecord.URMPoints);
                ResultDataIOHelper.WriteURMPointNumsToFile(pointNumsPath, modeRecord.URMPointNums);

                var coverFile = args[2];
                int coverImageWidth = 0;
                int coverImageHeight = 0;
                using (var image = Image.Load(coverFile))
                {
                    coverImageWidth = image.Width;
                    coverImageHeight = image.Height;
                }
                var urmProcess = new ImagePostProcess();
                var imgBase64 = urmProcess.DoUrmProcess(new UrmProcessRequest
                {
                    FamilyName = familyName,
                    TypeInfo = typeInfo,
                    NativeId = nativeId,
                    Isliner = isliner,
                    ScaleOfPixel_x = ScaleOfPixel_x,
                    ScaleOfPixel_y = ScaleOfPixel_y,
                    Urmsrcwidth = SrcWidth,
                    Urmsrcheight = SrcHeight,
                    DenDataPath = denPath,
                    DirDataPath = dirPath,
                    VelDataPath = velPath,
                    AngleDataPath = angelPath,
                    MaskDataPath = maskPath,
                    Res = modeRecord.URMRes,
                    UrmImageType = "0",
                    UrmBlend = true,
                    DownsampleIndex = 3,
                    IntPowerDen = 4,
                    IntPowerDir = 4,
                    SigmaGauss = 2.4f,
                    VessScale = 1,
                    VelMaxScaler = 1,
                    VelMinScaler = 0,
                    Iterations = 1,
                    ImgProcessVer = 1,
                    ZoomOn = false,
                    ZoomRoix = 0,
                    ZoomRoiy = 0,
                    ZoomRoiwidth = 1,
                    ZoomRoiheight = 1,
                    LeftRight = false,
                    UpDown = false,
                    UrmTraceDPoints = new DPoint[] { },
                    Roix = (int)(coverImageWidth * roiXPercent),
                    Roiy = (int)(coverImageHeight * roiYPercent),
                    Roiwidth = (int)(coverImageWidth * roiWPercent),
                    Roiheight = (int)(coverImageHeight * roiHPercent),
                    ScreenWidth = coverImageWidth,
                    ScreenHeight = coverImageHeight,
                });
                var mergeFilePath = coverFile;
                if (!string.IsNullOrWhiteSpace(imgBase64))
                {
                    mergeFilePath = Path.Combine(outputFolder, $"{Guid.NewGuid():N}.png");
                    using (var image1 = Image.Load(coverFile))
                    {
                        // 将base64字符串转换为字节数组
                        byte[] bytes = Convert.FromBase64String(imgBase64);

                        // 将字节数组转换为Image对象
                        using (var image2 = Image.Load(bytes))
                        {
                            // 将第二张图片画在第一张图片上
                            image1.Mutate(ctx => ctx.DrawImage(image2, new Point(0, 0), 1f));

                            // 保存合成后的图片
                            image1.Save(mergeFilePath);
                        }
                    }
                }

                var outMsg = new URMAnalysisV2Result
                {
                    URMSrcWidth = modeRecord.URMSrcWidth,
                    URMSrcHeight = modeRecord.URMSrcHeight,
                    URMRes = modeRecord.URMRes,
                    ConverImageUrl = mergeFilePath,
                };
                return outMsg;
            }
            catch (Exception ex)
            {

            }
            return null;
        }


        private void AppendEnvironmentPath()
        {
            var urmFolder = Path.Combine(ServiceManager.RootPath, "URM");
            var privatePath = @$"C:\VinnoApp_Lab\Depends;C:\VinnoApp_Lab\ipp_2018;AIMeasure;AI;Depends;DicomMpeg;Syncfusion;RemoteDiagnosis;vCloud;Test;VFetus;{urmFolder}";
            bool enforcePentiumMode = false;
            string workPathPerCPU = string.Empty;
            string workPathForGPU = string.Empty;
            workPathPerCPU = Path.Combine(ServiceManager.RootPath, "NON_PENTIUM");

            privatePath = privatePath + ";" + workPathPerCPU + ";";

            string gpuName = string.Empty;

            workPathForGPU = Path.Combine(ServiceManager.RootPath, "NVIDIA");

            if (!string.IsNullOrEmpty(workPathForGPU))
            {
                privatePath = privatePath + workPathForGPU + ";";
            }

            if (!string.IsNullOrEmpty(privatePath))
            {
                string path = Environment.GetEnvironmentVariable("PATH");
                string newPath = string.Empty;
                if (path != null)
                {
                    string upperPath = path.ToUpper();
                    var subPathes = privatePath.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                    foreach (var subPath in subPathes)
                    {
                        VinnoDirectoryInfo dir = null;
                        if (Path.IsPathRooted(subPath))
                        {
                            dir = new VinnoDirectoryInfo(subPath);
                        }
                        else
                        {
                            dir = new VinnoDirectoryInfo(Path.Combine(ServiceManager.RootPath, subPath));
                        }
                        if (dir.Exists)
                        {
                            var fullName = dir.FullName;
                            if (!upperPath.Contains(fullName.ToUpper()))
                            {
                                newPath += ";" + fullName;
                            }
                        }
                    }

                    if (!string.IsNullOrEmpty(newPath))
                    {
                        Environment.SetEnvironmentVariable("PATH", newPath + ";" + path, EnvironmentVariableTarget.Process);
                    }
                }
            }
        }

        private int ConvertToInt(string value)
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                return 0;
            }
            if (int.TryParse(value, out int x))
            {
                return x;
            }
            return 0;
        }
        private int? ConvertToIntCanNull(string value)
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                return null;
            }
            if (int.TryParse(value, out int x))
            {
                return x;
            }
            return 0;
        }
        private double ConvertToDouble(string value)
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                return 0;
            }
            if (double.TryParse(value, out double x))
            {
                return x;
            }
            return 0;
        }
    }
}