OTS/OxfordExtenderWrapper/ExtenderWrapper1.cs


using OINA.Extender;
using OINA.Extender.Acquisition;
using OINA.Extender.Acquisition.Ed;
using OINA.Extender.Acquisition.Image;
using OINA.Extender.Data;
using OINA.Extender.Data.Ed;
using OINA.Extender.Data.Image;
using OINA.Extender.MicroscopeControl;
using OINA.Extender.Processing;
using OINA.Extender.Processing.Ed;
using OINA.Extender.Processing.Quant;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
//显示弹出信息
//using System.Windows.Forms;

namespace OxfordExtenderWrapper1
{
    enum OxfordControllerState
    {
        READY = 0,
        WORKING = 1,
        SUCCEEDED = 2,
        FAILED = 3,
        ABORT = 4
    };
    [Serializable]
    public class Segment
    {
        private int m_nX;
        private int m_nY;
        private int m_nLength;

        public int X
        {
            get { return m_nX; }
            set
            {
                if (value > 0)
                {
                    m_nX = value;
                }
            }
        }

        public int Y
        {
            get { return m_nY; }
            set
            {
                if (value > 0)
                {
                    m_nY = value;
                }
            }
        }

        public int Length
        {
            get { return m_nLength; }
            set
            {
                if (value > 0)
                {
                    m_nLength = value;
                }
            }
        }
    };
    /// <summary>
    /// Enum EDSConst definition.
    /// </summary>
    enum EDSConst
    {
        MAX_XRAY_BATCH = 1024,
        XANA_CHANNELS = 2000,
        XANA_CHANNELS_MAX = 4192,
        MAX_AMPTIME_CONSTANTS = 10,
        MAX_EV_PER_CHANNELS = 5,
        MAX_ANALYZERS = 5,
        MAX_LEN_ANALYZER_NAME = 16
    };
    [Serializable]
    struct OxfordChord
    {
        public long m_nX;
        public long m_nY;
        public long m_nLength;

    };
    enum OxfordCommandType
    {
        
        GetMagnification = 0,
        SetMagnification = 1,

       
        GetWorkingDistance = 2,
        SetWorkingDistance = 3,

     
        GetBrightness = 4,
        SetBrightness = 5,

      
        GetContrast = 6,
        SetContrast = 7,

    
        GetSEMVoltage = 8,
        SetSEMVoltage = 9,

        //样品台        
        GetStagePosition = 10,
        SetStagePosition = 11,
        GetStageAtX = 12,
        GetStageAtY = 13,
        GetStageAtZ = 14,
        GetStageAtT = 15,
        GetStageAtR = 16,
        SetStageGotoX = 17,
        SetStageGotoY = 18,
        SetStageGotoZ = 19,
        SetStageGotoT = 20,
        SetStageGotoR = 21,
        MoveStageXY = 22,

        //拍图
        ImageAquisition = 23,
        //采集参数设置
        SetImageAcquistionSetting = 24,

        //获取分辨率
        GetImageResolution = 25,
        //设置分辨率
        SetImageResolution= 26,
        //获取bitmap
        GetBitmap = 27,

        IsAcquiringSpectrum = 28,

        //X-ray
        //点采集
        XrayPointCollection = 29,
        COLLECT_XRAYPOINTS=30,
        //面采集
        XrayAreaCollection = 31,
        COLLECT_XRAYFEATURES = 32,

        BeginMultipleAquisition = 33,
        EndMultipleAquisition = 34,
        BeginAreaModeMultipleAquisition = 35,
        EndAreaModeMultipleAquisition = 36,
        Exit = 100,

    }
    [Serializable]
    public class ImageAquistionParam
    {

        public ImageAquistionParam()
        {

            this.ImageData = new byte[width * height];

        }
        //in
        public int width;
        public int height;
        public double DwellTime;
        public ImageInputSources sourceType;
        //out
        public byte[] ImageData;

    }
    [Serializable]
    public class PointXrayParam
    {
        public PointXrayParam()
        {

            this.XrayData = new uint[2000];
            this.listElement = new Dictionary<string, double>();
        }
        public double dMilliSecondsTime;
        public double x;
        public double y;
        //out
        public uint[] XrayData;
        public Dictionary<string, double> listElement;

    }
    [Serializable]
    public class AreaXrayParam
    {
        public AreaXrayParam()
        {

            this.XrayData = new uint[2000];
            this.listElement = new Dictionary<string, double>();
        }
        public double dMilliSecondsTime;
        public List<Segment> a_listChord=new List<Segment>();
        public uint[] XrayData;
        public Dictionary<string, double> listElement;

    }
    [Serializable]
    public struct MoveStageParam
    {
        public float x;
        public float y;
    }
    struct oxfordCommandData
    {
        public OxfordCommandType commandType;
        public bool returnType;
        public MoveStageParam moveStagePrm;

        public ImageAquistionParam grabImgParam;
        public PointXrayParam pointXrayPrm;
        public AreaXrayParam areaXrayPrm;
        public List<PointXrayParam> XrayPrmForPoints;
        public int PointXrayDataReceived;
        public List<AreaXrayParam> XrayPrmForFeatures;
        public int AreaXrayDataReceived;
    }
    public class ExtenderWrapper:MarshalByRefObject
    {

        NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();
        private Thread controlThread;
        AutoResetEvent startEvent = new AutoResetEvent(false);
        AutoResetEvent endEvent = new AutoResetEvent(false);
        private oxfordCommandData currentCommand;

        #region 电镜控制、样品台
        //控制电镜
        private IMicroscopeController microscopeController = null;
        /// <summary>
        /// IImageAcquisitionController object
        /// </summary>
        private IImageAcquisitionController imageAcquisitionController = null;

        /// <summary>
        /// IImageSettings object
        /// </summary>
        private IImageAcquisitionSettings imageAcquisitionSettings = null;
        //控制器
        private IEdSpectrumAcquisitionController EdSpectrumAcquisitionController = null;
        private IEdSpectrumSettings EdSpectrumSettings = null;
        private IEdSpectrumProcessing EdSpectrumProcessing = null;
        // Use the autoIdSettings to define elements that are known or elements that you want to exclude. They also list elements that cannot be identified
        private IAutoIdSettings autoIdSettings = null;
        private ISEMQuantSettings quantSettings = null;

        private IEdChordListAcquisitionController _edsChordListController = null;
        private OxfordControllerState m_nState;
        private IEdChordListSettings _edsChordListSetting;
        private int XRayChannelLength = 2000;

        private int EDSColletionTimeOut = 10000;
        private AutoResetEvent m_endControllerEvent;

        //当前feature的pixel数控制 
        private long m_nCollectedPixelCounts;
        private long m_nPixelNum;
        private List<Element> m_listElementResult;
        private OxfordXrayData[] m_pXrayData;

        const int g_nOxfordControllerProcessTime = 4;
        const int g_nOxfordControllerEnergyRange = 20;


        // feature计数控制
        private long m_nXrayDataCount;
        private long m_nCollectedXrayCounts;

        private bool m_bXrayDone = false;
        //电压
        private double m_dHighVoltage;
        //放大倍数
        private double m_dMagnification;
        //工作距离
        private double m_dWorkingDistance;
        //亮度
        private double m_dBirghtness;
        //对比度
        private double m_dContrast;
        //BeamOn
        private bool m_bBeamOn;
        //FilamentOn
        private bool m_bFilamentOn;

