OTS/OTSIncAReportApp/1-UI/Control_Graph/Controls/Control_DrawDistrbutionImageAndBSE.cs

using NLog;
using OTSCommon.Model;
using OTSIncAReportApp;
using OTSIncAReportApp._3_ServiceCenter;
using OTSIncAReportApp.DataOperation.DataAccess;
using OTSIncAReportApp.OTSSampleReportInfo;
using OTSIncAReportApp.SysMgrTools;
using OTSIncAReportGraph.Class;

using OTSIncAReportGraph.OTSIncAReportGraphFuncation;
using OTSIncAReportMailInterface;
using OTSPeriodicTable;
using OTSRptPeriodicTable;

using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows.Forms;


namespace OTSIncAReportGraph.Controls
{
    public enum SelectedShape
    {        
        Rectangle=0,
        Ellipse = 1
    }
    public struct SelectTool
    {
       public SelectedShape Shape;
       public Point StartPoint;
       public bool IsSelecting;
        //进行选择的矩形范围
       public RectangleF Rect ;

    }
    public struct ParticleSegmentation
    {
        public Point StartPoint;
        public bool IsParticleSegmentation;
        public Point EndPoint;
        public Particle ParticleData;
        public RectangleF Rectangle;
    }
    public enum RightButtonMenu
    { 
       Include=0,
      
       MoveSEMToParticle=1,
       CopyImage=2,
       OriginalSplicing= 3,
       DeleteParticle=4,       
	   ParticleSegmentation=5,
       ImportSTDDb=6
    }
    /// <summary>
    /// 选择导出的图片是原图还是颗粒渲染后的图片
    /// </summary>
    public enum Outpic_enum
    {
        pic=0,
        Render_pic=1,
            noBackground_pic=2
    }

    public partial class Control_DrawDistrbutionImageAndBSE : UserControl
    {

        private OTSImageDisHelp imageDisHelper = null;
        //缩放的增大缩小的增量
        private const float const_zoom_increment = 0.05f;

        //最大缩放倍数
        private const float m_f_zoom_max = 4f;

        //最小缩放倍数
        private  float m_f_zoom_mix = 0.05f;

        //标尺原先大小的记录，参与计算
        private const float m_f_old_ruler_size = 100;

       
        double ls_d_cz_width;
        double ls_d_cz_height;
        #region 变量定义
        private SelectTool m_SelectTool;
        private ParticleSegmentation m_ParticleSegmentation;
        public bool isReView = false;
        public int reViewFieldId = 0;
        public int reViewParticleId = 0;
       

        //与原先缩放的记录数
        private float m_zoom_record = 1;

        //标尺的大小记录
        public float m_f_ruler_size = 100;
        
        public float m_pixelSize = 4.5f;
   
        //国际化存储信息
        System.Collections.Hashtable table;

        //包含particle的field的列表对象
        public List<DisplayField> m_list_allDfield = null;


        //这里要做成控件，不要是窗体
        public List<DisplayParticle> m_list_allDPart = null;

        public List<DisplayField> m_CurGBFields=new List<DisplayField>();

        //总背景矩形
        private RectangleF m_backRect = new RectangleF();

        private PointF m_ScaleRefPoint;


        //记录总物理矩形总大小
        public RectangleF m_back_wl_rectf = new RectangleF();

        //是否显示网格线
        private bool m_is_showgrid = false;

        //是否拖动
        private bool m_isDrag = false;

        //拖动前的坐标记录
        private PointF m_beforedrag_pointf = new PointF();


        //提供鼠标在右下角显示的文本，左侧
        private string m_str_mouseshow_left = "";

        //提供鼠标在右下角显示的文本,右侧
        private string m_str_mouseshow_right = "";

      

     

       

        //当前鼠标的位置
        Point m_mouse_now_point = new Point();

        //记录当前鼠标位置对应SEM电镜的位置
        Point m_sem_mouse_now_point = new Point();

        //鼠标移动经过的颗粒对象，临时存放，用来记录是否要显示xray与隐藏xray
        DisplayParticle m_mouseOver_dparticle = null;

        //保存数据源名称
        private string m_showsourcename = "";

        //保存当前数据源的ID
        private int m_datasourceid = 0;

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



        private Color m_ColorNotContent = Color.SkyBlue;

        //读取背景原图的名称和图片
        private Dictionary<string, Image> originalImages = new Dictionary<string, Image>();
     

        private DISTRIBUTION_IMAGE_SHOW_MODE showMode;

        static System.Windows.Forms.Timer delaytimer = new System.Windows.Forms.Timer();
        Logger log;
        /// <summary>
        /// 当前正在显示的数据源名称，用来与框架调用条件判断使用
        /// </summary>
        public string ShowSourceName
        {
            set { m_showsourcename = value; }
            get { return m_showsourcename; }
        }

        /// <summary>
        /// 当前正在显示的数据源的ID
        /// </summary>
        public int DataSourceID
        {
            set { m_datasourceid = value; }
            get { return m_datasourceid; }
        }
        /// <summary>
        /// 背景矩形属性
        /// </summary>
        //public RectangleF BackRectF
        //{
        //    set { m_backRect = value; }
        //    get { return m_backRect; }
        //}

        //public OTSImageDisHelp ImageDisHelper { get => imageDisHelper; set => imageDisHelper = value; }



        //进度条窗体
        public Frm_UserProgress m_frm_userprogress;

   

  

        OTSIncAReportApp.frmReportApp m_ReportApp;
        ResultFile resultFile = null;
        //private Cursor cursor1;

        #endregion

        #region 构造函数及窗体加载

        public Control_DrawDistrbutionImageAndBSE(OTSIncAReportApp.frmReportApp ReportApp)
        {
            log = NLog.LogManager.GetCurrentClassLogger();
            m_list_allDfield = new List<DisplayField>();
            m_list_allDPart = new List<DisplayParticle>();

            m_frm_userprogress = new Frm_UserProgress();

            //cursor1 = Cursor;

            m_mythread = new Thread(new ParameterizedThreadStart(Thread_GO));
            
            m_ReportApp = ReportApp;
            resultFile = m_ReportApp.m_rstDataMgr.CurResultFile;

          

            InitializeComponent();
            #region 国际化语言
            Language lan = new Language(this);
            table = lan.GetNameTable(this.Name);
            #endregion

            //load the userdefine control dynamically
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Control_DrawDistrbutionImageAndBSE));
           
