OTS/OTSIncAMeasureApp/ServiceCenter/CoxmSem/CoxmScanController.cs

using OTSModelSharp.ServiceCenter;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using OTSMeasureApp.ServiceCenter;
using OTSCLRINTERFACE;
using OxfordExtenderWrapper;
using System.Drawing;
using static OxfordExtenderWrapper.ExtenderIpcUI;
using OpenCvSharp;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Threading;
using OpenCvSharp.Extensions;
using System.Drawing.Imaging;
using System.IO;
using NSDLL_CLR;
using System.Runtime.InteropServices;

namespace OTSMeasureApp.ServiceCenter
{
    public class CoxmScanController : IScanController
    {
        public NSRestClient m_api =null;
        private int imageWidth = 640;
        private int imageHeight = 480;
        double dwelltime = 10;
        int port = 7321;
        string ip = "127.0.0.1";

        

     public   CoxmScanController()
        {
            m_api = NSDLL_CLR.NSRestClient.GetControllerInstance();
        }
        private Bitmap base64_encode(string base64Data, int w, int h, int b)
        {
            byte[] decodedData = Convert.FromBase64String(base64Data);
            Bitmap img = null;
            Mat m_image=new Mat();
            if (decodedData.Length == w * h * b)
            {
                m_image.Create(h, w, MatType.CV_16UC1);
                Marshal.Copy(decodedData, 0, m_image.Data, decodedData.Length);
                //Cv2.ImShow("img", m_image);
                //Cv2.WaitKey(0);
                //Cv2.DestroyWindow("img");
            }

            else
            {
                m_image.Create(0, 0, MatType.CV_16UC1);

            }
            Mat bitmap_mat = new Mat(h, w, MatType.CV_8UC1);
            m_image.ConvertTo(bitmap_mat, MatType.CV_8UC1, 1.0 / 256.0, 0);
            img = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(bitmap_mat);
            //disp.Image = img;
            //disp.Update();
            bitmap_mat.Dispose();
            m_image.Dispose();
            return img;
        }
      private  ImageInputSourceType imagesourceType = new ImageInputSourceType();
        CBSEImgClr IScanController.AcquireBSEImage()
        {
            try
            {
                Rectangle r = new Rectangle();
                CBSEImgClr bse = new CBSEImgClr(r);
                bse.InitImageData(imageWidth, imageHeight);

                ImageAquistionParam p = new ImageAquistionParam();
                p.width = imageWidth;
                p.height = imageHeight;
                p.DwellTime = dwelltime;
                p.sourceType = imagesourceType;
                byte[] ImageData;
                NLog.LogManager.GetCurrentClassLogger().Info("Begin to acquire BSE image!");
                //get image
                string base64data = "";
                int b=0;
                uint dwrealtime=0;
                if (m_api.GetImageRealTime(ref base64data,ref imageWidth,ref imageHeight,ref b,ref dwrealtime))
                {
                    p.width = imageWidth;
                    p.height = imageHeight;
                    p.DwellTime = (double)dwrealtime;
                    Bitmap bitmap =base64_encode(base64data, imageWidth, imageHeight, b);
                    using (MemoryStream stream = new MemoryStream())
                    {
                        bitmap.Save(stream, ImageFormat.Bmp);
                        ImageData = stream.ToArray();
                        bse.SetImageData(ImageData, imageWidth, imageHeight);
                        NLog.LogManager.GetCurrentClassLogger().Info("End acquiring BSE image!");
                    }
                   
                }
                else
                {
                    NLog.LogManager.GetCurrentClassLogger().Info("acquiring BSE image timeout!");
                }

                return bse;
            }
            catch (Exception e)
            {
                NLog.LogManager.GetCurrentClassLogger().Warn(e.Message);

            }
            return null;

        }

        bool IScanController.Init()
        {
            string FEIIP = FileHelper.GetXMLInformations("FEIIP");
            string FEIPORT = FileHelper.GetXMLInformations("FEIPORT");
            if (FEIIP == "" || FEIPORT == "")
            {
                NLog.LogManager.GetCurrentClassLogger().Error("FEI电镜端口配置为空！");
                return false;
            }
           
            return m_api.ServerConnect();
        }

        //bool IScanController.SetDwellTime(double val)
        //{
        //    scan_chanel = (int)val;
        //    return true;
        //}

        bool IScanController.SetImageSize(int nWidth, int nHeight)
        {
            this.imageWidth = nWidth;
            this.imageHeight = nHeight;
            return true;
        }

        public bool SetDwellTime(DwellTimeLevel val)
        {
            return true;
        }

        public CBSEImgClr AcquireRectangleBSEImage(Rectangle rec)
        {
            Rectangle r = new Rectangle();
            CBSEImgClr bse = new CBSEImgClr(r);
            return bse;
        }
    }
}