        //样品台位置
        private double m_dStageX;
        private double m_dStageY;
        private double m_dStageZ;
        private double m_dStageR;
        private double m_dStageT;

        private double m_dStageXMax;

        //构造函数
        public ExtenderWrapper()
        {
           
        }
        public bool ConnectToEDSHardware()
        {
            try
            {
                InitMicroscopeController();
                InitImageAcquisition();
                InitXrayAcquistion();

                controlThread = new Thread(this.ControlerThread);
                controlThread.Start();
                return true;
            }
            catch (Exception e)
            {
                log.Error(e.Message);
                return false;
            }
           

        }
       
        //结束
        public void CloseExtender()
        {
            CloseMicroscopeController();
            CloseImageAcquisition();
            CloaseXrayAcquistion();
            currentCommand.commandType = OxfordCommandType.Exit;
            if (controlThread != null)
            {
                startEvent.Set();
                controlThread.Join();
            }
            controlThread = null;


        }
        private void ControlerThread()
        {

            log.Info("this has been initialized");
            while (true)
            {

                while (true)
                {
                    if (startEvent.WaitOne(0, true))
                    {

                        break;
                    }
                    //Thread.Sleep(50);
                    Application.DoEvents();
                }


                switch (currentCommand.commandType)
                {
                    case OxfordCommandType.MoveStageXY:
                        {
                            MoveStageParam p = currentCommand.moveStagePrm;

                            double stageX = (double)p.x;
                            if (stageX > StageXMax || stageX < StageXMin)
                            {
                                currentCommand.returnType = false;
                            }
                            double stageY = (double)p.y;
                            if (stageY > StageYMax || stageY < StageYMin)
                            {
                                currentCommand.returnType = false;
                            }

                            var stageDictionary = new Dictionary<Stage, double>
                            {
                                { Stage.StageX, (double)stageX },
                                { Stage.StageY, (double)stageY }
                            };

                            this.microscopeController.SetStageConditions(stageDictionary);
                            currentCommand.returnType = true;
                            
                            endEvent.Set();
                        }
                        break;
                    case OxfordCommandType.ImageAquisition:
                        {
                            ImageAquistionParam p = currentCommand.grabImgParam;
                            log.Info("begin:GrabImage:oxford thread 线程ID：" + Thread.CurrentThread.ManagedThreadId.ToString());
                            SetImageAcquistionSetting(p.DwellTime, p.sourceType, p.width);


                            try
                            {
                                int lastingTime = 0;

                                imageAcquisitionController.BeginMultipleAcquisition();
                                IEnumerable<IElectronImage> images = imageAcquisitionController.StartAcquisition(imageAcquisitionSettings);

                                log.Info("拍图开始 startAcquisition 完成");


                                while (true)
                                {
                                    if (m_bAcquistionDone)
                                    {
                                        p.ImageData = m_ImageBit;
                                        currentCommand.returnType = true;

                                        break;
                                    }
                                    Application.DoEvents();

                                    Thread.Sleep(100);
                                    lastingTime += 100;
                                    if (lastingTime > EDSColletionTimeOut * 6)
                                    {
                                        currentCommand.returnType = false;
                                    }
                                }
                            }
                            catch (InvalidSettingsException settingsException)
                            {
                                var sb = new StringBuilder(@"Invalid settings have been supplied: ");
                                sb.AppendLine();
                                settingsException.ValidationResults.ValidationErrors.ToList().ForEach(ve => sb.AppendFormat("{0}{1}", Environment.NewLine, ve));

                                NLog.LogManager.GetCurrentClassLogger().Error(sb.ToString());
                            }
                            catch (AcquisitionStartException startException)
                            {
                                string msg = string.Format(@"AcquisitionStartException: {0}", startException.Message);
                                NLog.LogManager.GetCurrentClassLogger().Error(msg);
                            }

                            endEvent.Set();
                        }
                        break;

                    case OxfordCommandType.XrayPointCollection:
                        {
                            PointXrayParam p = currentCommand.pointXrayPrm;

                            //log.Info("线程：开始采集单点xray");

                            //m_XrayData = null;
                            m_bXrayDone = false;

                            p.XrayData = new uint[XRayChannelLength];
                            p.listElement = new Dictionary<string, double>();

                            SetXrayAcquisitionParam(p.dMilliSecondsTime);

                            //SetPointAcquistionRegion(x*m_dImagePixelsize, y*m_dImagePixelsize);
                            EdSpectrumSettings.ScanSettings.AcquisitionRegion.CreatePointRegion(new System.Windows.Point(p.x * m_dImagePixelsize, p.y * m_dImagePixelsize));
                            NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();
                            log.Info("开始XrayStartAcquisition:t=" + p.dMilliSecondsTime.ToString() + "pos=" + "(" + p.x.ToString() + "," + p.y.ToString() + ")");

                            
                            try
                            {
                                m_bXrayDone = false;
                                int lastingTime = 0;

                                IEdSpectrum edSpectrum = EdSpectrumAcquisitionController.StartAcquisition(EdSpectrumSettings);
                             

                                while (true)
                                {
                                    if (m_bXrayDone)
                                    {
                                      
                                        currentCommand.returnType = true;
                                        break;
                                    }
                                    Application.DoEvents();

                                    Thread.Sleep(100);
                                    lastingTime += 100;
                                    if (lastingTime > EDSColletionTimeOut * 3)
                                    {
                                        //EdSpectrumAcquisitionController.EndMultipleAcquisition();
                                        log.Warn("XrayStartAcquisition 超时！");
                                       
                                        currentCommand.returnType = false;
                                    }
                                }
                            }
                            catch (InvalidSettingsException invalidSettingsException)
                            {

                                string msg = string.Format(@"Invalid Settings Exception:{0}, {1}",
                                    invalidSettingsException.Message,
                                    invalidSettingsException.ValidationResults.ValidationErrors);
                                log.Error(msg);
                            }
                            catch (AcquisitionStartException acquisitionStartException)
                            {

                                string msg = string.Format(@"Acquisition Start Exception:{0}", acquisitionStartException.Message);
                                log.Error(msg);
                            }
                           
                            endEvent.Set();
                        }
                        break;
                    case OxfordCommandType.COLLECT_XRAYPOINTS:
                        {
                            var p = currentCommand.XrayPrmForPoints;

                            log.Info("线程：开始采集多点xray");
                            var PointXrayDatas = currentCommand.XrayPrmForPoints;
                            currentCommand.PointXrayDataReceived = 0;
                         
                            m_bXrayDone = false;
                            int lastingTime = 0;

                            var dMilliSecondsTime = PointXrayDatas[0].dMilliSecondsTime;
                            SetXrayAcquisitionParam(dMilliSecondsTime);
                            foreach (var prm in PointXrayDatas)
                            {

                              
                                EdSpectrumSettings.ScanSettings.AcquisitionRegion.CreatePointRegion(new System.Windows.Point(prm.x * m_dImagePixelsize, prm.y * m_dImagePixelsize));

                                log.Info("开始XrayStartAcquisition:t=" + dMilliSecondsTime.ToString() + "pos=" + "(" + prm.x.ToString() + "," + prm.y.ToString() + ")");

                                try
                                {
                                    m_bXrayDone = false;


                                    IEdSpectrum edSpectrum = EdSpectrumAcquisitionController.StartAcquisition(EdSpectrumSettings);
            

                                }
                                catch (InvalidSettingsException invalidSettingsException)
                                {

                                    string msg = string.Format(@"Invalid Settings Exception:{0}, {1}",
                                        invalidSettingsException.Message,
                                        invalidSettingsException.ValidationResults.ValidationErrors);
                                    log.Error(msg);
                                }
                                catch (AcquisitionStartException acquisitionStartException)
                                {

                                    string msg = string.Format(@"Acquisition Start Exception:{0}", acquisitionStartException.Message);
                                    log.Error(msg);
                                }



                            }


                            while (true)
                            {
                                if (m_bXrayDone)
                                {
                                    currentCommand.returnType = true;
                                    break;
                                }
                                Application.DoEvents();

                                Thread.Sleep(100);
                                lastingTime += 100;
                                if (lastingTime > EDSColletionTimeOut * 3)
                                {
                                    EdSpectrumAcquisitionController.EndMultipleAcquisition();
                                    log.Warn("XrayStartAcquisition 超时！");
                                    currentCommand.returnType = false;
                                }
                            }

                            endEvent.Set();
                        }
                        break;
                    case OxfordCommandType.XrayAreaCollection:
                        {
                            AreaXrayParam p = currentCommand.areaXrayPrm;
                            log.Info("线程：开始面扫xray");
                            
                            m_bXrayDone = false;

                            SetXrayAcquisitionParam(p.dMilliSecondsTime);
                            List<Chord> Chords = new List<Chord>();

                            foreach (Segment seg in p.a_listChord)
                            {
                                Chord chord = new Chord(seg.X, seg.Y, seg.Length);
                                Chords.Add(chord);
                            }
                            SetAreaAcquistionRegion(Chords);

                            try
                            {
                                int lastingTime = 0;
                                IEdSpectrum edSpectrum = EdSpectrumAcquisitionController.StartAcquisition(EdSpectrumSettings);


                                while (true)
                                {
                                    if (m_bXrayDone)
                                    {
                                       
                                        currentCommand.returnType = true;
                                        break;
                                    }

                                    Thread.Sleep(100);
                                    Application.DoEvents();
                                    lastingTime += 100;
                                    if (lastingTime > EDSColletionTimeOut * 8)
                                    {
                                        currentCommand.returnType = false;
                                       
                                    }
                                }
                            }
                            catch (InvalidSettingsException invalidSettingsException)
                            {
                                string msg = string.Format(@"Invalid Settings Exception:{0}, {1}",
                                    invalidSettingsException.Message,
                                    invalidSettingsException.ValidationResults.ValidationErrors);
                                log.Error(msg);
                            }
                            catch (AcquisitionStartException acquisitionStartException)
                            {
                                string msg = string.Format(@"Acquisition Start Exception:{0}", acquisitionStartException.Message);
                                log.Error(msg);
                            }
                            
                            endEvent.Set();
                        }
                        break;
                    case OxfordCommandType.COLLECT_XRAYFEATURES:
                        {
                            var p = currentCommand.XrayPrmForFeatures;
                            currentCommand.AreaXrayDataReceived = 0;
                            log.Info("线程：开始线扫xray");
                            //m_XrayData = null;
                            m_bXrayDone = false;
                            int lastingTime = 0;

                            var dMilliSecondsTime = p[0].dMilliSecondsTime;
                            SetXrayAcquisitionParam(p[0].dMilliSecondsTime);
                            foreach (var prm in p)
                            {
                                List<Chord> Chords = new List<Chord>();

                                foreach (Segment seg in prm.a_listChord)
                                {
                                    Chord chord = new Chord(seg.X, seg.Y, seg.Length);
                                    Chords.Add(chord);
                                }
                                SetAreaAcquistionRegion(Chords);

                                try
                                {
                                    m_bXrayDone = false;


                                    IEdSpectrum edSpectrum = EdSpectrumAcquisitionController.StartAcquisition(EdSpectrumSettings);

                                }
                                catch (InvalidSettingsException invalidSettingsException)
                                {

                                    string msg = string.Format(@"Invalid Settings Exception:{0}, {1}",
                                        invalidSettingsException.Message,
                                        invalidSettingsException.ValidationResults.ValidationErrors);
                                    log.Error(msg);
                                }
                                catch (AcquisitionStartException acquisitionStartException)
                                {

                                    string msg = string.Format(@"Acquisition Start Exception:{0}", acquisitionStartException.Message);
                                    log.Error(msg);
                                }



                            }


                            while (true)
                            {
                                if (m_bXrayDone)
                                {
                                    currentCommand.returnType = true;

                                    break;
                                }
                                Application.DoEvents();

                                Thread.Sleep(100);
                                lastingTime += 100;
                                if (lastingTime > EDSColletionTimeOut * 3)
                                {
                                    EdSpectrumAcquisitionController.EndMultipleAcquisition();
                                    log.Warn("XrayStartAcquisition 超时！");
                                    //return false;
                                    currentCommand.returnType = false;
                                }
                            }


                            endEvent.Set();
                        }
                        break;
                   
                    case OxfordCommandType.Exit:
                        {
                            endEvent.Set();
                            log.Info("receive exit command");
                        }
                        break;

                }
                if (currentCommand.commandType == OxfordCommandType.Exit)
                {
                    log.Info("exiting the thread");
                    break;
                }
            }


        }
        public bool AquisitionImage(ref ImageAquistionParam p)
        {
            currentCommand.grabImgParam = p;
            currentCommand.commandType = OxfordCommandType.ImageAquisition;
            startEvent.Set();
            while (true)
            {
                if (endEvent.WaitOne(0, false))
                {
                    break;
                }
               
                Application.DoEvents();
            }
            log.Info("GrabImage:oxford thread return: " + currentCommand.returnType.ToString());
            if (currentCommand.returnType == true)
            {

                return true;
            }
            else
            {
                return false;
            }


        }
        public bool MoveStageXY(float x, float y)
        {
            currentCommand.moveStagePrm = new MoveStageParam();
            currentCommand.moveStagePrm.x = x;
            currentCommand.moveStagePrm.y = y;
            currentCommand.commandType = OxfordCommandType.MoveStageXY;
            startEvent.Set();
            while (true)
            {
                if (endEvent.WaitOne(0, false))
                {
                    break;
                }
            }
            if (currentCommand.returnType == true)
            {
                return true;
            }
            else
            {
                return false;
            }

        }
        public bool XrayAreaCollecting(ref AreaXrayParam p)
        {
           
            currentCommand.areaXrayPrm = p;
            currentCommand.commandType = OxfordCommandType.XrayAreaCollection;
            startEvent.Set();
            while (true)
            {
                if (endEvent.WaitOne(0, false))
                {
                    break;
                }
            }
            if (currentCommand.returnType == true)
            {

                return true;
            }
            else
            {

                return false;
            }
        }
        public bool XrayPointCollecting(ref PointXrayParam p)
        {

            currentCommand.pointXrayPrm = p;
            currentCommand.commandType = OxfordCommandType.XrayPointCollection;
            startEvent.Set();
            while (true)
            {
                if (endEvent.WaitOne(0, false))
                {
                    break;
                }
                Application.DoEvents();
            }
            if (currentCommand.returnType == true)
            {

                return true;
            }
            else
            {

                return false;
            }
        }
        public bool CollectXrayByPoints(ref List<PointXrayParam> a_listPoints, uint a_nXRayAQTime, bool a_bElementInfo)
        {


            currentCommand.XrayPrmForPoints = a_listPoints;
            currentCommand.commandType = OxfordCommandType.COLLECT_XRAYPOINTS;
            startEvent.Set();

            while (true)
            {
                if (endEvent.WaitOne(0, false))
                {
                    break;
                }
                Application.DoEvents();
            }
            if (currentCommand.returnType == true)
            {
                //a_listPoints.Clear();
                //foreach (var p in currentCommand.XrayPrmForPoints)
                //{
                //    a_listPoints.Add(p);
                //}
                //a_listPoints = currentCommand.XrayPrmForPoints;
                return true;
            }
            else
            {

                return false;
            }
        }
        public bool CollectXrayByFeatures(ref List<AreaXrayParam> a_listFeatures, double a_nXRayAQTime, bool a_bElementInfo)
        {


            currentCommand.XrayPrmForFeatures = a_listFeatures;


            currentCommand.commandType = OxfordCommandType.COLLECT_XRAYFEATURES;
            startEvent.Set();

            while (true)
            {
                if (endEvent.WaitOne(0, false))
                {
                    break;
                }

            }
            if (currentCommand.returnType == true)
            {
                a_listFeatures = currentCommand.XrayPrmForFeatures;
                return true;
            }
            else
            {

                return false;
            }


        }
        //public void BeginMultipleAquisition()
        //{
        //    currentCommand.commandType = OxfordCommandType.BeginMultipleAquisition;
        //    startEvent.Set();
        //    while (true)
        //    {
        //        if (endEvent.WaitOne(0, false))
        //        {
        //            break;
        //        }
        //        //Application.DoEvents();
        //    }



