WingAIDiagnosisService/URMManage/URMProcess.cs

using System.IO;
using System.Runtime.InteropServices;
using Vinno.DataManager.Process;
using Vinno.DataTypes;
using Vinno.Infrastructure;
using Vinno.Services.ServiceManagerImpl;
using Vinno.DataManager.GraphTransform;
using Vinno.Enums;
using Vinno.ProcessUnits.DisplayLib;
using System.Collections.Generic;
using Vinno.DataManager.Infrastructure;
using System;
using Vinno.DataManager.Utilities;
using SkiaSharp;

namespace WingAIDiagnosisService.URMManage
{
    public class URMProcess
    {
        private URMProcessAlg _urmProcessAlg;
        private URMProcessParams _urmProcessParams = new URMProcessParams();
        private URMImgBaseParam _urmImgBaseParam = new URMImgBaseParam();
        private URMImgDrawParam _urmImgDrawParam = new URMImgDrawParam();
        private URMVideoParam _urmVideoParam = new URMVideoParam();
        public ProcessUnitParam<URMType> _urmType;
        public ImagePP ImagePP { get; private set; }
        private bool Mixflag;
        private DPoint[] urmTraceDPoints;

        private byte[] imagePixels;
        private int ScreenWidth;
        private int ScreenHeight;
        private GCHandle handle;
        private ColorTable videoColorTable;

        public bool init(string familyName, string typeInfo, string nativeId)
        {
            ResourceManagerImpl resourceManager = new ResourceManagerImpl(Path.Combine(ServiceManager.RootPath, "URM", "dev"));
            ResourceManager.Initialize(resourceManager);
            var dir = new VinnoDirectoryInfo(Path.Combine(ServiceManager.RootPath, "URM"));
            NativeProxy.UpdateSection("Path", "ShippedRoot", dir.FullName);
            NativeProxy.UpdateSection("Product-GeneralSpecification", "ImagePPFileName", "ImagePP_Tulip");
            if (ServiceManager.Os.IsWin())
            {
                ImagePP = new ImagePPNative_Win();
            }
            else
            {
                ImagePP = new ImagePPNative();
            }
            ImagePP.Initial();
            Logger.WriteLineInfo("Record.SetProbeApp({0},{1},{2})", familyName, typeInfo, nativeId);
            ImagePP.Initial(familyName, typeInfo, nativeId);
            // TODO Delete me
            var maplength = new List<int>();
            var result = ImagePP.GetParameter("SRColorMap:AngleMap", "SR_Map_Length", maplength, null);
            Logger.WriteLineInfo("ImagePP.GetParameter", result);
            // TODO Delete me
            _urmProcessAlg = new URMProcessAlg(ImagePP);
            _urmType.Init(URMType.Den);
            urmTraceDPoints = new DPoint[0];
            return result;
        }

        // 调节后处理参数调用此函数
        public void setUrmParams(RecordParams paramName, object param)
        {
            switch (paramName)
            {
                case RecordParams.URMDownSampleIndex:
                    _urmProcessParams.DownsampleIndex = (float)param;
                    break;
                case RecordParams.URMIntPowerDen:
                    _urmProcessParams.IntPowerDen = (float)param / 10.0;
                    break;
                case RecordParams.URMIntPowerDir:
                    _urmProcessParams.IntPowerDir = (float)param / 10.0;
                    break;
                case RecordParams.URMSigmaGauss:
                    _urmProcessParams.SigmaGauss = (float)param / 2.0;
                    break;
                case RecordParams.URMVessScale:
                    _urmProcessParams.VessScale = (float)param / 5.0;
                    break;
                case RecordParams.URMVelMaxScaler:
                    _urmProcessParams.VelMaxScaler = (float)param;
                    break;
                case RecordParams.URMVelMinScaler:
                    _urmProcessParams.VelMinScaler = (float)param;
                    break;
                case RecordParams.URMIterations:
                    _urmProcessParams.iterations = (int)(float)param;
                    break;
                case RecordParams.URMSigmaDen:
                    _urmProcessParams.URMSigmaDen = (float)param;
                    break;
                case RecordParams.URMSigmaStep:
                    _urmProcessParams.URMSigmaStep = (float)param;
                    break;
                case RecordParams.URMDirIterGauss:
                    _urmProcessParams.URMDirIterGauss = (int)(float)param;
                    break;
                case RecordParams.URMVideoScaler:
                    _urmVideoParam._VideoScaler = (float)param;
                    break;
                case RecordParams.URMVideoParameter:
                    _urmVideoParam._VideoDownSampleIndex = (float)param;
                    break;
                case RecordParams.URMVideoType:
                    _urmVideoParam._VideoType = (float)param;
                    break;
                case RecordParams.UrmImageType:
                    _urmType.SetCurrent((URMType)Enum.Parse(typeof(URMType), (string)param));
                    break;
                case RecordParams.UrmBlend:
                    Mixflag = (bool)param;
                    break;
            }
        }