            this.control_XRayTable1 = new Control_XRayTable();
            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.TabIndex = 6;
            this.control_XRayTable1.Visible = false;
            // 
            // control_Ruler1
            // 
            this.control_Ruler1 = new Control_Ruler();
            this.control_Ruler1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(200)))), ((int)(((byte)(255)))), ((int)(((byte)(255)))), ((int)(((byte)(255)))));
            this.control_Ruler1.Location = new System.Drawing.Point(3, 400);
            this.control_Ruler1.Name = "control_Ruler1";
            this.control_Ruler1.RulerWidth = 100;
            this.control_Ruler1.ShowString = "100um";
            this.control_Ruler1.Size = new System.Drawing.Size(120, 40);
            this.control_Ruler1.TabIndex = 8;
            this.control_Ruler1.Value = 0D;
            this.control_Ruler1.Visible = false;
            this.Controls.Add(this.control_XRayTable1);
            this.Controls.Add(this.control_Ruler1);
        }
        private void ProgressBarUpdate(int progress, string message)
        {
            //显示进度条,计算进度条应该显示的位置和宽度
            if (m_frm_userprogress.Visible == false)
            {
                Form ls_main_form = this.ParentForm.ParentForm;//取出父窗体
                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(progress, message);

        }

       
        private void Control_DrawDistrbutionImageAndBSE_Load(object sender, EventArgs e)
        {
            //设置双缓冲
            SetDoubleBufferByIsDraw();

            ProgressBarUpdate(0, table["str1"].ToString());
            //初始化底层操作类
            imageDisHelper = new OTSImageDisHelp(resultFile);

            m_backRect = imageDisHelper.m_originalBackRect;

            string str29 = "begin to compose field picture....";
            log.Info(str29);

            ProgressBarUpdate(20, "compose whole picture....");
            List<Field> fieldlist = resultFile.List_OTSField;

            float ls_int_progresscalc = 0;
            if (fieldlist.Count > 0)
                ls_int_progresscalc = (float)70 / (float)fieldlist.Count;


            m_list_allDfield.Clear();
            m_list_allDPart.Clear();
            var fieldSize = imageDisHelper.GetFieldImageSize();
            for (int i = 0; i < fieldlist.Count(); i++)
            {
                ProgressBarUpdate(20 + (int)(ls_int_progresscalc * (i + 1)), "finished " + i.ToString() + "total " + resultFile.List_OTSField.Count.ToString() + "field...");
              
                Point thisfield_point = new Point() { X = fieldlist[i].FieldPosX, Y = fieldlist[i].FieldPosY };//get OTS coordination

                Point offset_point = imageDisHelper.ConvertOTSCoordToScreenCoord(thisfield_point);//the ots coordinate is always the up right positive.
                DisplayField df;
                try
                {

                    df = new DisplayField(fieldlist[i], (int)fieldSize.Width, (int)fieldSize.Height, offset_point);
                    df.ContentColor = Color.Black;
                    m_list_allDfield.Add(df);
                    m_list_allDPart.AddRange(df.List_DParticle);
                }
                catch (Exception ex)
                {
                    NLog.LogManager.GetCurrentClassLogger().Info(ex.ToString());
                }



            }


            //设置标尺
            //根据f_onepixel_size计算出要显示出100um的实际宽度
            double d_onefixel_width = 100 / m_pixelSize;
            if (d_onefixel_width == 0)
            {
                this.control_Ruler1.Visible = false;
            }
            else
            {
                //将标尺定位到合理的位置上
                this.control_Ruler1.Location = new Point(10, MyPrimaryScreen.WorkingArea.Height - 300);
                this.control_Ruler1.Visible = true;
                this.control_Ruler1.SetValue(m_f_ruler_size, m_pixelSize);
                this.control_Ruler1.ShowString = Convert.ToInt32(100).ToString() + "μm";
            }
           



            ProgressBarUpdate(100, table["str2"].ToString());



            m_frm_userprogress.Visible = false;
          


        }
  

    

        /// <summary>
        /// 分布图和BSE图中，从底层获取相关结果后，重新组织显示
        /// </summary>
        /// <param name="sourceGridData"></param>
        public void FilterParticleByOtherCondition(ReportCondition sourceGridData)
        {
            bool sizeconditionResult;
            bool stdIdconditionResult;
            string stdId = "";
            int stdIdIndex = 0;
            //find the stdId condition
            var STDIdItm = sourceGridData.ConditionItemList.Find(s => s.iItemId == OTS_REPORT_PROP_GRID_ITEMS.STD_ID);
            if (STDIdItm != null)
            {
                stdId = STDIdItm.itemDisplayVal.ToString();
                stdIdIndex = STDIdItm.comboDownList.IndexOf(stdId);
            }
            //find the size condition
            var size_cal_method_type = (SIZE_CAL_METHOD_TYPE)sourceGridData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.SIZE_CAL_METHOD_TYPE);
            var itm = sourceGridData.ConditionItemList.Find(s => s.iItemId == OTS_REPORT_PROP_GRID_ITEMS.GRAIN_SIZE_CLASS);
            string size = itm.itemDisplayVal.ToString();
            int index = itm.comboDownList.IndexOf(size);

            string min = "0";
            string max = "999";
            if (index > 0)
            {
                max = sourceGridData.ConditionItemList.Find(s => s.iItemId == OTS_REPORT_PROP_GRID_ITEMS.GRAIN_SIZE_MAX).itemDisplayVal.ToString();
                min = sourceGridData.ConditionItemList.Find(s => s.iItemId == OTS_REPORT_PROP_GRID_ITEMS.GRAIN_SIZE_MIN).itemDisplayVal.ToString();
                if (max.ToLower() == "max")
                {
                    max = "999";
                }
            }

            double dia_min = Convert.ToDouble(min);
            double dia_max = Convert.ToDouble(max);


            foreach (DisplayParticle ls_dp in m_list_allDPart)
            {
                if (index > 0)
                {
                    double diameter = 0;
                    switch (size_cal_method_type)
                    {
                        case SIZE_CAL_METHOD_TYPE.DMAX:
                            diameter = ls_dp.objParticleData.DMAX;
                            break;
                        case SIZE_CAL_METHOD_TYPE.DMIN:
                            diameter = ls_dp.objParticleData.DMIN;
                            break;
                        case SIZE_CAL_METHOD_TYPE.CIRCLE:
                            diameter = Math.Sqrt(ls_dp.objParticleData.Area / 3.14159f) * 2f;
                            break;
                        case SIZE_CAL_METHOD_TYPE.DFERET:
                            diameter = ls_dp.objParticleData.DFERET;
                            break;
                        default:
                            diameter = 0;
                            break;
                    }

                    if (diameter >= dia_min && diameter <= dia_max)
                    {
                        sizeconditionResult = true;

                    }
                    else
                    {
                        sizeconditionResult = false;
                    }
                }
                else 
                {
                    sizeconditionResult = true;
                }

                if (stdIdIndex > 0)// it's not "All" 
                {
                    if (ls_dp.objParticleData.TypeName != stdId)
                    {
                        stdIdconditionResult = false;
                    }
                    else
                    {
                        stdIdconditionResult = true;
                    }


                }
                else
                {
                    stdIdconditionResult = true;
                
                }
                if (stdIdconditionResult && sizeconditionResult)
                {
                    ls_dp.SetDisplayState(DisplayState.DISPLAY);
                }
                else
                {
                    ls_dp.SetDisplayState(DisplayState.NODISPLAY);

                }
                

            }

        }
        #endregion

        #region 设置双缓冲
        /// <summary>
        /// 设置双缓冲
        /// </summary>
        public void SetDoubleBufferByIsDraw()
        {
            SetStyle(ControlStyles.UserPaint, true);                    //没什么效果，开与关
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);         // 禁止擦除背景,关了闪
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);   // 双缓冲,关了闪

            //上面是必须有的
            SetStyle(ControlStyles.UserMouse, true);    //执行自己的鼠标行为，这个打开后，在win7下鼠标操作明显改善

        }
        #endregion

        #region 绘制函数
        protected override void OnPaint(PaintEventArgs e)//处理重绘情况
        {
           
            switch (showMode)
            {
                case DISTRIBUTION_IMAGE_SHOW_MODE.BSE:

                    e.Graphics.FillRectangle(new SolidBrush(Color.Gainsboro), m_backRect);
                    foreach (DisplayParticle dp in m_list_allDPart)
                    {
                        dp.SetDisplayState(DisplayState.DISPLAY);
                        dp.ShowMode = SegmentShowMode.DRAWPARTICLEIMAGE;
                        if (dp.GetPaintState() != PaintState.NOPAINT)
                        {
                            dp.OnPaint(e);
                        }

                    }

                    break;
                case DISTRIBUTION_IMAGE_SHOW_MODE.CLASSIFIED:

                    e.Graphics.FillRectangle(new SolidBrush(Color.Gainsboro), m_backRect);
                  
                    foreach (DisplayParticle dp in m_list_allDPart)
                    {
                        dp.SetDisplayState(DisplayState.DISPLAY);
                        dp.ShowMode = SegmentShowMode.DRAWLINE;

                        if (dp.GetPaintState() != PaintState.NOPAINT)
                        {
                            dp.OnPaint(e);
                        }
                    }
                    break;
                case DISTRIBUTION_IMAGE_SHOW_MODE.ORIGINAl:
                    foreach (DisplayParticle ls_dp in m_list_allDPart)
                    {
                        ls_dp.SetDisplayState(DisplayState.NODISPLAY);

                    }
                    DrawOriginalImageAsBackground(e);
                    break;
                case DISTRIBUTION_IMAGE_SHOW_MODE.ORIGINALCLASSIFIED:
                    DrawOriginalImageAsBackground(e);
                    foreach (DisplayParticle dp in m_list_allDPart)
                    {

                        dp.ShowMode = SegmentShowMode.DRAWLINE;
                      
                      

                        if (dp.GetPaintState() != PaintState.NOPAINT)
                        {
                            dp.OnPaint(e);

                        }
                    }
                  
                    break;
                default:
                    break;
            
            
            }
           
            //display GB field
            if (m_CurGBFields.Count > 0)
            {
                foreach (var f in m_CurGBFields)
                {
                    f.OnPaint(e,Color.Red);
                }
                


            }
            #region 绘制网格线，帧图边框部份
            if (true == m_is_showgrid)
            {
                foreach (var fld in m_list_allDfield)
                {
                    fld.OnPaint(e,Color.Black);
                }


            }
            #endregion



            #region //判断是否使用了矩形或圆形工具进行多选，是的话，那么这里就开始绘制------------------------
            if (m_SelectTool.IsSelecting)
            {
                if (m_SelectTool.Shape==SelectedShape.Rectangle && m_SelectTool.Rect.Width > 0 && m_SelectTool.Rect.Height > 0)
                {
                    Graphics g = e.Graphics;

                    //绘制矩形
                    g.DrawRectangle(new Pen(Color.Blue), m_SelectTool.Rect.X, m_SelectTool.Rect.Y, m_SelectTool.Rect.Width, m_SelectTool.Rect.Height);

                    //半透明画刷
                    SolidBrush brush = new SolidBrush(Color.FromArgb(50, m_ColorNotContent));

                    //填充选择矩形
                    g.FillRectangle(brush, m_SelectTool.Rect.X, m_SelectTool.Rect.Y, m_SelectTool.Rect.Width, m_SelectTool.Rect.Height);
                }

                if (m_SelectTool.Shape == SelectedShape.Ellipse && m_SelectTool.Rect.Width > 0 && m_SelectTool.Rect.Height > 0)
                {
                    Graphics g = e.Graphics;

                    //绘制圆形
                    g.DrawEllipse(new Pen(Color.Blue), m_SelectTool.Rect.X, m_SelectTool.Rect.Y, m_SelectTool.Rect.Width, m_SelectTool.Rect.Height);

                    //半透明画刷
                    SolidBrush brush = new SolidBrush(Color.FromArgb(50, m_ColorNotContent));

                    //填充选择圆形
                    g.FillEllipse(brush, m_SelectTool.Rect.X, m_SelectTool.Rect.Y, m_SelectTool.Rect.Width, m_SelectTool.Rect.Height);
                }
            }
            #endregion
            #region //判断是否使用颗粒分割，是的话，那么这里就开始绘制------------------------
            if (m_ParticleSegmentation.IsParticleSegmentation)
            {
                e.Graphics.DrawLine(new Pen(Color.Red), m_ParticleSegmentation.StartPoint.X, m_ParticleSegmentation.StartPoint.Y, m_ParticleSegmentation.EndPoint.X, m_ParticleSegmentation.EndPoint.Y);
            }
            #endregion
           

            #region 绘制鼠标跟踪线部份
            //XX虚线-----------------------------------------------
            Pen xxpen = new Pen(Color.GreenYellow, 1);
            xxpen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom;
            xxpen.DashPattern = new float[] { 5, 5 };
            //竖线
            e.Graphics.DrawLine(xxpen, 0, m_mouse_now_point.Y, m_mouse_now_point.X - 10, m_mouse_now_point.Y);
            e.Graphics.DrawLine(xxpen, m_mouse_now_point.X + 10, m_mouse_now_point.Y, this.Width, m_mouse_now_point.Y);
            //横线
            e.Graphics.DrawLine(xxpen, m_mouse_now_point.X, 0, m_mouse_now_point.X, m_mouse_now_point.Y - 10);
            e.Graphics.DrawLine(xxpen, m_mouse_now_point.X, m_mouse_now_point.Y + 10, m_mouse_now_point.X, this.Height);
            ////--------------------------------------------------------------------------------
            #endregion

        }
        #endregion

        #region 鼠标操作事件

      
        private void ImageZoom(float newZoom,PointF refPoint)
        {
           
            m_ScaleRefPoint = refPoint;
            float zoomDelta = newZoom - m_zoom_record;
        
           
            m_backRect.Width +=  m_backRect.Width/m_zoom_record*zoomDelta;
            m_backRect.Height +=  m_backRect.Height / m_zoom_record*zoomDelta;
            //锚点缩放补差值计算,得出差值
            float xShiftOld = (m_backRect.X-refPoint.X );
            float yShiftOld = (m_backRect.Y-refPoint.Y );
            float xShift = m_backRect.X-refPoint.X + xShiftOld/m_zoom_record * zoomDelta;
            float yShift = m_backRect.Y-refPoint.Y + yShiftOld/m_zoom_record * zoomDelta;


            //对背景矩形与所有的segment进行修补差值
            m_backRect.X = refPoint.X + xShift;
            m_backRect.Y = refPoint.Y + yShift;


            for (int i = 0; i < m_list_allDPart.Count(); i++)
            {
                DisplayParticle dp = m_list_allDPart[i];

                dp.Zoom(zoomDelta, refPoint);

                PointF ct =dp. GetCenterPoint();
                if (ct.X < -100 || ct.X > this.Width + 100 || ct.Y < -100 || ct.Y > this.Height + 100)
                {
                    dp.SetPaintState(PaintState.NOPAINT);//the particles which are out of screen don't display.to speed up the display efficient.

                }

            }
            if (m_list_allDfield != null)
            {
                if (m_list_allDfield.Count > 0)
                {
                    for (int i = 0; i < m_list_allDfield.Count; i++)
                    {
                        DisplayField theField = m_list_allDfield[i];
                        theField.Zoom(zoomDelta,refPoint);
                      
                    }
                }
            }

            if (m_CurGBFields.Count > 0)
            {

                for (int i = 0; i < m_CurGBFields.Count; i++)
                {
                    var r = m_CurGBFields[i];
                    r.Zoom(zoomDelta, refPoint);

                }

            }

            #region 计算标尺尺寸部份-----放大------
            //计算标尺实际占用像素的宽度
            m_f_ruler_size = m_f_ruler_size + Convert.ToInt32(m_f_old_ruler_size * zoomDelta);//m_f_old_ruler_size
            control_Ruler1.SetValue(m_f_ruler_size, m_pixelSize);
            #endregion
            m_zoom_record = newZoom;
            if (m_zoom_record <= m_f_zoom_mix)
            {
                MoveImageToPoint(new PointF(0, 0));
            }
        }

        protected override void OnMouseWheel(MouseEventArgs e)
        {
            //float zoomDelta;
            float currentZoom;
            if (e.Delta > 0)
            {
               
                    currentZoom=m_zoom_record + const_zoom_increment;
                
            }
            else
            {
               
                    currentZoom=m_zoom_record - const_zoom_increment;
               

            }

          

            if (currentZoom > m_f_zoom_max) currentZoom = m_f_zoom_max;
            if(currentZoom < m_f_zoom_mix) currentZoom=m_f_zoom_mix;


           
            ImageZoom(currentZoom, new PointF(e.X, e.Y));

           
            Invalidate();
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                this.Cursor = Cursors.Hand;

                isReView = false;

                if (m_SelectTool.IsSelecting)
                {
                  
                    m_SelectTool.StartPoint = e.Location;
                }
                else if (m_ParticleSegmentation.IsParticleSegmentation)
                {
                    m_ParticleSegmentation.StartPoint= e.Location;
                }
                else
                {
                    bool ifClickOnParticle=false;
                    foreach (DisplayParticle item in m_list_allDPart)
                    {
                        var dp = item;
                        if (imageDisHelper.WhetherInRange(dp, e.Location))
                        {
                            dp.IsSelect = !dp.IsSelect;
                            ifClickOnParticle = true;
                            break;
                        }
                    }
                    if (ifClickOnParticle == false)
                    { 
                        foreach (DisplayParticle dp in m_list_allDPart)
                        {
                            if (showMode == DISTRIBUTION_IMAGE_SHOW_MODE.ORIGINALCLASSIFIED)
                            {
                                dp.SetPaintState(PaintState.NOPAINT);
                            }


                            PointF ct = dp.GetCenterPoint();
                            if (ct.X > -100 && ct.X < this.Width + 100 && ct.Y > -100 && ct.Y < this.Height + 100)
                            {
                                dp.IsDragging = true;

                            }

                            dp.DraggingPoint = e.Location;
                                                
                            

                        }
                        foreach (DisplayField item in m_list_allDfield)
                        {
                            item.IsDragging = true;
                            item.DraggingPoint = e.Location;
                        }
                        foreach (DisplayField item in m_CurGBFields)
                        {
                            item.IsDragging = true;
                            item.DraggingPoint = e.Location;
                        }
                        m_isDrag = true;
                        m_beforedrag_pointf = e.Location;
                    }

                }
            }
            Invalidate();
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
        
            //当前鼠标的位置,用来绘制鼠标线用
            m_mouse_now_point = e.Location;
            if (m_ParticleSegmentation.IsParticleSegmentation)
            {
                if (e.Button == MouseButtons.Left)
                {
                    m_ParticleSegmentation.EndPoint = e.Location;
                }
            }

            if (m_SelectTool.IsSelecting)
            {
                if (e.Button == MouseButtons.Left)
                {
                    if (e.Location.X > m_SelectTool.StartPoint.X && e.Location.Y > m_SelectTool.StartPoint.Y)
                    {
                        //右下拖动
                        m_SelectTool.Rect = new RectangleF(m_SelectTool.StartPoint, new SizeF(e.Location.X - m_SelectTool.StartPoint.X, e.Location.Y - m_SelectTool.StartPoint.Y));
                    }
                    if (e.Location.X < m_SelectTool.StartPoint.X && e.Location.Y < m_SelectTool.StartPoint.Y)
                    {
                        //左上拖动
                        PointF lspointf = new PointF(e.Location.X, e.Location.Y);
                        m_SelectTool.Rect = new RectangleF(lspointf, new SizeF(m_SelectTool.StartPoint.X - e.Location.X, m_SelectTool.StartPoint.Y - e.Location.Y));
                    }
                    if (e.Location.X > m_SelectTool.StartPoint.X && e.Location.Y < m_SelectTool.StartPoint.Y)
                    {
                        //右上，这种画法，需要将左下，右上两点转换成左上，右下
                        PointF left_pointf = new PointF(m_SelectTool.StartPoint.X, e.Location.Y);
                        PointF right_pointf = new PointF(e.Location.X, m_SelectTool.StartPoint.Y);
                        m_SelectTool.Rect = new RectangleF(left_pointf, new SizeF(right_pointf.X - left_pointf.X, right_pointf.Y - left_pointf.Y));

                    }
                    if (e.Location.X < m_SelectTool.StartPoint.X && e.Location.Y > m_SelectTool.StartPoint.Y)
                    {
                        //左下,这种画法，需要将左下，右上两点转换成左上，右下
                        PointF left_pointf = new PointF(e.Location.X, m_SelectTool.StartPoint.Y);
                        PointF right_pointf = new PointF(m_SelectTool.StartPoint.X, e.Location.Y);
                        m_SelectTool.Rect = new RectangleF(left_pointf, new SizeF(right_pointf.X - left_pointf.X, right_pointf.Y - left_pointf.Y));
                    }
                }
            }          
            else
            {
                if (m_isDrag)
                {
                    foreach (DisplayParticle dp in m_list_allDPart)
                    {
                       
                        if ( dp.IsDragging)
                        {
                            dp.DraggingMove(e.Location);
                         
 
                        }
                    }
                    foreach (var item in m_list_allDfield)
                    {
                        if ( item.IsDragging)
                        {
                           
                            item.DraggingMove(e.Location);
                        }
                    }
                    foreach (var item in m_CurGBFields)
                    {
                        if (item.IsDragging)
                        {

                            item.DraggingMove(e.Location);
                        }
                    }
                    //同样重新计算backrectf的坐标
                    m_backRect = new RectangleF(m_backRect.Location.X + e.X - m_beforedrag_pointf.X,
                         m_backRect.Location.Y + e.Y - m_beforedrag_pointf.Y, m_backRect.Width, m_backRect.Height);
                    m_beforedrag_pointf = e.Location;

                
                }
                else 
                {
                    foreach (DisplayParticle item in m_list_allDPart)
                    {
                        DisplayParticle dp = item;
                        if (dp.GetPaintState() == PaintState.PAINT)
                        {
                            if (imageDisHelper.WhetherInRange(dp, e.Location))
                            {
                                dp.IsMouseOver = true;


                                Point point = CalculateParticleCenterPosition(resultFile, new Point(dp.SEMPosX, dp.SEMPosY), new Point(dp.objParticleData.PosX, dp.objParticleData.PosY));

                         

                                m_ParticleSegmentation.Rectangle = dp.GetShowRect();
                            }
                            else
                            {

                                dp.IsMouseOver = false;


                                HideParticleInfo(dp);
                               
                            }
                        }
                        


                    }
                }
               

              
            }

            #region 向报告程序右下角，传送鼠标颗粒等相关信息
           

            //获取颜色方法1，使用API来获取当前鼠标指向位置的颜色值-----------------------------------------------------
            Color ls_c = GetColorByMousePoint(e.X, e.Y);
            m_str_mouseshow_right = "灰度#" + ls_c.R.ToString();

          

            m_ReportApp.mouseMatter.Text = m_str_mouseshow_right ;
            m_ReportApp.RSGrayVal.Text = m_str_mouseshow_left;

            #endregion

            Invalidate();
        }

        /// <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 = float.Parse(SEMDataMsr["ScanFieldSize"].ToString());
            string leftOrRight = SEMStageData["xAxisDir"].ToString().Split(':')[1];
            string downOrUp = SEMStageData["yAxisDir"].ToString().Split(':')[1];
            string ImageResolution = imageScanParam["ImageResolution"].ToString();
            int width = int.Parse(ImageResolution.Split('_')[1]);
            int height = int.Parse(ImageResolution.Split('_')[2]);
            float ScanFieldSizeY = ScanFieldSizeX * height / width;
            float m_pixelSize = ScanFieldSizeX / width;
            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;
        }

        /// <summary>
        /// 获取鼠标所在位置的信息，显示在框架的右下角
        /// </summary>
        /// <param name="mouseshow_left"></param>
        /// <param name="mouseshow_rightb"></param>
        public void GetMouseLowerRightCornerText(out string mouseshow_left, out string mouseshow_rightb)
        {
            mouseshow_left = m_str_mouseshow_left;
            mouseshow_rightb = m_str_mouseshow_right;
        }

        /// <summary>
        /// 鼠标抬起事件
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseUp(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                this.Cursor = Cursors.Default;
               
                if (m_SelectTool.IsSelecting)
                {
                   
         
                  
                    if (m_SelectTool.Rect.Width > 0 && m_SelectTool.Rect.Height > 0)
                    {
                        GraphicsPath ls_gpath = new GraphicsPath();
                        switch (m_SelectTool.Shape)
                        {
                            case SelectedShape.Rectangle:
                               ls_gpath.AddRectangle(m_SelectTool.Rect);
                                break;
                            case SelectedShape.Ellipse:
                                ls_gpath.AddEllipse(m_SelectTool.Rect);
                                break;
                            default:
                                break;

                        }
                        

                        foreach (DisplayParticle dp in m_list_allDPart)
                        {
                            if (dp.GetPaintState() != PaintState.NOPAINT )
                            {
                                PointF[] lspointf = ls_gpath.PathPoints;
                               
                                    if (true == imageDisHelper.WhetherInRange(m_SelectTool.Rect, lspointf,new Point((int)dp.GetShowRect().X,(int)dp.GetShowRect().Y)))
                                    {
                                    
                                    dp.IsSelect =!dp.IsSelect ;// set the particle to the oposite selected state
                                    }
                              
                            }
                        }
                    }

               
                    m_SelectTool.IsSelecting = false;

                }
                else if(m_ParticleSegmentation.IsParticleSegmentation)
                {
                    m_ParticleSegmentation.EndPoint = e.Location;
                    DialogResult res = MessageBox.Show(table["str11"].ToString(), "", MessageBoxButtons.OKCancel);
                    if (res == DialogResult.OK)
                    {
                        imageDisHelper.m_ParticleSegmentation = m_ParticleSegmentation;
                        bool isTrue = imageDisHelper.isLineIntersectRectangle(m_ParticleSegmentation.StartPoint.X, m_ParticleSegmentation.StartPoint.Y, m_ParticleSegmentation.EndPoint.X, m_ParticleSegmentation.EndPoint.Y,
                            m_ParticleSegmentation.Rectangle.Left, m_ParticleSegmentation.Rectangle.Top, m_ParticleSegmentation.Rectangle.Right, m_ParticleSegmentation.Rectangle.Bottom);

                        if (isTrue)//判断绘制线段是否与颗粒外接矩形相交
                        {
                            List<Point> pointList = new List<Point>();
                            if (imageDisHelper.GetInterBetweenLinesAndRect(m_ParticleSegmentation.StartPoint, m_ParticleSegmentation.EndPoint, m_ParticleSegmentation.Rectangle, ref pointList))
                            {
                                if (pointList.Count != 2)
                                {
                                    MessageBox.Show(table["str12"].ToString());
                                }
                                else
                                {
                                    if (!imageDisHelper.GetSplitPartFun(pointList[0], pointList[1], m_pixelSize))
                                    {
                                        MessageBox.Show(table["str13"].ToString());
                                    }
                                    else
                                    {
                                        FieldData fieldData = new FieldData(resultFile.FilePath);
                                        List<Field> fieldlist = fieldData.GetFieldList();
                                        //resultFile.List_OTSField = fieldlist;
                                        //LoadUpdateDisplay();
                                        m_ReportApp.m_rstDataMgr.CurResultFile.List_OTSField = fieldlist;
                                        m_ReportApp.rbRenewFun(true, m_ParticleSegmentation.ParticleData.FieldId, m_ParticleSegmentation.ParticleData.ParticleId);
                                    }
                                }
                            }   
                        }
                        else
                        {
                            MessageBox.Show(table["str14"].ToString());
                        }
                    }
                    m_ParticleSegmentation.IsParticleSegmentation = false;
                }
                else
                {
                    if (m_isDrag)
                    {
                        
                        foreach (DisplayParticle dp in m_list_allDPart)
                        {
             
                            dp.DraggingMove(e.Location);
                            dp.DraggingPoint = Point.Empty;
                            dp.IsDragging = false;
                 

                            PointF ct = dp.GetCenterPoint();
                            if (ct.X < -100 || ct.X > this.Width + 100 || ct.Y < -100 || ct.Y > this.Height + 100)
                            {
                                dp.SetPaintState(PaintState.NOPAINT);//the particles which are out of screen don't display.to speed up the display efficient.

                            }
                            else
                            {
                                dp.SetPaintState(PaintState.PAINT);
                            }

                        }


                        m_isDrag = false;

                    }
                   
                }
            }


            if (e.Button == MouseButtons.Right)
            {
           
                
                bool ifClickOnParticle=false;
                bool ifThereIsSelectedParticle = false;

               
                foreach (DisplayParticle item in m_list_allDPart)
                {
                    if (true == imageDisHelper.WhetherInRange(item, e.Location))
                    {
                        ifClickOnParticle = true;
                        CMenuStrip.Items[(int)RightButtonMenu.Include].Visible = false;
                       
                        CMenuStrip.Items[(int)RightButtonMenu.CopyImage].Visible = false;
                        CMenuStrip.Items[(int)RightButtonMenu.OriginalSplicing].Visible = false;
                        CMenuStrip.Items[(int)RightButtonMenu.DeleteParticle].Visible = true;
                  

                        CMenuStrip.Items[(int)RightButtonMenu.MoveSEMToParticle].Visible = true;
                        CMenuStrip.Items[(int)RightButtonMenu.MoveSEMToParticle].Tag = item;

                        DisplayParticle dp = (DisplayParticle)item;
                     
                            CMenuStrip.Items[(int)RightButtonMenu.ImportSTDDb].Visible = true;
                     

                        CMenuStrip.Items[(int)RightButtonMenu.ParticleSegmentation].Visible = true;
                        m_ParticleSegmentation.ParticleData = dp.objParticleData;
                    }
                    if (((DisplayParticle)item).IsSelect)
                    {
                        ifThereIsSelectedParticle = true;
                    }
                }
                if (ifClickOnParticle == false)
                {
                    if (ifThereIsSelectedParticle)
                    {

                        CMenuStrip.Items[(int)RightButtonMenu.Include].Visible = true;
                       
                       
                    }
                    else
                    {
                        CMenuStrip.Items[(int)RightButtonMenu.Include].Visible = false;
                       
                       

                    }
                    CMenuStrip.Items[(int)RightButtonMenu.DeleteParticle].Visible = false;
                
                    CMenuStrip.Items[(int)RightButtonMenu.CopyImage].Visible = true;
                    CMenuStrip.Items[(int)RightButtonMenu.OriginalSplicing].Visible = true;
                    CMenuStrip.Items[(int)RightButtonMenu.MoveSEMToParticle].Visible = false;
                    CMenuStrip.Items[(int)RightButtonMenu.ParticleSegmentation].Visible = false;
                    CMenuStrip.Items[(int)RightButtonMenu.ImportSTDDb].Visible = false;
                }
                      

            }

            Invalidate();
        }
        #endregion

        #region 鼠标右键菜单
        private void ToolStripMenuItem_id_Click(object sender, EventArgs e)
        {
            //ID
            //DisplayParticle dp = (DisplayParticle)CMenuStrip.Items[0].Tag;
            //MessageBox.Show(dp.guid.ToString());
        }


        //是否显示过小颗菜单
        private void ToolStripMenuItem_ShowSmallParticle_Click(object sender, EventArgs e)
        {
           
        }


        private void ToolStripMenuItem_selected_Click(object sender, EventArgs e)
        {
            List<DisplayParticle> selectedParts = new List<DisplayParticle>();
            List<Particle> Particles = new List<Particle>();
            foreach (var dp  in m_list_allDPart)
            {
                if (dp.IsSelect)
                {
                    selectedParts.Add((DisplayParticle)dp);
                    Particle particle = new Particle();
                    particle.FieldId = ((OTSIncAReportGraph.DisplayParticle)dp).FieldId;
                    particle.ParticleId = ((OTSIncAReportGraph.DisplayParticle)dp).ParticleId;
                    Particles.Add(particle);
                }
            }

            frmReportApp.selectedRegion = m_SelectTool.Rect; 
           
            SendSelectParticleListToReportFrame(selectedParts);
        }

        /// <summary>
        /// 显示x-ray能谱图
        /// </summary>
        /// <param name="in_dparticle"></param>
        private void ShowParticleInfo(DisplayParticle in_dparticle)
        {

         
            if (delaytimer.Enabled == false)
            {

                m_mouseOver_dparticle = in_dparticle;//将显示xray的dparticle记录给全局变量
                delaytimer.Tick += Delaytimer_Tick;
                delaytimer.Interval = 500;
                delaytimer.Start();

            }
            
           
        }

        private void Delaytimer_Tick(object sender, EventArgs e)
        {
            delaytimer.Enabled = false;

            Point point = CalculateParticleCenterPosition(resultFile, new Point(m_mouseOver_dparticle.SEMPosX, m_mouseOver_dparticle.SEMPosY), new Point(m_mouseOver_dparticle.objParticleData.PosX, m_mouseOver_dparticle.objParticleData.PosY));

            m_str_mouseshow_left = "颗粒SEM位置:" + point.X.ToString() + ":" + point.Y.ToString();
            m_sem_mouse_now_point = point;
            //显示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数据
            imageDisHelper.GetXrayByParticleTagIDAndFieldID_ForDrawDistrbutionImageAndBSE(m_mouseOver_dparticle.ParticleId, m_mouseOver_dparticle.FieldId, 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 = m_mouseOver_dparticle.TypeName;

            Particle particle = resultFile.List_OTSField.Find(x => x.FieldID == m_mouseOver_dparticle.FieldId).ParticleList.Find(x => x.ParticleId == m_mouseOver_dparticle.ParticleId);
            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(Search_xray, Analysis_xray, list_showelementinfo);
            //颗粒国标信息
            control_XRayTable1.GBInfoStr = "";
            control_XRayTable1.MaterialName = str_IncAName;//杂夹物
         
            control_XRayTable1.List_ShowElementInfo = list_showelementinfo;

          
            Invalidate();
           
        }
        /// <summary>
        /// 隐藏x-ray能谱图
        /// </summary>
        private void HideParticleInfo(DisplayParticle in_dparticle)
        {
            if (m_mouseOver_dparticle == null)
                return;
            if (m_mouseOver_dparticle.guid == in_dparticle.guid || m_mouseOver_dparticle.IsDeleted==true)
            {
                //如果是刚才移动过的颗粒的话，那么这里再对xray进行隐藏
                control_XRayTable1.Visible = false;
                delaytimer.Enabled = false;
              
            }
          

        }


        /// <summary>
        /// 根据传入的鼠标位置，来获取当前鼠标位置上的灰度值
        /// </summary>
        /// <param name="int_x"></param>
        /// <param name="int_y"></param>
        /// <returns></returns>
        private Color GetColorByMousePoint(int int_x, int int_y)
        {
            Graphics g = Graphics.FromHwnd(this.Handle);
            IntPtr hdc = g.GetHdc();

            uint u_color = 0;
            try
            {
                u_color = DrawFunction.GetPixel(hdc, int_x, int_y);
            }
            catch
            { }
            Color ls_c = Color.FromArgb
                (
                (int)(u_color << 24 >> 24),
                (int)(u_color << 16 >> 24),
                (int)(u_color << 8 >> 24)
                );

            return ls_c;
        }
        /// <summary>
        /// 封装，将分布图中的颗粒list传送给报告项目框架中
        /// </summary>
        private void SendSelectParticleListToReportFrame(List<DisplayParticle> selectParts)
        {
            //先获取分布图中，有哪些颗粒已经被选择上了
            foreach (var p in selectParts)
            {
                if (!frmReportApp.selectedParticles.ContainsKey(p.guid))
                {
                    frmReportApp.selectedParticles.Add(p.guid, p);
                }
            
            }
           
        }

        /// <summary>
        /// 设置当前对哪些颗粒进行设置为选择状态
        /// </summary>
        /// <param name="in_list_cotsparticleclr"></param>
        public void SetSelectParticle(List<Particle> particles)
        {
            if (particles == null)
            {
                return;
            }
            if (particles.Count == 0)
            {
                return;
            }

            foreach (DisplayParticle ls_dp in m_list_allDPart)
            {
              
                if (ls_dp.GetPaintState() == PaintState.PAINT)
                {
                    for (int i = 0; i < particles.Count; i++)
                    {
                        if (particles[i].ParticleId == ls_dp.ParticleId
                               && particles[i].FieldId == ls_dp.FieldId)
                        {
                            ls_dp.IsSelect=true;
                        }
                    }
                }
            }
        }


        private void ToolStripMenuItem_delete_Click(object sender, EventArgs e)
        {
            List<DisplayParticle> selectedParts = new List<DisplayParticle>();
            foreach (var obj in m_list_allDPart)
            {
              var  dp = (DisplayParticle)obj;
                if (dp.IsSelect)
                {
                    dp.IsDeleted = true;
                }
                else 
                {
                    selectedParts.Add(dp);
                }
   
              

            }
            SendSelectParticleListToReportFrame(selectedParts);
           
        }

        //复制图像
        private void toolStripMenuItem_copyimage_Click(object sender, EventArgs e)
        {
           
            SaveFileDialog sfd = new SaveFileDialog();
          
            sfd.Filter = "png Files(*.png)| *.png |BMP Files(*.bmp)| *.bmp |JPG Files(*.jpg)|*.jpg;*.jpeg";
            if (sfd.ShowDialog() == DialogResult.OK)
            {
                this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
                OutPIC outpic = new OutPIC();
                outpic.m_list_allDfield = m_list_allDfield;
                outpic.resultFile = resultFile;
                outpic.sfd = sfd;
                outpic.type = (int)Outpic_enum.pic;
                outpic.m_ReportApp = m_ReportApp;
                Thread bThread = new Thread(new ThreadStart(outpic.opencv_outpic));

                bThread.IsBackground = true;

                bThread.Start();

            }
           
          
            
        }

        public void msgInform()
        {

           MessageBox.Show("Export completed!");

            this.Cursor = System.Windows.Forms.Cursors.Default;



        }


        private void ToolStripMenuItem_movesempoint_Click(object sender, EventArgs e)
        {
            //移动SEM到指定位置
            if (m_mythread == null)
            {
                return;
            }

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

            if (m_mythread.ThreadState == System.Threading.ThreadState.Stopped)
            {
                m_mythread = new Thread(new ParameterizedThreadStart(Thread_GO));
            }

            //改为线程调用,先判断线程状态
            m_mythread.Start(new Point(m_sem_mouse_now_point.X, m_sem_mouse_now_point.Y));
        }
        #endregion

        #region 自定义功能函数
        /// <summary>
        /// 复制图像
        /// </summary>
        private void CopyImage()
        {
            int height, width;
            width = this.Width;
            height = this.Height;

            Bitmap image = new Bitmap(width, height);
            //this.BackgroundImage
            this.DrawToBitmap(image, new Rectangle(0, 0, width, height));

            Clipboard.SetImage(image);
        }

        /// <summary>
        /// 移动SEM到指定位置线程函数
        /// </summary>
        private void Thread_GO(object in_obj)
        {
      

                Point sem_point = (Point)in_obj;

              


                //第二步，移动到指定位置,先读取再设置
                if (imageDisHelper.ConnectToIpcSvr())
                {

                    imageDisHelper.MoveSemToPointXY(sem_point.X, sem_point.Y);

                }

               

               

        }

        /// <summary>
        /// 按框架传入的底层计算结果，重新对颗粒进行区分显示
        /// </summary>
        /// <param name="in_cgriddataclr"></param>
        public void DrawDistrbutionImageAndBSE_ByQuery(ReportCondition in_griddata)
        {
            FilterParticleByOtherCondition(in_griddata);
            Invalidate();
            this.Refresh();
        }

        /// <summary>
        /// 对分布图进行宽度匹配操作
        /// </summary>
        public void WidthMatch()
        {
            if (this.Width != m_backRect.Width)
            {
                float f_cz = 0;//进行调整的差值
                f_cz = -((m_backRect.Width - this.Width) / m_backRect.Width);

              var  theZoom = m_zoom_record + m_zoom_record * f_cz;//更新上缩放值，与下面处理缩放对应上
                ImageZoom(theZoom, new PointF(0, 0));
            }
           
            MoveImageToPoint(new PointF(0, 0));

        }

        /// <summary>
        /// 对分布图进行高度匹配操作
        /// </summary>
        public void HeightMatch()
        {
            if (this.Height != m_backRect.Height)
            {
                float f_cz = 0;//进行调整的差值
                f_cz = -((m_backRect.Height - this.Height) / m_backRect.Height);

                var currentZoom = m_zoom_record + f_cz;//更新上缩放值，与下面处理缩放对应上
                ImageZoom(currentZoom, new PointF( 0, 0));
            }

            //移动到，this.width - backrectf.width /2
            int ls_x = (int)(this.Width - m_backRect.Width) / 2;
            MoveImageToPoint(new PointF(ls_x, 0));
        }

        /// <summary>
        /// 对分布图进行全图匹配操作
        /// </summary>
        public void FullGraphMatch()
        {
  
                //全图匹配，首先要判断出来是按宽度来计算缩放，还是按高度来计算缩放
                double thiswidth = this.Width;
            double thisheight = this.Height;
            double imagewidth = m_backRect.Width;
            double imageheight = m_backRect.Height;

            //如果宽已相等rect在thisheight范围内，是宽度匹配已经达到目的,或是高已相等rect在thiswidth范围内，是高度匹配已经达到目的
            if ((thiswidth == imagewidth && thisheight > imagewidth) || (thisheight == imageheight && thiswidth > imagewidth))
            {
                //已经达到目的不操作,返回
                return;
            }

            //判断当前是否宽度匹配未达到全图匹配效果
            if (thiswidth == imagewidth && thisheight < imageheight)
            {
                //说明目前已经达到了宽度匹配，但是未能显示完全整图需要高度匹配
                HeightMatch();
                m_f_zoom_mix = m_zoom_record;
                return;

            }

            //判断当前是否高度匹配未达到全图匹配效果
            if (thisheight == imageheight && thiswidth < imagewidth)
            {
                //说明目前已经达到了高度匹配，但是未能显示完全的整图需要宽度匹配
                WidthMatch();
                m_f_zoom_mix = m_zoom_record;
                return;
            }

            ls_d_cz_width = Math.Abs(thiswidth / imagewidth);
            ls_d_cz_height = Math.Abs(thisheight / imageheight);

            //应该是看谁差的倍数大就按谁的进行调整，而不只能看高宽的差值
            if ((1 - ls_d_cz_width) > (1 - ls_d_cz_height))
            {
                //宽差大，就调用WidthMate
                WidthMatch();
            }
            else
            {
                //高差大，则调用HightMate
                HeightMatch();
            }
            m_f_zoom_mix = m_zoom_record;
        }

        /// <summary>
        /// 将整个图像的位置移动到指定的位置上
        /// </summary>
        private void MoveImageToPoint(PointF in_pointf)
        {
          

           
            SizeF offex_p = new SizeF(m_backRect.X - in_pointf.X, m_backRect.Y - in_pointf.Y);

            //同样重新计算backrectf的坐标
            m_backRect = new RectangleF(in_pointf.X, in_pointf.Y,
                 m_backRect.Width, m_backRect.Height);

            for (int i = 0; i < m_list_allDPart.Count; i++)
            {
                DisplayParticle dp = m_list_allDPart[i];              

                dp.Move(offex_p);
      
                PointF ct = dp.GetCenterPoint();
                if (ct.X < -100 || ct.X > this.Width + 100 || ct.Y < -100 || ct.Y > this.Height + 100)
                {
                    dp.SetPaintState(PaintState.NOPAINT);//the particles which are out of screen don't display.to speed up the display efficient.

                }
                else
                {
                    dp.SetPaintState(PaintState.PAINT);
                }
            }
           


            for (int i =0;i< m_list_allDfield.Count;i++)
            {
                var f = m_list_allDfield[i];
                f.Move(offex_p);
         
            }
            for (int i = 0; i < m_CurGBFields.Count; i++)
            {
                var f = m_CurGBFields[i];
                f.Move(offex_p);

            }


            Invalidate();
        }

    


 

        /// <summary>
        /// 是否显示边框格线,自动切换显示与不显示
        /// </summary>
        /// <param name="b_show"></param>
        public void ShowGridLine()
        {
            m_is_showgrid = !m_is_showgrid;
        }

        /// <summary>
        /// 是否显示标尺控件
        /// </summary>
        /// <param name="b_show"></param>
        public void ShowRulerControl()
        {
            control_Ruler1.Visible = !control_Ruler1.Visible;
        }

        /// <summary>
        /// 是否显示边框格线,带参重载
        /// </summary>
        /// <param name="b_show"></param>
        public void ShowGridLine(bool b_show)
        {
            m_is_showgrid = b_show;
        }

        /// <summary>
        /// 是否显示标尺控件,带参重载
        /// </summary>
        /// <param name="b_show"></param>
        public void ShowRulerControl(bool b_show)
        {
            control_Ruler1.Visible = b_show;
        }
        /// <summary>
        /// 颗粒分割
        /// </summary>
        public void Particle_Segmentation()
        {
            m_ParticleSegmentation.IsParticleSegmentation = true;
            m_ParticleSegmentation.StartPoint = new Point();
            m_ParticleSegmentation.EndPoint = new Point();
        }

        /// <summary>
        /// 是否进行矩形多选操作
        /// </summary>
        public void MultiSelect_Rectangle()
        {
 
            m_SelectTool.IsSelecting = true;
            m_SelectTool.Shape = SelectedShape.Rectangle;
            m_SelectTool.Rect = new RectangleF();
            m_SelectTool.Rect.Width = 0;
            m_SelectTool.Rect.Height = 0;
        }

        /// <summary>
        /// 是否进行圆形多选操作
        /// </summary>
        public void MultiSelect_Ellipse()
        {
 
            m_SelectTool.IsSelecting = true;
            m_SelectTool.Shape = SelectedShape.Ellipse;
            m_SelectTool.Rect = new RectangleF();
            m_SelectTool.Rect.Width = 0;
            m_SelectTool.Rect.Height = 0;
        }

        /// <summary>
        /// 对选择的多边形进行反选操作
        /// </summary>
        public void ReverseSelection()
        {
            foreach (DisplayParticle dp in m_list_allDPart)
            {
            
                if (dp.IsSelect)
                {
                    dp.IsSelect = false;
                }
                else
                {
                    dp.IsSelect = true;
                }
            }

           

            this.Invalidate();
        }

        /// <summary>
        /// 取消所有的颗粒的选择状态
        /// </summary>
        public void DeselectAllParticle()
        {
            foreach (DisplayParticle dp in m_list_allDPart)
            {
               
                    dp.IsSelect=false;
                
            }

          

            this.Invalidate();
        }


        

        /// <summary>
        /// 将整个图像拷贝到内存中
        /// </summary>
        public void CopyToBitmap()
        {
            Bitmap bp = new Bitmap(this.Size.Width, this.Size.Height);
            this.DrawToBitmap(bp, new Rectangle(0, 0, this.Size.Width, this.Size.Height));

            Clipboard.SetImage(bp);
        }

        /// <summary>
        /// 设置显示BSE原图，还是显示分布图带有标准库的
        /// </summary>
       
        public void SetShowMode(DISTRIBUTION_IMAGE_SHOW_MODE a_type)
        {

            showMode = a_type;
           

        
            this.Invalidate();
        }

        /// <summary>
        /// 根据传入的颗粒状态，来获取所有该颗粒状态下的数据，用来测试统计使用
        /// </summary>
        /// <param name="str_particlestate"></param>
        /// <returns></returns>
        public int GetParticleNumberByState(PaintState in_ParticleState)
        {
            int icount = 0;
            foreach (DisplayParticle ls_dp in m_list_allDPart)
            {
                if (ls_dp.GetPaintState() == in_ParticleState)
                {
                    icount++;
                }
            }

            return icount;
        }

        /// <summary>
        /// 获取所有原图
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        private void DrawOriginalImageAsBackground(PaintEventArgs args)
        {
          
            
            foreach (var f in m_list_allDfield)
            {

                var curfldrec = f.GetShowRect();
                if (curfldrec.Left > -2000 && curfldrec.Right < this.Width + 2000 && curfldrec.Top > -2000 && curfldrec.Bottom < this.Height + 2000)
                {
                   
                  
                    args.Graphics.DrawImage(f.OriginalImage, curfldrec.X, curfldrec.Y, curfldrec.Width, curfldrec.Height);

                    if (curfldrec.Width>this.Width)// only when zoom to a certain magnification do we display the xray Positon  point as "+"
                    {
                        Graphics g = args.Graphics;
                        for (int i = 0; i < f.List_DParticle.Count; i++)
                        {
                            PointF xrayPos = new PointF(f.List_DParticle[i].objParticleData.PosX, f.List_DParticle[i].objParticleData.PosY);

                            PointF p = new PointF(xrayPos.X / f.OriginalImage.Width * curfldrec.Width + curfldrec.X, xrayPos.Y / f.OriginalImage.Height * curfldrec.Height + curfldrec.Y);
                            g.DrawString("+", new Font("黑体", 6), new SolidBrush(Color.Red), p);
                        }


                    }


                }
               
            }

        }

        
        #endregion

    
     

        private void ExportoriginalspliceToolStripMenuItem_Click(object sender, EventArgs e)
        {
            
            SaveFileDialog sfd = new SaveFileDialog();

            var particledata = new ParticleData(resultFile.FilePath);
            DataTable ParticleAll = particledata.GetParticleTypeInformation();
            DataTable ParticleClass = particledata.GetParticleClassAll();
            //|ALL Files(*.*)|*.*
            //BMP Files(*.bmp)| *.bmp |
            sfd.Filter = "png Files(*.png)| *.png |BMP Files(*.bmp)| *.bmp |JPG Files(*.jpg)|*.jpg;*.jpeg";
            if (sfd.ShowDialog() == DialogResult.OK)
            {
                this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
                OutPIC outpic = new OutPIC();
                outpic.m_list_allDfield = m_list_allDfield;
                outpic.resultFile = resultFile;
                outpic.sfd = sfd;
                outpic.type = (int)Outpic_enum.Render_pic;
                outpic.ParticleData = ParticleAll.Copy();
                outpic.ParticleClassData = ParticleClass.Copy();
                outpic.m_ReportApp = m_ReportApp;
                Thread bThread = new Thread(new ThreadStart(outpic.opencv_outpic));
                bThread.IsBackground = true;
                bThread.Start();
            }
          
        }

        private void ToolStripMenuItemDelete_Particle_Click(object sender, EventArgs e)
        {
            DialogResult dr = MessageBox.Show("Remove all these particles permanently?", "Tips", MessageBoxButtons.OKCancel, MessageBoxIcon.Question);
            if (dr== DialogResult.OK)
            {
                foreach (var p in m_list_allDPart)
                {
                    if (p.IsSelect)
                    {
                        DeleteParticlesFromLibrary(p.objParticleData.ParticleId, p.objParticleData.FieldId);

                        p.IsDeleted = true;
                    }
                  
                
                }
                MessageBox.Show("Deleted successfully");
         
                Invalidate();
            }
            else
            {
                return;
            }
           
        }


        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;
        }
        int GetsIntersectionOfTheIntercepts(Point P1,Point P2,int y)
        {
            int x = (y - P1.Y * P2.X + P1.X * P2.Y) / (P2.Y - P1.Y);
            return x;
        }

    

        private void 分割颗粒ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Particle_Segmentation();
        }

        private void ImportSTDDb_Click(object sender, EventArgs e)
        {
            Dictionary<string, object> sampleMembers = ((Dictionary<string, object>)((Dictionary<string, object>)resultFile.ResultInfo["Sample"])["Members"]);
            string STDName = ((Dictionary<string, object>)sampleMembers["MsrParams"])["STDName"].ToString();
            string ResultDbPath = resultFile.FilePath + "\\FIELD_FILES\\Inclusion.db";
            if (STDName.ToLower().Split('.')[0] == "nostddb")
            {
                OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.Filter = "(*.db)|*.db";
                openFileDialog.RestoreDirectory = true;
                openFileDialog.FilterIndex = 1;
                openFileDialog.Title = "Please choose a STD to add the rule!";
                if (openFileDialog.ShowDialog() == DialogResult.OK)
                {
                    try
                    {
                        string arguments = openFileDialog.FileName;
                        foreach (DisplayParticle item in m_list_allDPart)
                        {
                            DisplayParticle dp = item;

                            if (imageDisHelper.WhetherInRange(dp, m_mouse_now_point))
                            {
                                arguments += " " + ResultDbPath + " " + dp.FieldId + " " + dp.ParticleId + " " + dp.XRayId;
                                break;
                            }
                        }

                        System.Diagnostics.Process p = System.Diagnostics.Process.Start(".\\OTSPartA_STDEditor.exe", arguments);
                        p.WaitForExit();
                    }
                    catch (Exception ex)
                    {
                        log.Error("OTSPartA_STDEditor:" + ex.ToString());
                    }
                }
            }
            else
            {
                string arguments = ".\\Config\\SysData\\"+ STDName.Split('.')[0]+".db";
                foreach (DisplayParticle item in m_list_allDPart)
                {
                    DisplayParticle dp = item;

                    if (imageDisHelper.WhetherInRange(dp, m_mouse_now_point))
                    {
                        arguments += " " + ResultDbPath + " " + dp.FieldId + " " + dp.ParticleId + " " + dp.XRayId;
                        break;
                    }
                }

                System.Diagnostics.Process p = System.Diagnostics.Process.Start(".\\OTSPartA_STDEditor.exe", arguments);
                p.WaitForExit();
            }
        }

        private void 显示国标信息ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;
            m_CurGBFields.Clear();
            int index = m_ReportApp.m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.DATA_SOURCE);

            for (int i = 0; i < m_ReportApp.m_rstDataMgr.ResultFilesList.Count; i++)
            {
                string anothername = m_ReportApp.m_rstDataMgr.ResultFilesList[i].anotherFileName.ToString();
                string resultfile = m_ReportApp.m_rstDataMgr.ResultFilesList[i].FilePath.ToString() + "\\" + m_ReportApp.m_rstDataMgr.ResultFilesList[i].FileName_real.ToString();
                m_ReportApp.m_rstDataMgr.m_ReportMgr.AddASmplMsrResultMgr(resultfile, anothername);
            }
            OTSCLRINTERFACE.CPropParamClr clr_prop = m_ReportApp.m_rstDataMgr.m_ReportMgr.GetPropertyParamTable();
            List<string> datasourcelist = m_ReportApp.m_conditionChoose.m_conditionData.GetComboDownListByItemName(OTS_REPORT_PROP_GRID_ITEMS.DATA_SOURCE);
           
            clr_prop.SetDataSourceList(datasourcelist);
            clr_prop.SetDataSourceId(index);//

            clr_prop.SetType((int)DisplayPicutureType.AnalyzeDataTable);//table
                        

            DataTable tbl;//
            var menuItm = (ToolStripMenuItem)sender;
            string tag = menuItm.Tag.ToString();
            switch (tag)
            {
                case "All1":
                    clr_prop.SetCalTableType((int)CALCULATE_TABLE_TYPE.GB_Method1);
                    tbl = m_ReportApp.m_rstDataMgr.m_ReportMgr.GetAllGBFields(clr_prop);
                    break;
                case "DS1":
                    clr_prop.SetCalTableType((int)CALCULATE_TABLE_TYPE.GB_Method1);
                    tbl = m_ReportApp.m_rstDataMgr.m_ReportMgr.GetGBDSParticles(clr_prop);
                    break;
                case "All2":
                    clr_prop.SetCalTableType((int)CALCULATE_TABLE_TYPE.GB_Method2);
                    tbl = m_ReportApp.m_rstDataMgr.m_ReportMgr.GetAllGBFields(clr_prop);
                    break;
                case "DS2":
                    clr_prop.SetCalTableType((int)CALCULATE_TABLE_TYPE.GB_Method2);
                    tbl = m_ReportApp.m_rstDataMgr.m_ReportMgr.GetGBDSParticles(clr_prop);
                    break;
                case "ASTMAll":
                    clr_prop.SetCalTableType((int)CALCULATE_TABLE_TYPE.ASTM);
                    tbl = m_ReportApp.m_rstDataMgr.m_ReportMgr.GetAllGBFields(clr_prop);
                    break;

                default:
                    tbl = new DataTable();
                    break;



            }
           
            if (tag == "All1" || tag == "All2" || tag=="ASTMAll")
            {
                if (tbl.Rows.Count > 0)
                {
                    foreach (DataRow r in tbl.Rows)
                    {
                        Point p = new Point(Convert.ToInt32(r["fieldX"]), Convert.ToInt32(r["fieldY"]));
                       
                        Point screenP = imageDisHelper.ConvertOTSCoordToScreenCoord(p);

                        int gbfldwidth = Convert.ToInt32(710.0 / imageDisHelper.m_pixelSize);
                       

                        var df = new DisplayField(gbfldwidth, gbfldwidth, screenP);

                        
                        df.Zoom(m_zoom_record - 1, new PointF(0, 0));

                        

                        df.Move(new SizeF(-m_backRect.X,-m_backRect.Y));

                        int topgrade = Convert.ToInt32(r["topGrade"]);
                        switch (topgrade)
                        {
                            case 0:
                                df.ContentColor = Color.White;
                                break;
                            case 1:
                                df.ContentColor = Color.DarkGray;
                                break;
                            case 2:
                                df.ContentColor = Color.Purple;
                                break;
                            case 3:
                                df.ContentColor = Color.Blue;
                                break;
                            case 4:
                                df.ContentColor = Color.Red;
                                break;
                            case 5:
                                df.ContentColor = Color.Red;
                                break;
                            default:
                                df.ContentColor = Color.Red;
                                break;

                        }

                       
                        string grade = r["grade"].ToString();
                        df.gradeString = grade;
                        m_CurGBFields.Add(df);
                    }


                }

            }
            else if (tag == "DS1" || tag == "DS2")
            {
                if (tbl.Rows.Count > 0)
                {
                    foreach (DataRow r in tbl.Rows)
                    {
                        int fid = Convert.ToInt32(r["fieldId"]);
                        int pid = Convert.ToInt32(r["particleId"]);
                        foreach (var p in m_list_allDPart)
                        {
                            if (p.objParticleData.FieldId == fid && p.objParticleData.ParticleId == pid)
                            {
                                p.IsSelect = true;
                                break;
                            }
                        
                        }
                    }
                }
            }
            Cursor = Cursors.Default;
            
            Invalidate();
        }

       

        private void 清除ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            m_CurGBFields.Clear();
            Invalidate();
        }

        private void ToolStripMenuItem_ParticleSplicing_Click(object sender, EventArgs e)
        {
            SaveFileDialog sfd = new SaveFileDialog();

            sfd.Filter = "png Files(*.png)| *.png |BMP Files(*.bmp)| *.bmp |JPG Files(*.jpg)|*.jpg;*.jpeg";
            if (sfd.ShowDialog() == DialogResult.OK)
            {
                this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
                OutPIC outpic = new OutPIC();
                outpic.m_list_allDfield = m_list_allDfield;
                outpic.resultFile = resultFile;
                outpic.sfd = sfd;
                outpic.type = (int)Outpic_enum.noBackground_pic;
                outpic.m_ReportApp = m_ReportApp;
                Thread bThread = new Thread(new ThreadStart(outpic.opencv_outpic));

                bThread.IsBackground = true;

                bThread.Start();

            }
        }
    }
}