        //}

        //public void EndMultipleAquisition()
        //{
        //    currentCommand.commandType = OxfordCommandType.EndMultipleAquisition;
        //    startEvent.Set();
        //    while (true)
        //    {
        //        if (endEvent.WaitOne(0, false))
        //        {
        //            break;
        //        }
        //        //Application.DoEvents();
        //    }
        //}

        //public void BeginAreaModeMultipleAquisition()
        //{
        //    currentCommand.commandType = OxfordCommandType.BeginAreaModeMultipleAquisition;
        //    startEvent.Set();
        //    while (true)
        //    {
        //        if (endEvent.WaitOne(0, false))
        //        {
        //            break;
        //        }
        //        //Application.DoEvents();
        //    }


        //}

        //public void EndAreaModeMultipleAquisition()
        //{
        //    currentCommand.commandType = OxfordCommandType.EndAreaModeMultipleAquisition;
        //    startEvent.Set();
        //    while (true)
        //    {
        //        if (endEvent.WaitOne(0, false))
        //        {
        //            break;
        //        }
        //        //Application.DoEvents();
        //    }
        //}
       
        public double StageXMax
        {
            get { return this.m_dStageXMax; }
            set { this.m_dStageXMax = value; }
        }
        private double m_dStageXMin;
        public double StageXMin
        {
            get { return this.m_dStageXMin; }
            set { this.m_dStageXMin = value; }
        }

