OTS/OTSIncAMeasureApp/ServiceCenter/EDSController.cs


using OTSDataType;
using FEIApiControl;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using OTSCLRINTERFACE;
namespace OTSModelSharp.ServiceCenter
{
    using  OTSCLRINTERFACE;
    using OTSMeasureApp._0_OTSModel.Measure._5_OTSMining;
    using System.Drawing;
    using System.Windows.Forms;

    public class EDSController : IEDSController
    {
        private COTSControlFunExport eds;
        static EDSController edsctrl = null;
        public static APIClass ApiClass = null;
        private static bool isFEI = false;
        private int AnalyExpCount = 100000;
        private string strResolution = "";
        public static EDSController GetEDSController()
        {
            if (FileHelper.GetXMLInformations("EDSName") == "FEI")
            {
                isFEI = true;
            }
            if (edsctrl == null)
            {
                edsctrl = new EDSController();
            }
            return edsctrl;
        }

        private EDSController()
        {
            if (isFEI)
            {
                ApiClass = new APIClass();
                Connect();
            }
            else
            {
                eds = OTSCLRINTERFACE.COTSControlFunExport.GetControllerInstance();
            }
        }
        private void ProcessXrayInfo(COTSParticleClr partWithXrayInfo)//sometime the result will contain repeat percentage data for one element.It must be processed.
        {
         var eleChemistry =  partWithXrayInfo.GetXray().GetElementQuantifyData();
            Dictionary<string, List<double>> eleInfoDic = new Dictionary<string, List<double>>();
            bool hasRepeatEle = false;
            foreach (var ele in eleChemistry)
            {
                if (eleInfoDic.ContainsKey(ele.GetName()))//contain repeat data;
                {
                    eleInfoDic[ele.GetName()].Add(ele.GetPercentage());
                    hasRepeatEle = true;
                }
                else
                {

                    eleInfoDic.Add(ele.GetName(), new List<double>() { ele.GetPercentage() });
                }



            }
            if (hasRepeatEle)
            {
                Dictionary<string, double> resultInfo = new Dictionary<string, double>();
                foreach (var eleInfo in eleInfoDic)
                {
                    double newPercentData=0;
                    foreach (var p  in eleInfo.Value)
                    {
                        newPercentData += p;
                    }
                    newPercentData = newPercentData / eleInfo.Value.Count;
                    resultInfo.Add(eleInfo.Key, newPercentData);              
                }
                foreach (var e in eleChemistry)
                {
                    e.SetPercentage(resultInfo[e.GetName()]);
                
                }
                partWithXrayInfo.GetXray().SetElementQuantifyData(eleChemistry);


            }


        }
        public bool GetXRayByFeatures(List<COTSParticleClr> a_listParticles,  double a_nXRayAQTime, bool a_bElementInfo)
        {
            bool result = false;
            if (isFEI)
            {
                for (int i = 0; i < a_listParticles.Count; i++)
                {
                    Rectangle rectangle = (Rectangle)a_listParticles[i].GetParticleRect();
                    Dictionary<string, double> eleItems = new Dictionary<string, double>();
                    uint[] spectrumItems = new uint[2000];
                    if (!ApiClass.GetXRayByRect(rectangle, strResolution, a_nXRayAQTime, AnalyExpCount, a_bElementInfo, ref eleItems, ref spectrumItems))
                    {
                        return false;
                    }
                    a_listParticles[i].GetXray().SetXrayData(spectrumItems);
                    if (a_bElementInfo)
                    {
                        List<CElementChemistryClr> elementChemistryClrs = new List<CElementChemistryClr>();
                        for (int j = 0; j < eleItems.Count; j++)
                        {
                            CElementChemistryClr chemistryClr = new CElementChemistryClr();
                            chemistryClr.SetName(eleItems.ElementAt(j).Key);
                            chemistryClr.SetPercentage(eleItems.ElementAt(j).Value);
                            elementChemistryClrs.Add(chemistryClr);
                        }
                        a_listParticles[i].GetXray().SetElementQuantifyData(elementChemistryClrs);
                    }
                }
                result = true;
           
            }
            else
            {
                if (!eds.IsConnected())
                {
                    return false;
                }

                COTSParticleClr[] parts = a_listParticles.ToArray();


                result= eds.GetXRayByFeatures((uint)a_nXRayAQTime, parts, a_bElementInfo);
            }

            if (result == true)
            {
                foreach (var p in a_listParticles)
                {
                    ProcessXrayInfo(p);
                }
               
            
            }
            return result;
        }