        public void setUrmBaseParam(double res, NativeArray urmDenArray, NativeArray urmDirArray, NativeArray urmVelArray, NativeArray urmAngleArray, NativeArray urmMask, int urmSrcWidth, int urmSrcHeight, double scaleOfPixel_x, double scaleOfPixel_y, int ImgProcessVer, bool isliner)
        {
            _urmImgBaseParam.Res = res; // 参数
            _urmImgBaseParam.Denptr = urmDenArray.Start; // den 数组的指针
            _urmImgBaseParam.Dirptr = urmDirArray.Start; // dir 数组的指针
            _urmImgBaseParam.Velptr = urmVelArray.Start; // vel 数组的指针
            _urmImgBaseParam.Angleptr = urmAngleArray.Start; // angle 数组的指针
            _urmImgBaseParam.MaskPtr = urmMask.Start; // mask 数组的指针
            _urmImgBaseParam.Urmsrcwidth = urmSrcWidth; // 参数
            _urmImgBaseParam.Urmsrcheight = urmSrcHeight; // 参数
            _urmImgBaseParam.ScaleOfPixel_x = scaleOfPixel_x; // 参数
            _urmImgBaseParam.ScaleOfPixel_y = scaleOfPixel_y; // 参数
            _urmImgBaseParam.ImgProcessVer = ImgProcessVer; // urm算法版本 0 是 v2 1 是 v3
            _urmImgBaseParam.ProbeType = isliner ? 0 : 1;
            _urmProcessAlg.SetURMBaseParam(_urmImgBaseParam);
        }

        public void setUrmDrawParam(
            bool ZoomOn, double ZoomRoix, double ZoomRoiy, double ZoomRoiwidth, double ZoomRoiheight, int Roix, int Roiy, int Roiwidth, int Roiheight, bool LeftRight, bool UpDown, int screenWidth, int screenHeight)
        {
            // 初始化图像
            ScreenWidth = screenWidth;
            ScreenHeight = screenHeight;
            imagePixels = new byte[ScreenWidth * ScreenHeight * 4];
            for (int i = 0; i < ScreenWidth * ScreenHeight; i++)
            {
                int index = i * 4;
                imagePixels[index] = 0;     // Blue
                imagePixels[index + 1] = 0; // Green
                imagePixels[index + 2] = 0; // Red
                imagePixels[index + 3] = 1; // Alpha
            }
            // 获取指针
            handle = GCHandle.Alloc(imagePixels, GCHandleType.Pinned);
            _urmImgDrawParam.ZoomOn = ZoomOn; // 是否启用 zoom
            _urmImgDrawParam.ZoomRoix = ZoomRoix; // zoom 后 ROI X
            _urmImgDrawParam.ZoomRoiy = ZoomRoiy; // zoom 后 ROI X
            _urmImgDrawParam.ZoomRoiwidth = ZoomRoiwidth; // zoom 后 ROI 宽度
            _urmImgDrawParam.ZoomRoiheight = ZoomRoiheight; // zoom 后 ROI 宽度
            _urmImgDrawParam.Screenimgptr = handle.AddrOfPinnedObject(); // 图像指针（最重要，用于获取图像）
            _urmImgDrawParam.Screenimgwidth = ScreenWidth; // 图像输出的宽度
            _urmImgDrawParam.Screenimgheight = ScreenHeight; // 图像输出的高度
            _urmImgDrawParam.Roix = Roix; // ROI x
            _urmImgDrawParam.Roiy = Roiy; // ROI  y
            _urmImgDrawParam.Roiwidth = Roiwidth; // 宽度
            _urmImgDrawParam.Roiheight = Roiheight; // 高度
            _urmImgDrawParam.LeftRight = LeftRight ? 1 : 0; // 是否左右翻转
            _urmImgDrawParam.UpDown = UpDown ? 1 : 0; // 是否上下翻转
            _urmProcessAlg.SetURMDrawParam(_urmImgDrawParam);
        }