        private double m_dStageYMax;
        public double StageYMax
        {
            get { return this.m_dStageYMax; }
            set { this.m_dStageYMax = value; }
        }
        private double m_dStageYMin;
        public double StageYMin
        {
            get { return this.m_dStageYMin; }
            set { this.m_dStageYMin = value; }
        }

        private double m_dStageZMax;
        public double StageZMax
        {
            get { return this.m_dStageZMax; }
            set { this.m_dStageZMax = value; }
        }
        private double m_dStageZMin;
        public double StageZMin
        {
            get { return this.m_dStageZMin; }
            set { this.m_dStageZMin = value; }
        }

        private double m_dStageTMax;
        public double StageTMax
        {
            get { return this.m_dStageTMax; }
            set { this.m_dStageTMax = value; }
        }
        private double m_dStageTMin;
        public double StageTMin
        {
            get { return this.m_dStageTMin; }
            set { this.m_dStageTMin = value; }
        }

        private double m_dStageRMax;
        public double StageRMax
        {
            get { return this.m_dStageRMax; }
            set { this.m_dStageRMax = value; }
        }
        private double m_dStageRMin;
        public double StageRMin
        {
            get { return this.m_dStageRMin; }
            set { this.m_dStageRMin = value; }
        }

        internal oxfordCommandData GetCurrentCommand()
        {
            return currentCommand;
        }

        internal void SetCurrentCommand(oxfordCommandData value)
        {
            currentCommand = value;
        }

        //控制电镜初始化
        void InitMicroscopeController(float a_fStageXMin = 0, float a_fStageXMax = 130,
            float a_fStageYMin = 0, float a_fStageYMax = 130,
            float a_fStageZMin = 0, float a_fStageZMax = 40,
            float a_fStageTMin = 0, float a_fStageTMax = 90,
            float a_fStageRMin = 0, float a_fStageRMax = 360)
        {
            this.microscopeController = AcquireFactory.CreateMicroscopeControl();
            this.microscopeController.ColumnChange += this.OnMicroscopeColumnChange;
            this.microscopeController.StageChange += this.OnMicroscopeStageChange;
            this.microscopeController.ColumnConnected += this.OnMicroscopeColumnConnected;
            this.microscopeController.StageConnected += this.OnMicroscopeStageConnected;
            this.microscopeController.ChangeCompleted += this.OnMicroscopeChangeCompleted;

            ReadMicroscopeColumn();
            ReadStage();

            StageXMax = a_fStageXMax;
            StageXMin = a_fStageXMin;
            StageYMax = a_fStageYMax;
            StageYMin = a_fStageYMin;
            StageZMax = a_fStageZMax;
            StageZMin = a_fStageZMin;
            StageTMax = a_fStageTMax;
            StageTMin = a_fStageTMin;
            StageRMax = a_fStageRMax;
            StageRMin = a_fStageRMin;
        }

        //控制电镜释放
        void CloseMicroscopeController()
        {
            if (microscopeController != null)
            {
              
                this.microscopeController.ColumnChange -= this.OnMicroscopeColumnChange;
                this.microscopeController.StageChange -= this.OnMicroscopeStageChange;
                this.microscopeController.ColumnConnected -= this.OnMicroscopeColumnConnected;
                this.microscopeController.StageConnected -= this.OnMicroscopeStageConnected;
                this.microscopeController.ChangeCompleted -= this.OnMicroscopeChangeCompleted;
                microscopeController = null;
            }
           
        }

        //读取当前的电镜控制值
        private void ReadMicroscopeColumn()
        {
            var columnCapabilities = this.microscopeController.ColumnCapabilities;
            var columnConditions = this.microscopeController.ColumnConditions;

            if (columnCapabilities.Magnification.CanRead)
            {
                m_dMagnification = columnConditions.Magnification;
            }

            if (columnCapabilities.WorkingDistance.CanRead)
            {
                m_dWorkingDistance = columnConditions.WorkingDistance;
            }

            if (columnCapabilities.HighVoltage.CanRead)
            {
                m_dHighVoltage = columnConditions.HighVoltage;
            }

            if (columnCapabilities.Brightness.CanRead)
            {
                m_dBirghtness = columnConditions.Brightness;
            }

            if (columnCapabilities.Contrast.CanRead)
            {
                m_dContrast = columnConditions.Contrast;
            }

            if (columnCapabilities.BeamOn.CanRead)
            {
                m_bBeamOn = Convert.ToBoolean(columnConditions.BeamOn);
            }

            if (columnCapabilities.FilamentOn.CanRead)
            {
                m_bFilamentOn = Convert.ToBoolean(columnConditions.FilamentOn);
            }
        }

