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;

namespace WingAIDiagnosisService.URMManage
{
    [StructLayout(LayoutKind.Sequential)]
    public class URMAVIParam
    {
        public double Res { get; set; }
        public double ScaleOfPixel_x { get; set; }
        public double ScaleOfPixel_y { get; set; }
        public double IntPowerDir { get; set; }
        public double DownsampleIndexVideo { get; set; }
        public IntPtr MaskArray { get; set; }
        public URMAVIParam()
        {
            Res = 10;
            ScaleOfPixel_x = 1.0;
            ScaleOfPixel_y = 1.0;
            IntPowerDir = 0.25;
            DownsampleIndexVideo = 2;
            MaskArray = IntPtr.Zero;
        }
    };



    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 static ManualResetEvent signal = new ManualResetEvent(false);
        private int urmStabilizer = 0;
        private static URMAnalysisProcess instance;
        private bool _processFlag = false;
        private static readonly bool Debug = true;

        //private IMode _mode; // _mode 只是用于读取一个 urmStabilizer(int) 这里直接省略，先默认为 1，后续直接传入 urmStabilizer
        private URMAVIParam _urmaviParam;
        private URMAnalysisProcess()
        {

            _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()
        {
            if (_file != null)
                _file.Dispose();
            if (_SRLibWrapperProcess != null && !_SRLibWrapperProcess.HasExited)
            {
                _SRLibWrapperProcess.Kill();
                _SRLibWrapperProcess.Dispose();
            }
        }

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


        private void OutputHandler(object sender, DataReceivedEventArgs e)
        {
            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.ForceWriteLineIf(Debug, "Akio step1ok needmemorysize is {0}", 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.ForceWriteLineIf(Debug, "Akio step2ok");
                            signal.Set();
                            break;
                        case "SRLibFail":
                            _processFlag = false;
                            signal.Set();
                            Logger.WriteLineErrorIf(Debug, "AKio " + e.Data);
                            break;

                    }
                }
            }
        }

        public bool URMAnalysis(string urmFold, URMAnalysisModeRecord urmModeRecord)
        {
            using (new AutoPerformance("Akio:URMAnalysisProcess"))
            {
                signal.Reset();
                if (ResourceManager.GetValue("Product-GeneralSpecification", "UrmParamLogOut", false))
                {
                    Logger.ForceWriteLine("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 = false,
                        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.WriteLineErrorIf(Debug, "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 {0},_urmSamples is {1},packets is {2}", _urmwidth,
                            _urmheight, 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 {0},_urmSamples is {1}", _urmwidth,
                            _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;
        }
    }
}