        // public WriteableBitmap getURMImage()
        // {
        //     WriteableBitmap bitmap = new WriteableBitmap(ScreenWidth, ScreenHeight, 96, 96, PixelFormats.Bgra32, null);
        //     _urmProcessAlg.SetURMParam(_urmProcessParams);
        //     double urmMaxVal = 0; // 这个输出需要给到前端
        //     double urmMinVal = 0; // 这个输出需要给到前端
        //     _urmProcessAlg.CalURMImg(ref urmMaxVal, ref urmMinVal, (int)_urmType.Current);
        //     Logger.WriteLineInfo($"CalURMImg urmMaxVal:{urmMaxVal} urmMinVal:{urmMinVal} {bitmap.PixelWidth}");
        //     var urmcolormapname = getColormapname((int)_urmType.Current);
        //     var urmcolortable = GetURMColorMap(urmcolormapname);
        //     var Colormapptr = urmcolortable.Address; // 获取颜色映射表
        //     if (_urmType == URMType.Angle && urmcolortable.Length != 1440)
        //     {
        //         Logger.WriteLineInfo("Akio:Angle ColorMapError");
        //         return bitmap;
        //     }
        //     _urmProcessAlg.DrawURM((int)_urmType.Current, Colormapptr, Mixflag);
        //     Int32Rect rect = new Int32Rect(0, 0, ScreenWidth, ScreenHeight);
        //     bitmap.WritePixels(rect, imagePixels, ScreenWidth * 4, 0);
        //     return bitmap;
        // }

        public void GetURMImage()
        {
            // SKBitmap bitmap = new SKBitmap(ScreenWidth, ScreenHeight);

            _urmProcessAlg.SetURMParam(_urmProcessParams);
            double urmMaxVal = 0;
            double urmMinVal = 0;
            _urmProcessAlg.CalURMImg(ref urmMaxVal, ref urmMinVal, (int)_urmType.Current);
            Logger.WriteLineInfo($"CalURMImg urmMaxVal:{urmMaxVal} urmMinVal:{urmMinVal}");

            var urmcolormapname = getColormapname((int)_urmType.Current);
            var urmcolortable = GetURMColorMap(urmcolormapname);
            var Colormapptr = urmcolortable.Address;

            if (_urmType == URMType.Angle && urmcolortable.Length != 1440)
            {
                Logger.WriteLineInfo("Akio:Angle ColorMapError");
                // return bitmap;
                return;
            }

            _urmProcessAlg.DrawURM((int)_urmType.Current, Colormapptr, Mixflag);

            // using (var surface = SKSurface.Create(new SKImageInfo(ScreenWidth, ScreenHeight, SKColorType.Bgra8888)))
            // {
            //     SKCanvas canvas = surface.Canvas;

            //     // Draw your URM image on the canvas here

            //     SKImage image = surface.Snapshot();

            //     byte[] imageBytes = image.Encode().ToArray();
            //     bitmap = SKBitmap.Decode(imageBytes);
            // }

            // return bitmap;
        }

