WingAIDiagnosisService/URMManage/URMAnalysisProcessV3.cs

using System;
using System.IO;
using System.Runtime.InteropServices;
using Vinno.Infrastructure;
using System.Diagnostics;
using System.IO.MemoryMappedFiles;
using System.Threading;
using Vinno.DataManager.Utilities;
using Vinno.DataTypes;
using WingServerCommon.Log;
using Logger = WingServerCommon.Log.Logger;

namespace WingAIDiagnosisService.URMManage
{
    public class URMAnalysisProcess
    {

        private bool initSrMain;
        private int _urmwidth;
        private int _urmheight;
        private int aviFrames;
        private URMAnalysisModeRecord _urmModeRecord;
        private Process _SRLibWrapperProcess;
        private MemoryMappedFile _file;
        string mapName = "VinnoSrResultV1";
        private ManualResetEvent signal = new ManualResetEvent(false);
        private int urmStabilizer = 0;
        private static URMAnalysisProcess instance;
        private bool _processFlag = false;
        private static readonly bool Debug = false;
        public URMAnalysisProcess()
        {
            mapName = Guid.NewGuid().ToString("N");
            _SRLibWrapperProcess = new Process();
            var analyzeHostName = Path.Combine(ServiceManager.RootPath, "URM", "net6.0", "SRLibWrapper.exe");
            //if (!VinnoFile.Exists(analyzeHostName) || !DigitalSignatureChecker.VerifySignature(analyzeHostName))
            //{
            //    Logger.WriteLineErrorIf(Debug, "SRLibWrapper.exe not found or signature is invalid.");
            //}
            var startInfo = new ProcessStartInfo
            {
                FileName = analyzeHostName,
                Arguments = $"",
                CreateNoWindow = true,
                UseShellExecute = false,
                RedirectStandardOutput = true,
                RedirectStandardInput = true,
                RedirectStandardError = true,
            };
            _SRLibWrapperProcess.StartInfo = startInfo;
            _SRLibWrapperProcess.Start();
            _SRLibWrapperProcess.OutputDataReceived += OutputHandler;
            _SRLibWrapperProcess.ErrorDataReceived += OutputHandler;
            _SRLibWrapperProcess.BeginOutputReadLine();
            _SRLibWrapperProcess.BeginErrorReadLine();

        }
        ~URMAnalysisProcess()
        {
            ProcessDispose();
        }

        public void ProcessDispose()
        {
            try
            {
                if (_file != null)
                    _file.Dispose();
                WingServerCommon.Log.Logger.WriteLineInfo($"URMAnalysisProcess ProcessDispose start, HasExited:{_SRLibWrapperProcess?.HasExited}");
                // Console.WriteLine($"URMAnalysisProcess ProcessDispose start, HasExited:{_SRLibWrapperProcess?.HasExited}");
                if (_SRLibWrapperProcess != null && !_SRLibWrapperProcess.HasExited)
                {
                    _SRLibWrapperProcess?.Kill();
                    _SRLibWrapperProcess?.Dispose();
                }
            }
            catch (Exception ex)
            {
                WingServerCommon.Log.Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisProcess ProcessDispose error, ex:{ex}");
                // Console.WriteLine($"AIDiagnosisService URMAnalysisProcess ProcessDispose error, ex:{ex}");
            }
        }

        public static URMAnalysisProcess GetInstance()
        {
            if (instance == null)
            {
                instance = new URMAnalysisProcess();
            }
            return instance;
        }


        private void OutputHandler(object sender, DataReceivedEventArgs e)
        {
            try
            {
                if (!string.IsNullOrEmpty(e.Data))
                {
                    if (!e.Data.Contains("SRLibLog"))
                        return;
                    var infos = e.Data.Split(',');
                    if (!string.IsNullOrEmpty(infos[1]))
                    {
                        _processFlag = true;
                        switch (infos[1])
                        {
                            case "step1ok":
                                var needmemorysize = long.Parse(infos[2]);
                                Logger.WriteLineInfo($"Akio step1ok needmemorysize is {needmemorysize}");
                                if (_file != null)
                                    _file.Dispose();
                                _file = MemoryMappedFile.CreateNew(mapName, needmemorysize,
                                    MemoryMappedFileAccess.ReadWrite);
                                var step2info = "Step2," + mapName;
                                _SRLibWrapperProcess.StandardInput.WriteLine(step2info);
                                break;
                            case "step2ok":
                                Logger.WriteLineInfo("Akio step2ok");
                                signal.Set();
                                break;
                            case "SRLibFail":
                                _processFlag = false;
                                signal.Set();
                                Logger.WriteLineError("AKio " + e.Data);
                                break;

                        }
                    }
                }
            }
            catch (Exception ex)
            {
                WingServerCommon.Log.Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisProcess OutputHandler error, ex:{ex}");
            }
        }