        //读取样品台位置
        private void ReadStage()
        {
            var stageCapabilities = this.microscopeController.StageCapabilities;
            var stageConditions = this.microscopeController.StageConditions;

            if (stageCapabilities.StageX.CanRead)
            {
                this.m_dStageX = stageConditions.StageX;
            }

            if (stageCapabilities.StageY.CanRead)
            {
                this.m_dStageY = stageConditions.StageY;
            }

            if (stageCapabilities.StageZ.CanRead)
            {
                this.m_dStageZ = stageConditions.StageZ;
            }

            if (stageCapabilities.StageT.CanRead)
            {
                this.m_dStageT = stageConditions.StageT;
            }

            if (stageCapabilities.StageR.CanRead)
            {
                this.m_dStageR = stageConditions.StageR;
            }
        }

        //电镜控制改变事件
        private void OnMicroscopeColumnChange(object sender, EventArgs e)
        {
          
            ReadMicroscopeColumn();
        }

        //样品台控制改变事件
        private void OnMicroscopeStageChange(object sender, EventArgs e)
        {
            
            ReadStage();
        }

        //列控制连接或断开时的事件
        private void OnMicroscopeColumnConnected(object sender, EventArgs e)
        {
          
        }

        //样品台控制连接或断开时的事件
        private void OnMicroscopeStageConnected(object sender, EventArgs e)
        {
          
            ReadStage();
        }

        //样品台控制、电镜控制、外围控制的事件改变完成
        private void OnMicroscopeChangeCompleted(object sender, EventArgs e)
        {
         
            ReadMicroscopeColumn();
            ReadStage();
        }

        public float GetMagnification()
        {
            return (float)m_dMagnification;
        }
        public Boolean SetMagnification(float set)
        {
            Dictionary<Column, double> columnDictionary = new Dictionary<Column, double>
            {
                { Column.Magnification, (double)set }

            };

            this.microscopeController.SetColumnConditions(columnDictionary);
            return true;
        }

        //焦距
        public float GetWorkingDistance()
        {
            return (float)m_dWorkingDistance;
        }
        public Boolean SetWorkingDistance(float set)
        {
            Dictionary<Column, double> columnDictionary = new Dictionary<Column, double>
            {
                { Column.WorkingDistance, (double)set }

            };

            this.microscopeController.SetColumnConditions(columnDictionary);
            return true;
        }

        //亮度
        public float GetBrightness()
        {

            return (float)m_dBirghtness;
        }
        public Boolean SetBrightness(float set)
        {
            Dictionary<Column, double> columnDictionary = new Dictionary<Column, double>
            {
                { Column.Brightness, (double)set }

            };

            this.microscopeController.SetColumnConditions(columnDictionary);
            return true;
        }

        //对比度
        public float GetContrast()
        {
            return (float)m_dContrast;
        }
        public Boolean SetContrast(float set)
        {
            Dictionary<Column, double> columnDictionary = new Dictionary<Column, double>
            {
                { Column.Contrast, (double)set }

            };

            this.microscopeController.SetColumnConditions(columnDictionary);

            return true;
        }

        //SEM电压
        public float GetSEMVoltage()
        {
            return (float)m_dHighVoltage;
        }
        public Boolean SetSEMVoltage(float set)
        {
            Dictionary<Column, double> columnDictionary = new Dictionary<Column, double>
            {
                { Column.HighVoltage, (double)set }

            };

            this.microscopeController.SetColumnConditions(columnDictionary);
            return true;
        }
        public bool SetSemScanExternal(bool b)
        {
            this.microscopeController.SetExternalScan(b);
            return true;
        }
       
        //样品台
        public float[] GetStagePosition()
        {
            float[] ret = new float[5];

            ret[0] = (float)m_dStageX;
            ret[1] = (float)m_dStageY;
            ret[2] = (float)m_dStageZ;
            ret[3] = (float)m_dStageT;
            ret[4] = (float)m_dStageR;

            return ret;
        }
        public Boolean SetStagePosition(float[] set)
        {
            double stageX = (double)set[0];
            if (stageX > StageXMax || stageX < StageXMin)
            {
                return false;
            }
            double stageY = (double)set[1];
            if (stageY > StageYMax || stageY < StageYMin)
            {
                return false;
            }
            double stageZ = (double)set[2];
            if (stageZ > StageZMax || stageZ < StageZMin)
            {
                return false;
            }
            double stageT = (double)set[3];
            if (stageT > StageTMax || stageT < StageTMin)
            {
                return false;
            }
            double stageR = (double)set[4];
            if (stageR > StageRMax || stageR < StageRMin)
            {
                return false;
            }

            var stageDictionary = new Dictionary<Stage, double>
            {
                { Stage.StageX, (double)stageX },
                { Stage.StageY, (double)stageY },
                { Stage.StageZ, (double)stageZ },
                { Stage.StageT, (double)stageT },
                { Stage.StageR, (double)stageR }
            };

            this.microscopeController.SetStageConditions(stageDictionary);
            return true;
        }
        public float GetStageAtX()
        {
            return (float)m_dStageX;
        }
        public float GetStageAtY()
        {
            return (float)m_dStageY;
        }
        public float GetStageAtZ()
        {
            return (float)m_dStageZ;
        }
        public float GetStageAtT()
        {
            return (float)m_dStageT;
        }
        public float GetStageAtR()
        {
            return (float)m_dStageR;
        }

        public Boolean SetStageGotoX(float set)
        {
            double stageX = (double)set;
            if (stageX > StageXMax || stageX < StageXMin)
            {
                return false;
            }

            var stageDictionary = new Dictionary<Stage, double>
            {
                { Stage.StageX, (double)stageX }
            };

            this.microscopeController.SetStageConditions(stageDictionary);
            return true;
        }
        public Boolean SetStageGotoY(float set)
        {

            double stageY = (double)set;
            if (stageY > StageYMax || stageY < StageYMin)
            {
                return false;
            }

            var stageDictionary = new Dictionary<Stage, double>
            {
                { Stage.StageY, (double)stageY }
            };

            this.microscopeController.SetStageConditions(stageDictionary);
            return true;
        }
        public Boolean SetStageGotoZ(float set)
        {
            double stageZ = (double)set;
            if (stageZ > StageZMax || stageZ < StageZMin)
            {
                return false;
            }

            var stageDictionary = new Dictionary<Stage, double>
            {
                { Stage.StageZ, (double)stageZ }
            };

            this.microscopeController.SetStageConditions(stageDictionary);
            return true;
        }
        public Boolean SetStageGotoT(float set)
        {
            double stageT = (double)set;
            if (stageT > StageTMax || stageT < StageTMin)
            {
                return false;
            }

            var stageDictionary = new Dictionary<Stage, double>
            {
                { Stage.StageT, (double)stageT }
            };

            this.microscopeController.SetStageConditions(stageDictionary);
            return true;
        }
        public Boolean SetStageGotoR(float set)
        {
            double stageR = (double)set;
            if (stageR > StageRMax || stageR < StageRMin)
            {
                return false;
            }

            var stageDictionary = new Dictionary<Stage, double>
            {
                { Stage.StageR, (double)stageR }
            };

            this.microscopeController.SetStageConditions(stageDictionary);
            return true;
        }
        private Boolean MoveStage(float x, float y)
        {
            double stageX = (double)x;
            if (stageX > StageXMax || stageX < StageXMin)
            {
                return false;
            }
            double stageY = (double)y;
            if (stageY > StageYMax || stageY < StageYMin)
            {
                return false;
            }

            var stageDictionary = new Dictionary<Stage, double>
            {
                { Stage.StageX, (double)stageX },
                { Stage.StageY, (double)stageY }
            };

            this.microscopeController.SetStageConditions(stageDictionary);
            return true;
        }
        #endregion