        public void getUrmVal(ref double urmMaxVal, ref double urmMinVal)
        {
            _urmProcessAlg.SetURMParam(_urmProcessParams);
            _urmProcessAlg.CalURMImg(ref urmMaxVal, ref urmMinVal, (int)_urmType.Current);
            Logger.WriteLineInfo($"CalURMImg urmMaxVal:{urmMaxVal} urmMinVal:{urmMinVal}");
        }

        public string getURMImageBase64(ref double urmMinVal, ref double urmMaxVal)
        {
            _urmProcessAlg.SetURMParam(_urmProcessParams);
            urmMinVal = 0; // 这个输出需要给到前端
            urmMaxVal = 0; // 这个输出需要给到前端
            _urmProcessAlg.CalURMImg(ref urmMaxVal, ref urmMinVal, (int)_urmType.Current);
            Logger.WriteLineInfo($"CalURMImg urmMaxVal:{urmMaxVal} urmMinVal:{urmMinVal}");
            var urmcolormapname = getColormapname((int)_urmType.Current);
            var urmcolortable = GetURMColorMap(urmcolormapname);
            var Colormapptr = urmcolortable.Address; // 获取颜色映射表
            if (_urmType == URMType.Angle && urmcolortable.Length != 1440)
            {
                Logger.WriteLineInfo("Akio:Angle ColorMapError");
                return "";
            }
            _urmProcessAlg.DrawURM((int)_urmType.Current, Colormapptr, Mixflag);
            //using (SKImage image = SKImage.FromEncodedData(SKData.CreateCopy(imagePixels)))
            //{
            //    SKBitmap bitMap = SKBitmap.FromImage(image);
            //}
            SKImageInfo info = new SKImageInfo(ScreenWidth, ScreenHeight, SKColorType.Bgra8888, SKAlphaType.Unpremul);

            // Create an SKBitmap with the given SKImageInfo
            SKBitmap skBitmap = new SKBitmap(info);
            // Copy the pixel data from the imagePixels array to the SKBitmap
            using (SKImage skImage = SKImage.FromPixelCopy(info, imagePixels))
            {
                skImage.ReadPixels(skBitmap.Info, skBitmap.GetPixels(), skBitmap.RowBytes, 0, 0);
            }
            using (var image = SKImage.FromBitmap(skBitmap))
            using (var data = image.Encode(SKEncodedImageFormat.Png, 100))
            {
                byte[] imageBytes = data.ToArray();
                string base64String = Convert.ToBase64String(imageBytes);
                return base64String;
            }
        }


        string getColormapname(int type)
        {
            switch (type)
            {
                case 0:
                    return "SRColorMap:ColorMap1";
                case 1:
                    return "SRColorMap:ColorMap2";
                case 2:
                    return "SRColorMap:ColorMap3";
                case 3:
                    return "SRColorMap:AngleMap";
                default:
                    return "SRColorMap:ColorMap1";
            }

        }

        public ColorTable GetURMColorMap(string colorMap)
        {
            var rValue = new List<int>();
            var gValue = new List<int>();
            var bValue = new List<int>();

            var maplength = new List<int>();
            var result = ImagePP.GetParameter(colorMap, "SR_Map_R", rValue, null);
            result = result && ImagePP.GetParameter(colorMap, "SR_Map_G", gValue, null);
            result = result && ImagePP.GetParameter(colorMap, "SR_Map_B", bValue, null);
            result = result && ImagePP.GetParameter(colorMap, "SR_Map_Length", maplength, null);
            ColorTable URMTable = new ColorTable(maplength[0] * sizeof(uint));
            if (result)
            {
                IValueAccessor<uint> intValueAccessor = URMTable;
                for (int i = 0; i < maplength[0]; i++)
                {
                    var temp = rValue[i] << 16 | gValue[i] << 8 | bValue[i] | 0xFF000000;
                    intValueAccessor[i] = (uint)temp;
                }

            }
            return URMTable;
        }

