OTS/OTSIncAReportApp/1-UI/Control_Grids/ParticlesGridDevidePage/ParticlesGridDevidePage.cs

using NPOI.HSSF.UserModel;
using NPOI.SS.UserModel;
using OTSIncAReportApp;
using OTSIncAReportApp.DataOperation.DataAccess;
using OTSCommon.Model;
using OTSIncAReportApp.SysMgrTools;
using OTSIncAReportGraph.Class;
using OTSIncAReportGraph.OTSIncAReportGraphFuncation;
using OTSIncAReportGrids.OTSIncAReportGridsFuncation;
using OTSIncAReportMailInterface;

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
using NPOI.XSSF.UserModel;
using NPOI.SS.UserModel.Charts;
using NPOI.SS.Util;
using OTSIncAReportApp._1_UI.Control_Grids.ParticlesGridDevidePage;
using OTSIncAReportGraph.Controls;
using OTSIncAReportApp.Properties;
using OTSPeriodicTable;

namespace OTSIncAReportGrids
{
    public partial class ParticlesGridDevidePage : UserControl
    {
        ParticlesGridDevidePageShowConfig m_particlesGridDevidePageShowConfig=null;

        //设置模拟数据表
        public DataTable m_dt = new DataTable();

        //底层操作类
        OTSReportGridsFun m_OTSIncAReportGridsFun = null;

        //进度条窗体
        public Frm_UserProgress m_frm_userprogress;

        //移动SEM到指定位置发生线程
        private Thread m_mythread;

        //记录线程是否已经运行完成的状态
        private bool m_mythread_state = false;

        //导出图像文件的路径
        private string m_imagefilepath = "";

        //显示元素列表
        public List<string> m_list_elementscolname = null;

        //单个数据源所拥有的列数，这里保存下来，供导出模块使用
        public int m_oneresult_columncount = 0;

        OTSImageDisHelp m_ReportFun = null;
        private OTSImageDisHelp ReportFun { get => m_ReportFun; set => m_ReportFun = value; }
        /// <summary>
        /// 选择颗粒缓存表
        /// </summary>
        List<Particle> Particleslist_selecttodisplay = new List<Particle>();

        //多个数据源，每个数据源拥有的列数，这里保存下来，供分组使用
        public List<int> m_list_oneresult_columncount;

        //国际化
        Language lan;
        Hashtable table;
        //测量结果
        ResultFile result = null;
        frmReportConditionChoose m_condition;
        FieldData fieldData;
        DataTable particlesAll;
        DataTable particles;
        ParticleData Particledata;
        UserLibraryData userLibrary;
        DataTable userLibraryData;
        NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();

        enum SelItem
        {
            analyticalParticle = 0,
            otherParticles = 1,
            MergeParticles = 2,
            allParticles=3
        }

        #region 分页器相关

        #region 分页字段和属性

        string condition = "";
        public string FileName = null;
        private int pageIndex = 1;

        /// <summary>
        /// 当前页面
        /// </summary>
        public virtual int PageIndex
        {
            get { return pageIndex; }
            set { pageIndex = value; }
        }

        private int pageSize = 20;
        /// <summary>
        /// 每页记录数
        /// </summary>
        public virtual int PageSize
        {
            get { return pageSize; }
            set { pageSize = value; }
        }

        //string OrderFunction = "fieldid,particleid";

        private int recordCount = 0;
        /// <summary>
        /// 总记录数
        /// </summary>
        public virtual int RecordCount
        {
            get { return recordCount; }
            set { recordCount = value; }
        }

        private int pageCount = 0;
        /// <summary>
        /// 总页数
        /// </summary>
        public int PageCount
        {
            get
            {
                pageCount = GetPageCount();
                return pageCount;
            }
        }
        /// <summary>
        /// 计算总页数
        /// </summary>
        /// <returns></returns>
        private int GetPageCount()
        {
            if (PageSize == 0)
            {
                return 0;
            }
            int pageCount = RecordCount / PageSize;
            if (RecordCount % PageSize == 0)
            {
                pageCount = RecordCount / PageSize;
            }
            else
            {
                pageCount = RecordCount / PageSize + 1;
            }
            return pageCount;
        }
        #endregion

        frmReportApp m_ReportApp;
        ResultFile resultFile = null;
        #endregion

        public ParticlesGridDevidePage(frmReportApp ReportApp)
        {
            m_ReportApp = ReportApp;
            m_condition = ReportApp.m_conditionChoose;
            resultFile = ReportApp.m_rstDataMgr.CurResultFile;
            ReportFun = new OTSImageDisHelp(resultFile);

            string sou = m_condition.m_CurrentConditions[OTSIncAReportApp.OTSSampleReportInfo.OTS_REPORT_PROP_GRID_ITEMS.DATA_SOURCE].itemDisplayVal.ToString();
            if (sou.Contains("+"))
            {
                MessageBox.Show("This function does not support multiple samples!");
                result = m_ReportApp.m_rstDataMgr.ResultFilesList[0];
            }
            else
            {
                result = m_ReportApp.m_rstDataMgr.ResultFilesList[m_ReportApp.m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTSIncAReportApp.OTSSampleReportInfo.OTS_REPORT_PROP_GRID_ITEMS.DATA_SOURCE)];
            }


            //设置窗体的双缓冲,以保证大数据时拖动不卡
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw | ControlStyles.AllPaintingInWmPaint, true);
            this.UpdateStyles();

            InitializeComponent();

            //利用反射设置DataGridView的双缓冲
            Type dgvType = this.dgV_ParticlesDevidePage.GetType();
            PropertyInfo pi = dgvType.GetProperty("DoubleBuffered", BindingFlags.Instance | BindingFlags.NonPublic);
            pi.SetValue(this.dgV_ParticlesDevidePage, true, null);