        #region 拍图
       

        //图像扫描尺寸
        public double[] ImageScanSize =
        {
            32,
            64,
            128,
            256,
            512,
            704,
            768,
            1024,
            4096,
            8192
        };

        private byte[] m_ImageBit = null;
        private long m_nImageWidth = 0;
        private long m_nImageHeight = 0;
        private double m_dImagePixelsize = 0;//it will be initialized when we get an image from the EDS.
        bool m_bAcquistionDone = false;
        //private Bitmap m_Bitmap = null;


        void InitImageAcquisition()
        {

            imageAcquisitionController = AcquireFactory.CreateImageServer();
            imageAcquisitionSettings = AcquireFactory.CreateImageSettings();
            //imageAcquisitionSettings.
            imageAcquisitionController.ExperimentStarted += this.OnImageExperimentStarted;
            imageAcquisitionController.ExperimentFinished += this.OnImageExperimentFinished;

        }
        void InitXrayAcquistion()
        {
            EdSpectrumSettings = AcquireFactory.CreateEdSpectrumSettings();
            EdSpectrumAcquisitionController = AcquireFactory.CreateEdSpectrumServer();
            EdSpectrumProcessing = ProcessingFactory.CreateSpectrumProcessing();
            // Use the autoIdSettings to define elements that are known or elements that you want to exclude. They also list elements that cannot be identified
            autoIdSettings = ProcessingFactory.CreateAutoIdSettings();
            quantSettings = ProcessingFactory.CreateSEMQuantSettings();

            EdSpectrumAcquisitionController.ExperimentFinished += this.OnEdSpectrumExperimentFinished;
            //EdSpectrumAcquisitionController.ExperimentStarted += this.OnEdSpectrumExperimentStarted;
        }
        //控制电镜释放
        void CloseImageAcquisition()
        {
            if (imageAcquisitionController != null)
            {
                imageAcquisitionController.ExperimentStarted -= this.OnImageExperimentStarted;
                imageAcquisitionController.ExperimentFinished -= this.OnImageExperimentFinished;
                imageAcquisitionController = null;
            }
            
        }
        void CloaseXrayAcquistion()
        {
            if (EdSpectrumAcquisitionController != null)
            {
                EdSpectrumAcquisitionController.ExperimentFinished -= this.OnEdSpectrumExperimentFinished;
                //EdSpectrumAcquisitionController.ExperimentStarted -= this.OnEdSpectrumExperimentStarted;
                EdSpectrumAcquisitionController = null;
            }

        }

        /// <summary>
        /// OnImageExperimentStarted
        /// </summary>
        private void OnImageExperimentStarted(object sender, AcquisitionStartedEventArgs<IElectronImage[]> e)
        {
            NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();
            log.Info("拍图开始事件！");
        }

        //int m_nState;
        /// <summary>
        /// OnImageExperimentFinished
        /// </summary>
        private void OnImageExperimentFinished(object sender, AcquisitionFinishedEventArgs<IElectronImage[]> e)
        {
            IElectronImage electronImage = e.Value[0];

            if (!ReadImageData(electronImage, out m_ImageBit, out m_nImageWidth, out m_nImageHeight, out m_dImagePixelsize))
            {
                //MessageBox.Show("图像采集完成，获取图像像素失败！");
                NLog.LogManager.GetCurrentClassLogger().Error("图像采集完成，获取图像像素失败！");
            }

            if (m_ImageBit != null && m_ImageBit.Length == m_nImageWidth * m_nImageHeight)
            {
                m_bAcquistionDone = true;
            }
        }


        bool ReadImageData(IElectronImage a_electronImage, out Byte[] a_pImageBits, out long a_nImageHeight, out long a_nImageWidth, out double a_nPixelSize)
        {
            a_nImageHeight = 0;
            a_nImageWidth = 0;
            a_nPixelSize = 0;
            a_pImageBits = null;

            if (a_electronImage == null)
            {
                return false;
            }

            a_nImageHeight = a_electronImage.Height;
            a_nImageWidth = a_electronImage.Width;
            a_nPixelSize = a_electronImage.PixelSize;

            int nBytesPerPixel = a_electronImage.BytesPerPixel;
            long nImageSize = a_nImageHeight * a_nImageWidth;
            long nBufferSize = nImageSize * nBytesPerPixel;

            Byte[] imageData = new Byte[nBufferSize];
            a_electronImage.GetData(imageData);

            a_pImageBits = new Byte[nImageSize];
            // default, oxford will return short image, we need to convert to byte
            if (nBytesPerPixel == 2)
            {
                int nBSEValue = 0;
                for (int i = 0; i < nImageSize; ++i)
                {
                    nBSEValue = imageData[0 + i * nBytesPerPixel] + imageData[1 + i * nBytesPerPixel] * 255;
                    a_pImageBits[i] = (Byte)(nBSEValue / 128.0 + 0.5);
                }
            }
            else
            {
                string msg = string.Format("image byte per pixel other than 2({0}), image convert may wrong", nBytesPerPixel);
                NLog.LogManager.GetCurrentClassLogger().Error(msg);

                int nOffset = nBytesPerPixel - 1;
                for (int i = 0; i < nImageSize; ++i)
                {
                    a_pImageBits[i] = imageData[nOffset + i * nBytesPerPixel];
                }
            }

            return true;
        }

        void AcquisitionParamInit()
        {
            m_ImageBit = null;
            m_nImageWidth = 0;
            m_nImageHeight = 0;
            m_bAcquistionDone = false;
            Bitmap m_Bitmap = null;
        }

        //a_dDwellTime : 1~100000之间的数 
        //a_sImageType : 1: SE, 2: Bse
        //a_dImageScanSize : 图像分辨率，图像的高
        public bool SetImageAcquistionSetting(double a_dDwellTime, ImageInputSources a_nImageType, double a_dImageScanSize)
        {


            IImageSettings imageSettings = imageAcquisitionSettings.ImageSettings;
            IImageCapabilities imageCapabilities = imageAcquisitionSettings.ImageCapabilities;
            IImageScanSettings scanSettings = imageAcquisitionSettings.ScanSettings;



            if (a_dDwellTime > imageCapabilities.MaximumImageDwellMicroseconds)
            {
                imageSettings.DwellTimeMicroSeconds = imageCapabilities.MaximumImageDwellMicroseconds;
            }

            if (a_dDwellTime < imageCapabilities.MinimumImageDwellMicroseconds)
            {
                imageSettings.DwellTimeMicroSeconds = imageCapabilities.MinimumImageDwellMicroseconds;
            }
            else
            {
                imageSettings.DwellTimeMicroSeconds = a_dDwellTime;
            }

            imageSettings.InputSources.ToList().ForEach(i => imageSettings.EnableInputSource(i.Key, false));
            imageSettings.EnableInputSource((ImageInputSources)a_nImageType, true);

            if (!ImageScanSize.Contains(a_dImageScanSize))
            {
                NLog.LogManager.GetCurrentClassLogger().Error("图像尺寸输入无效");
                return false;
            }

            var pixelSize = 1d / a_dImageScanSize;


            scanSettings.AcquisitionRegion.CreateFullFieldRegion(pixelSize);
            
            return true;
        }

       
        #endregion