        public bool GetXRayByPoints(List<COTSParticleClr> a_listParticles, uint a_nXRayAQTime, bool a_bElementInfo)
        {
            bool result = false;
            if (isFEI)
            {
                for (int i = 0; i < a_listParticles.Count; i++)
                {
                    Point point = (Point)a_listParticles[i].GetXRayPos();
                    Dictionary<string, double> eleItems = new Dictionary<string, double>();
                    uint[] spectrumItems = new uint[2000];
                    if (!ApiClass.GetXRayByPoint(point.X, point.Y, strResolution, a_nXRayAQTime, AnalyExpCount, a_bElementInfo, ref eleItems, ref spectrumItems))
                    {
                        return false;
                    }
                    a_listParticles[i].GetXray().SetXrayData(spectrumItems);
                    if (a_bElementInfo)
                    {
                        List<CElementChemistryClr> elementChemistryClrs = new List<CElementChemistryClr>();
                        for (int j = 0; j < eleItems.Count; j++)
                        {
                            CElementChemistryClr chemistryClr = new CElementChemistryClr();
                            chemistryClr.SetName(eleItems.ElementAt(j).Key);
                            chemistryClr.SetPercentage(eleItems.ElementAt(j).Value);
                            elementChemistryClrs.Add(chemistryClr);
                        }
                        a_listParticles[i].GetXray().SetElementQuantifyData(elementChemistryClrs);
                    }
                }
                result= true;
            }
            else
            {
                if (!eds.IsConnected())
                {
                    return false;
                }

                int xrayNum = a_listParticles.Count;
                Point[] Ps = new Point[xrayNum];

                for (int i = 0; i < xrayNum; i++)
                {
                    Point p = (Point)a_listParticles[i].GetXRayPos();
                    Ps[i].X = p.X;
                    Ps[i].Y = p.Y;
                }

                COTSParticleClr[] parts = a_listParticles.ToArray();

                result= eds.GetXRayByPoints(a_nXRayAQTime, Ps, parts, a_bElementInfo);
            }
            if (result == true)
            {
                foreach (var p in a_listParticles)
                {
                    ProcessXrayInfo(p);
                }


            }
            return result;
        }
        public bool GetXRayBySubParticles(List<COTSParticleClr> a_listParticles, uint a_nXRayAQTime)
        {
         
            if (isFEI)
            {
                for (int i = 0; i < a_listParticles.Count; i++)
                {
                    foreach (var matrixP in a_listParticles[i].GetSubParticles())
                    {
                                      
                        Dictionary<string, double> eleItems = new Dictionary<string, double>();
                        uint[] spectrumItems = new uint[2000];
                        Point xrayPos = (Point)matrixP.GetXRayPos();
                        if (!ApiClass.GetXRayByPoint(xrayPos.X, xrayPos.Y, strResolution, a_nXRayAQTime, AnalyExpCount, false, ref eleItems, ref spectrumItems))
                        {
                            continue;
                        }
                        CPosXrayClr posxray = new CPosXrayClr();
                        posxray.SetXrayData(spectrumItems);
                        posxray.SetPosition(xrayPos);
                        posxray.SetScanFieldId(matrixP.GetFieldId());
                        matrixP.SetXray(posxray);


                    }
                  
                }
                return true;
            }
            else
            {
                if (!eds.IsConnected())
                {
                    return false;
                }
             
                List<CPosXrayClr> posxrays = new List<CPosXrayClr>();
                foreach (var rawpart in a_listParticles)
                {
                    var parts = rawpart.GetSubParticles();
                    foreach (var part in parts)
                    {
                        var xray = new CPosXrayClr();
                        xray.SetPosition((Point)part.GetXRayPos());
                        xray.SetScanFieldId(part.GetFieldId());
                        posxrays.Add(xray);
                        part.SetXray(xray);
                    }
                  
                }
             
              
                var xrays = posxrays.ToArray();
               return  eds.GetXRayByPoints(a_nXRayAQTime,ref xrays,  false);


            }
        }

        public bool CollectSpectrum(uint a_nXRayAQTime, ref uint[] a_XrayData)
        {
            if (isFEI)
            {
                Dictionary<string, double> eleItems = new Dictionary<string, double>();

                return ApiClass.AcquireSpectrum(false, ref eleItems, ref a_XrayData);
            }
            else
            {
                if (!eds.IsConnected())
                {
                    return false;
                }

                return eds.CollectSpectrum(a_nXRayAQTime, ref a_XrayData);
            }
        }

        public bool GetXRayBySinglePoint(uint a_nXRayAQTime, Point point, ref uint[] a_XrayData, ref string ele, bool a_bElementInfo)
        {
            if (isFEI)
            {
                double x = point.X;
                double y = point.Y;
                double z = 0;
                double r = 0;
                double t = 0;
                Dictionary<string, double> eleItems = new Dictionary<string, double>();
                if (!ApiClass.GetSemPositionXYZRT(ref x, ref y, ref z, ref r, ref t))
                {
                    return false;
                }
                return ApiClass.GetXRayByPoint((int)x, (int)y, strResolution, a_nXRayAQTime, AnalyExpCount, a_bElementInfo, ref eleItems, ref a_XrayData);
            }
            else
            {
                if (!eds.IsConnected())
                {
                    return false;
                }

                return eds.GetXRayBySinglePoint(a_nXRayAQTime, point, ref a_XrayData, ref ele, a_bElementInfo);
            }
        }

