WingAIDiagnosisService/Service/AIDiagnosisService.ImageResize.cs

using WingServerCommon.Service;
using WingInterfaceLibrary.Interface;
using System.Threading.Tasks;
using WingServerCommon.Log;
using WingInterfaceLibrary.Request.AIDiagnosis;
using ImageResizeLib;
using System.IO;
using System;
using AI.Common;
using Vinno.vCloud.Common.Vid2;
using System.Collections.Generic;
using System.Linq;
using AI.Common.Log;
using System.Drawing;
using SkiaSharp;

namespace WingAIDiagnosisService.Service
{
    /// <summary>
    /// URM分析服务
    /// </summary>
    public partial class AIDiagnosisService : JsonRpcService, IAIDiagnosisService
    {
        private ImageResize _imageResize;

        private ImageResize ImageResize
        {
            get
            {
                if (_imageResize == null)
                {
                    var modelFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "AIDiagnosis", "ImageResize");
                    _imageResize = new ImageResize(modelFolder);
                    _imageResize.NotifyError += ImageResize_NotifyError;
                    _imageResize.NotifyLog += ImageResize_NotifyLog;
                }
                return _imageResize;
            }
        }

        /// <summary>
        /// 远程图像区域缩放
        /// </summary>
        /// <param name="request">远程图像区域缩放请求实体</param>
        /// <returns>远程图像区域缩放结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<VidImageZoomResult> VidImageZoomAsync(VidImageZoomRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            var currentFolder = string.Empty;

            var resultData = new VidImageZoomResult();
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    Logger.WriteLineInfo($"AIDiagnosisService VidImageZoomAsync start, remedicalCode:{remedicalCode}");
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    if (remedical != null)
                    {
                        var fileToken = remedical.ImgList?.FirstOrDefault(x => x.ImgType == 5)?.FileToken;
                        if (string.IsNullOrWhiteSpace(fileToken))
                        {
                            fileToken = remedical.TerminalImages?.OriginImageUrl;
                        }
                        var origialName = Path.GetFileName(fileToken);

                        currentFolder = Path.Combine(_urmTempFolder, Guid.NewGuid().ToString("N"));
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile, "", remedicalCode);
                            await Task.Delay(50);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService VidImageZoomAsync download success, remedicalCode:{remedicalCode}");
                            using (var imageData = new VinnoImageData(origialFile, OperationMode.Open))
                            {
                                var frameIndex = request.FrameIndex;
                                if (imageData.ImageCount < frameIndex)
                                {
                                    frameIndex = 0;
                                }
                                var frameImage = imageData.GetImage(frameIndex);
                                using (var bitmap = CreateBitmap(frameImage))
                                {
                                    Logger.WriteLineInfo($"AIDiagnosisService VidImageZoomAsync RawImage, remedicalCode:{remedicalCode}");
                                    using (var rawImage = new RawImage(bitmap.Bytes, bitmap.Width, bitmap.Height, MapTo(bitmap.ColorType)))
                                    {
                                        // File.WriteAllBytes(Path.Combine(currentFolder, "123123.png"), frameImage.ImageData);
                                        Logger.WriteLineInfo($"AIDiagnosisService VidImageZoomAsync ImageRegion, remedicalCode:{remedicalCode}");
                                        var imageRegion = new List<Rect>();
                                        if (request.ImageRegion?.Any() ?? false)
                                        {
                                            foreach (var item in request.ImageRegion)
                                            {
                                                imageRegion.Add(new Rect((int)item.Left, (int)item.Top, (int)item.Width, (int)item.Height));
                                            }
                                        }
                                        var sampleBoxReq = request.SampleBox ?? new ImageRect();
                                        var sampleBox = new AI.Common.Rectangle(new Rect((int)sampleBoxReq.Left, (int)sampleBoxReq.Top, (int)sampleBoxReq.Width, (int)sampleBoxReq.Height));
                                        var resizeType = (EnumResizeMethodType)request.ResizeType;
                                        Logger.WriteLineInfo($"AIDiagnosisService VidImageZoomAsync PushOneImage, remedicalCode:{remedicalCode}");
                                        Logger.WriteLineInfo($"imageRegion:{Newtonsoft.Json.JsonConvert.SerializeObject(imageRegion)}");
                                        Logger.WriteLineInfo($"sampleBox:{Newtonsoft.Json.JsonConvert.SerializeObject(sampleBox)}");
                                        var imageResizeBytes = ImageResize.PushOneImage(rawImage, imageRegion.ToArray(), sampleBox, resizeType);
                                        if (imageResizeBytes != null)
                                        {
                                            SKImageInfo info = new SKImageInfo((int)bitmap.Width, (int)bitmap.Height, SKColorType.Bgra8888, SKAlphaType.Unpremul);

                                            // Create an SKBitmap with the given SKImageInfo
                                            using (SKBitmap skBitmap = new SKBitmap(info))
                                            {
                                                // Copy the pixel data from the imagePixels array to the SKBitmap
                                                using (SKImage skImage = SKImage.FromPixelCopy(info, imageResizeBytes))
                                                {
                                                    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();
                                                    resultData.Base64String = Convert.ToBase64String(imageBytes);
                                                }
                                            }
                                        }
                                    }
                                    Logger.WriteLineInfo($"AIDiagnosisService VidImageZoomAsync end, remedicalCode:{remedicalCode}");
                                }

                            }
                        }

                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService VidImageZoomAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"AIDiagnosisService VidImageZoomAsync finally, remedicalCode:{remedicalCode}");
                try
                {
                    if (Directory.Exists(currentFolder))
                    {
                        Directory.Delete(currentFolder, true);
                    }
                }
                catch { }
            }
            return resultData;
        }


        private void ImageResize_NotifyError(object sender, ErrorEventArgs e)
        {
            try
            {
                Logger.WriteLineWarn($"AIDiagnosisService ImageResize_NotifyError: {e.GetException()}");
            }
            catch { }
        }
        private void ImageResize_NotifyLog(object sender, LogEventArgs e)
        {
            try
            {
                if (e?.LogType == EnumLogType.WarnLog || e?.LogType == EnumLogType.ErrorLog)
                {
                    Logger.WriteLineWarn($"AIDiagnosisService ImageResize_NotifyLog. LogType: {e.LogType}, Msg: {e.Msg}");
                }
                else
                {
                    Logger.WriteLineInfo($"AIDiagnosisService ImageResize_NotifyLog. LogType: {e.LogType}, Msg: {e.Msg}");
                }
            }
            catch { }
        }


    }
}