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

using NLog;
using OTSCLRINTERFACE;
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 OTSMeasureApp._0_OTSModel.OTSDataType;
using OTSPeriodicTable;

using System;
using System.Collections;
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
    {
        CopyImage = 0,
        OriginalSplicing = 1
    }
    /// <summary>
    /// 选择导出的图片是原图还是颗粒渲染后的图片
    /// </summary>
    public enum Outpic_enum
    {
        pic = 0,
        Render_pic = 1,
        noBackground_pic = 2,
        GBOne = 3,
        ColoredParticles=4,
        Combin,
        Render_Combin
    }

    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 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<DisplayRectangle> m_list_allDfield = null;


        //这里要做成控件，不要是窗体
        public List<DisplayParticle> m_list_allDPart_original = null;
        public List<DisplayRectangle> m_CurGBFields = new List<DisplayRectangle>();
        public List<DisplayRectangle> m_CurGBParticles = new List<DisplayRectangle>();

        //总背景矩形
        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();

        Point m_currentMouseDownPoint;
        //记录当前鼠标位置对应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;

        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; }
        }



        //进度条窗体
        public Frm_UserProgress m_frm_userprogress;


        Hashtable resTable;


        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<DisplayRectangle>();

            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);

            Language language = new Language(this);
            resTable = language.GetNameTable(this.Name.ToString());

        }
        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();
            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...");

                PointF thisfield_point = new PointF() { X = fieldlist[i].FieldPosX, Y = fieldlist[i].FieldPosY };//get OTS coordination

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

                    df = new DisplayRectangle(fieldlist[i], fieldSize.Width,fieldSize.Height, resultFile.GetPixelSize(), offset_point);
                    df.ContentColor = Color.Black;
                    m_list_allDfield.Add(df);
                }
                catch (Exception ex)
                {
                    NLog.LogManager.GetCurrentClassLogger().Info(ex.ToString());
                }
            }
            m_list_allDPart_original = new List<DisplayParticle>();
            foreach (var fil in m_list_allDfield)
            {
                foreach (var apart in fil.List_DParticle)
                {
                    m_list_allDPart_original.Add(apart.Clone() as DisplayParticle);
                }
            }

            m_pixelSize = resultFile.GetPixelSize();
            //设置标尺
            //根据f_onepixel_size计算出要显示出100um的实际宽度
            float d_onefixel_width = 100 / m_pixelSize;
            if (d_onefixel_width == 0)
            {
                this.control_Ruler1.Visible = false;
            }
            else
            {
                m_f_ruler_size = d_onefixel_width;
                m_f_old_ruler_size = d_onefixel_width;
                //将标尺定位到合理的位置上
                this.control_Ruler1.Location = new Point(10, MyPrimaryScreen.WorkingArea.Height - 300);
                this.control_Ruler1.Visible = true;
                if (d_onefixel_width > MyPrimaryScreen.WorkingArea.Width /2)
                {
                    if (d_onefixel_width / 10 > MyPrimaryScreen.WorkingArea.Width/2)
                    {
                        this.control_Ruler1.SetValue(d_onefixel_width / 100);
                        m_f_ruler_size = d_onefixel_width / 100;
                        m_f_old_ruler_size = d_onefixel_width / 100;
                        this.control_Ruler1.ShowString = Convert.ToInt32(1).ToString() + "μm";
                    }
                    else
                    {
                        this.control_Ruler1.SetValue(d_onefixel_width / 10);
                        m_f_ruler_size = d_onefixel_width / 10;
                        m_f_old_ruler_size = d_onefixel_width / 10;
                        this.control_Ruler1.ShowString = Convert.ToInt32(10).ToString() + "μm";
                    }
                }
                else
                {
                    this.control_Ruler1.SetValue(m_f_ruler_size);
                    this.control_Ruler1.ShowString = Convert.ToInt32(100).ToString() + "μm";
                }
                this.control_Ruler1.Visible = true;
            }
            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 (DisplayRectangle a_field in m_list_allDfield)
            {
                foreach (DisplayParticle ls_dp in a_field.List_DParticle)
                {
                    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 (DisplayRectangle a_field in m_list_allDfield)
                    {
                        foreach (DisplayParticle dp in a_field.List_DParticle)
                        {
                            //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 (DisplayRectangle a_field in m_list_allDfield)
                    {
                        foreach (DisplayParticle dp in a_field.List_DParticle)
                        {
                            dp.ShowMode = SegmentShowMode.DRAWLINE;

                            if (dp.GetPaintState() != PaintState.NOPAINT)
                            {
                                dp.OnPaint(e);
                            }
                        }
                    }
                    break;
                case DISTRIBUTION_IMAGE_SHOW_MODE.ORIGINAl:
                    foreach (DisplayRectangle a_field in m_list_allDfield)
                    {
                        foreach (DisplayParticle ls_dp in a_field.List_DParticle)
                        {
                            ls_dp.SetDisplayState(DisplayState.NODISPLAY);
                        }
                    }
                    DrawOriginalImageAsBackground(e);
                    break;
                case DISTRIBUTION_IMAGE_SHOW_MODE.ORIGINALCLASSIFIED:
                    DrawOriginalImageAsBackground(e);
                    foreach (DisplayRectangle a_field in m_list_allDfield)
                    {
                        foreach (DisplayParticle dp in a_field.List_DParticle)
                        {
                            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);
                }
            }
            if (m_CurGBParticles.Count > 0)
            {
                foreach (var f in m_CurGBParticles)
                {
                    f.OnPaint(e, Color.Blue);
                }
            }
            #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;

            foreach (DisplayRectangle a_field in m_list_allDfield)
            {
                for (int i = 0; i < a_field.List_DParticle.Count(); i++)
                {
                    DisplayParticle dp = a_field.List_DParticle[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++)
                    {
                        DisplayRectangle 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);

                }

            }
            if (m_CurGBParticles.Count > 0)
            {

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

                }

            }

            #region 计算标尺尺寸部份-----放大------
            //计算标尺实际占用像素的宽度
            m_f_ruler_size = m_f_ruler_size + m_f_old_ruler_size * zoomDelta;//m_f_old_ruler_size
            control_Ruler1.SetValue(m_f_ruler_size);
            #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 (DisplayRectangle a_field in m_list_allDfield)
                    {
                        if (imageDisHelper.WhetherInRange(a_field, e.Location))
                        {
                            foreach (DisplayParticle item in a_field.List_DParticle)
                            {
                                var dp = item;
                                if (imageDisHelper.WhetherInRange(dp, e.Location))
                                {
                                    dp.IsSelect = !dp.IsSelect;
                                    ifClickOnParticle = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (ifClickOnParticle == false)
                    {
                        foreach (DisplayRectangle item in m_list_allDfield)
                        {
                            item.IsDragging = true;
                            item.DraggingPoint = e.Location;
                            foreach (DisplayParticle dp in item.List_DParticle)
                            {
                                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 (DisplayRectangle item in m_CurGBFields)
                        {
                            item.IsDragging = true;
                            item.DraggingPoint = e.Location;
                        }
                        foreach (DisplayRectangle item in m_CurGBParticles)
                        {
                            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 (var item in m_list_allDfield)
                    {
                        if (item.IsDragging)
                        {
                            item.DraggingMove(e.Location);
                        }
                        foreach (DisplayParticle dp in item.List_DParticle)
                        {
                            if (dp.IsDragging)
                            {
                                dp.DraggingMove(e.Location);
                            }
                        }
                    }
                    foreach (var item in m_CurGBFields)
                    {
                        if (item.IsDragging)
                        {

                            item.DraggingMove(e.Location);
                        }
                    }
                    foreach (var item in m_CurGBParticles)
                    {
                        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 (DisplayRectangle a_field in m_list_allDfield)
                    {

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



                                    ShowParticleInfo(dp);

                                    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();
            float ScanFieldSizeX = resultFile.GetScanFieldSizeX();
            string leftOrRight = resultFile.GetXAxisDir();
            string downOrUp = resultFile.GetYAxisDir();

            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;
        }

        /// <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 (DisplayRectangle a_field in m_list_allDfield)
                        {
                            foreach (DisplayParticle dp in a_field.List_DParticle)
                            {
                                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 = true;//框选
                                    }

                                }
                            }
                        }
                    }


                    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();

                                        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 (DisplayRectangle a_field in m_list_allDfield)
                        {
                            foreach (DisplayParticle dp in a_field.List_DParticle)
                            {

                                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)
            {
                m_currentMouseDownPoint = e.Location;
                
                bool ifClickOnParticle = false;

                
                foreach (DisplayRectangle a_field in m_list_allDfield)
                {
                    if (imageDisHelper.WhetherInRange(a_field, e.Location))
                    {
                        foreach (DisplayParticle item in a_field.List_DParticle)
                        {
                            if (true == imageDisHelper.WhetherInRange(item, e.Location))
                            {
                                ifClickOnParticle = true;
                                CMenuStrip.Visible = false;

                                //CMenuStrip.Items[(int)RightButtonMenu.CopyImage].Visible = false;
                                //CMenuStrip.Items[(int)RightButtonMenu.OriginalSplicing].Visible = false;
                                contextMenuStrip_Particle.Visible = true;
                                contextMenuStrip_Particle.Show(this, e.Location);
                                ToolStripMenuItem_movesempoint.Tag = item;

                                DisplayParticle dp = (DisplayParticle)item;
                                dp.IsSelect = true;
                                m_ParticleSegmentation.ParticleData = dp.objParticleData;
                            }
                        }
                    }
                }
                if (ifClickOnParticle == false)
                {
                    contextMenuStrip_Particle.Visible = false;

                    CMenuStrip.Items[(int)RightButtonMenu.CopyImage].Visible = true;
                    CMenuStrip.Items[(int)RightButtonMenu.OriginalSplicing].Visible = true;
                }
                var m_RptConfigFile = RptConfigFile.GetRptConfig();         //报表程序的配置文件
                if (m_RptConfigFile.Systype == OTS_SysType_ID.CleannessA)
                {
                    显示国标信息ToolStripMenuItem.Visible = false;
                    国标图导出ToolStripMenuItem.Visible = false;
                }

                if(Control.ModifierKeys==Keys.Shift)
                {
                    toolStripMenuItem_backgroundcombin.Visible = true;
                    toolStripMenuItem_backgroundcombinClass.Visible = true;
                }
                else
                {
                    toolStripMenuItem_backgroundcombin.Visible = false;
                    toolStripMenuItem_backgroundcombinClass.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)
        {

        }

        /// <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 = 100;
                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>
        /// 设置当前对哪些颗粒进行设置为选择状态
        /// </summary>
        /// <param name="in_list_cotsparticleclr"></param>
        public void SetSelectParticle(List<Particle> particles)
        {
            if (particles == null)
            {
                return;
            }
            if (particles.Count == 0)
            {
                return;
            }
            foreach (DisplayRectangle a_field in m_list_allDfield)
            {
                for (int i = 0; i < particles.Count; i++)
                {
                    if (particles[i].FieldId.ToString() == a_field.FieldID)
                    {
                        foreach (DisplayParticle ls_dp in a_field.List_DParticle)
                        {
                            if (ls_dp.GetPaintState() == PaintState.PAINT)
                            {
                                if (particles[i].ParticleId == ls_dp.ParticleId)
                                {
                                    ls_dp.IsSelect = true;
                                }
                            }
                        }
                    }
                }
            }
        }

        
        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();
            //}
            SaveFileDialog sfd = new SaveFileDialog();

            var particledata = new ParticleData(resultFile.FilePath);
            DataTable ParticleAll = particledata.GetParticleTypeInformation();
            DataTable ParticleClass = particledata.GetParticleClassAll();

            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;
                ImageExporter outpic = new ImageExporter();
                outpic.m_list_allDfield = m_list_allDfield;
                outpic.resultFile = resultFile;
                outpic.ParticleData = ParticleAll.Copy();
                outpic.ParticleClassData = ParticleClass.Copy();
                outpic.pixelSize = imageDisHelper.m_pixelSize;
                outpic.sfd = sfd;
                outpic.type = (int)Outpic_enum.ColoredParticles;
                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);
            foreach (DisplayRectangle a_field in m_list_allDfield)
            {
                for (int i = 0; i < a_field.List_DParticle.Count; i++)
                {
                    DisplayParticle dp = a_field.List_DParticle[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);

            }
            for (int i = 0; i < m_CurGBParticles.Count; i++)
            {
                var f = m_CurGBParticles[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 (DisplayRectangle a_field in m_list_allDfield)
            {
                foreach (DisplayParticle dp in a_field.List_DParticle)
                {

                    if (dp.IsSelect)
                    {
                        dp.IsSelect = false;
                    }
                    else
                    {
                        dp.IsSelect = true;
                    }
                }
            }



            this.Invalidate();
        }

        /// <summary>
        /// 取消所有的颗粒的选择状态
        /// </summary>
        public void DeselectAllParticle()
        {
            foreach (DisplayRectangle a_field in m_list_allDfield)
            {
                foreach (DisplayParticle dp in a_field.List_DParticle)
                {

                    dp.IsSelect = false;

                }
            }
            m_CurGBParticles.Clear();


            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 (DisplayRectangle a_field in m_list_allDfield)
            {
                foreach (DisplayParticle dp in a_field.List_DParticle)
                {
                    if (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;
                ImageExporter outpic = new ImageExporter();
                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 (DisplayRectangle a_field in m_list_allDfield)
                {
                    foreach (var p in a_field.List_DParticle)
                    {
                        if (p.IsSelect)
                        {
                            DeleteParticlesFromLibrary(p.objParticleData.ParticleId, p.objParticleData.FieldId);

                            p.IsDeleted = true;
                        }


                    }
                }
                MessageBox.Show("Deleted successfully");

                Invalidate();
            }
            else
            {
                return;
            }

        }

        public void DeletesParticlesSynchronously(List<Particle> list_Part)
        {
            foreach (DisplayRectangle a_field in m_list_allDfield)
            {
                foreach (var p_Selected in list_Part)
                {
                    if (int.Parse(a_field.FieldID) == p_Selected.FieldId)
                    {
                        foreach (var p in a_field.List_DParticle)
                        {
                            if (p.ParticleId == p_Selected.ParticleId)
                            {
                                p.IsDeleted = true;
                                break;
                            }
                        }
                    }
                }
            }
            Invalidate();
        }

        public 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;
            }
        }
        public bool WhetherThereAreDeleteParticles()
        {
            foreach (DisplayRectangle a_field in m_list_allDfield)
            {
                foreach (var p in a_field.List_DParticle)
                {
                    if (p.IsDeleted)
                    {
                        return true;
                    }
                }
            }

            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)
        {
            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)
                    {
                        PointF p = new PointF(Convert.ToSingle( r["fieldX"]),Convert.ToSingle(r["fieldY"]));

                        PointF screenP = imageDisHelper.ConvertOTSCoordToScreenCoord(p);

                        float gbfldwidth = (float)((float)710.0 / imageDisHelper.m_pixelSize);


                        var df = new DisplayRectangle(gbfldwidth, gbfldwidth, p, 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["gradeDetail"].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"]);
                        string pid =Convert.ToString( r["particleId"]);
                        string[] partid = pid.Split(':');
                        foreach (DisplayRectangle a_field in m_list_allDfield)
                        {
                            if (int.Parse(a_field.FieldID) == fid)
                            {
                                foreach (var p in a_field.List_DParticle)
                                {
                                    if (p.objParticleData.ParticleId == Convert.ToInt32( partid[1]))
                                    {
                                        p.IsSelect = true;
                                        break;
                                    }

                                }
                            }
                        }
                    }
                }
            }
            Cursor = Cursors.Default;

            Invalidate();
        }



        private void 清除ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            m_CurGBFields.Clear();
            m_CurGBParticles.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;
                ImageExporter outpic = new ImageExporter();
                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;

                outpic.pixelSize = imageDisHelper.m_pixelSize;
                Thread bThread = new Thread(new ThreadStart(outpic.opencv_outpic));

                bThread.IsBackground = true;

                bThread.Start();

            }
        }

        protected override bool ProcessDialogKey(Keys keyData)
        {
            if (keyData == Keys.Escape)
            {
                DeselectAllParticle();  
                return false;
            }
            if (keyData == Keys.Delete)
            {
                DialogResult dr = MessageBox.Show("Remove all these particles permanently?", "Tips", MessageBoxButtons.OKCancel, MessageBoxIcon.Question);
                if (dr == DialogResult.OK)
                {
                    bool deleteflag = true;

                    foreach (DisplayRectangle a_field in m_list_allDfield)
                    {
                        foreach (var p in a_field.List_DParticle)
                        {
                            if (p.IsSelect)
                            {
                                if (!DeleteParticlesFromLibrary(p.objParticleData.ParticleId, p.objParticleData.FieldId))
                                {
                                    deleteflag = false;
                                }
                                p.IsDeleted = true;
                            }
                        }
                    }
                        if (deleteflag)
                        {
                            MessageBox.Show("Deleted successfully!");
                        }
                        else
                        {
                            MessageBox.Show("Deleted failed!");
                        }

                    Invalidate();
                }
                else
                {

                }
            }
            return base.ProcessDialogKey(keyData);
        }

        private void toolStripMenuItem_Segmentation_Click(object sender, EventArgs e)
        {
            Particle_Segmentation();
        }

        private void toolStripMenuItem_combinClass_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;
                ImageExporter outpic = new ImageExporter();
                outpic.m_list_allDfield = m_list_allDfield;
                outpic.resultFile = resultFile;
                outpic.sfd = sfd;
                outpic.type = (int)Outpic_enum.Render_pic;
                outpic.m_ReportApp = m_ReportApp;
                Thread bThread = new Thread(new ThreadStart(outpic.opencv_outpic));

                bThread.IsBackground = true;

                bThread.Start();

            }
        }

        private void toolStripMenuItem_combin_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;
                ImageExporter outpic = new ImageExporter();
                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();

            }
        }

        private void 显示当前帧国标分类ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            
        }
        DataTable GetAllPartsOfCurrentGBField()
        {
            DataTable tbl;//
            if (m_CurGBFields.Count == 0)
            {

                return new DataTable();

            }
            int index = m_ReportApp.m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.DATA_SOURCE);

            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
            DisplayRectangle curfld = new DisplayRectangle(1024,768,new Point(0,0),new Point(0,0));
            foreach (var f in m_CurGBFields)
            {
                if (imageDisHelper.WhetherInRange(f, m_currentMouseDownPoint))
                {
                    curfld = f;
                }
            }


           
           

            clr_prop.SetCalTableType((int)CALCULATE_TABLE_TYPE.GB_Method1);
            tbl = m_ReportApp.m_rstDataMgr.m_ReportMgr.GetAllParticlesOfOneGBField(clr_prop, curfld.OTSCoordinatePos.X, curfld.OTSCoordinatePos.Y);
            return tbl;

        }
        private void 全部ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;
            ////m_CurGBFields.Clear();
            //var tbl = GetAllPartsOfCurrentGBField();
            //if (tbl.Rows.Count > 0)
            //{
            //    foreach (DataRow r in tbl.Rows)
            //    {
            //        int fid = Convert.ToInt32(r["fieldId"]);
            //        int pid = Convert.ToInt32(r["particleId"]);
            //        foreach (DisplayRectangle a_field in m_list_allDfield)
            //        {
            //            if (int.Parse(a_field.FieldID) == fid)
            //            {
            //                foreach (var p in a_field.List_DParticle)
            //                {
            //                    if (p.objParticleData.ParticleId == pid)
            //                    {
            //                        p.IsSelect = true;
            //                        break;
            //                    }
            //                }
            //            }
            //        }
            //    }
            //}
            DisplayGBParticles("A");
            DisplayGBParticles("B");
            DisplayGBParticles("C");
            DisplayGBParticles("D");

            Cursor = Cursors.Default;

            Invalidate();
        }
        private void DisplayGBParticles(string parttype)
        {
            var tbl = GetAllPartsOfCurrentGBField();

            if (tbl.Rows.Count > 0)
            {
                foreach (DataRow r in tbl.Rows)
                {
                    int fid = Convert.ToInt32(r["fieldId"]);
                    string pid = Convert.ToString(r["particleId"]);
                    string[] GBpartsid = pid.Split(' ');
                    var typestr = Convert.ToString(r["gbClassify"]);
                    List<DisplayParticle> parts = new List<DisplayParticle>();
                    if (typestr == parttype)
                    {
                        foreach (DisplayRectangle a_field in m_list_allDfield)
                        {

                            foreach (var p1 in a_field.List_DParticle)
                            {
                                string partid = a_field.FieldID.ToString() + ":" + p1.objParticleData.ParticleId.ToString();
                                if (GBpartsid.Contains(partid))
                                {

                                    parts.Add(p1);

                                }

                            }
                        }
                        var pfirst = parts[0];
                        float top = pfirst.OTSRect.GetTopLeft().Y;
                        float bottom = pfirst.OTSRect.GetBottomRight().Y;
                        float left = pfirst.OTSRect.GetTopLeft().X;
                        float right = pfirst.OTSRect.GetBottomRight().X;
                        foreach (var p2 in parts)
                        {
                            if (p2.OTSRect.GetTopLeft().Y > top)
                            {
                                top = p2.OTSRect.GetTopLeft().Y;
                            }
                            if (p2.OTSRect.GetTopLeft().X < left)
                            {
                                left = p2.OTSRect.GetTopLeft().X;
                            }
                            if (p2.OTSRect.GetBottomRight().X > right)
                            {
                                right = p2.OTSRect.GetBottomRight().X;
                            }
                            if (p2.OTSRect.GetBottomRight().Y < bottom)
                            {
                                bottom = p2.OTSRect.GetBottomRight().Y;
                            }
                        }
                        COTSRect rec = new COTSRect(left, top, right, bottom);


                        PointF otsPos = new PointF(rec.GetCenterPoint().X, rec.GetCenterPoint().Y);
                        PointF screenP = imageDisHelper.ConvertOTSCoordToScreenCoord(otsPos);

                        double gbpartwidth = ((right - left) / imageDisHelper.m_pixelSize);
                        double gbpartheight = ((top - bottom) / imageDisHelper.m_pixelSize);


                        var gbprec = new DisplayRectangle((float)gbpartwidth, (float)gbpartheight, otsPos, screenP);


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



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


                        m_CurGBParticles.Add(gbprec);
                    }

                }
            }

        }
        private void aToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;

            DisplayGBParticles("A");

            Cursor = Cursors.Default;

            Invalidate();
        }

        private void bToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;
            DisplayGBParticles("B");

            Cursor = Cursors.Default;

            Invalidate();
        }

        private void cToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;

            DisplayGBParticles("C");

            Cursor = Cursors.Default;

            Invalidate();
        }

        private void dToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;

            DisplayGBParticles("D");

            Cursor = Cursors.Default;

            Invalidate();
        }
        private DataTable GetGBDataTable(object sender, int met)
        {
            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;//
            clr_prop.SetCalTableType(met);
            tbl = m_ReportApp.m_rstDataMgr.m_ReportMgr.GetAllGBFields(clr_prop);
            return tbl;
        }
        private void 方法一ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveFileDialog sfd = new SaveFileDialog();

            var particledata = new ParticleData(resultFile.FilePath);
            DataTable ParticleAll = particledata.GetParticleTypeInformation();
            DataTable ParticleClass = particledata.GetParticleClassAll();


            sfd.Filter = "png Files(*.png)| *.png |BMP Files(*.bmp)| *.bmp |JPG Files(*.jpg)|*.jpg;*.jpeg";
            if (sfd.ShowDialog() == DialogResult.OK)
            {
                var datd = GetGBDataTable(sender, (int)CALCULATE_TABLE_TYPE.GB_Method1);
                this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
                ImageExporter outpic = new ImageExporter();
                outpic.GBDatatableOne = datd;
                outpic.GridLength = Convert.ToInt32(710.0 / imageDisHelper.m_pixelSize);

                outpic.pixelSize = imageDisHelper.m_pixelSize;

                outpic.ParticleData = ParticleAll.Copy();
                outpic.ParticleClassData = ParticleClass.Copy();

                outpic.m_list_allDfield = m_list_allDfield;
                outpic.resultFile = resultFile;
                outpic.sfd = sfd;
                outpic.type = (int)Outpic_enum.GBOne;
                outpic.m_ReportApp = m_ReportApp;
                Thread bThread = new Thread(new ThreadStart(outpic.opencv_outpic));
                bThread.IsBackground = true;
                bThread.Start();

            }
        }

        private void 方法二ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveFileDialog sfd = new SaveFileDialog();

            var particledata = new ParticleData(resultFile.FilePath);
            DataTable ParticleAll = particledata.GetParticleTypeInformation();
            DataTable ParticleClass = particledata.GetParticleClassAll();

            sfd.Filter = "png Files(*.png)| *.png |BMP Files(*.bmp)| *.bmp |JPG Files(*.jpg)|*.jpg;*.jpeg";
            if (sfd.ShowDialog() == DialogResult.OK)
            {
                var datd = GetGBDataTable(sender, (int)CALCULATE_TABLE_TYPE.GB_Method2);
                this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
                ImageExporter outpic = new ImageExporter();
                outpic.GBDatatableOne = datd;
                outpic.GridLength = Convert.ToInt32(710.0 / imageDisHelper.m_pixelSize);
                outpic.m_list_allDfield = m_list_allDfield;
                outpic.resultFile = resultFile;
                outpic.sfd = sfd;
                outpic.type = (int)Outpic_enum.GBOne;
                outpic.m_ReportApp = m_ReportApp;
                

                outpic.ParticleData = ParticleAll.Copy();
                outpic.ParticleClassData = ParticleClass.Copy();

                Thread bThread = new Thread(new ThreadStart(outpic.opencv_outpic));
                bThread.IsBackground = true;
                bThread.Start();

            }
        }

        private void aSTMToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            SaveFileDialog sfd = new SaveFileDialog();
            var particledata = new ParticleData(resultFile.FilePath);
            DataTable ParticleAll = particledata.GetParticleTypeInformation();
            DataTable ParticleClass = particledata.GetParticleClassAll();
            sfd.Filter = "png Files(*.png)| *.png |BMP Files(*.bmp)| *.bmp |JPG Files(*.jpg)|*.jpg;*.jpeg";
            if (sfd.ShowDialog() == DialogResult.OK)
            {
                var datd = GetGBDataTable(sender, (int)CALCULATE_TABLE_TYPE.ASTM);
                this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
                ImageExporter outpic = new ImageExporter();
                outpic.GBDatatableOne = datd;
                outpic.GridLength = Convert.ToInt32(710.0 / imageDisHelper.m_pixelSize);
                outpic.m_list_allDfield = m_list_allDfield;
                outpic.resultFile = resultFile;
                outpic.sfd = sfd;
                outpic.type = (int)Outpic_enum.GBOne;
                outpic.m_ReportApp = m_ReportApp;

                outpic.ParticleData = ParticleAll.Copy();
                outpic.ParticleClassData = ParticleClass.Copy();
                Thread bThread = new Thread(new ThreadStart(outpic.opencv_outpic));
                bThread.IsBackground = true;
                bThread.Start();

            }
        }

        private void 查找相似颗粒ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            DisplayParticle selpart = new DisplayParticle();
            var overlap = resultFile.GetOverlapParam();
            foreach (DisplayRectangle a_field in m_list_allDfield)
            {
                foreach (var p in a_field.List_DParticle)
                {
                    if (p.IsSelect)
                    {

                        selpart = p;
                        break;

                    }
                }


            }
            var selpartPos = selpart.OTSRect.GetCenterPoint();

            var selpartclrobj = GetParticleclrObjFromParticleData(selpart);
            foreach (DisplayRectangle a_field in m_list_allDfield)
            {
                foreach (var otherP in a_field.List_DParticle)
                {
                    var partPos = otherP.OTSRect.GetCenterPoint();
                    if ((Math.Abs(partPos.X - selpartPos.X) < (float)overlap * 2) && (Math.Abs(partPos.Y - selpartPos.Y) < 2 * (float)overlap))
                    {

                        var otherpartclrObj = GetParticleclrObjFromParticleData(otherP);

                        var sim = selpartclrobj.CalculateSimilarity(otherpartclrObj);
                        if (sim > 0.95)
                        {
                            otherP.IsSelect = true;
                        }
                    }
                }
            }

        }

        private COTSParticleClr GetParticleclrObjFromParticleData(DisplayParticle p)
        {
            
            COTSParticleClr newPart = new COTSParticleClr();

            OTSMeasureApp._0_OTSModel.OTSDataType.COTSRect rec = p.OTSRect;

            newPart.SetOTSRect((int)rec.GetTopLeft().X, (int)rec.GetTopLeft().Y, (int)rec.GetBottomRight().X, (int)rec.GetBottomRight().Y);
            newPart.SetActualArea(p.objParticleData.Area);
            newPart.SetAveGray((byte)p.objParticleData.AveGray);
            newPart.SetDMAX(p.objParticleData.DMAX);
            newPart.SetDMIN(p.objParticleData.DMIN);
            newPart.SetDMEAN(p.objParticleData.DMEAN);
            newPart.SetDMPERP(p.objParticleData.DPERP);
            newPart.SetFeretDiameter(p.objParticleData.DFERET);
            newPart.SetDPRIMETER(p.objParticleData.PERIMETER);
            newPart.SetDELONG(p.objParticleData.DELONG);
            newPart.SetDINSCR(p.objParticleData.DINSCR);
            newPart.SetORIENTATION(p.objParticleData.ORIENTATION);
            return newPart;
        }

        public void DisplayParticleByParticlelist(List<Particle> particle)
        {
            bool flag = true;
            foreach (var fil in m_list_allDfield)
            {
                foreach (var p2 in particle)
                {
                    if (int.Parse(fil.FieldID) == p2.FieldId)
                    {
                        foreach (var p in fil.List_DParticle)
                        {
                            var dp = p;
                            if (dp.objParticleData.ParticleId == p2.ParticleId)
                            {
                                if (flag)
                                {
                                    var p1 = dp.GetCenterPoint();
                                    foreach (var item in m_list_allDfield)
                                    {
                                        item.DraggingPoint = p1;
                                        item.DraggingMove(new PointF(this.Width / 2, this.Height / 2));
                                        foreach (DisplayParticle dp1 in item.List_DParticle)
                                        {

                                            dp1.DraggingPoint = p1;
                                            dp1.DraggingMove(new PointF(this.Width / 2, this.Height / 2));
                                            dp1.DraggingPoint = Point.Empty;
                                        }
                                    }
                                    foreach (var item in m_CurGBFields)
                                    {
                                        item.DraggingPoint = p1;
                                        item.DraggingMove(new PointF(this.Width / 2, this.Height / 2));
                                    }
                                    m_beforedrag_pointf = p1;
                                    //同样重新计算backrectf的坐标
                                    m_backRect = new RectangleF(m_backRect.Location.X + this.Width / 2 - m_beforedrag_pointf.X,
                                         m_backRect.Location.Y + this.Height / 2 - m_beforedrag_pointf.Y, m_backRect.Width, m_backRect.Height);

                                    ImageZoom(2.5f, new PointF(dp.GetCenterPoint().X, dp.GetCenterPoint().Y));
                                    flag = false;
                                }
                                dp.IsSelect = true;
                                break;
                            }
                        }
                    }
                }
            }
            Invalidate();
        }
    }
}