        #region X-ray
      
 

     

        void SetXrayAcquisitionParam(double a_dMilliSecondsTime)
        {
            EdSpectrumSettings.EdSettings.AcquisitionMode = EdAcquireMode.LiveTime; // RealTime or LiveTime

            EdSpectrumSettings.EdSettings.AcquisitionTime = TimeSpan.FromMilliseconds(a_dMilliSecondsTime);

            EdSpectrumSettings.EdSettings.ProcessTime = 4;
            EdSpectrumSettings.EdSettings.EnergyRange = 20;
            EdSpectrumSettings.EdSettings.NumberOfChannels = 4096;

            // EdSpectrumSettings.ScanSettings.AcquisitionRegion.CreateFullFieldRegion(1.0 / 1024.0);
        }
        void SetAreaXrayAcquisitionParam(IEdChordListSettings EdSpectrumSettings, double a_dMilliSecondsTime)
        {
            EdSpectrumSettings.EdSettings.AcquisitionMode = EdAcquireMode.LiveTime; // RealTime or LiveTime


            EdSpectrumSettings.EdSettings.AcquisitionTime = TimeSpan.FromMilliseconds(a_dMilliSecondsTime);

            EdSpectrumSettings.EdSettings.ProcessTime = 4;
            EdSpectrumSettings.EdSettings.EnergyRange = 20;
            EdSpectrumSettings.EdSettings.NumberOfChannels = 4096;

            //EdSpectrumSettings.ScanSettings.AcquisitionRegion.CreateFullFieldRegion(1.0 / 1024.0);
        }
        void SetPointAcquistionRegion(double a_nX, double a_nY)
        {

            EdSpectrumSettings.ScanSettings.AcquisitionRegion.CreatePointRegion(new System.Windows.Point(a_nX, a_nY));
        }

        void SetAreaAcquistionRegion(List<Chord> a_nChords)
        {
            ChordList chordsList = null;
            chordsList = new ChordList(a_nChords, m_dImagePixelsize);
            EdSpectrumSettings.ScanSettings.AcquisitionRegion.CreateChordListRegion(chordsList);
        }


       


        /// <summary>
        /// Called when IEdSpectrumAcquisitionController Experiment Starting.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="AcquisitionFinishedEventArgs{IEdSpectrum}"/> instance containing the event data.</param>
        private void OnEdSpectrumExperimentStarting(object sender, AcquisitionStartingEventArgs<IEdSpectrum> e)
        {

        }

        /// <summary>
        /// Called when IEdSpectrumAcquisitionController Experiment Started.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="AcquisitionFinishedEventArgs{IEdSpectrum}"/> instance containing the event data.</param>
        private void OnEdSpectrumExperimentStarted(object sender, AcquisitionStartedEventArgs<IEdSpectrum> e)
        {
        }
        private IEdChordListSettings GetChordlistSettings()
        {
            if (_edsChordListSetting == null)
            {
                _edsChordListSetting = AcquireFactory.CreateEdChordListSettings();
                if (_edsChordListSetting != null)
                {
                    _edsChordListSetting.EdSettings.AcquisitionMode = EdAcquireMode.LiveTime;
                    _edsChordListSetting.EdSettings.NumberOfChannels = 1024;
                    _edsChordListSetting.EdSettings.ProcessTime = g_nOxfordControllerProcessTime;
                    _edsChordListSetting.EdSettings.EnergyRange = g_nOxfordControllerEnergyRange;

                    _edsChordListSetting.AutoIdSettings.SetKnownElement(79, true);
                    _edsChordListSetting.NumberOfProcessingThreads = 1;
                }
                else
                {
                    NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();
                    log.Error("Create EDS chordlist setting failed.");
                }
            }
            return _edsChordListSetting;
        }
        private IEdChordListAcquisitionController CreateChordlistController()
        {
            if (_edsChordListController == null)
            {
                _edsChordListController = AcquireFactory.CreateEdChordListServer();
                _edsChordListController.PixelProcessed += new EventHandler<OINA.Extender.EventArgs<OINA.Extender.Processing.Quant.IPixelSEMQuantStatus>>(this.OnController_PixelProcessed);
                _edsChordListController.ExperimentFinished += new EventHandler<OINA.Extender.Acquisition.AcquisitionFinishedEventArgs>(this.OnController_ExperimentFinished);

                var edsChordListSettings = GetChordlistSettings();
                while (true)
                {
                    if (_edsChordListController.IsEdHardwareReady(edsChordListSettings))
                    {
                        if (edsChordListSettings.EdCapabilities.HasHardwareConnection)
                        {
                            break;
                        }
                    }
                }
            }
            return _edsChordListController;
        }

        struct Element
        {
            public int m_nAotomaticNo;
            public double m_dWeight;
        }
        private struct OxfordXrayData
        {
            public long m_nPosX;
            public long m_nPosY;
            public static readonly long[] m_pXrayData = new long[(int)EDSConst.XANA_CHANNELS];
            public static readonly char[] vs = new char[1024];