        public bool GetXRayBySingleFeature(uint a_nXRayAQTime, COTSFeatureClr fea, ref uint[] a_XrayData, ref string ele, bool a_bElementInfo)
        {
            if (isFEI)
            {
                Rectangle rectangle = new Rectangle();
                rectangle.X = fea.GetSegmentsList().Min(a => a.GetStart());
                rectangle.Y = fea.GetSegmentsList().Min(a => a.GetHeight());
                rectangle.Width = fea.GetSegmentsList().Max(a => a.GetLength());
                rectangle.Height = Math.Abs(rectangle.Y - rectangle.X);

                Dictionary<string, double> eleItems = new Dictionary<string, double>();
                return ApiClass.GetXRayByRect(rectangle, strResolution, a_nXRayAQTime, AnalyExpCount, a_bElementInfo, ref eleItems, ref a_XrayData);
            }
            else
            {
                if (!eds.IsConnected())
                {
                    return false;
                }

                return eds.GetXRayBySingleFeature(a_nXRayAQTime, fea, ref a_XrayData, ref ele, false);
            }
        }

        public bool GetXRayElements(uint a_nXRayAQTime, ref uint[] a_XrayData, ref ValueType a_nElementNum, ref string a_strResult)
        {
            if (isFEI)
            {
                Dictionary<string, double> eleItems = new Dictionary<string, double>();
                bool isTrue = ApiClass.AcquireSpectrum(true, ref eleItems, ref a_XrayData);
                a_nElementNum = eleItems.Count;
                for (int i = 0; i < eleItems.Count; i++)
                {
                    a_strResult += eleItems.ElementAt(i).Key + ":" + eleItems.ElementAt(i).Value + "\n";
                }

                return isTrue;
            }
            else
            {
                if (!eds.IsConnected())
                {
                    return false;
                }

                return eds.GetXRayElements(a_nXRayAQTime, ref a_XrayData, ref a_nElementNum, ref a_strResult);
            }
        }

        public bool GetXRayAndElements(uint a_nXRayAQTime, int dMouseImgX, int dMouseImgY, ref uint[] a_XrayData, ref ValueType a_nElementNum, ref string a_strResult)
        {
            if (isFEI)
            {
                Dictionary<string, double> eleItems = new Dictionary<string, double>();
                bool isTrue = ApiClass.GetXRayByPoint(dMouseImgX, dMouseImgY, strResolution, a_nXRayAQTime, AnalyExpCount, true, ref eleItems, ref a_XrayData);
                a_nElementNum = eleItems.Count;
                for (int i = 0; i < eleItems.Count; i++)
                {
                    a_strResult += eleItems.ElementAt(i).Key + ":" + eleItems.ElementAt(i).Value + "\n";
                }

                return isTrue;
            }
            else
            {
                if (!eds.IsConnected())
                {
                    return false;
                }

                return eds.GetXRayAndElements(a_nXRayAQTime, dMouseImgX, dMouseImgY, ref a_XrayData, ref a_nElementNum, ref a_strResult);
            }
        }

        public bool Init()
        {
            if (isFEI)
            {
                return ApiClass.isConnect();
            }
            else
            {
                bool m_init = eds.EDSInit();
                return m_init;
            }
        }

        public bool ScanInit()
        {
            if (isFEI)
            {
                return ApiClass.isConnect();
            }
            else
            {
                bool m_init = eds.ScanInit();
                return m_init;
            }
        }

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

                if (ApiClass.isConnect())
                {
                    return true;
                }

                return ApiClass.Connect(FEIIP, FEIPORT);
            }
            else
            {
                if (!eds.Init())
                {
                    return false;
                }
                if (eds.IsConnected())
                {
                    return true;
                }

                return eds.ConncetSem();
            }
        }

        public bool DisConnect()
        {
            if (isFEI)
            {
                return ApiClass.DisConnect();
            }
            else
            {
                if (eds.IsConnected())
                {
                    return eds.DisconnectSem();
                }

                return true;
            }
        }

        public bool SetResolution(int ResolutionWidth, int ResolutionHeight)
        {
            if (isFEI)
            {
                strResolution = ResolutionWidth + "x" + ResolutionHeight;
            }
            return true;
        }

        public bool SetAnalyExpCount(int MaxCounts)
        {
            if (isFEI)
            {
                AnalyExpCount = MaxCounts;
            }

            return true;
        }
    }
}