            this.control_XRayTable1 = new Control_XRayTable(null);
            this.control_XRayTable1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(180)))), ((int)(((byte)(255)))), ((int)(((byte)(255)))), ((int)(((byte)(255)))));
            this.control_XRayTable1.Dock = System.Windows.Forms.DockStyle.Bottom;
            this.control_XRayTable1.GBInfoStr = "";
            this.control_XRayTable1.GoodChineseName = "";
            this.control_XRayTable1.MaterialName = "";
            //this.control_XRayTable1.List_ShowElementInfo = ((System.Collections.Generic.List<OTSIncAReportGraph.Controls.ShowElementInfo>)(Resources.GetObject("control_XRayTable1.List_ShowElementInfo")));
            this.control_XRayTable1.Location = new System.Drawing.Point(0, 400);
            this.control_XRayTable1.Name = "control_XRayTable1";
            this.control_XRayTable1.ShowAnalysisXray = true;
            this.control_XRayTable1.ShowSearchXray = false;
            this.control_XRayTable1.Size = new System.Drawing.Size(1004, 200);
            this.control_XRayTable1.STDName = "";
            this.control_XRayTable1.Visible = false;
            this.control_XRayTable1.label_close.Visible = true;
            this.Controls.Add(this.control_XRayTable1);
        }
        bool Init()
        {
            if(result==null)
            {
                return false;
            }
            try
            {
                lan = new Language(this);
                table = lan.GetNameTable(this.Name);


                m_mythread_state = false;
                m_mythread = new Thread(new ParameterizedThreadStart(Thread_GO));
                //m_frm_userprogress = new Frm_UserProgress();
                fieldData = new FieldData(result.FilePath);
                Particledata = new ParticleData(result.FilePath);
                var systype = m_ReportApp.m_RptConfigFile.Systype;
                if (systype == OTSCommon.Model.OTS_SysType_ID.CleannessA)
                {
                    string str_libraryName = result.GetSTDName();
                    userLibrary = new UserLibraryData(str_libraryName,result.FilePath+"\\");
                    if (userLibrary.GetSqlHelper() != null)
                    {
                        userLibraryData = userLibrary.GetSubAttributeFromDatabase();
                    }
                    else
                    {
                        userLibraryData = null;
                        //MessageBox.Show("未读取到用户标准库！");
                    }
                }
                //初始化底层操作类
                m_OTSIncAReportGridsFun = new OTSReportGridsFun(m_ReportApp, this);
                return true;
            }
            catch (Exception ex)
            {
                log.Error(ex.ToString());
                return false;
            }

        }
        private void ParticlesGridDevidePage_Load(object sender, EventArgs e)
        {
            if (!Init())
            {
                return;
            }
            ProgressStart();//进度条关闭通过cbB_PageSize.SelectedIndex事件

            if (!UpdateTable())
            {
                return;
            }

            cbB_PageSize.Items.Add("20");
            cbB_PageSize.Items.Add("100");
            cbB_PageSize.Items.Add("500");
            cbB_PageSize.Items.Add("1000");
            cbB_PageSize.Items.Add("5000");
            cbB_PageSize.Items.Add("All");
            cbB_PageSize.SelectedIndex = 0;

            dgV_ParticlesDevidePage.Focus();
        }

        #region 自定义方法

        bool UpdateTable()
        {
            int sel = m_ReportApp.m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTSIncAReportApp.OTSSampleReportInfo.OTS_REPORT_PROP_GRID_ITEMS.PARTICE_LIST);

            //多次测试发现 读取数据库时间耗时长，但读取条数目对读取数据库时长影响不大，故此处直接读取所有数据库信息，以取代多次连接数据库方式，优化分页速度
            particlesAll = new DataTable();
            if (sel == (int)SelItem.analyticalParticle)
            {
                //particlesAll = Particledata.GetInfoForPartucleDevidePage2(condition);
                particlesAll = Particledata.GetInfoForPartucleDevidePage_analyticalParticle(condition);
                DataTable mergeParticles = Particledata.GetInfoForPartucleDevidePage_mergeParticles(condition);
                if (mergeParticles != null && mergeParticles.Rows.Count > 0)
                {
                    RemoveMergeParticles(ref particlesAll, mergeParticles);
                }
            }
            if (sel == (int)SelItem.otherParticles)
            {
                particlesAll = Particledata.GetInfoForPartucleDevidePage_otherParticle(condition);
                DataTable mergeParticles = Particledata.GetInfoForPartucleDevidePage_mergeParticles(condition);
                if (mergeParticles != null && mergeParticles.Rows.Count > 0)
                {
                    RemoveMergeParticles(ref particlesAll, mergeParticles);
                }
            }
            if (sel == (int)SelItem.MergeParticles)
            {
                particlesAll = Particledata.GetInfoForPartucleDevidePage_mergeParticles(condition);
            }
            if (sel == (int)SelItem.allParticles)
            {
                particlesAll = Particledata.GetInfoForPartucleDevidePage_allParticles(condition);
            }
            particlesAll.Columns.Add("Hardness");
            particlesAll.Columns.Add("Density");
            particlesAll.Columns.Add("Electrical_conductivity");
            if (userLibraryData != null)
            {
                for (int i = 0; i < particlesAll.Rows.Count; i++)
                {
                    DataRow[] dr = userLibraryData.Select("STDId=" + particlesAll.Rows[i]["TypeId"].ToString());
                    if (dr.Length > 0)
                    {
                        particlesAll.Rows[i]["Hardness"] = dr[0]["Hardness"].ToString();
                        particlesAll.Rows[i]["Density"] = dr[0]["Density"].ToString();
                        particlesAll.Rows[i]["Electrical_conductivity"] = dr[0]["Electrical_conductivity"].ToString();
                    }
                    else
                    {
                        particlesAll.Rows[i]["Hardness"] = "";
                        particlesAll.Rows[i]["Density"] = "";
                        particlesAll.Rows[i]["Electrical_conductivity"] = "";
                    }
                }
            }
            else
            {
                for (int i = 0; i < particlesAll.Rows.Count; i++)
                {
                    particlesAll.Rows[i]["Hardness"] = "";
                    particlesAll.Rows[i]["Density"] = "";
                    particlesAll.Rows[i]["Electrical_conductivity"] = "";
                }
            }

            btn_Sel.Enabled = true;

            if (particlesAll == null)
            {
                log.Error("There is an exception in the data of the database!");
                #region 加载进度条进度部份结束
                //加载完成设置鼠标为默认
                this.Cursor = Cursors.Default;
                //加载完成，关闭进度条
                m_frm_userprogress.Close();
                #endregion
                return false;
            }
            DataTable elementchemistry = Particledata.GetElementChemistry();
            for (int i = 0; i < particlesAll.Rows.Count; i++)
            {
                string str = "XRayId = " + particlesAll.Rows[i]["particleId"].ToString() + " and fieldid = " + particlesAll.Rows[i]["fieldid"].ToString();
                DataRow[] drs = elementchemistry.Select(str);
                string ConcatenatedString = "";
                for (int j = 0; j < drs.Length; j++)
                {
                    ConcatenatedString += drs[j]["name"] + "-" + drs[j]["Percentage"] + ';';
                }
                particlesAll.Rows[i]["Element"] = ConcatenatedString;
            }
            if (sel!=(int)SelItem.MergeParticles)
            {

                DataTable XRayData = Particledata.GetXRayData();
                particlesAll.Columns.Add("XRayDataCount");
                for (int i = 0; i < particlesAll.Rows.Count; i++)
                {
                    if (int.Parse(particlesAll.Rows[i]["particleId"].ToString()) > -1)
                    {
                        string str = " XrayIndex= " + particlesAll.Rows[i]["particleId"].ToString() + " and fieldid = " + particlesAll.Rows[i]["fieldid"].ToString();
                        DataRow[] drs = XRayData.Select(str);
                        uint xraycount = 0;
                        if (drs != null)
                        {
                            uint[] Analysis_xray = new uint[2000];
                            for (int j = 0; j < 2000; j++)
                            {
                                Analysis_xray[j] = BitConverter.ToUInt32((byte[])drs[0][2], j * 4);
                            }
                            for (int j = 0; j < 2000; j++)
                            {
                                xraycount += Analysis_xray[j];
                            }
                            particlesAll.Rows[i]["XRayDataCount"] = xraycount;
                        }

                    }
                }
            }
            return true;
        }

        /// <summary>
        /// 传入单颗颗粒的particle类对象,返回从field中抠取出的bitmap对象,抠取单颗颗粒
        /// </summary>
        /// <param name="in_cotsparticleclr"></param>
        /// <returns></returns>
        public Bitmap GetBitmapByParticle(string fieldImage, Rectangle offset_rect)
        {

            //然后将取出的数据，转换成Bitmap对象
            Bitmap ls_bt = DrawFunction.ReadImageFile(fieldImage);

            //为了能把整个颗粒显示完整
            offset_rect.X = offset_rect.X - 5;
            offset_rect.Y = offset_rect.Y - 5;
            offset_rect.Width = offset_rect.Width + 10;
            offset_rect.Height = offset_rect.Height + 10;

            //防止计算偏差后，有坐标溢出现象
            if (offset_rect.X < 0)
                offset_rect.X = 0;
            if (offset_rect.Y < 0)
                offset_rect.Y = 0;
            if (offset_rect.X + offset_rect.Width > ls_bt.Width)
            {
                offset_rect.Width = ls_bt.Width - offset_rect.X;
            }
            if (offset_rect.Y + offset_rect.Height > ls_bt.Height)
            {
                offset_rect.Height = ls_bt.Height - offset_rect.Y;
            }

            //
            Bitmap new_ret_bp;
            //防止为0后面计算出错
            if (offset_rect.Width > 0 && offset_rect.Height > 0)
            {
                //最后通过list_showsegment组建成新的图片，进行返回
                new_ret_bp = ls_bt.Clone(offset_rect, PixelFormat.Format8bppIndexed);
            }
            else
            {

                new_ret_bp = new Bitmap(offset_rect.Width, offset_rect.Height);
            }

            return new_ret_bp;
        }
        public Bitmap GetBitmapForBig(string sub, ParticleData fielddata, double xs)
        {

            string vs = "," + sub.Replace(':', '-') + ",";

            DataTable dataTable = fielddata.GetParticleAllforparticlelist(vs);
            if (dataTable.Rows.Count == 0)
            {
                return null;
            }
            string path = result.FilePath;

            //内接矩形
            double max_Y = Convert.ToInt64(dataTable.Rows[0]["FieldPosY"]) * xs - Convert.ToInt64(dataTable.Rows[0]["RectTop"]);
            double max_X = Convert.ToInt64(dataTable.Rows[0]["FieldPosX"]) * xs + Convert.ToInt64(dataTable.Rows[0]["RectLeft"]);
            double min_Y = max_Y;
            double min_X = max_X;

            //拼接field矩形
            double MAX_Y = Convert.ToInt64(dataTable.Rows[0]["FieldPosY"]) * xs;
            double MAX_X = Convert.ToInt64(dataTable.Rows[0]["FieldPosX"]) * xs;
            double MIN_Y = MAX_Y;
            double MIN_X = MAX_X;
            foreach (DataRow item in dataTable.Rows)
            {
                //颗粒外接矩形
                double lefttopX = Convert.ToInt64(item["FieldPosX"]) * xs + Convert.ToInt64(item["RectLeft"]);
                if (lefttopX < min_X)
                {
                    min_X = lefttopX;
                }
                if (lefttopX + Convert.ToInt64(item["RectWidth"]) > max_X)
                {
                    max_X = lefttopX + Convert.ToInt64(item["RectWidth"]);
                }
                double lrfttopY = Convert.ToInt64(item["FieldPosY"]) * xs - Convert.ToInt64(item["RectTop"]);
                if (max_Y < lrfttopY)
                {
                    max_Y = lrfttopY;
                }
                if (min_Y > lrfttopY - Convert.ToInt64(item["RectHeight"]))
                {
                    min_Y = lrfttopY - Convert.ToInt64(item["RectHeight"]);
                }
                //画布
                double lefttopXH = Convert.ToInt64(item["FieldPosX"]) * xs;
                if (lefttopXH > MAX_X)
                {
                    MAX_X = lefttopXH;
                }
                if (lefttopXH < MIN_X)
                {
                    MIN_X = lefttopXH;
                }
                double lrfttopYH = Convert.ToInt64(item["FieldPosY"]) * xs;
                if (MAX_Y < lrfttopYH)
                {
                    MAX_Y = lrfttopYH;
                }
                if (MIN_Y > lrfttopYH)
                {
                    MIN_Y = lrfttopYH;
                }
            }
            int WIDTH = Convert.ToInt32(MAX_X - MIN_X) + 1024;
            int HEIGHT = Convert.ToInt32(MAX_Y - MIN_Y) + 768;
            //构造最终的图片白板
            Bitmap tableChartImage = new Bitmap(WIDTH, HEIGHT);
            Graphics graph = Graphics.FromImage(tableChartImage);
            //初始化这个大图
            graph.DrawImage(tableChartImage, 0, 0);


            int width = Convert.ToInt32(max_X - min_X);
            int height = Convert.ToInt32(max_Y - min_Y);
            int X = Convert.ToInt32(min_X - MIN_X);
            int Y = Convert.ToInt32(MAX_Y - max_Y);
            Rectangle rectangle = new Rectangle() { X = X, Y = Y, Width = width, Height = height };


            foreach (DataRow item in dataTable.Rows)
            {
                string filePath = path + "\\FIELD_FILES\\";
                string imagePath = filePath + "Field" + item["fieldid"].ToString() + ".bmp";
                //然后将取出的数据，转换成Bitmap对象
                Bitmap ls_bt = DrawFunction.ReadImageFile(imagePath);
                int x = Convert.ToInt32(Convert.ToDouble(item["FieldPosX"]) * xs - MIN_X);
                int y = System.Math.Abs(Convert.ToInt32(Convert.ToDouble(item["FieldPosY"]) * xs - MAX_Y));
                try
                {
                    graph.DrawImage(ls_bt, x, y);
                }
                catch /*(Exception e)*/
                {

                    throw;
                }

            }

            Bitmap bmap = tableChartImage.Clone(rectangle, PixelFormat.Format8bppIndexed);
            return bmap;
        }


        private void BindDataGridView()
        {
            dgV_ParticlesDevidePage.Visible = false;

            if (m_frm_userprogress.IsDisposed)
            {
                ProgressStart();
            }

            dgV_ParticlesDevidePage.Rows.Clear();
            dgV_ParticlesDevidePage.Columns.Clear();

            var startFun = m_ReportApp.m_RptConfigFile.Systype;
            //从报告xml文件中加载,显示计算列，显示元素信息
            string str_DefaultComputedColName = "", str_ElementsColName = "";
            DataSet ds = XMLoperate.GetXmlData(Application.StartupPath + RptConfigFile.m_ReportMgrParamFile, "XMLData");
            DataTable dt = ds.Tables["Member"];
            foreach (DataRow element in dt.Rows)
            {
                string RegName = element["RegName"].ToString();

                if (RegName == "DefaultComputedColName")
                {
                    str_DefaultComputedColName = element["strValue"].ToString();
                }

                if (RegName == "ElementsColName")
                {
                    str_ElementsColName = element["strValue"].ToString();
                }
            }

            //获取需要显示的计算列
            string[] strs = str_DefaultComputedColName.Split(',');

            //列名
            Dictionary<string, string> keyValues = new Dictionary<string, string>() { };

            keyValues.Add("rowid", table["str4"].ToString());
            keyValues.Add("TypeName", table["str6"].ToString());
            keyValues.Add("ParticleImage", table["str5"].ToString());
            keyValues.Add("FieldId", "FieldId");
            keyValues.Add("ParticleId", "ParticleId");
            keyValues.Add("SEMPosX", "SEMPosX");
            keyValues.Add("SEMPosY", "SEMPosY");
            for (int i = 0; i < strs.Count(); i++)
            {
                if (strs[i] == "ParticleCoordinate")
                {
                    keyValues.Add("AbPosX", "PosX");
                    keyValues.Add("AbPosY", "PosY");
                }
                if (strs[i] == "Area")
                {
                    keyValues.Add("Area", table["str21"].ToString());
                }
                if (strs[i] == "EquivalentCircleDiameter")
                {
                    keyValues.Add("Equivalent", table["str22"].ToString());
                }
                if (strs[i] == "MaxDiameter")
                {
                    keyValues.Add("DMAX", table["str23"].ToString());
                }
                if (strs[i] == "MinDiameter")
                {
                    keyValues.Add("DMIN", table["str24"].ToString());
                }
                if (strs[i] == "DiameterRatio")
                {
                    keyValues.Add("DiameterRatio", table["str25"].ToString());
                }
                if (strs[i] == "FerretDiameter")
                {
                    keyValues.Add("DFERET", table["str26"].ToString());
                }
                if (strs[i] == "PERP")
                {
                    keyValues.Add("DPERP", table["str27"].ToString());
                }
                if (strs[i] == "PERI")
                {
                    keyValues.Add("PERIMETER", table["str28"].ToString());
                }
                if (strs[i] == "INSCR")
                {
                    keyValues.Add("DINSCR", table["str29"].ToString());
                }
                if (strs[i] == "MEAN")
                {
                    keyValues.Add("DMEAN", table["str30"].ToString());
                }
                if (strs[i] == "ELONG")
                {
                    keyValues.Add("DELONG", table["str31"].ToString());
                }
                if (strs[i] == "ASPECT_ELONG")
                {
                    keyValues.Add("ASPECT_ELONG", table["str32"].ToString());
                }
                if (strs[i] == "Orientation")
                {
                    keyValues.Add("ORIENTATION", table["str33"].ToString());
                }
                if (strs[i] == "XRayDataCount")
                {
                    keyValues.Add("XRayDataCount", "XRay计数");
                }
                if (startFun == OTS_SysType_ID.CleannessA)
                {
                    if (strs[i] == "Hardness")
                    {
                        keyValues.Add("Hardness", table["str34"].ToString());
                    }
                    if (strs[i] == "Density")
                    {
                        keyValues.Add("Density", table["str35"].ToString());
                    }
                    if (strs[i] == "Electrical_conductivity")
                    {
                        keyValues.Add("Electrical_conductivity", table["str36"].ToString());
                    }
                }

            }
            keyValues.Add("Element", "Element");

            Dictionary<string, string>.Enumerator en = keyValues.GetEnumerator();
            for (int irow = 0; irow < keyValues.Count; irow++)
            {
                if (en.MoveNext())
                {
                    if (en.Current.Key == "ParticleImage")
                    {
                        DataGridViewImageColumn iconColumn = new DataGridViewImageColumn();
                        iconColumn.Name = en.Current.Key;
                        iconColumn.HeaderText = en.Current.Value;
                        dgV_ParticlesDevidePage.Columns.Add(iconColumn);
                    }
                    else if (en.Current.Key == "Element")
                    {

                    }
                    else
                    {
                        dgV_ParticlesDevidePage.Columns.Add(en.Current.Key, en.Current.Value);
                        if (en.Current.Key == "Area" || en.Current.Key == "EquivalentCircleDiameter" || en.Current.Key == "MaxDiameter" || en.Current.Key == "MinDiameter" || en.Current.Key == "DiameterRatio" || en.Current.Key == "FerretDiameter" || en.Current.Key == "PERP" || en.Current.Key == "PERI" || en.Current.Key == "INSCR" || en.Current.Key == "MEAN" || en.Current.Key == "ELONG" || en.Current.Key == "ASPECT_ELONG" || en.Current.Key == "Orientation")
                        {
                            int id = dgV_ParticlesDevidePage.Columns.Count;
                            dgV_ParticlesDevidePage.Columns[id - 1].Tag = "NumericType";
                        }
                    }

                }
            }
            if (PageSize == -1)
            {
                PageSize = particlesAll.Rows.Count;
            }

            if (particlesAll == null)
            {
                return;
            }
            RecordCount = particlesAll.Rows.Count;
            particles = particlesAll.Clone();
            for (int fi = (PageIndex - 1) * pageSize; fi < PageIndex * pageSize; fi++)
            {
                if (fi > RecordCount - 1)
                {
                    break;
                }
                particles.ImportRow(particlesAll.Rows[fi]);
            }
            string particleM = "";
            //获取需要显示的元素名
            List<string> ElementTypeSort = new List<string>(str_ElementsColName.Split(',').ToList());//去重
            for (int i = 0; i < ElementTypeSort.Count; i++)
            {
                dgV_ParticlesDevidePage.Columns.Add(ElementTypeSort[i], ElementTypeSort[i]);
                int id = dgV_ParticlesDevidePage.Columns.Count;
                dgV_ParticlesDevidePage.Columns[id - 1].Tag = "NumericType";
            }
            double jd = 95f / (double)particles.Rows.Count;//计算进度刻度

            string filePath = result.FilePath + "\\FIELD_FILES\\";
            KeyValuePair<string, Bitmap> FieldImage = new KeyValuePair<string, Bitmap>();
            for (int i = 0; i < particles.Rows.Count; i++)
            {
                //更新进度,每100条记录加载完，更新一次进度
                if (i % 10 == 0)
                    m_frm_userprogress.SetProgressValueAndText((int)(jd * i), "loading..");

                Dictionary<string, string>.Enumerator enl = keyValues.GetEnumerator();

                int add_rowindex = dgV_ParticlesDevidePage.Rows.Add();
                dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[0].Value = (pageSize * (PageIndex - 1) + add_rowindex + 1).ToString();

                for (int k = 0; k < keyValues.Count; k++)
                {
                    if (enl.MoveNext())
                    {
                        if (enl.Current.Key == "rowid")
                        {
                            //dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = i + 1;
                        }
                        if (enl.Current.Key == "ParticleImage")
                        {
                            if (particles.Columns.Contains("SubParticles"))
                            {
                                string subt = particles.Rows[i]["SubParticles"].ToString();
                                if (subt != null && subt != "")
                                {
                                    //double ScanFieldSize = Convert.ToDouble(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)result.ResultInfo["Sample"])["Members"])["SEMDataMsr"])["ScanFieldSize"]);
                                    double ScanFieldSize = result.GetScanFieldSizeX();
                                    string filePatht = result.FilePath + "\\FIELD_FILES\\";
                                    string imagePatht = filePatht + "Field" + subt.Split(',')[0].Split(':')[0].ToString() + ".bmp";
                                    //然后将取出的数据，转换成Bitmap对象
                                    Bitmap tempbit = Particledata.ReadImageFile(imagePatht);
                                    int pixw = tempbit.Width;
                                    double xs = pixw / ScanFieldSize;

                                    particleM = particleM + "," + subt;
                                    Bitmap bmap = Particledata.GetBitmapForBig(subt, xs, result.FilePath, tempbit.Height, tempbit.Width);
                                    if (bmap != null)
                                    {
                                        string[] str = subt.Split(',');
                                        bmap.Tag = new List<string>() { str[0].Split(':')[0], str[0].Split(':')[1], particles.Rows[i]["TypeId"].ToString() };
                                        dgV_ParticlesDevidePage.Rows[add_rowindex].Height = 150;
                                        dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = bmap;
                                        dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Style.BackColor = Color.Azure;
                                        dgV_ParticlesDevidePage.Rows[add_rowindex].DefaultCellStyle.ForeColor = Color.Chocolate;
                                    }
                                    else
                                    {
                                        dgV_ParticlesDevidePage.Rows[add_rowindex].Height = 150;

                                        dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Style.BackColor = Color.Azure;
                                    }
                                }
                            }
                            else
                            {
                                if (FieldImage.Key != particles.Rows[i]["fieldid"].ToString() || FieldImage.Value == null)
                                {
                                    string imagePath = filePath + "Field" + particles.Rows[i]["fieldid"].ToString() + ".bmp";
                                    FieldImage = new KeyValuePair<string, Bitmap>(particles.Rows[i]["fieldid"].ToString(), Particledata.ReadImageFile(imagePath));
                                }

                                Rectangle rectangle = new Rectangle() { X = Convert.ToInt32(particles.Rows[i]["RectLeft"]), Y = Convert.ToInt32(particles.Rows[i]["RectTop"]), Width = Convert.ToInt32(particles.Rows[i]["RectWidth"]), Height = Convert.ToInt32(particles.Rows[i]["RectHeight"]) };
                                Bitmap bmap = Particledata.GetBitmapByParticle(FieldImage.Value, rectangle);
                                bmap.Tag = new List<string>() { particles.Rows[i]["FieldId"].ToString(), particles.Rows[i]["ParticleId"].ToString(), particles.Rows[i]["TypeId"].ToString(), particles.Rows[i]["XrayId"].ToString() };
                                dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = bmap;
                                dgV_ParticlesDevidePage.Rows[add_rowindex].Height = bmap.Height + 20;
                            }
                        }
                        if (enl.Current.Key == "DiameterRatio")
                        {
                            double d = Convert.ToDouble(particles.Rows[i]["DMAX"]) / Convert.ToDouble(particles.Rows[i]["DMIN"]);
                            dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = Math.Round(d, 2);
                        }
                        if (enl.Current.Key == "ASPECT_ELONG")
                        {
                            double d = Convert.ToDouble(particles.Rows[i]["DELONG"]) / Convert.ToDouble(particles.Rows[i]["DMEAN"]);
                            dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = Math.Round(d, 2);
                        }
                        if (particles.Columns.Contains(enl.Current.Key))
                        {
                            double num = 0;
                            if (double.TryParse(particles.Rows[i][enl.Current.Key].ToString(), out num))
                            {
                                dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = Math.Round(num, 2);
                            }
                            else if (enl.Current.Key == "Element")
                            {
                                List<string> elementtemp = new List<string>(ElementTypeSort);
                                string[] strcbo = particles.Rows[i][enl.Current.Key].ToString().Split(';');
                                for (int j = 0; j < strcbo.Length; j++)
                                {
                                    string[] str = strcbo[j].Split('-');
                                    if (ElementTypeSort.Contains(str[0]))
                                    { dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[str[0].ToString()].Value = Math.Round(double.Parse(str[1]), 2).ToString(); }
                                    elementtemp.Remove(str[0].ToString());
                                }
                                foreach (var ele in elementtemp)
                                {
                                    dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[ele].Value = "0";
                                }
                            }
                            else
                            {
                                double val = 0;
                                if(double.TryParse(Convert.ToString(particles.Rows[i][enl.Current.Key]),out val))
                                {
                                    dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = val;
                                }
                                else
                                {
                                    dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = particles.Rows[i][enl.Current.Key];
                                }
                                
                            }
                        }
                        if (enl.Current.Key == "TypeName")
                        {
                            if (particles.Rows[i]["TypeId"].ToString() == "9")
                            {
                                dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = "Not Identified";
                            }
                        }
                        if (enl.Current.Key == "Equivalent")
                        {
                            double dSize = Convert.ToDouble(particles.Rows[i]["Area"]);
                            double Diameter = Math.Sqrt(dSize / Math.PI) * 2;
                            dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Value = Math.Round(Diameter, 2);
                        }
                        if (enl.Current.Key == "Hardness")
                        {
                            string str = ChangeHardnessColor(particles.Rows[i]["Hardness"].ToString());
                            {
                                if (str == "#FF0000")
                                {
                                    dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[k].Style.ForeColor = Color.Red;
                                }
                            }
                        }
                        if (enl.Current.Key == "AbPosX")
                        {
                            Point point = CalculateParticleCenterPosition(resultFile, new Point(Convert.ToInt32(particles.Rows[i]["SEMPosX"]), Convert.ToInt32(particles.Rows[i]["SEMPosY"])), new Point(Convert.ToInt32(particles.Rows[i]["PosX"]), Convert.ToInt32(particles.Rows[i]["PosY"])));
                            dgV_ParticlesDevidePage.Rows[add_rowindex].Cells["AbPosX"].Value = point.X;
                            dgV_ParticlesDevidePage.Rows[add_rowindex].Cells["AbPosY"].Value = point.Y;
                        }
                    }
                }
            }

            #region 加载进度条进度部份结束
            //加载完成设置鼠标为默认
            this.Cursor = Cursors.Default;
            string str8 = table["str8"].ToString();
            m_frm_userprogress.SetProgressValueAndText(100, str8);
            //加载完成，关闭进度条
            m_frm_userprogress.Close();
            #endregion

            dgV_ParticlesDevidePage.Visible = true;
        }



        /// <summary>
        /// 设置DataGridView样式
        /// </summary>
        private void SetDataGridViewStyle()
        {
            //用户不能调整标题的高度
            dgV_ParticlesDevidePage.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //用户不能调整 行高
            dgV_ParticlesDevidePage.AllowUserToResizeRows = false;

            //点击选择整行
            dgV_ParticlesDevidePage.SelectionMode = DataGridViewSelectionMode.FullRowSelect;

            //居中显示
            System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
            dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleCenter;
            dgV_ParticlesDevidePage.DefaultCellStyle = dataGridViewCellStyle1;
            dgV_ParticlesDevidePage.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;

            //再次重覆禁用拖动表头高度，居然有效果了
            dgV_ParticlesDevidePage.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //设置grid可以复制
            dgV_ParticlesDevidePage.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;

            //设置每列的宽度
            dgV_ParticlesDevidePage.Columns[0].Width = 40;//第一列序号的宽度设置一下吧，要不太丑
            dgV_ParticlesDevidePage.Columns[1].Width = 150;
            //dgV_ParticlesDevidePage.Columns[dgV_ParticlesDevidePage.Columns.Count - 1].Width = 450;
            //dgV_ParticlesDevidePage.Columns[dgV_ParticlesDevidePage.Columns.Count - 1].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;

            //设置序号列不排序
            dgV_ParticlesDevidePage.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;

            //设置序号列不可以设置宽度
            dgV_ParticlesDevidePage.Columns[0].Resizable = DataGridViewTriState.False;

            dgV_ParticlesDevidePage.RowsDefaultCellStyle.BackColor = Color.Azure;
        }

        /// <summary>
        /// 计算颗粒中心的电镜坐标
        /// </summary>
        /// <param name="resultFile"></param>
        /// <param name="SEMPos"></param>
        /// <param name="ParticlePos"></param>
        /// <returns></returns>
        public static Point CalculateParticleCenterPosition(ResultFile resultFile, Point SEMPos, Point ParticlePos)
        {
            Point point = new Point();
            //Dictionary<string, object> sampleMembers = ((Dictionary<string, object>)((Dictionary<string, object>)resultFile.ResultInfo["Sample"])["Members"]);
            //Dictionary<string, object> imageScanParam = (Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)sampleMembers["MsrParams"])["Members"])["ImageScanParam"];
            //Dictionary<string, object> SEMDataMsr = (Dictionary<string, object>)sampleMembers["SEMDataMsr"];
            //Dictionary<string, object> SEMStageData = (Dictionary<string, object>)resultFile.ResultInfo["SEMStageData"];
            float ScanFieldSizeX = resultFile.GetScanFieldSizeX();
            string leftOrRight = resultFile.GetXAxisDir();
            string downOrUp = resultFile.GetYAxisDir();
            //string ImageResolution = imageScanParam["ImageResolution"].ToString();
            //int width = resultFile.GetImageWidth();
            //int height = resultFile.GetImageHeight();
            float ScanFieldSizeY = resultFile.GetScanFieldSizeY();
            float m_pixelSize = resultFile.GetPixelSize();
            if (leftOrRight == "RIGHT_TOWARD")
            {
                point.X = (int)(SEMPos.X - ScanFieldSizeX / 2 + ParticlePos.X * m_pixelSize);
            }
            else
            {
                point.X = (int)(SEMPos.X + ScanFieldSizeX / 2 - ParticlePos.X * m_pixelSize);
            }
            if (downOrUp == "UP_TOWARD")
            {
                point.Y = (int)(SEMPos.Y + ScanFieldSizeY / 2 - ParticlePos.Y * m_pixelSize);
            }
            else
            {
                point.Y = (int)(SEMPos.Y - ScanFieldSizeY / 2 + ParticlePos.Y * m_pixelSize);
            }

            return point;
        }
        #endregion

        #region 相关事件
        private void ToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            //复制整个表
            CopyAll();
        }

        private void ToolStripMenuItem2_Click(object sender, EventArgs e)
        {
            //复制选择区域
            CopySelected();
        }

        /// <summary>
        /// 复制选择区域
        /// </summary>
        public void CopySelected()
        {
            //复制选择区域
            object oo = dgV_ParticlesDevidePage.GetClipboardContent();
            if (oo != null)
                Clipboard.SetDataObject(dgV_ParticlesDevidePage.GetClipboardContent());
        }

        /// <summary>
        /// 复制所有
        /// </summary>
        public void CopyAll()
        {
            dgV_ParticlesDevidePage.SelectAll();
            Clipboard.SetDataObject(dgV_ParticlesDevidePage.GetClipboardContent());

        }

        /// <summary>
        /// 以图像的方式将GridView进行截图
        /// </summary>
        public void CopyImage()
        {
            int height, width;
            width = dgV_ParticlesDevidePage.Columns.GetColumnsWidth(DataGridViewElementStates.Visible) + 2;
            height = this.Height;

            Bitmap image = new Bitmap(width, height);
            dgV_ParticlesDevidePage.DrawToBitmap(image, new Rectangle(0, 0, width, height));

            Clipboard.SetImage(image);
        }

        private void toolStripMenuItem4_Click(object sender, EventArgs e)
        {
            //对gridview进行截图
            CopyImage();
        }


        private void dgV_ParticlesDevidePage_SortCompare(object sender, DataGridViewSortCompareEventArgs e)
        {
            //排序中
            if (e.Column.Tag != null && e.Column.Tag.ToString() == "NumericType")
            {
                e.SortResult = double.Parse(e.CellValue1.ToString()).CompareTo(double.Parse(e.CellValue2.ToString()));
                e.Handled = true;
            }
        }

        /// <summary>
        /// 将OTS坐标转换为Sem 坐标
        /// </summary>
        /// <param name="POTSCoord"></param>
        /// <returns></returns>
        public Point ChangeOTSToSemCoord(Point POTSCoord)
        {
            //first if m_semstagedata is null to get stage inforation

            //Convert.ToDouble(((Dictionary<string, object>)result.ResultInfo["SEMStageData"])["scanFieldSize"]);
            //after obtaining stage info,calc stage point data
            Point ret_SEM_point = new Point();

            // get center point, um
            //long xStart = Convert.ToInt64(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)result.ResultInfo["SEMStageData"])["Members"])["XAxis"])["start"]);
            //long xEnd = Convert.ToInt64(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)result.ResultInfo["SEMStageData"])["Members"])["XAxis"])["end"]);
            long xStart = result.GetXAxisStart();
            long xEnd = result.GetXAxisEnd();
            long xCenter = (xStart + xEnd) / 2;

            //long yStart = Convert.ToInt64(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)result.ResultInfo["SEMStageData"])["Members"])["YAxis"])["start"]);
            //long yEnd = Convert.ToInt64(((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)result.ResultInfo["SEMStageData"])["Members"])["YAxis"])["end"]);
            long yStart = result.GetYAxisStart();
            long yEnd = result.GetYAxisEnd();
            long yCenter = (yStart + yEnd) / 2;

            // delte = SEM - OTSa
            long deltex = xCenter - 0;
            long deltey = yCenter - 0;
            OTS_X_AXIS_DIRECTION xdir = result.GetXAxisDirEnum();
            OTS_Y_AXIS_DIRECTION ydir = result.GetYAxisDirEnum();
            if (xdir == OTS_X_AXIS_DIRECTION.LEFT_TOWARD)
            {
                ret_SEM_point.X = -1 * (POTSCoord.X - Convert.ToInt32(deltex));
            }
            else if (xdir == OTS_X_AXIS_DIRECTION.RIGHT_TOWARD)
            {
                ret_SEM_point.X = POTSCoord.X + Convert.ToInt32(deltex);
            }

            if (ydir == OTS_Y_AXIS_DIRECTION.UP_TOWARD)
            {
                ret_SEM_point.Y = POTSCoord.Y + Convert.ToInt32(deltey);
            }
            else if (ydir == OTS_Y_AXIS_DIRECTION.DOWN_TOWARD)
            {
                ret_SEM_point.Y = -1 * (POTSCoord.Y - Convert.ToInt32(deltey));
            }

            return ret_SEM_point;
        }
        #endregion

        #region 获取向导出模块提供的DataTable和GridView对象
        /// <summary>
        /// 获取到该模块输出后形成的DataTable,和GridView
        /// </summary>
        /// <param name="out_dt"></param>
        /// <param name="out_dg"></param>
        public void GetDataTableAndGridView(out DataTable out_dt, out DataGridView out_dg)
        {
            out_dt = m_dt;
            out_dg = this.dgV_ParticlesDevidePage;//同样通过 dgV_ParticlesDevidePage.Rows[add_rowindex].Cells[2].Value 来获取bitmap对象
        }



        #endregion

        #region 连接电镜相关
        /// <summary>
        /// 移动SEM到指定位置线程函数
        /// </summary>
        private void Thread_GO(object in_obj)
        {
            if (m_mythread_state == false)
            {
                m_mythread_state = true;

                Point sem_point = (Point)in_obj;

                //第一步，连接电镜
                m_OTSIncAReportGridsFun.Connection_ForParticlesGrid();

                Thread.Sleep(500);

                //第二步，移动到指定位置,先读取再设置
                if (m_OTSIncAReportGridsFun.m_SEMConnectionState == true)
                {
                    m_OTSIncAReportGridsFun.MoveSemToPointXY_ForParticlesGrid(sem_point.X, sem_point.Y);

                }

                Thread.Sleep(1500);

                //第三步，断开电镜连接
                //m_OTSIncAReportGridsFun.DisConnectSEM_ForParticlesGrid();

                //Thread.Sleep(500);

                m_mythread_state = false;
            }

        }
        #endregion




        private void ToolStripMenuItem_exportzoomimagefile_Click(object sender, EventArgs e)
        {
            //导出放大图像
            FolderBrowserDialog fbd = new FolderBrowserDialog();
            if (fbd.ShowDialog() == DialogResult.OK)
            {
                m_imagefilepath = fbd.SelectedPath;

                for (int i = 0; i < m_dt.Rows.Count; i++)
                {
                    Bitmap ls_bp = new Bitmap(1, 1);
                    ls_bp = (Bitmap)m_dt.Rows[i][1];

                    string strPath = m_imagefilepath + "\\" + (i + 1).ToString() + ".jpg";
                    string strPath2 = m_imagefilepath + "\\" + (i + 1).ToString() + "s.jpg";
                    ls_bp.Save(strPath);
                    //m_COTSReportProjFileMgrClr.ReZoom(strPath, strPath2);

                    System.IO.File.Delete(strPath);//再将文件删除
                }
                string str1 = table["str9"].ToString();
                MessageBox.Show(str1 + m_dt.Rows.Count.ToString());
            }
        }

        /// <summary>
        /// 导出二次放大图像
        /// </summary>
        /// <param name="str_srcPathName"></param>
        /// <param name="str_outPathName"></param>
        public void ParticleReZoom(string str_srcPathName, string str_outPathName)
        {
            //m_COTSReportProjFileMgrClr.ReZoom(str_srcPathName, str_outPathName);
        }

        private void ToolStripMenuItem3_Click(object sender, EventArgs e)
        {
            //恢复至初始状态

            dgV_ParticlesDevidePage.Rows.Clear();
            dgV_ParticlesDevidePage.Columns.Clear();

            BindDataGridView();

            SetDataGridViewStyle();
        }

        private void ToolStripMenuItem5_Click(object sender, EventArgs e)
        {
            /*注意:多数据源情况下，只获取第一个数据源的选择了多行的情况下，只获取最后一个选择行的,没有办法,这是为了符合李阳博士提出的要求*/

            //先获取鼠标所选择的行里的颗粒的FieldID和ParticleID
            string i_ls_fieldid = "";
            string i_ls_particleid = "";
            int cou = dgV_ParticlesDevidePage.SelectedRows.Count;
            if (cou > 0)
            {
                DataGridViewRow dgvr = dgV_ParticlesDevidePage.SelectedRows[cou - 1];
                Bitmap ls_bp = (Bitmap)dgvr.Cells[2].Value;
                List<string> list_str = (List<string>)ls_bp.Tag;
                if (list_str != null)
                {
                    i_ls_fieldid = list_str[0];
                    i_ls_particleid = list_str[1];
                }
            }
            ParticleData particleData = new ParticleData(result.FilePath);
            Particle particle = particleData.GetParticleByFidAndPid(i_ls_fieldid, i_ls_particleid);
            ////然后遍历所有的Field
            //Point ls_ots_point = new Point() { X = particle.PosX, Y = particle.PosY };
            ////将该坐标转成SEM坐标
            //Point ls_sem_point = ChangeOTSToSemCoord(ls_ots_point);

            //取得Field的Position,然后执行线程移动SEM到当前Field的位置
            if (m_mythread == null)
            {
                return;
            }

            if (m_mythread.ThreadState == ThreadState.Running || m_mythread.ThreadState == ThreadState.WaitSleepJoin)
            {
                return;
            }

            if (m_mythread.ThreadState == ThreadState.Stopped)
            {
                m_mythread = new Thread(new ParameterizedThreadStart(Thread_GO));
            }
            Point point = CalculateParticleCenterPosition(resultFile, new Point(particle.SEMPosX, particle.SEMPosY), new Point(particle.PosX, particle.PosY));
            //改为线程调用,先判断线程状态
            m_mythread.Start(point);

        }

        private void ToolStripMenuItem_exportimagefile_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog fbd = new FolderBrowserDialog();
            if (fbd.ShowDialog() == DialogResult.OK)
            {
                m_imagefilepath = fbd.SelectedPath;

                for (int i = 0; i < dgV_ParticlesDevidePage.Rows.Count; i++)
                {
                    Bitmap ls_bp = new Bitmap(1, 1);
                    ls_bp = (Bitmap)dgV_ParticlesDevidePage.Rows[i].Cells[2].Value;

                    ls_bp.Save(m_imagefilepath + "\\" + (i + 1).ToString() + ".jpg");
                }
                string str9 = table["str9"].ToString();
                MessageBox.Show(str9 + dgV_ParticlesDevidePage.Rows.Count.ToString());
            }
        }

        private void testToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ////测试导出指定颗粒的能谱图,测试相关代码
            //OTSIncAReportGraph.DParticle ls_dparticle = new OTSIncAReportGraph.DParticle();
            //for (int i = 0; i < dgV_ParticlesDevidePage.SelectedRows.Count; i++)
            //{
            //    //获取选择行颗粒的fieldid,和particleid
            //    string str_fieldid = "";
            //    string str_particleid = "";
            //    string str_stdtypeid = "";

            //    DataGridViewRow dgvr = dgV_ParticlesDevidePage.SelectedRows[i];
            //    Bitmap ls_bp = (Bitmap)dgvr.Cells[2].Value;
            //    List<string> list_str = (List<string>)ls_bp.Tag;
            //    if (list_str != null)
            //    {
            //        str_fieldid = list_str[0];
            //        str_particleid = list_str[1];
            //        str_stdtypeid = list_str[2];
            //    }

            //    ls_dparticle.CLRFieldID = Convert.ToInt32(str_fieldid);
            //    ls_dparticle.CLRTagID = Convert.ToInt32(str_particleid);
            //    ls_dparticle.STDTypeID = Convert.ToInt32(str_stdtypeid);
            //}

            ////显示xray能谱
            //ShowXRay(ls_dparticle);

            //Bitmap ls_bpex = new Bitmap(control_XRayTable1.Width, control_XRayTable1.Height);
            //control_XRayTable1.DrawToBitmap(ls_bpex, new Rectangle(0, 0, control_XRayTable1.Width, control_XRayTable1.Height));

            ////Bitmap ls_bpex = control_XRayTable1.ExportXRayImage();

            //ls_bpex.Save("e:\\test222.jpg");
        }
        /// <summary>
        /// 判断条件输入 前<后
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        bool CompareInput(string min, string max)
        {
            int imax = 0;
            int imin = 0;
            double dmax = 0;
            double dmin = 0;
            if (int.TryParse(max, out imax))
            {
                dmax = (double)imax;
            }
            else
            {
                dmax = Convert.ToDouble(max);
            }
            if (int.TryParse(min, out imin))
            {
                dmin = (double)imin;
            }
            else
            {
                dmin = Convert.ToDouble(min);
            }
            if (dmin <= dmax)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        private void btn_Sel_Click(object sender, EventArgs e)
        {
            condition = "";
            if (!string.IsNullOrWhiteSpace(tBx_AreaMin.Text))
            {
                double dnum = 0;
                int inum = 0;
                if (double.TryParse(tBx_AreaMin.Text, out dnum) && dnum >= 0)
                {
                    condition += " and Area" + " > " + tBx_AreaMin.Text;
                }
                else if (int.TryParse(tBx_AreaMin.Text, out inum) && inum >= 0)
                {
                    condition += " and Area" + " > " + tBx_AreaMin.Text;
                }
                else
                {
                    MessageBox.Show(table["str10"].ToString());
                    return;
                }
            }

            if (!string.IsNullOrWhiteSpace(Tbx_AreaMax.Text))
            {
                double dnum = 0;
                int inum = 0;
                if (double.TryParse(Tbx_AreaMax.Text, out dnum) && dnum >= 0)
                {
                    condition += " and Area" + "<" + Tbx_AreaMax.Text;
                }
                else if (int.TryParse(Tbx_AreaMax.Text, out inum) && inum >= 0)
                {
                    condition += " and Area" + "<" + Tbx_AreaMax.Text;
                }
                else
                {
                    MessageBox.Show(table["str10"].ToString());
                    return;
                }
            }

            if (!string.IsNullOrWhiteSpace(tBx_AreaMin.Text) && !string.IsNullOrWhiteSpace(Tbx_AreaMax.Text))
            {
                if (!CompareInput(tBx_AreaMin.Text, Tbx_AreaMax.Text))
                {
                    MessageBox.Show(table["str11"].ToString());
                    return;
                }
            }


            if (!string.IsNullOrWhiteSpace(tbx_DmaxMin.Text))
            {
                double dnum = 0;
                int inum = 0;
                if (double.TryParse(tbx_DmaxMin.Text, out dnum) && dnum >= 0)
                {
                    condition += " and DMAX" + " > " + tbx_DmaxMin.Text;
                }
                else if (int.TryParse(tbx_DmaxMin.Text, out inum) && inum >= 0)
                {
                    condition += " and DMAX" + " > " + tbx_DmaxMin.Text;
                }
                else
                {
                    MessageBox.Show(table["str10"].ToString());
                    return;
                }
            }

            if (!string.IsNullOrWhiteSpace(tbx_DmaxMax.Text))
            {
                double dnum = 0;
                int inum = 0;
                if (double.TryParse(tbx_DmaxMax.Text, out dnum) && dnum > 0)
                {
                    condition += " and DMAX" + "<" + tbx_DmaxMax.Text;
                }
                else if (int.TryParse(tbx_DmaxMax.Text, out inum) && inum >= 0)
                {
                    condition += " and DMAX" + "<" + tbx_DmaxMax.Text;
                }
                else
                {
                    MessageBox.Show(table["str10"].ToString());
                    return;
                }
            }

            if (!string.IsNullOrWhiteSpace(tB_FieldId.Text))
            {
                int inum = 0;
                if (int.TryParse(tB_FieldId.Text, out inum))
                {
                    condition += " and FieldId =" + tB_FieldId.Text;
                }
                else
                {
                    MessageBox.Show(table["str10"].ToString());
                    return;
                }
            }

            if (!string.IsNullOrWhiteSpace(tB_ParticleId.Text))
            {
                int inum = 0;
                if (int.TryParse(tB_ParticleId.Text, out inum))
                {
                    condition += " and ParticleId =" + tB_ParticleId.Text;
                }
                else
                {
                    MessageBox.Show(table["str10"].ToString());
                    return;
                }
            }

            if (!string.IsNullOrWhiteSpace(tbx_DmaxMin.Text) && !string.IsNullOrWhiteSpace(tbx_DmaxMax.Text))
            {
                if (!CompareInput(tbx_DmaxMin.Text, tbx_DmaxMax.Text))
                {
                    MessageBox.Show(table["str11"].ToString());
                    return;
                }
            }

            if (!string.IsNullOrWhiteSpace(tbx_Type.Text))
            {
                condition += " and TypeName Like \"%" + tbx_Type.Text + "%\" ";
            }

            if (m_frm_userprogress.IsDisposed)
            {
                ProgressStart();
            }

            UpdateTable();

            lnkFirst_Click(null, null);
            SetDataGridViewStyle();
        }

        void ProgressStart()
        {
            #region 加载显示进度条部份
            this.Cursor = Cursors.WaitCursor;
            m_frm_userprogress = new Frm_UserProgress();

            //显示进度条,计算进度条应该显示的位置和宽度
            Form ls_main_form = this.ParentForm.ParentForm;//取出父窗体
            if (ls_main_form == null)
            {
                m_frm_userprogress.Visible = false;
            }
            else
            {
                m_frm_userprogress.Width = (int)(MyPrimaryScreen.DESKTOP.Width / MyPrimaryScreen.ScaleX * 0.9);
                m_frm_userprogress.Location = new Point(ls_main_form.Location.X + 80, ls_main_form.Location.Y + (int)(MyPrimaryScreen.DESKTOP.Height / MyPrimaryScreen.ScaleX) / 2);
                m_frm_userprogress.Show();
                m_frm_userprogress.SetProgressValueAndText(0, "Loading data of particles...");
            }
            #endregion
        }

        private void cbB_order_SelectedIndexChanged(object sender, EventArgs e)
        {

            lnkFirst_Click(null, null);
            SetDataGridViewStyle();
        }

        /// <summary>
        /// 页面控件呈现
        /// </summary>
        private void DrawControl(bool callEvent)
        {
            BindDataGridView();
            lblTotalCount.Text = RecordCount.ToString();
            lblPageCount.Text = PageCount.ToString();
            txtPageNum.Text = PageIndex.ToString();

            SetFormCtrEnabled();
            if (PageCount == 0 || PageCount == 1)//有且仅有一页
            {
                lnkFirst.Enabled = false;
                lnkPrev.Enabled = false;
                lnkNext.Enabled = false;
                lnkLast.Enabled = false;
                btnGo.Enabled = false;
            }
            else if (PageIndex == 1)//第一页
            {
                lnkFirst.Enabled = false;
                lnkPrev.Enabled = false;
            }
            else if (PageIndex == PageCount)//最后一页
            {
                lnkNext.Enabled = false;
                lnkLast.Enabled = false;
            }

        }
        private void SetFormCtrEnabled()
        {
            lnkFirst.Enabled = true;
            lnkPrev.Enabled = true;
            lnkNext.Enabled = true;
            lnkLast.Enabled = true;
            btnGo.Enabled = true;
        }

        /// <summary>
        /// 分页属性改变了。
        /// </summary>
        private void txtPageSize_TextChanged(object sender, EventArgs e)
        {
            int num = 0;
            if (int.TryParse(txtPageNum.Text.Trim(), out num) && num > 0)
            {

            }
            else { txtPageNum.Text = "1"; }
        }

        private void lnkFirst_Click(object sender, EventArgs e)
        {
            PageIndex = 1;
            DrawControl(true);
        }

        private void lnkPrev_Click(object sender, EventArgs e)
        {
            PageIndex = Math.Max(1, PageIndex - 1);
            DrawControl(true);
        }

        private void lnkNext_Click(object sender, EventArgs e)
        {
            PageIndex = Math.Min(PageCount, PageIndex + 1);
            DrawControl(true);
        }

        private void lnkLast_Click(object sender, EventArgs e)
        {
            PageIndex = PageCount;
            DrawControl(true);
        }

        /// <summary>
        /// 跳转
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnGo_Click(object sender, EventArgs e)
        {
            int num = 0;
            if (int.TryParse(txtPageNum.Text.Trim(), out num) && num > 0)
            {
                if (num > PageCount)
                {
                    num = PageCount;
                    txtPageNum.Text = PageCount.ToString();
                }
                PageIndex = num;
                DrawControl(true);
            }
        }

        private void cbB_PageSize_SelectedIndexChanged(object sender, EventArgs e)
        {
            DisplayData();
        }

        /// <summary>
        /// 在帧图上标记颗粒的位置矩形,并保存到FIELD_FILES_MARK文件夹中
        /// </summary>
        public void SaveMarkParticleRectangleOnFieldFile(string str_resultPath, DataTable dataTable, out List<string> vs, out DataTable dt_FIeld)
        {
            if(!Init())
            {
                vs = null;
                dt_FIeld = null;
                return;
            }

            List<string> maxlength = new List<string>();
            for (int i = 0; i < dataTable.Rows.Count; i++)
            {
                if (dataTable.Rows[i]["TypeName"].ToString() != "Not Identified")
                {
                    if (maxlength.Count < 10)
                    {
                        maxlength.Add(dataTable.Rows[i]["Fieldid"].ToString());
                    }
                    else
                    {
                        break;
                    }
                }
            }
            List<string> max_list = maxlength.Distinct().ToList();

            string str_path_FIELD_FILES = str_resultPath + "\\FIELD_FILES\\";
            string str_path_FIELD_FILES_MARK = str_resultPath + "\\FIELD_FILES_MARK\\";
            int intQuantity = 0;
            //List<string> vs = new List<string>();
            dt_FIeld = new DataTable();
            vs = new List<string>();
            ////判断是否已经有导出过的标记帧图文件夹,如果已经存在，则直接返回不输出,先不加
            DirectoryInfo theFolder_FieldMark = new DirectoryInfo(str_path_FIELD_FILES_MARK);
            if (!theFolder_FieldMark.Exists)
            {
                //创建
                theFolder_FieldMark.Create();
            }
            else
            {
                theFolder_FieldMark.Delete(true);

                //创建
                theFolder_FieldMark.Create();
                //已经存在的话，直接返回
                //return;
            }

            //查找该field下对应所有的颗粒
            DataTable dt_AllParticle = fieldData.GetAllParticle_DataTable();

            DirectoryInfo theFolder = new DirectoryInfo(str_path_FIELD_FILES);
            if (theFolder.Exists)
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("fieldid");
                dt.Columns.Add("id");
                dt.Columns.Add("fieldName");
                dt.Columns.Add("cunt", typeof(int));
                dt.Columns.Add("fieldFullName");
                for (int i = 0; i < max_list.Count; i++)
                {
                    foreach (FileInfo nextifile in theFolder.GetFiles())
                    {
                        if (nextifile.Name.Contains(".bmp") == true || nextifile.Name.Contains(".BMP") == true)
                        {
                            //确认对应的帧图名
                            string str_fieldid = Path.GetFileNameWithoutExtension(nextifile.Name);
                            str_fieldid = str_fieldid.Substring(5, str_fieldid.Length - 5);//减去field字符长度
                            bool bl = false;

                            if (str_fieldid == max_list[i].ToString())
                            {
                                bl = true;
                            }

                            if (bl)
                            {
                                DataRow dr = dt.NewRow();
                                dr["fieldid"] = " fieldid = " + str_fieldid;
                                dr["cunt"] = dataTable.Select(" fieldid = " + str_fieldid).Count();
                                dr["fieldName"] = nextifile.Name;
                                dr["fieldFullName"] = nextifile.FullName;
                                dr["id"] = str_fieldid;
                                dt.Rows.Add(dr);
                            }

                        }
                    }
                }
                //DataView dv = dt.DefaultView;
                //dv.Sort = "cunt DESC";
                dt_FIeld = dt.Copy();

                for (int i = 0; i < dt_FIeld.Rows.Count; i++)
                {
                    if (dataTable.Select(dt_FIeld.Rows[i]["fieldid"].ToString()).Count() > 0)
                    {
                        vs.Add(dt_FIeld.Rows[i]["id"].ToString());

                        Image img = Image.FromFile(dt_FIeld.Rows[i]["fieldFullName"].ToString());
                        //img.Save(@"D:\1.bmp");
                        Bitmap ls_fieldbp = new Bitmap(img.Width, img.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
                        using (Graphics g = Graphics.FromImage(ls_fieldbp))
                        {
                            g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                            g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
                            g.DrawImage(img, new Rectangle(0, 0, img.Width, img.Height));
                        }
                        //ls_fieldbp.Save(@"D:\1.bmp");
                        img.Dispose();
                        img = null;


                        //循环将颗粒，进行标记到bitmap图上
                        DataRow[] drlist = dt_AllParticle.Select(dt_FIeld.Rows[i]["fieldid"].ToString());
                        if (drlist.Count() > 0)
                            intQuantity = intQuantity + 1;
                        for (int i_row = 0; i_row < drlist.Count(); i_row++)
                        {
                            //string str_fieldid = drlist[i_row]["fieldid"].ToString();
                            string str_particleid = drlist[i_row]["particleid"].ToString();
                            string str_stdtypeid = drlist[i_row]["typeid"].ToString();
                            string str_offset_rect_X = drlist[i_row]["RectLeft"].ToString();
                            string str_offset_rect_Y = drlist[i_row]["RectTop"].ToString();
                            string str_offset_rect_Width = drlist[i_row]["RectWidth"].ToString();
                            string str_offset_rect_Height = drlist[i_row]["RectHeight"].ToString();

                            //确定需要标记颗粒的定位
                            Rectangle offset_rect = new Rectangle(Convert.ToInt32(str_offset_rect_X), Convert.ToInt32(str_offset_rect_Y),
                    Convert.ToInt32(str_offset_rect_Width), Convert.ToInt32(str_offset_rect_Height));

                            //向帧图进行标记颗粒位置
                            Graphics g = Graphics.FromImage(ls_fieldbp);
                            g.DrawRectangle(new Pen(Color.Aquamarine), offset_rect);

                            //判断是否超出了图像外面，是的话，让文字在左侧显示，默认在右侧显示
                            int ls_offsetx = offset_rect.X + offset_rect.Width;
                            if (ls_offsetx > ls_fieldbp.Width - 10)
                            {
                                ls_offsetx = offset_rect.X - 10;
                            }

                            g.DrawString(dt_FIeld.Rows[i]["id"].ToString() + "" + str_particleid.ToString(),
                                new Font("黑体", 8), new SolidBrush(Color.Aqua), new PointF(ls_offsetx, offset_rect.Y));

                            //保存带有标记的帧图
                            ls_fieldbp.Save(str_path_FIELD_FILES_MARK + dt_FIeld.Rows[i]["id"].ToString() + ".bmp");

                            //ls_fieldbp.Dispose();
                        }
                    }
                }

            }
            //
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }

        private void testToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            //SaveMarkParticleRectangleOnFieldFile();
            MessageBox.Show("Export completed!");
        }

        private void EXCELToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OTSIncAReportApp._1_UI.Control_Grids.SpectrumExportConfirmation sfd = new OTSIncAReportApp._1_UI.Control_Grids.SpectrumExportConfirmation();

            if (sfd.ShowDialog() == DialogResult.OK)
            {
                Cursor = Cursors.WaitCursor;

                //var progr = new Frm_UserProgress();
                if (m_frm_userprogress.IsDisposed)
                {
                    ProgressStart();
                }

                //IWorkbook workbook = new HSSFWorkbook();   //用于创建.xls  office2003开始以前的
                IWorkbook workbook = new NPOI.XSSF.UserModel.XSSFWorkbook();        //用于创建.xlsx office2007开始以后的
                ISheet sheet;

                //创建Excel文件
                FileStream fs = File.Create(sfd.FileName);
                fs.Close();

                sheet = workbook.CreateSheet("Particles");//创建工作表


                //创建表格边框样式风格
                ICellStyle cellStyle = workbook.CreateCellStyle();
                cellStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Center;
                cellStyle.VerticalAlignment = VerticalAlignment.Center;

                //设置上4边
                cellStyle.BorderBottom = NPOI.SS.UserModel.BorderStyle.Thin;
                cellStyle.BorderTop = NPOI.SS.UserModel.BorderStyle.Thin;
                cellStyle.BorderLeft = NPOI.SS.UserModel.BorderStyle.Thin;
                cellStyle.BorderRight = NPOI.SS.UserModel.BorderStyle.Thin;

                //设置字符大小和颜色
                IFont font = workbook.CreateFont();
                font.FontName = "黑体";
                font.FontHeightInPoints = 10;
                cellStyle.SetFont(font);

                //设置颗粒名列宽
                sheet.SetColumnWidth(1, 30 * 256);//夹杂物名列宽
                sheet.SetColumnWidth(2, 7 * 256);//图像列宽

                IRow row;
                ICell cell;

                //插入表头
                row = sheet.CreateRow(1);//从第15行添加一行
                IDrawing patriarch;
                patriarch = sheet.CreateDrawingPatriarch();
                row.Height = 30 * 20;
                for (int i_cell = 0; i_cell < dgV_ParticlesDevidePage.Columns.Count; i_cell++)
                {
                    cell = row.CreateCell(i_cell);
                    cell.CellStyle = cellStyle;

                    cell.SetCellValue(dgV_ParticlesDevidePage.Columns[i_cell].HeaderText);
                }
                m_frm_userprogress.SetProgressValueAndText(0, "export:"+"0"+"/total:"+ dgV_ParticlesDevidePage.Rows.Count);

                IClientAnchor anchor;
                int pictureIdx;
                Bitmap bp;
                byte[] bytes;
                IPicture pict;
                //插入表内容
                for (int i_row = 0; i_row < dgV_ParticlesDevidePage.Rows.Count; i_row++)
                {
                    if (dgV_ParticlesDevidePage.Rows.Count > 100)
                    {

                        if (i_row%(dgV_ParticlesDevidePage.Rows.Count / 100) == 0)
                            m_frm_userprogress.SetProgressValueAndText(i_row * 100/ dgV_ParticlesDevidePage.Rows.Count, "export:" + i_row + "/total:" + dgV_ParticlesDevidePage.Rows.Count);
                    }
                    row = sheet.CreateRow(2 + i_row);
                    row.Height = 45 * 20;
                    for (int i_cell = 0; i_cell < dgV_ParticlesDevidePage.Columns.Count; i_cell++)
                    {
                        cell = row.CreateCell(i_cell);
                        cell.CellStyle = cellStyle;

                        if (dgV_ParticlesDevidePage[i_cell, i_row].Value == null)
                            continue;

                        if (i_cell == 2)
                        {
                            if (sfd.IfExportPicture)
                            {
                                //颗粒图像列
                                bp = (Bitmap)dgV_ParticlesDevidePage.Rows[i_row].Cells[2].Value;

                                bytes = ImageConvertToBytes(bp);

                                //第二步，将图片添加到workbook中，指定图片的格式，返回图片所在workbook->paicture数组中的索引的地址，从1开始
                                pictureIdx = workbook.AddPicture(bytes, PictureType.JPEG);

                                //第三步，在sheet中创建画布
                             

                                //第四步，设置锚点，（在起始单元格的X坐标0-1023，Y的坐标0-255，在终止单元格的X坐标0-1023，Y的坐标0-255，起始单元格行数，列数，终止单元格行数，列数）
                                anchor = patriarch.CreateAnchor(1, 1, 2, 2, i_cell, i_row + 2, i_cell + 1, i_row + 3);//终止比开始位置大1,会自动缩放到一个单元格内的

                                //第五步，创建图片
                                pict = patriarch.CreatePicture(anchor, pictureIdx);
                            }
                        }
                        else
                        {
                            //非图像列
                            
                            cell.SetCellValue(dgV_ParticlesDevidePage[i_cell, i_row].Value.ToString());
                        }

                    }
                }
                if (sfd.IfExportSpectrumData)
                {
                    ISheet sheet2;
                    sheet2 = workbook.CreateSheet("Peak spectrum Data");//创建工作表
                                                                        //插入表头
                    row = sheet2.CreateRow(1);
                    row.Height = 30 * 20;
                    cell = row.CreateCell(0);
                    cell.CellStyle = cellStyle;
                    cell.SetCellValue("rowid");

                    for (int i_cell = 1; i_cell < 2001; i_cell++)
                    {
                        cell = row.CreateCell(i_cell);
                        cell.CellStyle = cellStyle;
                        if (i_cell == 1)
                        {
                            cell.SetCellValue("PeakSpectrumData");
                        }
                    }

                    sheet2.AddMergedRegion(new NPOI.SS.Util.CellRangeAddress(1, 1, 1, 2000));

                    for (int j = 0; j < particles.Rows.Count; j++)
                    {
                        row = sheet2.CreateRow(2 + j);
                        cell = row.CreateCell(0);
                        cell.CellStyle = cellStyle;
                        cell.SetCellValue(j + 1);
                        var tmpPart = Particledata.GetParticleXrayDataByFidAndPid(particles.Rows[j]["fieldid"].ToString(), particles.Rows[j]["particleid"].ToString());
                        if (tmpPart != null)
                        {
                            if (tmpPart.XrayId > -1)
                            {
                                uint[] Analysis_xray = new uint[2000];
                                for (int i = 0; i < 2000; i++)
                                {
                                    Analysis_xray[i] = BitConverter.ToUInt32(tmpPart.XRayData, i * 4);
                                    cell = row.CreateCell(i + 1);
                                    cell.CellStyle = cellStyle;
                                    cell.SetCellValue(Analysis_xray[i]);
                                }

                            }

                        }
                    }
                }
                if (sfd.IfExportSpectrumConfirmation)
                {
                    ISheet sheet3;
                    sheet3 = workbook.CreateSheet("Peak spectrum");
                    sheet3.SetColumnWidth(1, 200 * 256);//图像列宽
                                                        //插入表头
                    row = sheet3.CreateRow(1);
                    row.Height = 30 * 20;
                    cell = row.CreateCell(0);
                    cell.CellStyle = cellStyle;
                    cell.SetCellValue("rowid");

                    cell = row.CreateCell(1);
                    cell.CellStyle = cellStyle;
                    cell.SetCellValue("PeakSpectrum");

                    IDrawing drawing;
                    IClientAnchor anchor3;
                    for (int j = 0; j < particles.Rows.Count; j++)
                    {
                        row = sheet3.CreateRow(j + 2);
                        row.Height = 120 * 20;
                        cell = row.CreateCell(0);
                        cell.CellStyle = cellStyle;
                        cell.SetCellValue(j + 1);
                        cell = row.CreateCell(1);
                        cell = row.CreateCell(2);
                        cell = row.CreateCell(3);
                        drawing = sheet3.CreateDrawingPatriarch();
                        //锚点
                        anchor3 = drawing.CreateAnchor(0, 0, 0, 0, 1, j + 2, 2, j + 3);//XSSFClientAnchor(dx1,dy1,dx2,dy2,col1,row1,col2,row2);参数说明:dx1 dy1 起始单元格中的x,y坐标.dx2 dy2 结束单元格中的x,y坐标col1, row1 指定起始的单元格，下标从0开始col2, row2 指定结束的单元格，下标从0开始
                        CreateChart(drawing, sheet3, anchor3, j + 2);
                    }
                }

                //完成后，对Excel进行保存
                FileStream file = new FileStream(sfd.FileName, FileMode.Create);
                workbook.Write(file);
                file.Close();

                //MessageBox.Show("Export complete!");
                m_frm_userprogress.SetProgressValueAndText(100, "export:" + dgV_ParticlesDevidePage.Rows.Count + "/total:" + dgV_ParticlesDevidePage.Rows.Count);
                //加载完成，关闭进度条
                m_frm_userprogress.Close();

                Cursor = Cursors.Default;
                //导出完成后，打开Excel文件
                if (File.Exists(sfd.FileName))
                {
                    //打开刚才导出的文件
                    System.Diagnostics.Process.Start(sfd.FileName);
                }
            }
        }


        void CreateChart(IDrawing drawing, ISheet sheet, IClientAnchor anchor, int rowid)
        {
            var chart = drawing.CreateChart(anchor) as XSSFChart;

            //图表
            var data = chart.ChartDataFactory.CreateLineChartData<double, double>(); //折线图

            IChartAxis bottomAxis = chart.ChartAxisFactory.CreateCategoryAxis(AxisPosition.Bottom);

            IValueAxis leftAxis = chart.ChartAxisFactory.CreateValueAxis(AxisPosition.Left);
            leftAxis.Crosses = AxisCrosses.AutoZero;
            leftAxis.IsVisible = true;
            bottomAxis.IsVisible = true;
            //数据源
            IChartDataSource<double> ys = DataSources.FromNumericCellRange(sheet, new CellRangeAddress(rowid, rowid, 1, 2001));

            Double[] doubles = new Double[2000];
            for (int i = 0; i < 2000; i++)
            {
                doubles[i] = i;
            }
            IChartDataSource<double> xs = DataSources.FromArray(doubles);

            //数据系列
            var s1 = data.AddSeries(xs, ys);

        }
        /// <summary>
        /// 将image转成bytes
        /// </summary>
        /// <param name="in_img"></param>
        /// <returns></returns>
        public byte[] ImageConvertToBytes(System.Drawing.Image in_img)
        {
            MemoryStream ms = new MemoryStream();
            in_img.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
            return ms.ToArray();
        }

        public bool CheckParamExist<T>(T Param)
        {
            if (Param == null)
            {
                return false;
            }
            else
            {
                return true;
            }
        }



        private void ToolStripMenuItem_Delete_Particle_Click(object sender, EventArgs e)
        {
            string path = result.FilePath;
            ParticleData fielddata = new ParticleData(result.FilePath);
            List<Particle> particles = fielddata.GetParticleAllList();
            DialogResult dr = MessageBox.Show("Remove all these particles permanently?", "Tips", MessageBoxButtons.OKCancel, MessageBoxIcon.Question);
            if (dr == DialogResult.OK)
            {
                List<Particle> list_Part = new List<Particle>();
                for (int ii = 0; ii < dgV_ParticlesDevidePage.SelectedRows.Count; ii++)
                {
                    //从事先加载的Bitmap对象的Tag中取出List<string>
                    DataGridViewRow dgvr = dgV_ParticlesDevidePage.SelectedRows[ii];
                    Bitmap ls_bp = (Bitmap)dgvr.Cells[2].Value;
                    List<string> list_str = (List<string>)ls_bp.Tag;
                    if (list_str != null)
                    {
                        int i_ls_fieldid = Convert.ToInt32(list_str[0]);
                        int i_ls_particleid = Convert.ToInt32(list_str[1]);
                        foreach (Particle item in particles)
                        {
                            if (i_ls_fieldid == item.FieldId && i_ls_particleid == item.ParticleId)
                            {
                                if (DeleteParticlesFromLibrary(item.ParticleId, item.FieldId))
                                {
                                    for (int i = 0; i < particlesAll.Rows.Count; i++)
                                    {
                                        if (particlesAll.Rows[i]["Fieldid"].ToString() == item.FieldId.ToString() && particlesAll.Rows[i]["Particleid"].ToString() == item.ParticleId.ToString())
                                        {
                                            particlesAll.Rows.RemoveAt(i);
                                            list_Part.Add(item);
                                        }
                                    }
                                }
                                else
                                {
                                    MessageBox.Show("Delete failed");
                                }
                                break;
                            }
                        }
                    }
                }
                RecordCount = recordCount - dgV_ParticlesDevidePage.SelectedRows.Count;
                lblTotalCount.Text = RecordCount.ToString();
                foreach (DataGridViewRow Row in dgV_ParticlesDevidePage.SelectedRows)
                {
                    dgV_ParticlesDevidePage.Rows.Remove(Row);
                }
                if(dgV_ParticlesDevidePage.Rows.Count==0)
                {
                    DisplayData();
                }
                for(int j=0;j< dgV_ParticlesDevidePage.Rows.Count;j++)
                {
                    dgV_ParticlesDevidePage.Rows[j].Cells[0].Value = (pageSize * (PageIndex - 1) + j + 1).ToString();
                }
                if (m_ReportApp.im_Control_DrawDistrbutionImageAndBSE != null)
                {
                    m_ReportApp.im_Control_DrawDistrbutionImageAndBSE.DeletesParticlesSynchronously(list_Part);
                }
                else
                {
                    var _Control_DrawDistrbutionImageAndBSE = new OTSIncAReportGraph.Controls.Control_DrawDistrbutionImageAndBSE(m_ReportApp);
                    foreach (var p in list_Part)
                    {
                        _Control_DrawDistrbutionImageAndBSE.DeleteParticlesFromLibrary(p.ParticleId, p.FieldId);
                    }
                }
            }
        }

        private bool DeleteParticlesFromLibrary(int in_clr_tagid, int in_clr_fieldid)
        {
            bool DoesItExist = false;
            for (int i = 1; i < 201; i++)
            {
                if (System.IO.Directory.Exists(resultFile.FilePath + "\\FIELD_FILES\\Backups" + i.ToString()))
                {
                    DoesItExist = true;
                    break;
                }
            }
            if (!DoesItExist)
            {
                //备份数据库
                BackupDatabase();
            }
            DoesItExist = false;

            //防止为空校验判断
            if (resultFile.List_OTSField == null)
                return false;
            Particle particle = resultFile.List_OTSField.Find(x => x.FieldID == in_clr_fieldid).ParticleList.Find(x => x.ParticleId == in_clr_tagid);
            if (new ParticleData(resultFile.FilePath).DeleteFromData(Convert.ToString(particle.FieldId), Convert.ToString(particle.XrayId)))
            {

                return true;
            }
            else

            {
                return false;
            }
        }
        private bool BackupDatabase()
        {
            //创建备份数据库文件夹
            string sourcePath = resultFile.FilePath + "\\FIELD_FILES\\Inclusion.db";//源文件路径
            string sourceName = "Inclusion.db";//源文件名称
            string folderPath = resultFile.FilePath + "\\FIELD_FILES\\Backups";//目标文件夹
            string Fields = "";
            for (int i = 1; i < 201; i++)
            {
                if (System.IO.Directory.Exists(folderPath + i.ToString()))
                {
                    Fields = folderPath + i.ToString();
                    continue;
                }
                else
                {
                    System.IO.Directory.CreateDirectory(folderPath + i.ToString());
                    Fields = folderPath + i.ToString();
                    break;
                }
            }
            if (Fields == "")
            {
                return false;
            }
            //复制数据库文件
            string targetPath = Path.Combine(Fields, sourceName);
            FileInfo file = new FileInfo(sourcePath);
            if (file.Exists)
            {
                file.CopyTo(targetPath, true);
            }

            return true;
        }
        private void DisplayData()
        {
            if (cbB_PageSize.SelectedItem.ToString() == "All")
            {
                pageSize = -1;
            }
            else
            {
                pageSize = int.Parse(cbB_PageSize.SelectedItem.ToString());
            }
            lnkFirst_Click(null, null);
            SetDataGridViewStyle();
        }


        string ChangeHardnessColor(string Hardness)
        {
            string str = System.Text.RegularExpressions.Regex.Replace(Hardness, @"[^\d.\d]", "");
            double hd;
            if (double.TryParse(str, out hd))
            {
                if (hd >= 1000)
                {
                    return "#FF0000";
                }
                else return "";
            }
            else
                return "";
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="str_resultPath"></param>
        /// <param name="dataTable"></param>
        /// <param name="vs"></param>
        /// <param name="dt_FIeld"></param>
        public void Out_MarkParticleRectangleOnFieldFile(string str_resultPath, DataTable dataTable, out List<string> vs, out DataTable dt_FIeld)
        {
            Init();

            List<string> maxlength = new List<string>();
            for (int i = 0; i < dataTable.Rows.Count; i++)
            {
                if (Convert.ToInt32(dataTable.Rows[i]["TypeId"])>9)
                {
                    if (maxlength.Count < 10)
                    {
                        maxlength.Add(dataTable.Rows[i]["Fieldid"].ToString());
                    }
                    else
                    {
                        break;
                    }
                }
            }
            List<string> max_list = maxlength.Distinct().ToList();

            string str_path_FIELD_FILES = str_resultPath + "\\FIELD_FILES\\";
            int intQuantity = 0;
            dt_FIeld = new DataTable();
            vs = new List<string>();
            ResultFile resfile = m_ReportApp.m_rstDataMgr.ResultFilesList[m_ReportApp.m_rstDataMgr.getSelectedIndex()];
            float PixelSize = resfile.GetPixelSize();

            float ScanFieldSizeX = resfile.GetScanFieldSizeX();

            int gauge = RulerSelection(ScanFieldSizeX);
            float RulerPixels = gauge / PixelSize;
            //查找该field下对应所有的颗粒
            DataTable dt_AllParticle = fieldData.GetAllParticle_DataTable();

            DirectoryInfo theFolder = new DirectoryInfo(str_path_FIELD_FILES);
            if (theFolder.Exists)
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("fieldid");
                dt.Columns.Add("id");
                dt.Columns.Add("fieldName");
                dt.Columns.Add("cunt", typeof(int));
                dt.Columns.Add("fieldFullName");
                for (int i = 0; i < max_list.Count; i++)
                {
                    foreach (FileInfo nextifile in theFolder.GetFiles())
                    {
                        if (nextifile.Name.Contains(".bmp") == true || nextifile.Name.Contains(".BMP") == true)
                        {
                            //确认对应的帧图名
                            string str_fieldid = Path.GetFileNameWithoutExtension(nextifile.Name);
                            str_fieldid = str_fieldid.Substring(5, str_fieldid.Length - 5);//减去field字符长度
                            bool bl = false;

                            if (str_fieldid == max_list[i].ToString())
                            {
                                bl = true;
                            }

                            if (bl)
                            {
                                DataRow dr = dt.NewRow();
                                dr["fieldid"] = " fieldid = " + str_fieldid;
                                int drcunt = 0;
                                for (int ia=0;ia< dataTable.Rows.Count;ia++)
                                {
                                    if (dataTable.Rows[ia]["fieldid"].ToString()== str_fieldid.ToString())
                                    {
                                        drcunt++;
                                    }
                                }
                                dr["cunt"] = drcunt;
                                //dr["cunt"] = dataTable.Select(" fieldid = " + str_fieldid).Count();
                                dr["fieldName"] = nextifile.Name;
                                dr["fieldFullName"] = nextifile.FullName;
                                dr["id"] = str_fieldid;
                                dt.Rows.Add(dr);
                            }

                        }
                    }
                }
                dt_FIeld = dt.Copy();
                dt_FIeld.Columns.Add("Field_pic", typeof(Bitmap));

                for (int i = 0; i < dt_FIeld.Rows.Count; i++)
                {
                    int drCount = 0;
                    for (int ia = 0; ia < dataTable.Rows.Count; ia++)
                        if (Convert.ToInt32(dt_FIeld.Rows[i]["id"]) == Convert.ToInt32(dataTable.Rows[ia]["fieldid"]))
                            drCount++;
                    //if (dataTable.Select(dt_FIeld.Rows[i]["fieldid"].ToString()).Count() > 0)
                        if (drCount > 0)
                        {
                        vs.Add(dt_FIeld.Rows[i]["id"].ToString());

                        Image img = Image.FromFile(dt_FIeld.Rows[i]["fieldFullName"].ToString());
                      
                        Bitmap ls_fieldbp = new Bitmap(img.Width, img.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);

                        using (Graphics g = Graphics.FromImage(ls_fieldbp))
                        {
                            g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                            g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
                            g.DrawImage(img, new Rectangle(0, 0, img.Width, img.Height));
                        }
                     
                        img.Dispose();
                        img = null;


                        //循环将颗粒，进行标记到bitmap图上
                        DataRow[] drlist = dt_AllParticle.Select(dt_FIeld.Rows[i]["fieldid"].ToString());
                        if (drlist.Count() > 0)
                            intQuantity = intQuantity + 1;
                        for (int i_row = 0; i_row < drlist.Count(); i_row++)
                        {
                            
                            string str_particleid = drlist[i_row]["particleid"].ToString();
                            string str_stdtypeid = drlist[i_row]["typeid"].ToString();
                            string str_offset_rect_X = drlist[i_row]["RectLeft"].ToString();
                            string str_offset_rect_Y = drlist[i_row]["RectTop"].ToString();
                            string str_offset_rect_Width = drlist[i_row]["RectWidth"].ToString();
                            string str_offset_rect_Height = drlist[i_row]["RectHeight"].ToString();

                            //确定需要标记颗粒的定位
                            Rectangle offset_rect = new Rectangle(Convert.ToInt32(str_offset_rect_X), Convert.ToInt32(str_offset_rect_Y),
                    Convert.ToInt32(str_offset_rect_Width), Convert.ToInt32(str_offset_rect_Height));

                            //向帧图进行标记颗粒位置
                            Graphics g = Graphics.FromImage(ls_fieldbp);
                            g.DrawRectangle(new Pen(Color.Aquamarine), offset_rect);

                            //判断是否超出了图像外面，是的话，让文字在左侧显示，默认在右侧显示
                            int ls_offsetx = offset_rect.X + offset_rect.Width;
                            if (ls_offsetx > ls_fieldbp.Width - 10)
                            {
                                ls_offsetx = offset_rect.X - 10;
                            }

                            g.DrawString(dt_FIeld.Rows[i]["id"].ToString() + "" + str_particleid.ToString(),
                                new Font("黑体", 8), new SolidBrush(Color.Aqua), new PointF(ls_offsetx, offset_rect.Y));
                            var bitmap = DrawRuler(ls_fieldbp, (int)(RulerPixels/2), 2, (gauge/2).ToString()+ "μm");
                            dt_FIeld.Rows[i]["Field_pic"] = bitmap;
                            //bitmap.Save("D:\\图片\\asd.bmp");


                        }

                    }
                }

            }
            //
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
        /// <summary>
        /// 在图片上绘制标尺
        /// </summary>
        /// <param name="bitmap">图片</param>
        /// <param name="LineLength">线长（像素）</param>
        /// <param name="LineWidth">线宽（像素）</param>
        /// <returns></returns>
        private Bitmap DrawRuler(Bitmap bitmap, int LineLength, int LineWidth,string a_str)
        {
            if (bitmap == null)
                throw new ArgumentNullException(nameof(bitmap));

            // 创建一个新的Bitmap，并设置其大小与原图相同 
            Bitmap rgbBitmap = new Bitmap(bitmap.Width, bitmap.Height);

            using (Graphics graphics = Graphics.FromImage(rgbBitmap))
            {
                // 将原图转换为RGB格式，并绘制到新的Bitmap上  
                graphics.DrawImage(bitmap, new Rectangle(0, 0, bitmap.Width, bitmap.Height));
                Color color = FromHex("#00FF00");
                //Color color = FromHex("#00FF00");

                // 设置线条颜色和宽度  
                Pen pen = new Pen(color, LineWidth);
                Font font = new Font("Arial", 20, GraphicsUnit.Pixel);
                Brush brush = new SolidBrush(color);
                StringFormat stringFormat = new StringFormat();
                stringFormat.Alignment = StringAlignment.Center; // 居中对齐  
                stringFormat.LineAlignment = StringAlignment.Center; // 居中对齐行  
                                                                     // 绘制文字  

                SizeF textSize = Graphics.FromImage(bitmap).MeasureString(a_str, font);
                PointF point = new PointF();
                // 计算文本应该开始的位置，使其居中  
                point.X = (bitmap.Width - LineLength - 20) + ((LineLength - textSize.Width) / 2);
                point.Y = bitmap.Height - 80;


                graphics.DrawString(a_str, font, new SolidBrush(color), point);
                graphics.DrawLine(pen, bitmap.Width - LineLength - 20, bitmap.Height - 40, bitmap.Width - 20, bitmap.Height - 40);
                graphics.DrawLine(pen, bitmap.Width - LineLength - 20, bitmap.Height - 40, bitmap.Width - LineLength - 20, bitmap.Height - 50);
                graphics.DrawLine(pen, bitmap.Width - 20, bitmap.Height - 40, bitmap.Width - 20, bitmap.Height - 50);


            }
            return rgbBitmap;
        }

        private static Color FromHex(string hex)
        {
            hex = hex.Replace("#", ""); // 移除 # 前缀  
            byte a = 255; // 默认Alpha值为255（不透明）  
            byte r = Convert.ToByte(hex.Substring(0, 2), 16);
            byte g = Convert.ToByte(hex.Substring(2, 2), 16);
            byte b = Convert.ToByte(hex.Substring(4, 2), 16);
            return Color.FromArgb(a, r, g, b);
        }
        /// <summary>
        /// 判断当前图片应该使用多大标尺
        /// </summary>
        /// <param name="a_value"> </param>
        /// <returns></returns>
        private int RulerSelection(float a_value)
        {
            int value = 0;
            a_value = a_value / 2;
            for (int i = 10; i < 5000; i += 5)
            {
                if (a_value < i)
                {
                    value = i - 5;
                    break;
                }
            }
            if (value == 0)
            {
                value = 5000;
            }
            return value;

        }

        private void dgV_ParticlesDevidePage_MouseDown(object sender, MouseEventArgs e)
        {
            var SelectRows = dgV_ParticlesDevidePage.SelectedRows;
            int sel = m_ReportApp.m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTSIncAReportApp.OTSSampleReportInfo.OTS_REPORT_PROP_GRID_ITEMS.PARTICE_LIST);
            {
                if (sel != (int)SelItem.MergeParticles)
                {
                    if (SelectRows != null && SelectRows.Count == 1)
                    {
                        DataGridViewRow dgvr = SelectRows[0];
                        Bitmap ls_bp = (Bitmap)dgvr.Cells[2].Value;
                        List<string> list_str = (List<string>)ls_bp.Tag;
                    }
                    ToolStripMenuItemDelete_Particle.Visible = true;
                }
                else
                {
                    ToolStripMenuItemDelete_Particle.Visible = false;
                }
            }
        }
        /// <summary>
        /// 去除拼接颗粒组成颗粒
        /// </summary>
        /// <param name="dataTable_Particle"></param>
        /// <param name="dataTable_MergeParticles"></param>
        void RemoveMergeParticles(ref DataTable dataTable_Particle, DataTable dataTable_MergeParticles)
        {
            foreach (DataRow row in dataTable_Particle.Rows)
            {
                foreach (DataRow MergeParticlesRow in dataTable_MergeParticles.Rows)
                {
                    string subt = MergeParticlesRow["SubParticles"].ToString();
                    string[] sub = subt.Split(',');
                    if (row.RowState == DataRowState.Deleted)
                    {
                        break;
                    }
                    if (row["fieldid"].ToString() == Convert.ToString(sub[0]).Split(':')[0] && row["ParticleId"].ToString() == Convert.ToString(sub[0]).Split(':')[1])
                    {
                        row.Delete();
                        break;
                    }
                    if (row["fieldid"].ToString() == Convert.ToString(sub[1]).Split(':')[0] && row["ParticleId"].ToString() == Convert.ToString(sub[1]).Split(':')[1])
                    {
                        row.Delete();
                        break; ;
                    }
                }
            }
            dataTable_Particle.AcceptChanges();
        }

        private void btn_showconfig_Click(object sender, EventArgs e)
        {
            //if (m_particlesGridDevidePageShowConfig == null|| m_particlesGridDevidePageShowConfig.IsDisposed)
            //{
            var p = particles; List<string> ele = new List<string>();
            string elementsstr = "";
            foreach (DataRow row in particles.Rows)
            {
                string[] strcbo = row["Element"].ToString().Split(';');
                for (int j = 0; j < strcbo.Length; j++)
                {
                    string[] str = strcbo[j].Split('-');
                    
                        if (!ele.Contains(str[0]) && str[0] != "")
                        { 
                            if (str[1] != ""&&double.Parse(str[1]) != 0)  //咨询demo后，元素含量返回值为零时一般去除此元素
                            {ele.Add(str[0]);}
                        }
                    
                }
            }
            foreach(var el in ele)
            {
                elementsstr += el.ToString() + ',';
            }
            if(elementsstr!="")
            {
                elementsstr=elementsstr.Remove(elementsstr.Length - 1, 1);
            }
            m_particlesGridDevidePageShowConfig = new ParticlesGridDevidePageShowConfig(m_ReportApp.m_RptConfigFile.Systype, elementsstr);
                m_particlesGridDevidePageShowConfig.ShowDialog();
            //}
            //else
            //{
            //    m_particlesGridDevidePageShowConfig.Activate();
            //}
            if (m_particlesGridDevidePageShowConfig.DialogResult == DialogResult.OK)
            {
                dgV_ParticlesDevidePage.Rows.Clear();
                dgV_ParticlesDevidePage.Columns.Clear();
                BindDataGridView();
                SetDataGridViewStyle();
            }
        }


        private void SaveParticleslist_select()
        {
            ParticleData fielddata = new ParticleData(result.FilePath);
            List<Particle> particles = fielddata.GetParticleAllList();

            Particleslist_selecttodisplay.Clear();
            for (int l = 0; l < dgV_ParticlesDevidePage.SelectedRows.Count; l++)
            {
                //从事先加载的Bitmap对象的Tag中取出List<string>
                DataGridViewRow dgvr = dgV_ParticlesDevidePage.SelectedRows[l];
                Bitmap ls_bp = (Bitmap)dgvr.Cells[2].Value;
                List<string> list_str = (List<string>)ls_bp.Tag;
                if (list_str != null)
                {
                    int i_ls_fieldid = Convert.ToInt32(list_str[0]);
                    int i_ls_particleid = Convert.ToInt32(list_str[1]);
                    foreach (Particle item in particles)
                    {
                        if (i_ls_fieldid == item.FieldId && i_ls_particleid == item.ParticleId)
                        {
                            Particleslist_selecttodisplay.Add(item);
                            break;
                        }
                    }

                }
            }
            //if(m_ReportApp.im_Control_DrawDistrbutionImageAndBSE!=null)
            //{
            //    m_ReportApp.im_Control_DrawDistrbutionImageAndBSE.DisplayParticleByParticlelist(Particleslist_selecttodisplay);
            //}
        }

        public List<Particle> GetParticleslist_select()
        {
            return Particleslist_selecttodisplay;
        }

        private void dgV_ParticlesDevidePage_MouseUp(object sender, MouseEventArgs e)
        {
            int sel = m_ReportApp.m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTSIncAReportApp.OTSSampleReportInfo.OTS_REPORT_PROP_GRID_ITEMS.PARTICE_LIST);
            if (sel == (int)SelItem.MergeParticles)
            {
                return;
            }
            var SelectRows = dgV_ParticlesDevidePage.SelectedRows;
            if (SelectRows.Count != 0)
            {
                if (SelectRows.Count == 1)
                {
                    DataGridViewRow dgvr = SelectRows[0];
                    Bitmap ls_bp = (Bitmap)dgvr.Cells[2].Value;
                    List<string> list_str = (List<string>)ls_bp.Tag;


                    //显示xray相关信息
                    uint[] Search_xray = new uint[2000];
                    uint[] Analysis_xray = new uint[2000];
                    int i_xray_id = 0;
                    List<Element> list_celementchemistryclr = new List<Element>();
                    //获取Xray数据
                    ReportFun.GetXrayByParticleTagIDAndFieldID_ForDrawDistrbutionImageAndBSE(Convert.ToInt32(dgvr.Cells["particleId"].Value), Convert.ToInt32(dgvr.Cells["fieldid"].Value), out Search_xray, out Analysis_xray, out i_xray_id, out list_celementchemistryclr);

                    //get CElementChemistryClr list
                    List<ShowElementInfo> list_showelementinfo = new List<ShowElementInfo>();
                    for (int i = 0; i < list_celementchemistryclr.Count; i++)
                    {
                        ShowElementInfo ls_sei = new ShowElementInfo();
                        ls_sei.ElementName = list_celementchemistryclr[i].Name;
                        ls_sei.Percentage = list_celementchemistryclr[i].Percentage;
                        ls_sei.dKF = Convert.ToDouble(CListPeriodic.GetPeriodicByEleName(ls_sei.ElementName).K_Peak);
                        double de_sx2 = 0;
                        if (CListPeriodic.GetPeriodicByEleName(ls_sei.ElementName).L_Peak == "" || CListPeriodic.GetPeriodicByEleName(ls_sei.ElementName).L_Peak == "-")
                        {
                            de_sx2 = 0;
                        }
                        else
                        {
                            de_sx2 = Convert.ToDouble(CListPeriodic.GetPeriodicByEleName(ls_sei.ElementName).L_Peak);
                        }
                        ls_sei.dLF = de_sx2;
                        list_showelementinfo.Add(ls_sei);
                    }
                    string str_IncAName = "";
                    str_IncAName = Convert.ToString(dgvr.Cells[1].Value);
                    Particle particle = resultFile.List_OTSField.Find(x => x.FieldID == Convert.ToInt32(dgvr.Cells["fieldid"].Value)).ParticleList.Find(x => x.ParticleId == Convert.ToInt32(dgvr.Cells["particleId"].Value));
                    control_XRayTable1.SetParticleInfo("Area:" + Math.Round(particle.Area, 2) + " " + "DELONG:" + Math.Round(particle.DELONG, 2) + " " + "DFERET:" + Math.Round(particle.DFERET, 2) + " " + "DINSCR:" + Math.Round(particle.DINSCR, 2) + " " + "DMAX:" + Math.Round(particle.DMAX, 2) + "\n" + "DMEAN:" + Math.Round(particle.DMEAN, 2) + " " + "DMIN:" + Math.Round(particle.DMIN, 2) + " " + "DPERP:" + Math.Round(particle.DPERP, 2) + " " + "ORIENTATION:" + Math.Round(particle.ORIENTATION, 2) + " " + "PERIMETER:" + Math.Round(particle.PERIMETER, 2));

                    //获取数据后，需要对xraytable设置
                    control_XRayTable1.Visible = true;
                    control_XRayTable1.SetXRayShowLineValue(null, Analysis_xray, list_showelementinfo);
                    //颗粒国标信息
                    control_XRayTable1.GBInfoStr = "";
                    control_XRayTable1.MaterialName = str_IncAName;//杂夹物

                    control_XRayTable1.List_ShowElementInfo = list_showelementinfo;


                    string filePath = result.FilePath + "\\FIELD_FILES\\";
                    string imagePath = filePath + "Field" + dgvr.Cells["fieldid"].Value.ToString() + ".bmp";
                    Bitmap originalFieldImage=Particledata.ReadImageFile(imagePath);
                    string str = " particleId= " + dgvr.Cells["particleId"].Value.ToString() + " and fieldid = " + dgvr.Cells["fieldid"].Value.ToString();
                    DataRow[] drs = particles.Select(str);
                    if (drs.Length > 0)
                    {
                        Rectangle rectangle = new Rectangle() { X = Convert.ToInt32(drs[0]["RectLeft"]), Y = Convert.ToInt32(drs[0]["RectTop"]), Width = Convert.ToInt32(drs[0]["RectWidth"]), Height = Convert.ToInt32(drs[0]["RectHeight"]) };
                        Bitmap dpImage = new Bitmap(originalFieldImage.Width, originalFieldImage.Height);
                        foreach (Segment seg in particle.SegmentList)
                        {
                            int f_length = seg.Length;
                            for (int m = 0; m < f_length; m++)
                            {
                                int lsjs_x = seg.Start + m;
                                int lsjs_y = seg.Height;
                                var pixelColor = originalFieldImage.GetPixel(lsjs_x, lsjs_y);
                                dpImage.SetPixel(lsjs_x, lsjs_y, pixelColor);
                            }
                        }


                        Bitmap bmap = Particledata.GetBitmapByParticle(dpImage, rectangle);
                        Bitmap binarizedBmp = new Bitmap(bmap.Width, bmap.Height);
                        for (int x = 0; x < bmap.Width; x++)
                        {
                            for (int y = 0; y < bmap.Height; y++)
                            {
                                Color color = bmap.GetPixel(x, y);
                                if (color.A == 255&&color.B==0 && color.G == 0 && color.R == 0)
                                {
                                    binarizedBmp.SetPixel(x, y, Color.White);
                                }
                                else
                                {
                                    int grayValue = (color.R + color.G + color.B) / 3;
                                    if(grayValue>0)
                                    {
                                        binarizedBmp.SetPixel(x, y, Color.Black);
                                    }
                                    else
                                    {
                                        binarizedBmp.SetPixel(x, y, Color.White);
                                    }
                                }
                            }
                        }
                        control_XRayTable1.SetBitmapOfPictureBox(ls_bp, binarizedBmp);
                        Invalidate();
                    }
                    else
                    {
                        control_XRayTable1.Visible = false;
                    }
                }
                SaveParticleslist_select();

            }
        }

        private void dgV_ParticlesDevidePage_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyData == Keys.Delete)
            {
                ToolStripMenuItem_Delete_Particle_Click(null, null);
            }
        }

        private void dgV_ParticlesDevidePage_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.KeyData == Keys.Down)
            {
                dgV_ParticlesDevidePage_MouseUp(null, null);
            }
            if (e.KeyData == Keys.Up)
            {
                dgV_ParticlesDevidePage_MouseUp(null, null);
            }
        }
    }
}