        public void CalTracePointMask(DPoint[] traceDPoints)
        {
            urmTraceDPoints = traceDPoints;
            var tracePointCount = urmTraceDPoints.Length;
            var validPoints = new List<DPoint>();
            for (int i = 0; i < tracePointCount; i++)
            {
                var curPiexlPoint = new DPoint(urmTraceDPoints[i].X * ScreenWidth, urmTraceDPoints[i].Y * ScreenHeight);
                validPoints.Add(curPiexlPoint);
            }
            _urmProcessAlg.CalTraceMaskImg(ScreenWidth, ScreenHeight, validPoints);
        }

        public void PreURMVideo(URMPoint[] urmPoints, int[] Pointsnums, ref double urmMaxVal, ref double urmMinVal)
        {
            var vediotable = GetURMColorMap("SRColorMap:ColorMap4");
            urmMaxVal = 0;
            urmMinVal = 0;
            _urmProcessAlg.SetURMParam(_urmProcessParams);
            _urmProcessAlg.CalURMImg(ref urmMaxVal, ref urmMinVal, (int)_urmType.Current);
            unsafe
            {
                fixed (URMPoint* AllPointsPtr = urmPoints)
                {
                    fixed (int* pointlengthsptr = Pointsnums)
                    {
                        _urmProcessAlg.PreURMVideo(_urmVideoParam, AllPointsPtr, Pointsnums.Length, pointlengthsptr, ref urmMaxVal, ref urmMinVal);
                    }
                }
            }
            videoColorTable = GetURMColorMap("SRColorMap:ColorMap4");
            Logger.WriteLineInfo($"PreURMVideo urmMaxVal:{urmMaxVal} urmMinVal:{urmMinVal}");
        }

        // public void getURMVideoImg(int index, WriteableBitmap dataHolder)
        // {
        //     _urmProcessAlg.DrawURMVideo(index, videoColorTable.Address, Mixflag);
        //     Int32Rect rect = new Int32Rect(0, 0, ScreenWidth, ScreenHeight);
        //     dataHolder.WritePixels(rect, imagePixels, ScreenWidth * 4, 0);
        // }

        public string getURMVideoImg(int index)
        {
            _urmProcessAlg.DrawURMVideo(index, videoColorTable.Address, Mixflag);
            SKImageInfo info = new SKImageInfo(ScreenWidth, ScreenHeight, SKColorType.Bgra8888, SKAlphaType.Unpremul);

            // Create an SKBitmap with the given SKImageInfo
            SKBitmap skBitmap = new SKBitmap(info);
            // Copy the pixel data from the imagePixels array to the SKBitmap
            using (SKImage skImage = SKImage.FromPixelCopy(info, imagePixels))
            {
                skImage.ReadPixels(skBitmap.Info, skBitmap.GetPixels(), skBitmap.RowBytes, 0, 0);
            }
            using (var image = SKImage.FromBitmap(skBitmap))
            using (var data = image.Encode(SKEncodedImageFormat.Png, 100))
            {
                byte[] imageBytes = data.ToArray();
                string base64String = Convert.ToBase64String(imageBytes);
                return base64String;
            }
        }

        public void CreateURMMeasuerImg(URMType urmtype, IntPtr MeasureImgStart, ref double max, ref double min)
        {
            if (urmtype == URMType.Den)
            {
                _urmProcessAlg.CalURMMeasurImg(MeasureImgStart, (int)urmtype, ref max,
                    ref min);
            }
            else if (urmtype == URMType.Vel)
            {
                _urmProcessAlg.CalURMMeasurImg(MeasureImgStart, (int)urmtype, ref max,
                    ref min);
            }
        }

        public void Dispose()
        {
            handle.Free();
            _urmProcessAlg.Release();
            if (ImagePP != null)
            {
                ImagePP.Dispose();
                ImagePP = null;
            }
        }
    }
}