URMDemo/URMPakcage/URM/URMAnalysisProcess.cs

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using MathWorks.MATLAB.NET.Arrays;
using Vinno.DataManager.Utilities;
using Vinno.DataTypes;
using Vinno.Infrastructure;
using Vinno.Models.Base.ParamMetas;
using SR_Main;
using SkiaSharp;
using System.IO;
using URMPakcage.URM;

namespace URMPackage.URM.URMAnalysis
{
    [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 struct POINT
    {
        public int X;
        public int Y;

        public POINT(int x, int y)
        {
            X = x;
            Y = y;
        }

        public override string ToString()
        {
            return ("X:" + X + ", Y:" + Y);
        }
    }


    public class URMAnalysisProcess
    {

        [DllImport("ImageProcessAlgWrapLibV2.dll")]
        private static extern IntPtr PIA_CreateURMAnalysisDataProcess();
        [DllImport("ImageProcessAlgWrapLibV2.dll")]
        private static extern void PIA_URMAnalysisDataProcess_Release(IntPtr handPtr);
        [DllImport("ImageProcessAlgWrapLibV2.dll")]
        private static extern unsafe bool PIA_URMGetLastResultFromPackets(IntPtr handPtr, IntPtr srcMats, IntPtr srcMatdirs, IntPtr srcMatvels, int packets, int srcwidth, int srcheight, IntPtr dstMat, IntPtr dstMatdir, IntPtr dstMatvel);
        [DllImport("ImageProcessAlgWrapLibV2.dll")]
        private static extern void PIA_TransposeImg(IntPtr handPtr, IntPtr srcdst, int beams, int samples);


        [DllImport("user32.dll", SetLastError = true)]
        private static extern bool GetCursorPos(out POINT pt);

        private IntPtr _handle;
        private IntPtr _handle_v1;
        //private ModeRecord _urmModeRecord;
        private bool initSrMain;
        private int _urmwidth;
        private int _urmheight;
        private double lambda;
        private int aviFrames;
        private VinnoSR urmAnalysis;
        //private IMode _mode;

        private URMAVIParam _urmaviParam;

        private double temp_ScaleOfPixel_x;
        private double temp_ScaleOfPixel_y;

        public double ScreenWidth = 980;
        public double ScreenHeight = 650;

        public List<List<SrPoint>> analysisDataPointNumListPoints;
        public int[] analysisDataPointNumList;


        //public URMAnalysisProcess(IMode mode, ModeRecord modeRecord)
        public URMAnalysisProcess()
        {
            _handle = PIA_CreateURMAnalysisDataProcess();
            _handle_v1 = URMAnalysisProcessV1.PIA_CreateSrProcess();
            urmAnalysis = new VinnoSR();
            //_urmModeRecord = modeRecord;
            //_mode = mode;
            _urmaviParam = new URMAVIParam();
        }

        public void Release()
        {
            PIA_URMAnalysisDataProcess_Release(_handle);
        }

        private NativeArray srcArray;
        private NativeArray srcArraydir;
        private NativeArray srcArrayvel;

        private int SrcWidth;
        private int SrcHeight;
        private Dictionary<string, SRColorBarParam> srColorBarParams;
        private NativeArray Densitycolormap;
        private int Densitycolormaplength;
        private NativeArray Directioncolormap;
        private int Directioncolormaplength;
        private NativeArray Velcolormap;
        private int Velcolormaplength;
        private NativeArray Avicolormap;
        private int AvicolormapLength;


        public bool URMAnalysis(string urmFold, string outputFolder, Action<string, string> funWriteLog)
        {

            if (urmAnalysis == null)
            {
                Logger.WriteLineError("SuperResolution error: SrMain, _srMain is null");

                return false;
            }
            funWriteLog.Invoke(outputFolder, "LoadColorBarParams start");
            LoadColorBarParams();
            funWriteLog.Invoke(outputFolder, "LoadColorBarParams end");

            int urmStabilizer = 0;
            MWArray folder = urmFold;
            //if (ResourceManager.GetValue("Product-GeneralSpecification", "UrmParamLogOut", false))
            //{
            //    Logger.ForceWriteLine("Matlab " + folder);
            //}
            //urmStabilizer = (int)_mode.Parameters.GetItem<FloatParameter>(RecordParams.URMStabilizer).Value;
            RecordNativeArray maskArray = new RecordNativeArray(0);
            funWriteLog.Invoke(outputFolder, $"urmStabilizer:{urmStabilizer}");
            if (urmStabilizer < 2)
            {
                var MatOuts = new List<float[,]>();
                var MatOutDirs = new List<float[,]>();
                var MatOutVels = new List<float[,]>();
                var PointList = new List<object[,]>();
                initSrMain = false;
                funWriteLog.Invoke(outputFolder, $"urmAnalysis.SR_Main start");
                var results = (MWCellArray)urmAnalysis.SR_Main(folder);
                funWriteLog.Invoke(outputFolder, $"urmAnalysis.SR_Main end");
                object[,] resultArrays = (object[,])results.ToArray();
                int packets = resultArrays.GetLength(1);
                for (int i = 0; i < packets; i++)
                {
                    funWriteLog.Invoke(outputFolder, $"packets1:{i}/{packets}");
                    object[,,] curresult = (object[,,])resultArrays[0, i];
                    float[,] curMat = (float[,])curresult[0, 0, 0];
                    float[,] curMatdir = (float[,])curresult[1, 0, 0];
                    float[,] curMatvel = (float[,])curresult[2, 0, 0];
                    object[,] curPoints = (object[,])curresult[7, 0, 0];
                    if (!initSrMain)
                    {
                        initSrMain = true;
                        _urmwidth = curMat.GetLength(1);
                        _urmheight = curMat.GetLength(0);
                        float[,] lambdaArray = (float[,])curresult[6, 0, 0];
                        lambda = (double)lambdaArray[0, 0];
                        aviFrames = curPoints.GetLength(1);
                        bool[,] maskdata = (bool[,])curresult[10, 0, 0];
                        double[,] Scalers = (double[,])curresult[8, 0, 0];
                        //var res = _urmModeRecord.GetParameter(RecordParams.URMRes, 10.0);
                        var res = 2.5;
                        var scaleofx = Scalers[0, 0] * res;
                        var scaleofy = Scalers[0, 1] * res;
                        temp_ScaleOfPixel_x = scaleofx;
                        temp_ScaleOfPixel_y = scaleofy;
                        //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_x, scaleofx);
                        //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_y, scaleofy);
                        unsafe
                        {
                            maskArray.Resize(_urmwidth * _urmheight * sizeof(byte));
                            byte* maskArrayPtr = (byte*)maskArray.Start.ToPointer();
                            for (int k = 0; k < _urmheight; k++)
                            {
                                for (int j = 0; j < _urmwidth; j++)
                                {
                                    var vel = maskdata[k, j];
                                    maskArrayPtr[j + k * _urmwidth] = vel ? (byte)1 : (byte)0;
                                }
                            }
                        }



                    }
                    MatOuts.Add(curMat);
                    MatOutDirs.Add(curMatdir);
                    MatOutVels.Add(curMatvel);
                    PointList.Add(curPoints);

                }
                funWriteLog.Invoke(outputFolder, $"packets1 end");
                RecordNativeArray matout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                RecordNativeArray matdirout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                RecordNativeArray matvelout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                // Console.WriteLine("Akio:_urmBeams is {0},_urmSamples is {1},packets is {2}", _urmwidth, _urmheight, packets);
                long nativelength = (long)_urmwidth * (long)_urmheight * 4L * (long)packets;
                NativeArray matOutNatveArray = new NativeArray(nativelength);
                NativeArray matOutDirNatveArray = new NativeArray(nativelength);
                NativeArray matOutVelNatveArray = new NativeArray(nativelength);
                funWriteLog.Invoke(outputFolder, $"unsafe 1");
                unsafe
                {
                    float* matOutNatveArrayPtr = (float*)matOutNatveArray.Start.ToPointer();
                    float* matOutDirNatveArrayPtr = (float*)matOutDirNatveArray.Start.ToPointer();
                    float* matOutVelNatveArrayPtr = (float*)matOutVelNatveArray.Start.ToPointer();
                    for (int i = 0; i < packets; i++)
                    {
                        funWriteLog.Invoke(outputFolder, $"packets2:{i}/{packets}");
                        float* curmatOutNatveArrayPtr = matOutNatveArrayPtr + (long)i * (_urmwidth * _urmheight);
                        float* curmatOutDirNatveArrayPtr = matOutDirNatveArrayPtr + (long)i * (_urmwidth * _urmheight);
                        float* curmatOutVelNatveArrayPtr = matOutVelNatveArrayPtr + (long)i * (_urmwidth * _urmheight);
                        float[,] MatOutArray = MatOuts[i];
                        float[,] MatOutDirArray = MatOutDirs[i];
                        float[,] MatOutVelArray = MatOutVels[i];
                        unsafe
                        {
                            for (int k = 0; k < _urmheight; k++)
                            {
                                for (int j = 0; j < _urmwidth; j++)
                                {
                                    var vel = MatOutArray[k, j];
                                    curmatOutNatveArrayPtr[j + k * _urmwidth] = vel;
                                    var veldir = MatOutDirArray[k, j];
                                    curmatOutDirNatveArrayPtr[j + k * _urmwidth] = veldir;
                                    var velvel = MatOutVelArray[k, j];
                                    curmatOutVelNatveArrayPtr[j + k * _urmwidth] = velvel;
                                }
                            }
                        }
                    }
                    funWriteLog.Invoke(outputFolder, $"packets2 end");
                    MatOuts.Clear();
                    MatOutDirs.Clear();
                    MatOutVels.Clear();



                    funWriteLog.Invoke(outputFolder, $"PIA_URMGetLastResultFromPackets start");
                    PIA_URMGetLastResultFromPackets(_handle, matOutNatveArray.Start, matOutDirNatveArray.Start, matOutVelNatveArray.Start, packets, _urmwidth,
                            _urmheight, matout.Start, matdirout.Start, matvelout.Start);
                    funWriteLog.Invoke(outputFolder, $"PIA_URMGetLastResultFromPackets end");

                    matOutNatveArray.Dispose();
                    matOutDirNatveArray.Dispose();
                    matOutVelNatveArray.Dispose();

                    SrcWidth = _urmwidth;
                    SrcHeight = _urmheight;
                    srcArray?.Dispose();
                    srcArray = new NativeArray(SrcWidth * SrcHeight * 8);
                    funWriteLog.Invoke(outputFolder, $"NativeArray init end");
                    unsafe
                    {
                        funWriteLog.Invoke(outputFolder, $"unsafe srcArray");
                        double* img = (double*)srcArray.Start.ToPointer();
                        double* matSrc = (double*)matout.Start.ToPointer();
                        funWriteLog.Invoke(outputFolder, $"SrcWidth * SrcHeight 1:{SrcWidth * SrcHeight}");
                        for (int i = 0; i < SrcWidth * SrcHeight; i++)
                        {
                            img[i] = matSrc[i];
                        }
                    }
                    funWriteLog.Invoke(outputFolder, $"WriteArrayToFile srcArray.bin start");
                    WriteArrayToFile(Path.Combine(outputFolder, "./srcArray.bin"), srcArray, SrcWidth * SrcHeight);
                    funWriteLog.Invoke(outputFolder, $"WriteArrayToFile srcArray.bin end");
                    srcArraydir?.Dispose();
                    srcArraydir = new NativeArray(SrcWidth * SrcHeight * 8);
                    unsafe
                    {
                        double* img = (double*)srcArraydir.Start.ToPointer();
                        double* matSrc = (double*)matdirout.Start.ToPointer();
                        funWriteLog.Invoke(outputFolder, $"SrcWidth * SrcHeight 2:{SrcWidth * SrcHeight}");
                        for (int i = 0; i < SrcWidth * SrcHeight; i++)
                        {
                            img[i] = matSrc[i];
                        }
                    }
                    funWriteLog.Invoke(outputFolder, $"WriteArrayToFile srcArraydir.bin start");
                    WriteArrayToFile(Path.Combine(outputFolder, "./srcArraydir.bin"), srcArraydir, SrcWidth * SrcHeight);
                    funWriteLog.Invoke(outputFolder, $"WriteArrayToFile srcArraydir.bin end");
                    srcArrayvel?.Dispose();
                    srcArrayvel = new NativeArray(SrcWidth * SrcHeight * 8);
                    unsafe
                    {
                        double* img = (double*)srcArrayvel.Start.ToPointer();
                        double* matSrc = (double*)matvelout.Start.ToPointer();
                        funWriteLog.Invoke(outputFolder, $"SrcWidth * SrcHeight 3:{SrcWidth * SrcHeight}");
                        for (int i = 0; i < SrcWidth * SrcHeight; i++)
                        {
                            img[i] = matSrc[i];
                        }
                    }
                    funWriteLog.Invoke(outputFolder, $"WriteArrayToFile srcArrayvel.bin start");
                    WriteArrayToFile(Path.Combine(outputFolder, "./srcArrayvel.bin"), srcArrayvel, SrcWidth * SrcHeight);
                    funWriteLog.Invoke(outputFolder, $"WriteArrayToFile srcArrayvel.bin end");

                    //_urmModeRecord.SetParameter(RecordParams.URMDenArray, matout, TimeStamp.ErrorTime);
                    //_urmModeRecord.SetParameter(RecordParams.URMDirArray, matdirout, TimeStamp.ErrorTime);
                    //_urmModeRecord.SetParameter(RecordParams.URMVelArray, matvelout, TimeStamp.ErrorTime);
                    //_urmModeRecord.SetParameter(RecordParams.URMMask, maskArray, TimeStamp.ErrorTime);
                    //_urmModeRecord.SetParameter(RecordParams.URMSrcHeight, _urmheight,TimeStamp.ErrorTime);
                    //_urmModeRecord.SetParameter(RecordParams.URMSrcWidth, _urmwidth, TimeStamp.ErrorTime);
                }



                List<List<SrPoint>> CombPointsList = new List<List<SrPoint>>();
                int[] PointNumList = new int[aviFrames];
                //List<URMPoint> pointsList = new List<URMPoint>();
                for (int i = 0; i < aviFrames; i++)
                {
                    funWriteLog.Invoke(outputFolder, $"aviFrames：{i}/{aviFrames}");
                    int PointNum = 0;
                    List<SrPoint> curPointsList = new List<SrPoint>();
                    for (int j = 0; j < PointList.Count; j++)
                    {
                        funWriteLog.Invoke(outputFolder, $"PointList：{j}/{PointList.Count}");
                        object[,] curpointArray = PointList[j];
                        if (curpointArray[0, i] is double[,])
                        {
                            double[,] CurPointsArray = (double[,])curpointArray[0, i];
                            var curPointsCount = CurPointsArray.GetLength(0);
                            PointNum += curPointsCount;
                            for (int k = 0; k < curPointsCount; k++)
                            {
                                //URMPoint curPoint = new URMPoint();
                                SrPoint curSrPoint = new SrPoint();
                                //curPoint.X = (float)CurPointsArray[k, 0];
                                //curPoint.Y = (float)CurPointsArray[k, 1];
                                //curPoint.vel = (float)CurPointsArray[k, 2];
                                curSrPoint.X = (float)CurPointsArray[k, 0];
                                curSrPoint.Y = (float)CurPointsArray[k, 1];
                                curSrPoint.vel = (float)CurPointsArray[k, 2];
                                //pointsList.Add(curPoint);
                                curPointsList.Add(curSrPoint);
                            }
                        }
                        else if (curpointArray[0, i] is float[,])
                        {
                            float[,] CurPointsArray = (float[,])curpointArray[0, i];
                            var curPointsCount = CurPointsArray.GetLength(0);
                            PointNum += curPointsCount;
                            for (int k = 0; k < curPointsCount; k++)
                            {
                                //URMPoint curPoint = new URMPoint();
                                SrPoint curSrPoint = new SrPoint();
                                //curPoint.X = CurPointsArray[k, 0];
                                //curPoint.Y = CurPointsArray[k, 1];
                                //curPoint.vel = CurPointsArray[k, 2];
                                curSrPoint.X = (float)CurPointsArray[k, 0];
                                curSrPoint.Y = (float)CurPointsArray[k, 1];
                                curSrPoint.vel = (float)CurPointsArray[k, 2];
                                //pointsList.Add(curPoint);
                                curPointsList.Add(curSrPoint);
                            }
                        }
                    }
                    CombPointsList.Add(curPointsList);
                    PointNumList[i] = PointNum;
                }
                analysisDataPointNumList = PointNumList;
                analysisDataPointNumListPoints = CombPointsList;
                //var pointsarray = pointsList.ToArray();

                //_urmModeRecord.SetParameter(RecordParams.URMPoints, pointsarray, TimeStamp.ErrorTime);
                //_urmModeRecord.SetParameter(RecordParams.URMPointNums, PointNumList, TimeStamp.ErrorTime);
            }
            else
            {

                funWriteLog.Invoke(outputFolder, $"urmAnalysis.SR_Main：start");
                var result = (MWStructArray)urmAnalysis.SR_Main(folder);
                var MatOut = (MWNumericArray)result.GetField("MatOut");
                var MatOut_zdir = (MWNumericArray)result.GetField("MatOut_zdir");
                var MatOut_vel = (MWNumericArray)result.GetField("MatOut_vel");
                var llz = (MWNumericArray)result.GetField("llz");
                var llx = (MWNumericArray)result.GetField("llx");
                var lambda = (MWNumericArray)result.GetField("lambda");
                var Points = (MWCellArray)result.GetField("Points");
                var Scalers = (MWNumericArray)result.GetField("SRscale");
                double[,] scalersArray = (double[,])Scalers.ToArray();
                //var res = _urmModeRecord.GetParameter(RecordParams.URMRes, 10.0);
                //var scaleofx = scalersArray[0, 0] * res;
                //var scaleofy = scalersArray[0, 1] * res;
                //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_x, scaleofx);
                //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_y, scaleofy);
                var ROIMask = (MWLogicalArray)result.GetField("ROIMask");
                double[,] lambdaArray = (double[,])lambda.ToArray();
                //var lambda1 = lambdaArray[0, 0];
                bool[,] maskdata = (bool[,])ROIMask.ToArray();
                double[,] MatOutArray = (double[,])MatOut.ToArray();
                double[,] MatOutDirArray = (double[,])MatOut_zdir.ToArray();
                double[,] MatOutVelArray = (double[,])MatOut_vel.ToArray();
                _urmwidth = MatOutArray.GetLength(1);
                _urmheight = MatOutArray.GetLength(0);
                funWriteLog.Invoke(outputFolder, $"RecordNativeArray：start");
                RecordNativeArray matout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                RecordNativeArray matdirout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                RecordNativeArray matvelout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
                maskArray.Resize(_urmwidth * _urmheight * sizeof(byte));
                unsafe
                {
                    double* matOutNatveArrayPtr = (double*)matout.Start.ToPointer();
                    double* matOutDirNatveArrayPtr = (double*)matdirout.Start.ToPointer();
                    double* matOutVelNatveArrayPtr = (double*)matvelout.Start.ToPointer();
                    byte* maskArrayPtr = (byte*)maskArray.Start.ToPointer();
                    for (int i = 0; i < _urmheight; i++)
                    {
                        funWriteLog.Invoke(outputFolder, $"_urmheight：{i}/{_urmheight}");
                        for (int j = 0; j < _urmwidth; j++)
                        {
                            funWriteLog.Invoke(outputFolder, $"_urmwidth：{j}/{_urmwidth}");
                            var vel = MatOutArray[i, j];
                            matOutNatveArrayPtr[j + i * _urmwidth] = vel;
                            var veldir = MatOutDirArray[i, j];
                            matOutDirNatveArrayPtr[j + i * _urmwidth] = veldir;
                            var velvel = MatOutVelArray[i, j];
                            matOutVelNatveArrayPtr[j + i * _urmwidth] = velvel;
                            var maskvel = maskdata[i, j];
                            maskArrayPtr[j + i * _urmwidth] = maskvel ? (byte)1 : (byte)0;
                        }
                    }
                }

                object[,] pointArray = (object[,])Points.ToArray();
                aviFrames = Points.Dimensions[1];
                //List<URMPoint> pointsList = new List<URMPoint>();
                int[] PointNumList = new int[aviFrames];
                for (int i = 0; i < aviFrames; i++)
                {
                    funWriteLog.Invoke(outputFolder, $"aviFrames2：{i}/{aviFrames}");

                    float[,] CurPointsArray = (float[,])pointArray[0, i];
                    var curPointsCount = CurPointsArray.GetLength(0);
                    for (int k = 0; k < curPointsCount; k++)
                    {
                        funWriteLog.Invoke(outputFolder, $"curPointsCount2：{k}/{curPointsCount}");
                        //URMPoint curPoint = new URMPoint();
                        //curPoint.X = CurPointsArray[k, 0];
                        //curPoint.Y = CurPointsArray[k, 1];
                        //curPoint.vel = CurPointsArray[k, 2];
                        //pointsList.Add(curPoint);
                    }
                    PointNumList[i] = curPointsCount;
                }
                //var pointsarray = pointsList.ToArray();

            }


            /// 尝试获取图像并保存
            var DensityColorParam = srColorBarParams["Density"];
            var lambda1 = lambda;
            int srcwidth = SrcWidth;
            int srcheight = SrcHeight;
            int downsampleIndex = 3;

            int dstwidthbeforeResize = (int)(srcwidth * downsampleIndex * (temp_ScaleOfPixel_y / temp_ScaleOfPixel_x) / 2.5 + 0.5);
            int dstheightbeforeResiz = (int)(srcheight * downsampleIndex / 2.5 + 0.5);
            double widthScale = ScreenWidth / dstwidthbeforeResize;
            double heightScale = ScreenHeight / dstheightbeforeResiz;
            double ScanScale = widthScale < heightScale ? widthScale : heightScale;

            //int dstwidth = (int)(dstwidthbeforeResize * ScanScale + 0.5);
            //int dstheight = (int)(dstheightbeforeResiz * ScanScale + 0.5);

            int dstwidth = (int)(dstwidthbeforeResize);
            int dstheight = (int)(dstheightbeforeResiz);

            //var cmPerPixel = GetCmPerPixel(srParams, ScanScale, lambda1);
            //var scaleBar = _adorners.FirstOrDefault(x => x is TissueScaleBar) as TissueScaleBar;
            //var logoMark = _adorners.FirstOrDefault(x => x is LogoMark) as LogoMark;

            double tempmax = 0;
            double tempmin = 0;
            funWriteLog.Invoke(outputFolder, $"NativeArray48 start");
            NativeArray dstArray = new NativeArray(4 * dstwidth * dstheight);
            NativeArray dstArrayu = new NativeArray(8 * dstwidth * dstheight); //需要保存的原始八位数据
            funWriteLog.Invoke(outputFolder, $"GetSRColorMap start");
            GetSRColorMap(DensityColorParam.ColorMap, ref Densitycolormap, out Densitycolormaplength);
            funWriteLog.Invoke(outputFolder, $"GetSRColorMap end");

            var srParams = new SrParams();
            srParams.Res = 1;
            srParams.ScaleOfPixel_x = temp_ScaleOfPixel_x;
            srParams.ScaleOfPixel_y = temp_ScaleOfPixel_y;
            srParams.DownsampleIndex = 1;

            funWriteLog.Invoke(outputFolder, $"URMAnalysisProcessV1.PIA_SetSrParam start");
            URMAnalysisProcessV1.PIA_SetSrParam(_handle_v1, srParams);
            funWriteLog.Invoke(outputFolder, $"URMAnalysisProcessV1.PIA_SetSrParam end");


            try
            {
                funWriteLog.Invoke(outputFolder, $"URMAnalysisProcessV1.PIA_SRGetDensityImg start");
                bool success = URMAnalysisProcessV1.PIA_SRGetDensityImg(_handle_v1, srcArray.Start, srcwidth, srcheight, dstArray.Start, dstArrayu.Start, dstwidth, dstheight, Densitycolormap.Start, Densitycolormaplength, lambda1, ref tempmax, ref tempmin, 1);
                funWriteLog.Invoke(outputFolder, $"URMAnalysisProcessV1.PIA_SRGetDensityImg end");

                // Console.WriteLine("PIA_SRGetDensityImg: " + success);
                funWriteLog.Invoke(outputFolder, $"SaveDstImg.den start");
                SaveDstImg(dstwidth, dstheight, dstArray, "den", outputFolder);
                funWriteLog.Invoke(outputFolder, $"SaveDstImg.den end");
            }
            catch (Exception e)
            {
                // Console.WriteLine("An error occurred: " + e.Message);
            }

            /// Direction
            var DirectionColorParam = srColorBarParams["Direction"];
            funWriteLog.Invoke(outputFolder, $"GetSRColorMap Directioncolormap Directioncolormaplength start");
            GetSRColorMap(DirectionColorParam.ColorMap, ref Directioncolormap, out Directioncolormaplength);
            funWriteLog.Invoke(outputFolder, $"GetSRColorMap Directioncolormap Directioncolormaplength end");
            dstArrayu = new NativeArray(dstwidth * dstheight);
            try
            {
                funWriteLog.Invoke(outputFolder, $"URMAnalysisProcessV1.PIA_SRGetDirectionImg 123 start");
                bool success = URMAnalysisProcessV1.PIA_SRGetDirectionImg(_handle_v1, srcArraydir.Start, srcArray.Start, srcwidth, srcheight, dstArray.Start, dstArrayu.Start, dstwidth, dstheight, Directioncolormap.Start, Directioncolormaplength, lambda1, ref tempmax, ref tempmin, 5);
                funWriteLog.Invoke(outputFolder, $"URMAnalysisProcessV1.PIA_SRGetDirectionImg 123 end");
                // Console.WriteLine("PIA_SRGetDirectionImg: " + success);
                funWriteLog.Invoke(outputFolder, $"SaveDstImg。dir 123 start");
                SaveDstImg(dstwidth, dstheight, dstArray, "dir", outputFolder);
                funWriteLog.Invoke(outputFolder, $"SaveDstImg。dir 123 end");
            }
            catch (Exception e)
            {
                // Console.WriteLine("An error occurred: " + e.Message);
            }

            /// Vel
            var VelColorParam = srColorBarParams["Vel"];
            funWriteLog.Invoke(outputFolder, $"1");
            GetSRColorMap(VelColorParam.ColorMap, ref Velcolormap, out Velcolormaplength);
            funWriteLog.Invoke(outputFolder, $"2");
            dstArrayu = new NativeArray(8 * dstwidth * dstheight);
            funWriteLog.Invoke(outputFolder, $"3");
            try
            {
                funWriteLog.Invoke(outputFolder, $"4");
                bool success = URMAnalysisProcessV1.PIA_SRGetVelImg(_handle_v1, srcArrayvel.Start, srcArray.Start, srcwidth, srcheight, dstArray.Start, dstArrayu.Start, dstwidth, dstheight, Velcolormap.Start, Velcolormaplength, lambda1, ref tempmax, ref tempmin, 1);
                funWriteLog.Invoke(outputFolder, $"5");
                // Console.WriteLine("PIA_SRGetVelImg: " + success);
                funWriteLog.Invoke(outputFolder, $"6");
                SaveDstImg(dstwidth, dstheight, dstArray, "vel", outputFolder);
                funWriteLog.Invoke(outputFolder, $"7");
            }
            catch (Exception e)
            {
                // Console.WriteLine("An error occurred: " + e.Message);
            }

            // 生成 avi
            //生成avi 先设置背景图
            //int dstwidthback = (int)(srcwidth * srParams.DownsampleIndexVideo * (srParams.ScaleOfPixel_y / srParams.ScaleOfPixel_x) / srParams.Res + 0.5);
            //int dstheightback = (int)(srcheight * srParams.DownsampleIndexVideo / srParams.Res + 0.5);
            int dstwidthback = srcwidth;
            int dstheightback = srcheight;
            funWriteLog.Invoke(outputFolder, $"8");
            URMAnalysisProcessV1.PIA_CalBackgroundImg(_handle_v1, srcArray.Start, srcArraydir.Start, srcwidth, srcheight, dstwidthback, dstheightback);
            funWriteLog.Invoke(outputFolder, $"9");
            int aviwidth = srcwidth;
            int aviheight = srcheight;
            aviwidth += (aviwidth % 2);
            aviheight += (aviheight % 2);

            int[] pointlengths = analysisDataPointNumList;
            var frams = pointlengths.Length;
            funWriteLog.Invoke(outputFolder, $"10");
            NativeArray dstMats = new NativeArray((long)aviheight * aviwidth * 4 * frams);//所有的图都保存在这个段内存中
            funWriteLog.Invoke(outputFolder, $"11");
            unsafe
            {
                SrPoint*[] DrawPoints = new SrPoint*[frams];
                List<List<SrPoint>> CombPoints = analysisDataPointNumListPoints;
                for (int i = 0; i < frams; i++)
                {
                    funWriteLog.Invoke(outputFolder, $"12 {i}/{frams}");
                    SrPoint[] curPoints = CombPoints[i].ToArray();
                    if (curPoints == null || curPoints.Length == 0)
                    {
                        DrawPoints[i] = null;
                    }
                    else
                    {
                        fixed (SrPoint* curPointsptr = &curPoints[0])
                        {
                            DrawPoints[i] = curPointsptr;
                        }
                    }
                }

                funWriteLog.Invoke(outputFolder, $"13");
                fixed (SrPoint** AllPointsPtr = &DrawPoints[0])
                {
                    fixed (int* pointlengthsptr = &pointlengths[0])
                    {
                        var AviColorParam = srColorBarParams["SRAvi"];
                        funWriteLog.Invoke(outputFolder, $"14");
                        GetSRColorMap(AviColorParam.ColorMap, ref Avicolormap, out AvicolormapLength);
                        funWriteLog.Invoke(outputFolder, $"15");
                        URMAnalysisProcessV1.PIA_CalSrAvi(_handle_v1, AllPointsPtr, frams, pointlengthsptr, dstMats.Start, aviwidth,
                            aviheight, Avicolormap.Start, AvicolormapLength);
                        funWriteLog.Invoke(outputFolder, $"16");
                    }
                }
            }

            var aviframesize = aviwidth * aviheight * 4;
            var curptr = dstMats.Start;
            // 获取当前时间戳
            funWriteLog.Invoke(outputFolder, $"17");
            string timeStamp = DateTime.Now.ToString("yyyyMMddHHmmss");
            for (var i = 0; i < frams; i++)
            {
                funWriteLog.Invoke(outputFolder, $"18 {i}/{frams}");
                var curMatptr = curptr;
                SaveDstImgByPtr(aviwidth, aviheight, curMatptr, i.ToString(), outputFolder);
                curptr = curMatptr + aviframesize;
            }



            dstArray.Dispose();
            dstArrayu.Dispose();
            return true;
        }

        public bool URMAnalysisFromData(string outputFolder)
        {
            LoadColorBarParams();
            SrcWidth = 320;
            SrcHeight = 1185;
            temp_ScaleOfPixel_x = 0.212260852677748;
            temp_ScaleOfPixel_y = 0.493506493506494;
            lambda = 0.4;
            if (!File.Exists("./srcArray.bin"))
            {
                // Console.WriteLine("Error: File not found - " + "srcArray.bin");
                return false;
            }
            srcArray = ReadArrayFromFile("./srcArray.bin", SrcWidth * SrcHeight);
            srcArraydir = ReadArrayFromFile("./srcArraydir.bin", SrcWidth * SrcHeight);
            srcArrayvel = ReadArrayFromFile("./srcArrayvel.bin", SrcWidth * SrcHeight);
            /// 尝试获取图像并保存

            var lambda1 = lambda;
            int srcwidth = SrcWidth;
            int srcheight = SrcHeight;
            int downsampleIndex = 3;

            int dstwidthbeforeResize = (int)(srcwidth * downsampleIndex * (temp_ScaleOfPixel_y / temp_ScaleOfPixel_x) / 2.5 + 0.5);
            int dstheightbeforeResiz = (int)(srcheight * downsampleIndex / 2.5 + 0.5);
            double widthScale = ScreenWidth / dstwidthbeforeResize;
            double heightScale = ScreenHeight / dstheightbeforeResiz;
            double ScanScale = widthScale < heightScale ? widthScale : heightScale;

            //int dstwidth = (int)(dstwidthbeforeResize * ScanScale + 0.5);
            //int dstheight = (int)(dstheightbeforeResiz * ScanScale + 0.5);

            int dstwidth = (int)(dstwidthbeforeResize);
            int dstheight = (int)(dstheightbeforeResiz);

            double tempmax = 0;
            double tempmin = 0;
            NativeArray dstArray = new NativeArray(4 * dstwidth * dstheight);
            NativeArray dstArrayu = new NativeArray(8 * dstwidth * dstheight); //需要保存的原始八位数据

            var srParams = new SrParams();
            srParams.Res = 1;
            srParams.ScaleOfPixel_x = temp_ScaleOfPixel_x;
            srParams.ScaleOfPixel_y = temp_ScaleOfPixel_y;
            srParams.DownsampleIndex = 1;

            URMAnalysisProcessV1.PIA_SetSrParam(_handle_v1, srParams);

            // Density
            var DensityColorParam = srColorBarParams["Density"];
            GetSRColorMap(DensityColorParam.ColorMap, ref Densitycolormap, out Densitycolormaplength);
            try
            {
                bool success = URMAnalysisProcessV1.PIA_SRGetDensityImg(_handle_v1, srcArray.Start, srcwidth, srcheight, dstArray.Start, dstArrayu.Start, dstwidth, dstheight, Densitycolormap.Start, Densitycolormaplength, lambda1, ref tempmax, ref tempmin, 1);
                byte[] dstMatu = new byte[8 * dstwidth * dstheight];
                Marshal.Copy(dstArrayu.Start, dstMatu, 0, 8 * dstwidth * dstheight);
                WriteByteArrayToFile("./urmMeasureData.bin", dstMatu);
                // Console.WriteLine("PIA_SRGetDensityImg: " + success);
                SaveDstImg(dstwidth, dstheight, dstArray, "den", outputFolder);
            }
            catch (Exception e)
            {
                // Console.WriteLine("An error occurred: " + e.Message);
            }

            /// Direction
            var DirectionColorParam = srColorBarParams["Direction"];
            GetSRColorMap(DirectionColorParam.ColorMap, ref Directioncolormap, out Directioncolormaplength);
            dstArrayu = new NativeArray(dstwidth * dstheight);
            try
            {
                bool success = URMAnalysisProcessV1.PIA_SRGetDirectionImg(_handle_v1, srcArraydir.Start, srcArray.Start, srcwidth, srcheight, dstArray.Start, dstArrayu.Start, dstwidth, dstheight, Directioncolormap.Start, Directioncolormaplength, lambda1, ref tempmax, ref tempmin, 5);
                // Console.WriteLine("PIA_SRGetDirectionImg: " + success);
                SaveDstImg(dstwidth, dstheight, dstArray, "dir", outputFolder);
            }
            catch (Exception e)
            {
                // Console.WriteLine("An error occurred: " + e.Message);
            }

            /// Vel
            var VelColorParam = srColorBarParams["Vel"];
            GetSRColorMap(VelColorParam.ColorMap, ref Velcolormap, out Velcolormaplength);
            dstArrayu = new NativeArray(8 * dstwidth * dstheight);
            try
            {
                bool success = URMAnalysisProcessV1.PIA_SRGetVelImg(_handle_v1, srcArrayvel.Start, srcArray.Start, srcwidth, srcheight, dstArray.Start, dstArrayu.Start, dstwidth, dstheight, Velcolormap.Start, Velcolormaplength, lambda1, ref tempmax, ref tempmin, 1);
                // Console.WriteLine("PIA_SRGetVelImg: " + success);
                SaveDstImg(dstwidth, dstheight, dstArray, "vel", outputFolder);
            }
            catch (Exception e)
            {
                // Console.WriteLine("An error occurred: " + e.Message);
            }

            // 生成 avi
            //生成avi 先设置背景图
            //int dstwidthback = (int)(srcwidth * srParams.DownsampleIndexVideo * (srParams.ScaleOfPixel_y / srParams.ScaleOfPixel_x) / srParams.Res + 0.5);
            //int dstheightback = (int)(srcheight * srParams.DownsampleIndexVideo / srParams.Res + 0.5);
            //int dstwidthback = srcwidth;
            //int dstheightback = srcheight;
            //URMAnalysisProcessV1.PIA_CalBackgroundImg(_handle_v1, srcArray.Start, srcArraydir.Start, srcwidth, srcheight, dstwidthback, dstheightback);
            //int aviwidth = srcwidth;
            //int aviheight = srcheight;
            //aviwidth += (aviwidth % 2);
            //aviheight += (aviheight % 2);

            //int[] pointlengths = analysisDataPointNumList;
            //var frams = pointlengths.Length;
            //NativeArray dstMats = new NativeArray((long)aviheight * aviwidth * 4 * frams);//所有的图都保存在这个段内存中
            //unsafe
            //{
            //    SrPoint*[] DrawPoints = new SrPoint*[frams];
            //    List<List<SrPoint>> CombPoints = analysisDataPointNumListPoints;
            //    for (int i = 0; i < frams; i++)
            //    {
            //        SrPoint[] curPoints = CombPoints[i].ToArray();
            //        if (curPoints == null || curPoints.Length == 0)
            //        {
            //            DrawPoints[i] = null;
            //        }
            //        else
            //        {
            //            fixed (SrPoint* curPointsptr = &curPoints[0])
            //            {
            //                DrawPoints[i] = curPointsptr;
            //            }
            //        }
            //    }

            //    fixed (SrPoint** AllPointsPtr = &DrawPoints[0])
            //    {
            //        fixed (int* pointlengthsptr = &pointlengths[0])
            //        {
            //            var AviColorParam = srColorBarParams["SRAvi"];
            //            GetSRColorMap(AviColorParam.ColorMap, ref Avicolormap, out AvicolormapLength);
            //            URMAnalysisProcessV1.PIA_CalSrAvi(_handle_v1, AllPointsPtr, frams, pointlengthsptr, dstMats.Start, aviwidth,
            //                aviheight, Avicolormap.Start, AvicolormapLength);
            //        }
            //    }
            //}

            //var aviframesize = aviwidth * aviheight * 4;
            //var curptr = dstMats.Start;
            //for (var i = 0; i < frams; i++)
            //{
            //    var curMatptr = curptr;
            //    SaveDstImgByPtr(aviwidth, aviheight, curMatptr, i.ToString());
            //    curptr = curMatptr + aviframesize;
            //}


            dstArray.Dispose();
            dstArrayu.Dispose();
            return true;
        }
        private void GetSRColorMap(string colorMap, ref NativeArray colorMapArray, out int talbelength)
        {
            ColorMapConfig config = new ColorMapConfig(colorMap);
            colorMapArray?.Dispose();
            var talbelengthlist = new List<int>();
            var rValue = config.getValueR();
            var gValue = config.getValueG();
            var bValue = config.getValueB();
            talbelength = config.getValueLength();
            var result = talbelength > 0;
            colorMapArray = new NativeArray(talbelength * 4);
            if (result)
            {
                unsafe
                {
                    byte* colormapptr = (byte*)colorMapArray.Start.ToPointer();
                    for (int i = 0; i < talbelength; i++)
                    {
                        colormapptr[4 * i] = (byte)bValue[i];
                        colormapptr[4 * i + 1] = (byte)gValue[i];
                        colormapptr[4 * i + 2] = (byte)rValue[i];
                        colormapptr[4 * i + 3] = 0;
                    }
                }

            }
        }

        private void LoadColorBarParams()
        {
            srColorBarParams = new Dictionary<string, SRColorBarParam>();
            //var colorConfigs = ResourceManager.GetValue("SRMap", "SRMap", string.Empty);
            var colorConfigs = "[\"Density SRColorMap:ColorMap1\" \"Direction SRColorMap:ColorMap2\" \"Vel SRColorMap:ColorMap3\" \"SRAvi SRColorMap:ColorMap4\"]";
            if (!string.IsNullOrEmpty(colorConfigs))
            {
                EnumMeta enumMeta = ParamMetaSection.CreateMeta(colorConfigs) as EnumMeta;
                if (enumMeta?.Values.Length > 0)
                {
                    foreach (var config in enumMeta.Values)
                    {
                        SRColorBarParam curBarParam = new SRColorBarParam();
                        var elements = config.Split(' ');
                        if (elements.Length == 2)
                        {
                            var title = elements[0].Trim();
                            var mapConfigs = elements[1].Trim();
                            curBarParam.ColorMap = mapConfigs;
                            srColorBarParams.Add(title, curBarParam);
                        }
                    }
                }
            }
        }

        public void TransposeImg(IntPtr imgPtr, int beams, int samples)
        {
            PIA_TransposeImg(_handle, imgPtr, beams, samples);
        }

        static bool SaveDstImg(int dstWidth, int dstHeight, NativeArray dstArray, string imgType, string outputFolder)
        {
            unsafe
            {
                byte* ptr = (byte*)dstArray.Start.ToPointer();

                for (int i = 0; i < dstWidth * dstHeight; i++)
                {
                    int offset = i * 4;
                    byte blue = ptr[offset];
                    byte green = ptr[offset + 1];
                    byte red = ptr[offset + 2];
                    if (blue + green + red > 0)
                    {
                        ptr[offset + 3] = 255; // 设置alpha通道为不透明
                    }
                    else
                    {
                        ptr[offset + 3] = 0; // 设置alpha通道为透明
                    }
                }
            }

            var converter = new ImageConverter();
            if (converter.ConvertToImage(dstWidth, dstHeight, dstArray.Start, (int)dstArray.Length, out SKBitmap bitmap))
            {
                // 使用bitmap，例如保存为文件
                using (var image = SKImage.FromBitmap(bitmap))
                using (var data = image.Encode(SKEncodedImageFormat.Png, 100))
                {
                    // 将数据编码为Base64字符串并打印
                    var base64String = Convert.ToBase64String(data.ToArray());
                    // Console.WriteLine(base64String);
                    // 获取当前时间戳
                    string timeStamp = DateTime.Now.ToString("yyyyMMddHHmmss");

                    // 获取图像分辨率
                    string resolution = $"{dstWidth}x{dstHeight}";

                    // 创建带有时间戳和分辨率的文件名
                    string fileName = $"{imgType}_output_{timeStamp}_{resolution}.png";
                    var filePath = Path.Combine(outputFolder, fileName);
                    using (var stream = File.OpenWrite(filePath))
                    {
                        data.SaveTo(stream);
                    }
                }

                // 释放资源
                bitmap.Dispose();
            }

            return true;
        }

        static bool SaveDstImgByPtr(int dstWidth, int dstHeight, IntPtr intPtr, string index, string parentFolderName)
        {
            unsafe
            {
                byte* ptr = (byte*)intPtr;

                for (int i = 0; i < dstWidth * dstHeight; i++)
                {
                    int offset = i * 4;
                    byte blue = ptr[offset];
                    byte green = ptr[offset + 1];
                    byte red = ptr[offset + 2];
                    if (blue + green + red > 0)
                    {
                        ptr[offset + 3] = 255; // 设置alpha通道为不透明
                    }
                    else
                    {
                        ptr[offset + 3] = 0; // 设置alpha通道为透明
                    }
                }
            }

            var converter = new ImageConverter();
            if (converter.ConvertToImage(dstWidth, dstHeight, intPtr, dstWidth * dstHeight * 4, out SKBitmap bitmap))
            {
                // 使用bitmap，例如保存为文件
                using (var image = SKImage.FromBitmap(bitmap))
                using (var data = image.Encode(SKEncodedImageFormat.Png, 100))
                {
                    // 将数据编码为Base64字符串并打印
                    var base64String = Convert.ToBase64String(data.ToArray());

                    // 获取图像分辨率
                    string resolution = $"{dstWidth}x{dstHeight}";

                    // 创建带有时间戳和分辨率的文件名
                    string fileName = $"avi_{index}_output_{resolution}.png";

                    // 确保父级文件夹存在，如果不存在则创建
                    var aviFolder = Path.Combine(parentFolderName, "avi");
                    if (!Directory.Exists(aviFolder))
                    {
                        Directory.CreateDirectory(aviFolder);
                    }

                    // 生成文件路径
                    string filePath = Path.Combine(aviFolder, fileName);

                    using (var stream = File.OpenWrite(filePath))
                    {
                        data.SaveTo(stream);
                    }
                }

                // 释放资源
                bitmap.Dispose();
            }

            return true;
        }

        static void WriteArrayToFile(string filePath, NativeArray array, int length)
        {
            using (BinaryWriter writer = new BinaryWriter(File.Open(filePath, FileMode.Create)))
            {
                unsafe
                {
                    double* data = (double*)array.Start.ToPointer();
                    for (int i = 0; i < length; i++)
                    {
                        writer.Write(data[i]);
                    }
                }
            }
        }


        static NativeArray ReadArrayFromFile(string filePath, int length)
        {
            NativeArray array = new NativeArray(length * 8);
            using (BinaryReader reader = new BinaryReader(File.Open(filePath, FileMode.Open)))
            {
                unsafe
                {
                    double* data = (double*)array.Start.ToPointer();
                    for (int i = 0; i < length; i++)
                    {
                        data[i] = reader.ReadDouble();
                    }
                }
            }
            return array;
        }

        // 将 byte[] 数组写入文件
        public static void WriteByteArrayToFile(string filePath, byte[] array)
        {
            using (BinaryWriter writer = new BinaryWriter(File.Open(filePath, FileMode.Create)))
            {
                writer.Write(array);
            }
        }

        // 从文件读取 byte[] 数组
        public static byte[] ReadByteArrayFromFile(string filePath)
        {
            using (BinaryReader reader = new BinaryReader(File.Open(filePath, FileMode.Open)))
            {
                long length = reader.BaseStream.Length;
                byte[] array = new byte[length];
                reader.Read(array, 0, (int)length);
                return array;
            }
        }
    }
}

public enum UrmImageType
{
    Unknown,
    Raw,
    Den,
    Dir,
    Vel
}

[StructLayout(LayoutKind.Sequential), Serializable]
public struct SrPoint
{
    public float X;
    public float Y;
    public float vel;
}

[Serializable, StructLayout(LayoutKind.Sequential)]
public class SrParams
{
    //Todo 拆分C++需要的参数
    public double ScaleOfPixel_x { get; set; }
    public double ScaleOfPixel_y { get; set; }
    public double Res { get; set; }
    public double DownsampleIndex { get; set; }
    public double DownsampleIndexVideo { get; set; }
    public double VideoNorIndex { get; set; }
    public double IntPowerDen { get; set; }
    public double IntPowerDir { get; set; }
    public double SigmaGauss { get; set; }
    public double VessScale { get; set; }
    public double VelMaxValue { get; set; }
    public double VelMinValue { get; set; }
    public uint UrmLevel { get; set; }
    public uint VideoParameter { get; set; }
    public uint CaptureFrames { get; set; }
    public float FrequencyMin { get; set; }
    public string FrequencyMinUnit { get; set; }
    public float FrameRateDisplay { get; set; }
    public string FrameRateDisplayUnit { get; set; }