            public static readonly OxfordChord[] m_ChordList = new OxfordChord[1024];
            public long m_nChordNum;
            public long m_nPixelNum;
            internal char[] m_strElementResult;
        }
        private void OnController_ExperimentFinished(Object sender, OINA.Extender.Acquisition.AcquisitionFinishedEventArgs e)
        {
            if (m_nCollectedXrayCounts == m_nXrayDataCount)
            {
                m_nState = OxfordControllerState.SUCCEEDED;
            }
            else
            {
                m_nState = OxfordControllerState.FAILED;
            }
            m_endControllerEvent.Set();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnController_PixelProcessed(object sender, EventArgs<IPixelSEMQuantStatus> e)
        {
            m_nCollectedPixelCounts = m_nCollectedPixelCounts++;
            //更新当前feature的元素成分

            //获取单点的元素结果
            var ie = e.Value.QuantStatus.Results.GetEnumerator();
            while (ie.MoveNext())
            {
                ISEMQuantResult result = ie.Current;
                if (result.WeightPercent != 0)
                {
                    Element Quant = new Element();
                    Quant.m_nAotomaticNo = result.AtomicNumber;
                    Quant.m_dWeight = result.WeightPercent;

                    if (m_listElementResult == null)
                    {
                        m_listElementResult = new List<Element>
                        {
                            Quant
                        };
                    }
                    else
                    {
                        bool bFind = false;
                        for (int i = 0; i < m_listElementResult.Count; i++)
                        {
                            Element element = m_listElementResult[i];
                            if (Quant.m_nAotomaticNo == element.m_nAotomaticNo)
                            {
                                element.m_dWeight += Quant.m_dWeight;
                                bFind = true;
                            }
                        }
                        if (!bFind)
                        {
                            m_listElementResult.Add(Quant);
                        }
                    }

                }
            }

            //当前的chord数据中pixel没有采集完整
            if (m_nCollectedPixelCounts == m_nPixelNum)
            {
                //形成quant数据
                String Quant = "";
                for (int i = 0; i < m_listElementResult.Count; i++)
                {
                    Element result = m_listElementResult[i];
                    Quant += "Quant=";
                    String strAoto = ElementProperties.GetElementSymbol(result.m_nAotomaticNo);
                    Quant += strAoto;
                    Quant += ",";
                    Quant += "K-serials";
                    Quant += ",";
                    String strWeight = (result.m_dWeight / Convert.ToDouble(m_nPixelNum)).ToString();
                    Quant += strWeight;
                    Quant += "\n";
                }
                String msg = Quant;
                char[] dst = m_pXrayData[m_nCollectedXrayCounts].m_strElementResult;
                for (int i = 0; i < msg.Length; i++)
                {
                    dst[i] = (char)msg[i];
                }
                m_nCollectedXrayCounts++;
                if (m_nCollectedXrayCounts < m_nXrayDataCount)
                {
                    m_nPixelNum = m_pXrayData[m_nCollectedXrayCounts].m_nPixelNum;
                    m_nCollectedPixelCounts = 0;
                    m_listElementResult.Clear();
                }
            }
        }

        /// <summary>
        /// Called when IEdSpectrumAcquisitionController Experiment Finished
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">The instance containing the event data.</param>
        private void OnEdSpectrumExperimentFinished(object sender, AcquisitionFinishedEventArgs<IEdSpectrum> e)
        {

            IEdSpectrumAcquisitionController edSpectrumAcquisitionController = sender as IEdSpectrumAcquisitionController;

             uint[] m_XrayData;

            NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();
            IEdSpectrum edSpectrum = e.Value;

            if (!ReadXrayData(edSpectrum, out m_XrayData, XRayChannelLength))
            {
                NLog.LogManager.GetCurrentClassLogger().Error("Xray采集完成，获取xray失败！");
            }
            long nXraycount = 0;
            for (int i = 0; i < 2000; i++)
            {
                nXraycount += m_XrayData[i];
            }

            //Quantify processing

            EdSpectrumProcessing.IdentifyElements(e.Value, autoIdSettings);
            // While it is possible to choose other elements, Oxygen is the only supported element by stoichiometry.
            quantSettings.CombinedElement = 8;
            quantSettings.Normalised = true;
            ISEMQuantStatus quantStatus = EdSpectrumProcessing.SEMQuantifySpectrum(e.Value, quantSettings);//(a_nChannelData, OIHelper::SEMQuantSettings);
            IEnumerable<ISEMQuantResult> Results = quantStatus.Results;

            
            var ie = Results.GetEnumerator();

           var m_listElement = new Dictionary<string, double>();

            while (ie.MoveNext())
            {
                ISEMQuantResult result = ie.Current;

                if (result.WeightPercent != 0)
                {
                    m_listElement.Add(ElementProperties.GetElementSymbol(result.AtomicNumber), result.WeightPercent);
                }

            }

            if (m_XrayData != null && m_XrayData.Length == XRayChannelLength)
            {

                if (currentCommand.commandType == OxfordCommandType.XrayPointCollection)
                {
                    currentCommand.pointXrayPrm.XrayData = m_XrayData;
                    currentCommand.pointXrayPrm.listElement = m_listElement;
                    m_bXrayDone = true;
                }
                else if (currentCommand.commandType == OxfordCommandType.XrayAreaCollection)
                {
                    currentCommand.areaXrayPrm.XrayData = m_XrayData;
                    currentCommand.areaXrayPrm.listElement = m_listElement;
                    m_bXrayDone = true;
                }
                else if (currentCommand.commandType == OxfordCommandType.COLLECT_XRAYPOINTS)
                {
                    var curXrayData = currentCommand.XrayPrmForPoints[currentCommand.PointXrayDataReceived];
                    curXrayData.XrayData = m_XrayData;
                    curXrayData.listElement = m_listElement;
                    currentCommand.PointXrayDataReceived += 1;

                    if (currentCommand.PointXrayDataReceived == currentCommand.XrayPrmForPoints.Count)
                    {
                        m_bXrayDone = true;
                    }


                }
                else if (currentCommand.commandType == OxfordCommandType.COLLECT_XRAYFEATURES)
                {
                    var curXrayData = currentCommand.XrayPrmForFeatures[currentCommand.AreaXrayDataReceived];
                    curXrayData.XrayData = m_XrayData;
                    curXrayData.listElement = m_listElement;
                    currentCommand.AreaXrayDataReceived += 1;
                    if (currentCommand.AreaXrayDataReceived == currentCommand.XrayPrmForFeatures.Count)
                    {
                        m_bXrayDone = true;
                    }
                }
               

            }


        }

        bool ReadXrayData(IEdSpectrum a_spectrum, out uint[] a_pSpectrumData, int a_nBufferSize)
        {
            a_pSpectrumData = new uint[a_nBufferSize];

            int[] xrayData = new int[a_spectrum.NumberOfChannels];
            a_spectrum.GetChannelData(xrayData);

            double dZeroChannelValue = a_spectrum.ZeroChannelValue;

            int nChannelStart = 0;
            if (dZeroChannelValue < 0)  // zero channel value should less than zero
            {
                nChannelStart = (int)(-dZeroChannelValue / a_spectrum.ChannelWidth + 0.5);
            }

            int nDataLength = (int)(a_spectrum.EnergyRange * 1000 / a_spectrum.ChannelWidth + 0.5);

            double dStep1 = 1.0 / nDataLength;
            double dStep2 = 1.0 / a_nBufferSize;

            for (int i = 0; i < nDataLength; ++i)
            {
                uint nValue = (uint)(xrayData[i + nChannelStart] > 0 ? xrayData[i + nChannelStart] : 0);

                double dBinPos = i * dStep1;

                long nLeftBin = (long)(dBinPos / dStep2);

                // calculate % into left bin
                double dLeft_Percent = (double)(nLeftBin + 1) - dBinPos / dStep2; // ((nLeftBin + 1)*dStep2 - dBinPos)/dStep2

                // calculate data into the left bin
                uint nValueToLeftBin = (uint)((double)nValue * dLeft_Percent + 0.5);

                // put data into bins
                a_pSpectrumData[nLeftBin] += nValueToLeftBin;
                if ((nLeftBin + 1) < a_nBufferSize)
                {
                    a_pSpectrumData[nLeftBin + 1] += (nValue - nValueToLeftBin);
                }
            }

            return true;
        }
        /// <summary>
        /// Called when IEdSpectrum DataChanged
        /// </summary>
        /// <param name="sender">Event source</param>
        /// <param name="e">Event arguments</param>
        private void OnDataChanged(object sender, EventArgs e)
        {
        }

        public bool IsAcquiringSpectrum()
        {
            return EdSpectrumAcquisitionController.IsAcquiring;
        }

      


        public void BeginMultipleAquisition()
        {

            EdSpectrumAcquisitionController.BeginMultipleAcquisition();
        }

        public void EndMultipleAquisition()
        {
            EdSpectrumAcquisitionController.EndMultipleAcquisition();
        }

        public void BeginAreaModeMultipleAquisition()
        {
            var controller = CreateChordlistController();
            controller.BeginMultipleAcquisition();
        }

        public void EndAreaModeMultipleAquisition()
        {
            var controller = CreateChordlistController();
            controller.EndMultipleAcquisition();
        }

       
        public bool GetSemBeamOn()
        {
            var beamon = microscopeController.ColumnConditions.BeamOn;
            if (beamon == 1)
            {
                return true;
            }
            else 
            {
                return false;
            
            }
           
        }
        public void StopXrayAquisition()
        {

            EdSpectrumAcquisitionController.StopAcquisition();


        }


        #endregion

    }
}