        public bool URMAnalysis(string urmFold, URMAnalysisModeRecord urmModeRecord)
        {
            using (new AutoPerformance("Akio:URMAnalysisProcess"))
            {
                signal.Reset();
                if (ResourceManager.GetValue("Product-GeneralSpecification", "UrmParamLogOut", false))
                {
                    Logger.WriteLineInfo("Matlab " + urmFold);
                }

                if (_SRLibWrapperProcess.HasExited)
                {
                    var analyzeHostName = Path.Combine(ServiceManager.RootPath, "URM", "net6.0", "SRLibWrapper.exe");
                    //if (!VinnoFile.Exists(analyzeHostName) || !DigitalSignatureChecker.VerifySignature(analyzeHostName))
                    //{
                    //    Logger.WriteLineErrorIf(Debug, "SRLibWrapper.exe not found or signature is invalid.");
                    //}
                    var startInfo = new ProcessStartInfo
                    {
                        FileName = analyzeHostName,
                        Arguments = $"",
                        CreateNoWindow = true,
                        UseShellExecute = false,
                        RedirectStandardOutput = true,
                        RedirectStandardInput = true,
                        RedirectStandardError = true,
                    };
                    _SRLibWrapperProcess.StartInfo = startInfo;
                    _SRLibWrapperProcess.Start();
                    _SRLibWrapperProcess.OutputDataReceived += OutputHandler;
                    _SRLibWrapperProcess.ErrorDataReceived += OutputHandler;
                    _SRLibWrapperProcess.BeginOutputReadLine();
                }

                _urmModeRecord = urmModeRecord;
                //_mode = Mode;
                // TODO 通过接口传入 urmStabilizer 的值
                //urmStabilizer = (int)_mode.Parameters.GetItem<FloatParameter>(RecordParams.URMStabilizer).Value;
                var step1info = "Step1," + urmStabilizer.ToString() + "," + urmFold;
                _SRLibWrapperProcess.StandardInput.WriteLine(step1info);
                int alltime = 0;
                while (alltime < 1800000)
                {
                    if (!signal.WaitOne(5000))
                    {
                        alltime += 5000;
                        if (_SRLibWrapperProcess.HasExited)
                        {
                            _processFlag = false;
                            signal.Set();
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                if (signal.WaitOne() && !_SRLibWrapperProcess.HasExited)
                {
                    if (_processFlag)
                        URMAnalysis();
                }
                else
                {
                    Logger.WriteLineError("Akio:URMAnalysisi TimeOut Or _SRLibWrapperProcess not exit");
                }
                if (_file != null)
                    _file.Dispose();
                return _processFlag;

            }
        }


        public bool URMAnalysis()
        {
            RecordNativeArray maskArray = new RecordNativeArray(0);
            using (var accessor = _file.CreateViewAccessor(0, 0))
            {
                IntPtr accessorptr = accessor.SafeMemoryMappedViewHandle.DangerousGetHandle();
                unsafe
                {
                    var pointptr = (byte*)accessorptr.ToPointer();
                    if (urmStabilizer < 2)
                    {
                        int packets = *(int*)pointptr;
                        pointptr += sizeof(int);
                        _urmwidth = *(int*)pointptr;
                        pointptr += sizeof(int);
                        _urmheight = *(int*)pointptr;
                        pointptr += sizeof(int);
                        aviFrames = *(int*)pointptr;
                        pointptr += sizeof(int);
                        if (packets <= 0 || _urmwidth <= 0 || _urmheight <= 0 || aviFrames <= 0)
                        {
                            return false;
                        }

                        var res = _urmModeRecord.URMRes;
                        var scaleofx = *(float*)pointptr * res;
                        pointptr += sizeof(float);
                        var scaleofy = *(float*)pointptr * res;
                        pointptr += sizeof(float);
                        //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_x, scaleofx);
                        //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_y, scaleofy);
                        _urmModeRecord.URMScaleOfPixel_x = scaleofx;
                        _urmModeRecord.URMScaleOfPixel_y = scaleofy;

                        maskArray.Resize(_urmwidth * _urmheight * sizeof(byte));
                        Buffer.MemoryCopy(pointptr, maskArray.Start.ToPointer(), _urmwidth * _urmheight * sizeof(byte), _urmwidth * _urmheight * sizeof(byte));
                        pointptr += _urmwidth * _urmheight * sizeof(byte);

                        RecordNativeArray matout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                        Buffer.MemoryCopy(pointptr, matout.Start.ToPointer(), _urmwidth * _urmheight * sizeof(double), _urmwidth * _urmheight * sizeof(double));
                        pointptr += _urmwidth * _urmheight * sizeof(double);

                        RecordNativeArray matdirout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                        Buffer.MemoryCopy(pointptr, matdirout.Start.ToPointer(), _urmwidth * _urmheight * sizeof(double), _urmwidth * _urmheight * sizeof(double));
                        pointptr += _urmwidth * _urmheight * sizeof(double);

                        RecordNativeArray matvelout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                        Buffer.MemoryCopy(pointptr, matvelout.Start.ToPointer(), _urmwidth * _urmheight * sizeof(double), _urmwidth * _urmheight * sizeof(double));
                        pointptr += _urmwidth * _urmheight * sizeof(double);

                        RecordNativeArray matangleout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                        Buffer.MemoryCopy(pointptr, matangleout.Start.ToPointer(), _urmwidth * _urmheight * sizeof(double), _urmwidth * _urmheight * sizeof(double));
                        pointptr += _urmwidth * _urmheight * sizeof(double);

                        Logger.WriteLineInfo($"Akio:_urmBeams is {_urmwidth},_urmSamples is {_urmheight},packets is {packets}");


                        //_urmModeRecord.SetParameter(RecordParams.URMDenArray, matout, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMDirArray, matdirout, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMVelArray, matvelout, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMAngleImgArray, matangleout, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMMask, maskArray, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMSrcHeight, _urmheight, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMSrcWidth, _urmwidth, TimeStamp.ErrorTime);
                        _urmModeRecord.URMDenArray = matout;  // RecordNativeArray
                        _urmModeRecord.URMDirArray = matdirout; // RecordNativeArray
                        _urmModeRecord.URMVelArray = matvelout; // RecordNativeArray
                        _urmModeRecord.URMAngleImgArray = matangleout; // RecordNativeArray
                        _urmModeRecord.URMMask = maskArray; // RecordNativeArray
                        _urmModeRecord.URMSrcHeight = _urmheight; // int
                        _urmModeRecord.URMSrcWidth = _urmwidth; // int


                        int[] PointNumList = new int[aviFrames];
                        for (int i = 0; i < aviFrames; i++)
                        {
                            PointNumList[i] = *(int*)pointptr;
                            pointptr += sizeof(int);
                        }

                        var AllPointNum = *(int*)pointptr;
                        pointptr += sizeof(int);
                        var pointsArray = new URMPoint[AllPointNum];
                        int sizeOfPoint = Marshal.SizeOf<URMPoint>();
                        int totalSize = sizeOfPoint * AllPointNum;
                        fixed (URMPoint* PointsArrayptr = pointsArray)
                        {
                            Buffer.MemoryCopy(pointptr, PointsArrayptr, totalSize, totalSize);
                        }
                        //_urmModeRecord.SetParameter(RecordParams.URMPoints, pointsArray, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMPointNums, PointNumList, TimeStamp.ErrorTime);
                        _urmModeRecord.URMPoints = pointsArray; // URMPoint[]
                        _urmModeRecord.URMPointNums = PointNumList; // int[]
                    }
                    else
                    {
                        _urmwidth = *(int*)pointptr;
                        pointptr += sizeof(int);
                        _urmheight = *(int*)pointptr;
                        pointptr += sizeof(int);
                        aviFrames = *(int*)pointptr;
                        pointptr += sizeof(int);
                        if (_urmwidth <= 0 || _urmheight <= 0 || aviFrames <= 0)
                        {
                            return false;
                        }

                        //var res = _urmModeRecord.GetParameter(RecordParams.URMRes, 10.0);
                        var res = _urmModeRecord.URMRes;
                        var scaleofx = *(float*)pointptr * res;
                        pointptr += sizeof(float);
                        var scaleofy = *(float*)pointptr * res;
                        pointptr += sizeof(float);
                        //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_x, scaleofx);
                        //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_y, scaleofy);
                        _urmModeRecord.URMScaleOfPixel_x = scaleofx;
                        _urmModeRecord.URMScaleOfPixel_y = scaleofy;

                        maskArray.Resize(_urmwidth * _urmheight * sizeof(byte));

                        Buffer.MemoryCopy(pointptr, maskArray.Start.ToPointer(), _urmwidth * _urmheight * sizeof(byte), _urmwidth * _urmheight * sizeof(byte));
                        pointptr += _urmwidth * _urmheight * sizeof(byte);

                        RecordNativeArray matangleout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                        Buffer.MemoryCopy(pointptr, matangleout.Start.ToPointer(), _urmwidth * _urmheight * sizeof(double), _urmwidth * _urmheight * sizeof(double));
                        pointptr += _urmwidth * _urmheight * sizeof(double);

                        RecordNativeArray matout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                        Buffer.MemoryCopy(pointptr, matout.Start.ToPointer(), _urmwidth * _urmheight * sizeof(double), _urmwidth * _urmheight * sizeof(double));
                        pointptr += _urmwidth * _urmheight * sizeof(double);

                        RecordNativeArray matdirout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                        Buffer.MemoryCopy(pointptr, matdirout.Start.ToPointer(), _urmwidth * _urmheight * sizeof(double), _urmwidth * _urmheight * sizeof(double));
                        pointptr += _urmwidth * _urmheight * sizeof(double);

                        RecordNativeArray matvelout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                        Buffer.MemoryCopy(pointptr, matvelout.Start.ToPointer(), _urmwidth * _urmheight * sizeof(double), _urmwidth * _urmheight * sizeof(double));
                        pointptr += _urmwidth * _urmheight * sizeof(double);

                        Logger.WriteLineInfo($"Akio:_urmBeams is {_urmwidth},_urmSamples is {_urmheight}");

                        //_urmModeRecord.SetParameter(RecordParams.URMDenArray, matout, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMDirArray, matdirout, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMVelArray, matvelout, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMAngleImgArray, matangleout, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMMask, maskArray, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMSrcHeight, _urmheight, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMSrcWidth, _urmwidth, TimeStamp.ErrorTime);
                        _urmModeRecord.URMDenArray = matout;  // RecordNativeArray
                        _urmModeRecord.URMDirArray = matdirout; // RecordNativeArray
                        _urmModeRecord.URMVelArray = matvelout; // RecordNativeArray
                        _urmModeRecord.URMAngleImgArray = matangleout; // RecordNativeArray
                        _urmModeRecord.URMMask = maskArray; // RecordNativeArray
                        _urmModeRecord.URMSrcHeight = _urmheight; // int
                        _urmModeRecord.URMSrcWidth = _urmwidth;
                        int[] PointNumList = new int[aviFrames];
                        for (int i = 0; i < aviFrames; i++)
                        {
                            PointNumList[i] = *(int*)pointptr;
                            pointptr += sizeof(int);
                        }

                        var AllPointNum = *(int*)pointptr;
                        pointptr += sizeof(int);
                        var pointsArray = new URMPoint[AllPointNum];
                        int sizeOfPoint = Marshal.SizeOf<URMPoint>();
                        int totalSize = sizeOfPoint * AllPointNum;
                        fixed (URMPoint* PointsArrayptr = pointsArray)
                        {
                            Buffer.MemoryCopy(pointptr, PointsArrayptr, totalSize, totalSize);
                        }
                        //_urmModeRecord.SetParameter(RecordParams.URMPoints, pointsArray, TimeStamp.ErrorTime);
                        //_urmModeRecord.SetParameter(RecordParams.URMPointNums, PointNumList, TimeStamp.ErrorTime);
                        _urmModeRecord.URMPoints = pointsArray; // URMPoint[]
                        _urmModeRecord.URMPointNums = PointNumList; // int[]
                    }

                }
            }
            return true;
        }
    }
}