    public uint VSpeckle { get; set; }
    public uint Moco { get; set; }
    public UrmImageType ImageType { get; set; }

    public SrParams()
    {
        ScaleOfPixel_x = 1;
        ScaleOfPixel_y = 1;
        Res = 10;
        DownsampleIndex = 3.0;
        DownsampleIndexVideo = 1.5;
        VideoNorIndex = 2;
        IntPowerDen = 0.33;
        IntPowerDir = 0.25;
        SigmaGauss = 1.0;
        VessScale = 0.2;
        UrmLevel = 2;
        VideoParameter = 2;
        VelMaxValue = 1;
        VelMinValue = 0;
    }
}

public class ImageConverter
{
    public bool ConvertToImage(int dstWidth, int dstHeight, IntPtr tempArray, int tempArrayLength, out SKBitmap bitmap)
    {
        // 确保传入的参数有效
        if (tempArray == IntPtr.Zero || tempArrayLength <= 0)
        {
            bitmap = null;
            return false;
        }

        // 创建一个SKImageInfo对象来描述图像的信息
        var info = new SKImageInfo(dstWidth, dstHeight, SKColorType.Bgra8888, SKAlphaType.Premul);

        // 从内存数据创建SKBitmap
        bitmap = new SKBitmap(info);

        // 将内存数据拷贝到SKBitmap
        bool success = bitmap.InstallPixels(info, tempArray, info.RowBytes, (addr, ctx) =>
        {
            /* 释放资源的回调函数 */
        }, null);

        return success;
    }
}


public class URMAnalysisProcessV1
{
    [DllImport("ImageProcessAlgWrapLib.dll")]
    public static extern bool PIA_SRGetDensityImg(IntPtr handPtr, IntPtr srcMat, int srcWidth, int srcHeight,
            IntPtr dstMat, IntPtr dstMatu, int dstWidth, int dstHeight, IntPtr colorMap, int colorMapLength, double lambda, ref double barmax, ref double barmin, double ScanScale);
    [DllImport("ImageProcessAlgWrapLib.dll")]
    public static extern bool PIA_SRGetDirectionImg(IntPtr handPtr, IntPtr srcMat, IntPtr srcDenmat, int srcWidth, int srcHeight,
            IntPtr dstMat, IntPtr dstMatu, int dstWidth, int dstHeight, IntPtr colorMap, int colorMapLength, double lambda, ref double barmax, ref double barmin, double ScanScale);
    [DllImport("ImageProcessAlgWrapLib.dll")]
    public static extern bool PIA_SRGetVelImg(IntPtr handPtr, IntPtr srcMat, IntPtr srcDenmat, int srcWidth, int srcHeight,
            IntPtr dstMat, IntPtr dstMatu, int dstWidth, int dstHeight, IntPtr colorMap, int colorMapLength, double lambda, ref double barmax, ref double barmin, double ScanScale);
    [DllImport("ImageProcessAlgWrapLib.dll")]
    public static extern void PIA_SetSrParam(IntPtr handPtr, SrParams srParams);
    [DllImport("ImageProcessAlgWrapLib.dll")]
    public static extern IntPtr PIA_CreateSrProcess();
    [DllImport("ImageProcessAlgWrapLib.dll")]
    public static extern void PIA_CalBackgroundImg(IntPtr handPtr, IntPtr srcMat, IntPtr srcdirMat, int srcWidth, int srcHeight, int dstWidth, int dstHeight);
    [DllImport("ImageProcessAlgWrapLib.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern unsafe bool PIA_CalSrAvi(IntPtr handPtr, SrPoint** Points, int framecount, int* PointsCounts,
            IntPtr dstMats, int dstWidth, int dstHeight, IntPtr colorMap, int colorMapLength);
}