using OTSIncAReportApp.DataOperation.Model;
using OTSIncAReportApp.SysMgrTools;
using OTSIncAReportGraph.Class;

using OTSIncAReportGraph.OTSIncAReportGraphFuncation;
using OTSIncAReportMailInterface;
using OTSPeriodicTable;

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

namespace OTSIncAReportGraph.Controls
{
    public partial class Control_DrawDistrbutionImageAndBSE : UserControl
    {
        #region 变量定义

        //国际化
        Language lan;
        //国际化存储信息
        System.Collections.Hashtable table;

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

        //记录field列表的原值
        public List<DField> m_old_list_dfield = null;

        //这里要做成控件，不要是窗体
        public List<BaseObject> m_list_baseobject = null;
        //这里要做成控件，不要是窗体
        public List<BaseObject> m_list_usebject = new List<BaseObject>();
        //记录原值,颗粒和线段
        public List<BaseObject> m_old_list_baseobject = null;
        //记录国标区域列表对象
        public List<DField> m_list_GBobject = null;
        //record the GBField
        public List<DField> m_list_GBfield = null;
        //记录操作记录类
        public List<HistoryApolygon> m_list_historyapolygon = null;

        //操作历史类，当前操作到的id
        private int m_operator_currentid = 0;

        //总背景矩形
        public RectangleF m_backrectf = new RectangleF();

        //记录原值，总背景矩形
        public RectangleF m_old_backrectf = new RectangleF();

        //单一Field视域，屏幕像素的宽高
        public RectangleF m_OneField_Screen_BackRectf = new RectangleF();

        //单一Field视域,OTS物理像素的宽高
        public RectangleF m_OneField_OTS_Rectf = new RectangleF();

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

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

        //绘制的网格中，需要几条线,宽
        public double m_i_grid_showlinesnumber_width = 0;

        //绘制的网格中，需要几条线,高
        public double m_i_grid_showlinesnumber_height = 0;

        //是否使用矩形进行多选操作
        private bool m_is_multiselect_rectangle = false;

        //是否使用圆形进行多选操作
        private bool m_is_multiselect_ellipse = false;

        //是否可以进行绘制,提供给矩形多选与圆形多选使用的临时变量
        private bool m_is_multiselect_onpaint = false;

        //进行选择的矩形范围
        private RectangleF m_multiselect_rect = new RectangleF();

        //在进行拖选前鼠标记录的点
        private PointF m_beforemultiselect_point = new PointF();

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

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



        //缩放的增大缩小的增量
        private float m_f_zoom_increment = 0.05f;

        //缩放的基数,临时变量
        private float m_f_widthandheight_js = 0;

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

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

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

        //标尺的大小记录
        public float m_f_ruler_size = 100;

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

        //每像素代表的尺寸大小,还不知道在哪里进行计算
        public float m_f_onepixel_size = 4.5f;

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

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

        //整个背景矩形的背景色
        private Color m_backrangecolor = Color.White;

     

        //底层封装类
        OTSIncAReportFun m_OTSIncAReportFun = null;

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

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

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

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

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

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

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

        private Color m_ColorNotContent = Color.SkyBlue;

        //读取背景原图的名称和图片
        private List<Image> originalImages = new List<Image>();
        private List<string> originalImageNames = new List<string>();
        //背景使用原图
        private bool OriginalBackground = false;

        static System.Windows.Forms.Timer delaytimer = new System.Windows.Forms.Timer();

        /// <summary>
        /// 当前正在显示的数据源名称，用来与框架调用条件判断使用
        /// </summary>
        public string ShowSourceName
        {
            set { m_showsourcename = value; }
            get { return m_showsourcename; }
        }

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

        //测试用隐藏颗粒的id号，回头去掉
        public int test_hide_particle_tagid = 1000;

        //进度条窗体
        public Frm_UserProgress m_frm_userprogress;

        /// <summary>
        /// 是否显示过小颗粒
        /// </summary>
        public bool bShowSmallParticle = false;

  

        public List<Particle> SelectedParticles { set; get; }
        OTSIncAReportApp.frmReportApp m_ReportApp;
        ResultFile resultFile = null;


        #endregion

        #region 构造函数及窗体加载
        /// <summary>
        /// 分布图构造函数
        /// </summary>
        /// <param name="in_sec">传入,委托类对象</param>
        /// <param name="in_Cotsreportprojfilemgrclr">传入，项目管理类对象</param>
        public Control_DrawDistrbutionImageAndBSE(OTSIncAReportApp.frmReportApp ReportApp)
        {
            m_list_dfield = new List<DField>();
            m_old_list_dfield = new List<DField>();
            m_list_baseobject = new List<BaseObject>();
            m_old_list_baseobject = new List<BaseObject>();
            m_list_historyapolygon = new List<HistoryApolygon>();
            m_frm_userprogress = new Frm_UserProgress();

            m_mythread_state = false;

            m_mythread = new Thread(new ParameterizedThreadStart(Thread_GO));
            
            m_ReportApp = ReportApp;
            resultFile = m_ReportApp.resultFilesList[m_ReportApp.WorkingResult];

            //初始化底层操作类
            m_OTSIncAReportFun = new OTSIncAReportFun(this, resultFile);
            
            InitializeComponent();
            #region 国际化语言
            Language lan = new Language(this);
            table = lan.GetNameTable(this.Name);
            #endregion

        }

        private void Control_DrawDistrbutionImageAndBSE_Load(object sender, EventArgs e)
        {
            //显示进度条,计算进度条应该显示的位置和宽度
            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(0, table["str1"].ToString());


            //执行获取颗粒分布图数据，总过程函数
            m_OTSIncAReportFun.GetDistrbutionImageAndBSE_Total(m_ReportApp);

            //设置双缓冲
            SetDoubleBufferByIsDraw();

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

            //记录原值，用于缩放计算操作 ,此处要用克隆 ,原particle颗粒的值，在底层调用时已经赋值过了
            foreach (DParticle ls_dp in m_list_baseobject)
            {
                DParticle old_dp = ls_dp.Clone() as DParticle;
                m_old_list_baseobject.Add(old_dp);
            }

            //加载时将背景rect设置与整个窗体一边大小
            m_old_backrectf = m_backrectf;

            //赋值给old保存原值
            for (int i = 0; i < m_list_dfield.Count; i++)
            {
                DField df = new DField();
                df.Show_Rect = new RectangleF(m_list_dfield[i].Show_Rect.X,
                    m_list_dfield[i].Show_Rect.Y,
                    m_list_dfield[i].Show_Rect.Width,
                    m_list_dfield[i].Show_Rect.Height);
                m_old_list_dfield.Add(df);
            }
            ResetPicturePosition();
            //进入时首先对XRayTable进行隐藏
            control_XRayTable1.Visible = false;

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

            

            //加载完成，关闭进度条
            m_frm_userprogress.Close();
        }


        #endregion

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

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

        }
        #endregion

        #region 绘制函数
        protected override void OnPaint(PaintEventArgs e)//处理重绘情况
        {
            if (OriginalBackground)
            {
                GetPic(e);
            }
            else
            {
                #region //填充个背景色矩形-----------------------------------------------
                SolidBrush b = new SolidBrush(m_backrangecolor);
                e.Graphics.FillRectangle(b, m_backrectf);
                #endregion
            }





            #region //计算并进行绘制部份------------------------------------
            //绘制完缩放的图形后，将基数变回,否则会一直刷新无限变大变小
            if (m_f_widthandheight_js != 0)
            {
                //缩放完成，重新计算颗粒的矩形，和边缘路径,这里应该写成，判断 如果有进行了缩放的操作后，再进行重新的计算
                foreach (BaseObject item in m_list_baseobject)
                {
                    DParticle dp = (DParticle)item;

                    //获取矩形的rectangle
                    dp.Rect = dp.GetRectFromDSegment();

                    //通过line获取路径边缘
                    dp.GPath = dp.GetRegionFromDSegments();

                    //重新计算小矩形边框
                    dp.SmallRect = dp.GetSmallRectangleFromRect();
                }

                m_f_widthandheight_js = 0;
            }

            //开始向下传递并进行绘制
            foreach (BaseObject item in m_list_baseobject)
            {
                DParticle dp = (DParticle)item;
                if (dp.Operator != ParticleOperator.DELETED)
                    item.OnPaint(e);
            }
            #endregion

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

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

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

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

                if (true == m_is_multiselect_ellipse && m_multiselect_rect.Width > 0 && m_multiselect_rect.Height > 0)
                {
                    Graphics g = e.Graphics;

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

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

                    //填充选择圆形
                    g.FillEllipse(brush, m_multiselect_rect.X, m_multiselect_rect.Y, m_multiselect_rect.Width, m_multiselect_rect.Height);
                }
            }
            #endregion

            #region 绘制网格线，帧图边框部份
            if (true == m_is_showgrid)
            {
                RectangleF ls_rect_gridline = Rectangle.Round(new RectangleF(m_backrectf.X,
                   m_backrectf.Y,
                  m_backrectf.Width,
                   m_backrectf.Height));

                //共绘制外边框，和里面横竖，各4个线
                ControlPaint.DrawBorder(e.Graphics,
                             Rectangle.Ceiling(ls_rect_gridline),
                                    Color.BurlyWood,
                                    1,
                                    ButtonBorderStyle.Solid,
                                    Color.BurlyWood,
                                    1,
                                    ButtonBorderStyle.Solid,
                                    Color.BurlyWood,
                                    1,
                                    ButtonBorderStyle.Solid,
                                    Color.BurlyWood,
                                    1,
                                    ButtonBorderStyle.Solid);

                //然后再把rectangle，横竖分成4块，画上4条横竖线
                //画横线
                for (int i = 1; i < m_i_grid_showlinesnumber_height; i++)
                {
                    double y_zl = ls_rect_gridline.Height / m_i_grid_showlinesnumber_height;
                    e.Graphics.DrawLine(new Pen(Color.BurlyWood),
                        ls_rect_gridline.X,
                     Convert.ToInt64(ls_rect_gridline.Y + y_zl * i),
                        ls_rect_gridline.X + ls_rect_gridline.Width,
                      Convert.ToInt64(ls_rect_gridline.Y + y_zl * i));
                }

                //画竖线
                for (int i = 1; i < m_i_grid_showlinesnumber_width; i++)
                {
                    double x_zl = ls_rect_gridline.Width / m_i_grid_showlinesnumber_width;
                    e.Graphics.DrawLine(new Pen(Color.BurlyWood),
                     Convert.ToInt64(ls_rect_gridline.X + x_zl * i),
                        ls_rect_gridline.Y,
                     Convert.ToInt64(ls_rect_gridline.X + x_zl * i),
                        ls_rect_gridline.Y + ls_rect_gridline.Height);
                }

            }
            #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 鼠标操作事件

        /// <summary>
        /// 按指定的增量刻度对整个图像进行缩放,x,y为手动缩放时当前鼠标所在的位置，如果在其它地方调用则传入0在计算过程中，不会影响
        /// </summary>
        /// <param name="in_f_zoom_increment"></param>
        private void ImageZoomByIncrement(float in_f_zoom_increment, float in_mouse_x, float in_mouse_y)
        {
            //先计算鼠标的位置与背景rect的位置的差值
            //用于存储锚点缩放记录原backrectf值的，一用来于计算差值
            float ls_oldwidth = m_backrectf.Width;
            float ls_oldheight = m_backrectf.Height;

            //看来只有带有浮点数，损失造成的误差才会最小
            m_backrectf.Width = (float)(m_backrectf.Width + Convert.ToDouble(m_old_backrectf.Width * in_f_zoom_increment));
            m_backrectf.Height = (float)(m_backrectf.Height + Convert.ToDouble(m_old_backrectf.Height * in_f_zoom_increment));

            //锚点缩放补差值计算,得出差值
            float f_czx = (in_mouse_x - m_backrectf.X) * ((ls_oldwidth - m_backrectf.Width) / ls_oldwidth);
            float f_czy = (in_mouse_y - m_backrectf.Y) * ((ls_oldheight - m_backrectf.Height) / ls_oldheight);

            //对背景矩形与所有的segment进行修补差值
            m_backrectf.X = m_backrectf.X + f_czx;
            m_backrectf.Y = m_backrectf.Y + f_czy;

            for (int i = 0; i < m_list_baseobject.Count(); i++)
            {
                DParticle ls_dp = (DParticle)m_list_baseobject[i];

                for (int y = 0; y < ls_dp.DSegments.Count(); y++)
                {
                    //这里重新设置每条线的高度，和x,y坐标
                    DSegment ds = ls_dp.DSegments[y];
                    DSegment old_ds = ((DParticle)m_old_list_baseobject[i]).DSegments[y];
                    ds.PenWidthAndHeight = ds.PenWidthAndHeight + old_ds.PenWidthAndHeight
                        * in_f_zoom_increment;

                    ds.Rect = new RectangleF(ds.Rect.X + old_ds.Rect.X * in_f_zoom_increment + f_czx, ds.Rect.Y + old_ds.Rect.Y * in_f_zoom_increment + f_czy,
                       ds.Rect.Width + old_ds.Rect.Width * in_f_zoom_increment, ds.Rect.Height + old_ds.Rect.Height * in_f_zoom_increment);
                }
                //设置缩放到多少倍时进行显示
                if (ls_dp.Zoom_DisPlayMultiplier <= m_f_zoom_record)
                {
                    ls_dp.Zoom_DisPlay = true;
                }
                else
                {
                    ls_dp.Zoom_DisPlay = false;
                }
            }
            if (m_list_dfield != null)
            {
                if (m_list_dfield.Count > 0)
                {
                    for (int i = 0; i < m_list_dfield.Count; i++)
                    {
                        DField gbField = m_list_dfield[i];
                        gbField.Current_Rect = new RectangleF(gbField.Current_Rect.X + gbField.Show_Rect.X * in_f_zoom_increment + f_czx,
                                                              gbField.Current_Rect.Y + gbField.Show_Rect.Y * in_f_zoom_increment + f_czy,
                                                              gbField.Current_Rect.Width + gbField.Show_Rect.Width * in_f_zoom_increment,
                                                              gbField.Current_Rect.Height + gbField.Show_Rect.Height * in_f_zoom_increment);
                    }
                }
            }
            if (m_list_GBobject != null)
            {
                if (m_list_GBobject.Count > 0)
                {
                    foreach (var gbItem in m_list_GBobject)
                    {

                        PointF gbRectPoint = new PointF(gbItem.Current_Rect.X + gbItem.Show_Rect.X * in_f_zoom_increment + f_czx, gbItem.Current_Rect.Y + gbItem.Show_Rect.Y * in_f_zoom_increment + f_czy);
                        SizeF gbSizeF = new SizeF(gbItem.Current_Rect.Width + gbItem.Show_Rect.Width * in_f_zoom_increment, gbItem.Current_Rect.Height + gbItem.Show_Rect.Height * in_f_zoom_increment);
                        RectangleF gbRectF = new RectangleF(gbRectPoint, gbSizeF);
                        gbItem.Current_Rect = gbRectF;


                    }
                }
            }
            #region 计算标尺尺寸部份-----放大------
            //计算标尺实际占用像素的宽度
            m_f_ruler_size = m_f_ruler_size + Convert.ToInt32(m_f_old_ruler_size * in_f_zoom_increment);
            control_Ruler1.SetValue(m_f_ruler_size, m_f_onepixel_size);
            #endregion
        }

        protected override void OnMouseWheel(MouseEventArgs e)
        {
            if (e.Delta > 0)
            {
                if (m_f_zoom_record < m_f_zoom_max)
                {
                    //图形缩放计算部份-------放大------------//是放大 一个刻度
                    m_f_widthandheight_js = m_f_zoom_increment;
                }
                else return;
            }
            else
            {
                if (m_f_zoom_record > m_f_zoom_mix)
                {
                    //图形缩放计算部份------缩小--------------//是缩小 一个刻度
                    m_f_widthandheight_js = -m_f_zoom_increment;
                }
                else return;
            }

            //这里对缩放的总记录进行校验
            if (m_f_zoom_record > m_f_zoom_max)
            {
                m_f_zoom_record = m_f_zoom_max;
            }
            if (m_f_zoom_record < m_f_zoom_mix)
            {
                m_f_zoom_record = m_f_zoom_mix;
            }
            //如果在最小最大范围内，要对小位进行校验,如果小数位数大于2了，说明有可能是因为进行了全图匹配等操作出现的，
            //缩放时这里再重新校正为小数2位,并且与缩放刻度成完整的倍数无小数
            if (GetDecimalDigits(m_f_zoom_record) > 2)
            {
                //进入到这里，就应该已经说明是刚刚做了全图或宽度匹配的操作，
                //应该找出与下一个发生的刻度增长工作，找到与下一个刻度的差值

                //1,截取小数，后6位
                int i_length_f_zoom_record = GetDecimalDigits(m_f_zoom_record);
                float ls_cz_f = float.Parse("0.0" + m_f_zoom_record.ToString().Substring(m_f_zoom_record.ToString().IndexOf('.') + 2, i_length_f_zoom_record - 1));

                //2,判断是缩还是放
                if (m_f_widthandheight_js > 0)
                {
                    //增长,这里还有问题
                    m_f_widthandheight_js = m_f_widthandheight_js - ls_cz_f;//补充一个刻度,先不补，看看上面的算法是否不需要这个
                }
                else
                {
                    //减小
                    m_f_widthandheight_js = m_f_widthandheight_js - ls_cz_f;
                }

                //防止操作值过大，超过一刻度，容易出错---------将差值的刻度控制在0.05内--------------------------------------
                if (m_f_widthandheight_js > 0)
                {
                    if (m_f_widthandheight_js > m_f_zoom_increment)
                        m_f_widthandheight_js = m_f_widthandheight_js - m_f_zoom_increment;
                    if (m_f_widthandheight_js > m_f_zoom_increment)
                        m_f_widthandheight_js = m_f_widthandheight_js - m_f_zoom_increment;
                }
                else
                {
                    if (m_f_widthandheight_js < -m_f_zoom_increment)
                        m_f_widthandheight_js = m_f_widthandheight_js + m_f_zoom_increment;
                    if (m_f_widthandheight_js < -m_f_zoom_increment)
                        m_f_widthandheight_js = m_f_widthandheight_js + m_f_zoom_increment;
                }
                //补差的目的就是为了后面取0.00取整时，将小数损失降低到最低----------------------------
            }

            m_f_zoom_record = m_f_zoom_record + m_f_widthandheight_js;
            m_f_zoom_record = float.Parse(m_f_zoom_record.ToString("#0.00")); //四舍五入，保留2位小数，如果不这样，float会不附合规则

            //传入增减缩放的刻度,进行缩放
            ImageZoomByIncrement(m_f_widthandheight_js, e.X, e.Y);

            Invalidate();
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                this.Cursor = Cursors.Hand;
                //是否可以按矩形进行选取,如果选择了矩形或圆形多选后
                if (true == m_is_multiselect_rectangle || true == m_is_multiselect_ellipse)
                {
                    m_multiselect_rect.Width = 0;
                    m_multiselect_rect.Height = 0;

                    m_is_multiselect_onpaint = true;
                    m_beforemultiselect_point = e.Location;
                }

                //在进行多选时，不让其拖动
                if (false == m_is_multiselect_onpaint)
                {
                    //Drag_MouseDownFucntion(list_baseobject, e);
                    foreach (BaseObject item in m_list_baseobject)
                    {
                        item.IsDragging = true;
                        item.DraggingPoint = e.Location;

                        m_isDrag = true;
                        m_beforedrag_pointf = e.Location;
                    }
                    foreach (DField item in m_list_dfield)
                    {
                        item.IsDragging = true;
                        item.DraggingPoint = e.Location;
                    }
                    if (m_list_GBobject != null)
                    {
                        if (m_list_GBobject.Count > 0)
                        {
                            foreach (BaseObject item in m_list_GBobject)
                            {
                                item.IsDragging = true;
                                item.DraggingPoint = e.Location;
                            }
                        }
                    }
                }
            }
            Invalidate();
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            //当前鼠标的位置,用来绘制鼠标线用
            m_mouse_now_point = e.Location;

            //如果是进行多选的话
            if (true == m_is_multiselect_onpaint)
            {
                if (e.Location.X > m_beforemultiselect_point.X && e.Location.Y > m_beforemultiselect_point.Y)
                {
                    //右下拖动
                    m_multiselect_rect = new RectangleF(m_beforemultiselect_point, new SizeF(e.Location.X - m_beforemultiselect_point.X, e.Location.Y - m_beforemultiselect_point.Y));
                }
                if (e.Location.X < m_beforemultiselect_point.X && e.Location.Y < m_beforemultiselect_point.Y)
                {
                    //左上拖动
                    PointF lspointf = new PointF(e.Location.X, e.Location.Y);
                    m_multiselect_rect = new RectangleF(lspointf, new SizeF(m_beforemultiselect_point.X - e.Location.X, m_beforemultiselect_point.Y - e.Location.Y));
                }
                if (e.Location.X > m_beforemultiselect_point.X && e.Location.Y < m_beforemultiselect_point.Y)
                {
                    //右上，这种画法，需要将左下，右上两点转换成左上，右下
                    PointF left_pointf = new PointF(m_beforemultiselect_point.X, e.Location.Y);
                    PointF right_pointf = new PointF(e.Location.X, m_beforemultiselect_point.Y);
                    m_multiselect_rect = new RectangleF(left_pointf, new SizeF(right_pointf.X - left_pointf.X, right_pointf.Y - left_pointf.Y));

                }
                if (e.Location.X < m_beforemultiselect_point.X && e.Location.Y > m_beforemultiselect_point.Y)
                {
                    //左下,这种画法，需要将左下，右上两点转换成左上，右下
                    PointF left_pointf = new PointF(e.Location.X, m_beforemultiselect_point.Y);
                    PointF right_pointf = new PointF(m_beforemultiselect_point.X, e.Location.Y);
                    m_multiselect_rect = new RectangleF(left_pointf, new SizeF(right_pointf.X - left_pointf.X, right_pointf.Y - left_pointf.Y));
                }
            }

            //在进行多选时，不让其拖动
            if (false == m_is_multiselect_onpaint)
            {
                foreach (BaseObject item in m_list_baseobject)
                {
                    DParticle dp = (DParticle)item;
                    //明白了，选择第一个时，被第二个刷掉了
                    if (true == WhetherInRange(dp, e.Location))
                    {
                        dp.IsMouseMove = true;
                        //获取颗粒ID
                        int FieldID = dp.CLRFieldID;
                        int TagID = dp.CLRTagID;

                        //显示x-ray能谱图 
                        if (control_XRayTable1.Visible == false)
                            ShowXRay(dp);
                    }
                    else
                    {
                        dp.IsMouseMove = false;

                        //移动在颗粒外面时，要判断，Operator_ShowXray不为选下显示XRAY时，才对XRay进行隐藏
                        if (dp.Operator_ShowXRay != ParticleOperatorShowXray.SELECTANDDISPLAYXRAY)
                        {
                            //隐藏x-ray能谱图
                            HideXRay(dp);
                        }
                    }
                    if (true == item.IsDragging)
                    {
                        //再将里面的线也进行计算坐标
                        foreach (DSegment ds in dp.DSegments)
                        {
                            ds.Rect = new RectangleF(
                            ds.Rect.X + e.X - item.DraggingPoint.X,  //获取到原先点与移动点的增减量，+原先的x坐标，就是新的坐标
                            ds.Rect.Y + e.Y - item.DraggingPoint.Y,
                            ds.Rect.Width,
                            ds.Rect.Height);
                            ds.DraggingPoint = e.Location;
                        }
                        item.DraggingPoint = e.Location;

                        //获取矩形的rectangle
                        dp.Rect = dp.GetRectFromDSegment();

                        //通过line获取路径边缘
                        dp.GPath = dp.GetRegionFromDSegments();

                        //重新计算小矩形边框
                        dp.SmallRect = dp.GetSmallRectangleFromRect();
                    }
                }

                foreach (var item in m_list_dfield)
                {
                    if (true == item.IsDragging)
                    {
                        item.Current_Rect = new RectangleF(
                        item.Current_Rect.Left + Convert.ToSingle((e.X - item.DraggingPoint.X)),
                        item.Current_Rect.Top + Convert.ToSingle((e.Y - item.DraggingPoint.Y)),
                        item.Current_Rect.Width,
                        item.Current_Rect.Height);
                        item.DraggingPoint = e.Location;
                    }
                }
                //如果在拖动中
                if (true == m_isDrag)
                {
                    //同样重新计算backrectf的坐标
                    m_backrectf = new RectangleF(m_backrectf.Location.X + e.X - m_beforedrag_pointf.X,
                        m_backrectf.Location.Y + e.Y - m_beforedrag_pointf.Y, m_backrectf.Width, m_backrectf.Height);
                    m_beforedrag_pointf = e.Location;
                }
            }

            #region 向报告程序右下角，传送鼠标颗粒等相关信息
            m_str_mouseshow_left = "无";
            foreach (BaseObject item in m_list_baseobject)
            {
                DParticle dp = (DParticle)item;
                if (dp.Operator != ParticleOperator.NODISPLAY)
                {
                    if (true == WhetherInRange(dp, e.Location))
                    {
                        ////并保存到变量中，供移动电镜使用
       

                        m_sem_mouse_now_point = new Point(dp.SEMPosX, dp.SEMPosY);
                        m_str_mouseshow_left = "颗粒SEM位置:" + dp.SEMPosX.ToString() + ":" + dp.SEMPosY.ToString();
                    }
                }
            }

            //获取颜色方法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="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 (true == m_is_multiselect_onpaint)
                {
                    //首先清除掉所有已经选择的项
                    foreach (DParticle dp in m_list_baseobject)
                    {
                        if (dp.Operator == ParticleOperator.SELECTED)
                        {
                            dp.Operator = ParticleOperator.DISPLAY;
                        }
                    }


                    //然后在这里判断都有哪些颗粒所有的point点，是否在选取的图形graphicsPath闭合路径中
                    //首先先将选取的图形填充成graphicsPath
                    if (m_multiselect_rect.Width > 0 && m_multiselect_rect.Height > 0)
                    {
                        GraphicsPath ls_gpath = new GraphicsPath();
                        ls_gpath.AddRectangle(m_multiselect_rect);
                        foreach (DParticle dp in m_list_baseobject)
                        {
                            if (dp.Operator != ParticleOperator.NODISPLAY && dp.Operator != ParticleOperator.DELETED)//不显示的和删除状态的不让进行选择
                            {
                                PointF[] lspointf = dp.GPath.PathPoints;
                                for (int i = 0; i < lspointf.Count(); i++)
                                {
                                    if (true == WhetherInRange(dp, lspointf[i]))
                                    {
                                        //选择到了该路径,那么就选取该图像
                                        dp.Operator = ParticleOperator.SELECTED;
                                    }
                                }
                            }
                        }
                    }

                    //这里恢复默认值
                    m_multiselect_rect.Width = 0;
                    m_multiselect_rect.Height = 0;
                    m_is_multiselect_onpaint = false;
                    m_is_multiselect_ellipse = false;
                    m_is_multiselect_rectangle = false;

                    //将多选选择上的颗粒发送给报告框架
                    SelectParticleListSendToReportFrame();
                }

                //不在多选的状态时，可以进行拖动操作
                if (false == m_is_multiselect_onpaint)
                {
                    // Drag_MouseUpFucntion(list_baseobject, e);
                    foreach (BaseObject item in m_list_baseobject)
                    {
                        if (true == item.IsDragging)
                        {
                            item.IsSelect = false;
                            item.IsDragging = false;
                            item.DraggingPoint = Point.Empty;

                            m_isDrag = false;
                        }
                    }
                    if (m_list_GBobject != null)
                    {
                        if (m_list_GBobject.Count > 0)
                        {
                            foreach (DField item in m_list_GBobject)
                            {
                                if (true == item.IsDragging)
                                {
                                    item.IsSelect = false;
                                    item.IsDragging = false;
                                    item.DraggingPoint = Point.Empty;

                                    m_isDrag = false;
                                }
                            }
                        }
                    }
                    foreach (DField item in m_list_dfield)
                    {
                        if (true == item.IsDragging)
                        {
                            item.IsDragging = false;
                            item.DraggingPoint = Point.Empty;
                            m_isDrag = false;
                        }
                    }
                    //在颗粒上点击，则对该颗粒附加显示x-ray的状态，同时将其它颗粒上显示x-ray的状态全部去掉。
                    if (false == m_isDrag)
                    {
                        foreach (DParticle dp in m_list_baseobject)
                        {
                            PointF[] lspointf = dp.GPath.PathPoints;
                            if (true == WhetherInRange(dp, new Point(e.X, e.Y)))
                            {
                                //选择到了该路径,那么就选取该图像b
                                dp.Operator_ShowXRay = ParticleOperatorShowXray.SELECTANDDISPLAYXRAY;
                            }
                            else
                            {
                                dp.Operator_ShowXRay = ParticleOperatorShowXray.NODISPLAY;
                            }
                        }
                    }
                }
            }

            //右键菜单控件
            CMenuStrip.Items[0].Tag = "";
            CMenuStrip.Items[0].Enabled = false;
            CMenuStrip.Items[1].Tag = "";
            CMenuStrip.Items[1].Enabled = false;
            CMenuStrip.Items[2].Tag = "";
            CMenuStrip.Items[2].Enabled = false;
            CMenuStrip.Items[3].Tag = "";
            CMenuStrip.Items[3].Enabled = false;
            CMenuStrip.Items[4].Tag = "";
            CMenuStrip.Items[4].Enabled = false;

            if (e.Button == MouseButtons.Right)
            {
                //线程未执行完成，则不让再进行选择,右键移动到SEM位置的菜单选项
                if (m_mythread_state == false)
                    CMenuStrip.Items[4].Enabled = true;
                else
                    CMenuStrip.Items[4].Enabled = false;

                //这个判断右键菜单加在这里，也不知道对不对
                foreach (BaseObject item in m_list_baseobject)
                {
                    if (true == WhetherInRange((DParticle)item, e.Location))
                    {
                        DParticle dp = (DParticle)item;
                        CMenuStrip.Items[0].Enabled = true;
                        CMenuStrip.Items[0].Tag = dp;

                        CMenuStrip.Items[1].Enabled = true;
                        if (dp.Operator == ParticleOperator.SELECTED)
                        {
                            CMenuStrip.Items[1].Text = table["str5"].ToString();
                        }
                        else
                        {
                            CMenuStrip.Items[1].Text = table["str6"].ToString();
                        }

                        CMenuStrip.Items[2].Enabled = true;
                        CMenuStrip.Items[3].Enabled = true;

           

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

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

                    }
                }

                //判断菜单的状态，来判断当前鼠标是否在颗粒中，对菜单选项进行设置
                if (CMenuStrip.Items[1].Enabled == true)
                {
                    CMenuStrip.Items[4].Visible = false;//暂时隐藏
                    CMenuStrip.Items[4].Text = table["str8"].ToString();
                }
                else
                {
                    CMenuStrip.Items[4].Visible = true;//去除隐藏
                    CMenuStrip.Items[4].Text = table["str8"].ToString();
                }

            }

            Invalidate();
        }
        #endregion

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


        //是否显示过小颗菜单
        private void ToolStripMenuItem_ShowSmallParticle_Click(object sender, EventArgs e)
        {
            if (bShowSmallParticle == false)
            {
                bShowSmallParticle = true;
                CMenuStrip.Items[7].Text = table["str8"].ToString();
            }
            else
            {
                bShowSmallParticle = false;
                CMenuStrip.Items[7].Text = table["str9"].ToString();
            }

            //缩放的增大缩小的增量
            m_f_zoom_increment = 0.05f;
            //缩放的基数,临时变量
            m_f_widthandheight_js = 0;
            //与原先缩放的记录数
            m_f_zoom_record = 1;
            //最大缩放倍数
            m_f_zoom_max = 4f;
            //最小缩放倍数
            m_f_zoom_mix = 0.05f;
            //标尺的大小记录
            m_f_ruler_size = 100;
            //标尺原先大小的记录，参与计算
            m_f_old_ruler_size = 100;
            //每像素代表的尺寸大小,还不知道在哪里进行计算
            m_f_onepixel_size = 4.5f;
            //提供鼠标在右下角显示的文本，左侧
            m_str_mouseshow_left = "";
            //提供鼠标在右下角显示的文本,右侧
            m_str_mouseshow_right = "";
            //整个背景矩形的背景色
            m_backrangecolor = Color.White;


            m_list_dfield = new List<DField>();
            m_old_list_dfield = new List<DField>();
            m_list_baseobject = new List<BaseObject>();
            m_old_list_baseobject = new List<BaseObject>();
            m_list_historyapolygon = new List<HistoryApolygon>();
            m_frm_userprogress = new Frm_UserProgress();

            m_mythread_state = false;

            m_mythread = new Thread(new ParameterizedThreadStart(Thread_GO));

            Control_DrawDistrbutionImageAndBSE_Load(null, null);
        }


        private void ToolStripMenuItem_selected_Click(object sender, EventArgs e)
        {
            //选择
            DParticle dp = (DParticle)CMenuStrip.Items[0].Tag;
            if (ParticleOperator.SELECTED == dp.Operator)
            {
                dp.Operator = ParticleOperator.DISPLAY;
                CMenuStrip.Items[1].Text = table["str6"].ToString();
                control_XRayTable1.Visible = false;
            }
            else
            {
                dp.Operator = ParticleOperator.SELECTED;
                CMenuStrip.Items[1].Text = table["str5"].ToString();
            }

            //发送选择的颗粒到报告框架中
            SelectParticleListSendToReportFrame();
        }

        /// <summary>
        /// 显示x-ray能谱图
        /// </summary>
        /// <param name="in_dparticle"></param>
        private void ShowXRay(DParticle in_dparticle)
        {
            
            if (delaytimer.Enabled == false)
            {
                m_move_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;
            if (m_move_dparticle.IsMouseMove == false)
            {
                
                return;
            }
          
            //显示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数据
            m_OTSIncAReportFun.GetXrayByParticleTagIDAndFieldID_ForDrawDistrbutionImageAndBSE(m_move_dparticle.CLRTagID, m_move_dparticle.CLRFieldID, 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.GetPeriodicByYsm(CListPeriodic.GetListPeriodic(), ls_sei.ElementName).SX1);
                list_showelementinfo.Add(ls_sei);
            }

            //获取使用标准库的名称
            //string str_stdname = "";
            string str_IncALibName = "";
            str_IncALibName = m_move_dparticle.TypeName;


            //获取数据后，需要对xraytable设置
            control_XRayTable1.Visible = false;
            control_XRayTable1.SetXRayShowLineValue(Search_xray, Analysis_xray, list_showelementinfo);
            //颗粒国标信息
            control_XRayTable1.GBInfoStr = "";
            control_XRayTable1.GoodName = str_IncALibName;//杂夹物
            //control_XRayTable1.STDName = str_stdname;//标准库
            control_XRayTable1.List_ShowElementInfo = list_showelementinfo;
            control_XRayTable1.Visible = true;



            this.Refresh();
           
        }
        /// <summary>
        /// 隐藏x-ray能谱图
        /// </summary>
        private void HideXRay(DParticle in_dparticle)
        {
            if (m_move_dparticle == null)
                return;
            else if (m_move_dparticle.ID == in_dparticle.ID)
            {
                //如果是刚才移动过的颗粒的话，那么这里再对xray进行隐藏
                control_XRayTable1.Visible = 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 = DrawFuncation.GetPixel(hdc, int_x, int_y);
            }
            catch
            { }
            Color ls_c = Color.FromArgb
                (
                (int)(u_color << 24 >> 24),
                (int)(u_color << 16 >> 24),
                (int)(u_color << 8 >> 24)
                );

            return ls_c;
        }
        /// <summary>
        /// 封装，将分布图中的颗粒list传送给报告项目框架中
        /// </summary>
        private void SelectParticleListSendToReportFrame()
        {
            //先获取分布图中，有哪些颗粒已经被选择上了
            m_ReportApp.SelectedParticles = m_OTSIncAReportFun.GetSelectedParticleList_ForDrawDistrbutionImageAndBSE();
        }

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

            foreach (DParticle ls_dp in m_list_baseobject)
            {
                //只有显示状态，才可以切换到选择状态,考虑可能会出现如果在条件选择成不显示状态下，如果被选择了，是不是就强制切换成了选择状态
                if (ls_dp.Operator == ParticleOperator.DISPLAY)
                {
                    for (int i = 0; i < particles.Count; i++)
                    {
                        if (particles[i].ParticleId == ls_dp.CLRTagID
                               && particles[i].FieldId == ls_dp.CLRFieldID)
                        {
                            ls_dp.Operator = ParticleOperator.SELECTED;
                        }
                    }
                }
            }
        }


        private void ToolStripMenuItem_delete_Click(object sender, EventArgs e)
        {
            //删除颗粒
            DParticle dp = (DParticle)CMenuStrip.Items[0].Tag;

            //同样，要在历史操作记录类中，添加记录，好可以进行撤消操作
            HistoryApolygon hApolygon = new HistoryApolygon();
            hApolygon.APolygonID = dp.ID;
            hApolygon.Operator = ParticleOperator.DELETED;
            hApolygon.OldOperator = dp.Operator;
            hApolygon.ID = m_list_historyapolygon.Count;
            m_list_historyapolygon.Add(hApolygon);
            m_operator_currentid = hApolygon.ID;//当前操作到的历史操作记录
            //设置颗粒的状态为已经被删除
            dp.Operator = ParticleOperator.DELETED;
        }

        //复制图像
        private void toolStripMenuItem_copyimage_Click(object sender, EventArgs e)
        {
            CopyImage();
        }

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

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

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

            //改为线程调用,先判断线程状态
            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.DrawToBitmap(image, new Rectangle(0, 0, width, height));

            Clipboard.SetImage(image);
        }

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

                Point sem_point = (Point)in_obj;

                //第一步，连接电镜
                m_OTSIncAReportFun.ConnectToSEM();

                Thread.Sleep(500);

                //第二步，移动到指定位置,先读取再设置
                if (m_OTSIncAReportFun.m_SEMConnectionState == true)
                {

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

                }

                Thread.Sleep(1500);

                //第三步，断开电镜连接
                m_OTSIncAReportFun.DisConnectSEM();

                //Thread.Sleep(1000);

                m_mythread_state = false;
            }

        }

        /// <summary>
        /// 按框架传入的底层计算结果，重新对颗粒进行区分显示
        /// </summary>
        /// <param name="in_cgriddataclr"></param>
        public void DrawDistrbutionImageAndBSE_ByQuery(OTSIncAReportApp.OTSSampleReportInfo.OTSSampleMeaInfo in_list_cgriddataclr)
        {
            m_OTSIncAReportFun.GetDrawDistrbutionImageAndBSE_ByQuery(in_list_cgriddataclr);
        }

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

                m_f_zoom_record = m_f_zoom_record + f_cz;//更新上缩放值，与下面处理缩放对应上
                ImageZoomByIncrement(f_cz, 0, 0);
            }

            MoveImageToPoint(new PointF(0, 0));

        }

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

                m_f_zoom_record = m_f_zoom_record + f_cz;//更新上缩放值，与下面处理缩放对应上
                ImageZoomByIncrement(f_cz, 0, 0);
            }

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

        /// <summary>
        /// 对分布图进行全图匹配操作
        /// </summary>
        public void FullGraphMate()
        {
            //全图匹配，首先要判断出来是按宽度来计算缩放，还是按高度来计算缩放
            double ls_thiswidth = this.Width;
            double ls_thisheight = this.Height;
            double ls_imagewidth = m_backrectf.Width;
            double ls_imageheight = m_backrectf.Height;

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

            //判断当前是否宽度匹配未达到全图匹配效果
            if (ls_thiswidth == ls_imagewidth && ls_thisheight < ls_imageheight)
            {
                //说明目前已经达到了宽度匹配，但是未能显示完全整图需要高度匹配
                HeightMate();
                return;

            }

            //判断当前是否高度匹配未达到全图匹配效果
            if (ls_thisheight == ls_imageheight && ls_thiswidth < ls_imagewidth)
            {
                //说明目前已经达到了高度匹配，但是未能显示完全的整图需要宽度匹配
                WidthMate();
                return;
            }

            //然后还剩的匹配情况有，宽高都小于this,宽度都大于this,宽大于this高小于this,宽小于this高大于this


            //计算差值
            double ls_d_cz_width = 0;
            double ls_d_cz_height = 0;

            ls_d_cz_width = Math.Abs(ls_thiswidth / ls_imagewidth);
            ls_d_cz_height = Math.Abs(ls_thisheight / ls_imageheight);

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

        /// <summary>
        /// 将整个图像的位置移动到指定的位置上
        /// </summary>
        private void MoveImageToPoint(PointF in_pointf)
        {
            //先计算，当前所在的位置，和需要移动的位置之间的差
            //想复杂了，其实就是当前backrectf的x,y与in_pointf的差就完了呗
            PointF offex_p = new PointF(m_backrectf.X - in_pointf.X, m_backrectf.Y - in_pointf.Y);

            for (int i = 0; i < m_list_baseobject.Count; i++)
            {
                DParticle dp = (DParticle)m_list_baseobject[i];
                for (int k = 0; k < dp.DSegments.Count; k++)
                {
                    dp.DSegments[k].Rect = new RectangleF(
                        dp.DSegments[k].Rect.X - offex_p.X,
                        dp.DSegments[k].Rect.Y - offex_p.Y,
                        dp.DSegments[k].Rect.Width,
                        dp.DSegments[k].Rect.Height);
                }

                //获取矩形的rectangle
                dp.Rect = dp.GetRectFromDSegment();

                //通过line获取路径边缘
                dp.GPath = dp.GetRegionFromDSegments();

                //重新计算小矩形边框
                dp.SmallRect = dp.GetSmallRectangleFromRect();
            }
            //同样重新计算backrectf的坐标
            m_backrectf = new RectangleF(m_backrectf.X - offex_p.X, m_backrectf.Y - offex_p.Y,
                m_backrectf.Width, m_backrectf.Height);


            for (int i =0;i< m_list_dfield.Count;i++)
            {
                RectangleF dField = m_list_dfield[i].Current_Rect;
                dField.X = dField.X-offex_p.X;
                dField.Y = dField.Y - offex_p.Y;
                m_list_dfield[i].Current_Rect = dField;
            }


            Invalidate();
        }

        /// <summary>
        /// 判断该点是否在多边形的范围内
        /// </summary>
        /// <param name="inPoints"></param>
        /// <param name="WhetherPoint"></param>
        /// <returns></returns>
        private bool WhetherInRange(DParticle Part,/*PointF[] inPoints,*/ Point WhetherPoint)
        {
            var rect = Part.Rect;
            if ((rect.Left < WhetherPoint.X && WhetherPoint.X < rect.Right) && (rect.Top < WhetherPoint.Y && WhetherPoint.Y < rect.Bottom))
            {
                var itm = (BaseObject)Part;
                PointF[] inPoints = itm.GPath.PathPoints;
                bool b_inrange = false;
                GraphicsPath myGraphicsPath = new GraphicsPath();
                Region myRegion = new Region();
                myGraphicsPath.Reset();

                myGraphicsPath.AddPolygon(inPoints);
                myRegion.MakeEmpty();
                myRegion.Union(myGraphicsPath);
                //返回判断点是否在多边形里
                b_inrange = myRegion.IsVisible(WhetherPoint);
                return b_inrange;
            }
            else
            {
                return false;
            
            }
            
        }

        /// <summary>
        /// 判断该点是否在多边形的范围内的float版本重载
        /// </summary>
        /// <param name="inPoints"></param>
        /// <param name="WhetherPoint"></param>
        /// <returns></returns>
        private bool WhetherInRange(DParticle Part,/* PointF[] inPoints, */PointF WhetherPoint)
        {
            var rect = Part.Rect;
            if ((rect.Left < WhetherPoint.X && WhetherPoint.X < rect.Right) && (rect.Top < WhetherPoint.Y && WhetherPoint.Y < rect.Bottom))
            {
                var itm = (BaseObject)Part;
                PointF[] inPoints = itm.GPath.PathPoints;
                bool b_inrange = false;
                GraphicsPath myGraphicsPath = new GraphicsPath();
                Region myRegion = new Region();
                myGraphicsPath.Reset();

                myGraphicsPath.AddPolygon(inPoints);
                myRegion.MakeEmpty();
                myRegion.Union(myGraphicsPath);
                //返回判断点是否在多边形里
                b_inrange = myRegion.IsVisible(WhetherPoint);
                return b_inrange;
            }
            else 
            {
                return false;
            }
        }

        /// <summary>
        /// 重做删除
        /// </summary>
        public void ReDo()
        {
            //如果已经是最后一条了，那么不可以再进行重做操作
            if (m_list_historyapolygon.Count() < 1)
                return;
            HistoryApolygon hap = m_list_historyapolygon[m_operator_currentid];
            foreach (DParticle dp in m_list_baseobject)
            {
                if (hap.APolygonID == dp.ID)
                {
                    dp.Operator = hap.Operator;
                }
            }

            if (m_operator_currentid < m_list_historyapolygon.Count - 1)
                m_operator_currentid = m_operator_currentid + 1;
        }

        /// <summary>
        /// 撤消删除
        /// </summary>
        public void UnDo()
        {
            //首先找到历史操作记录类最后一项，然后取出颗粒操作的id,及颗粒最后的操作类型，还原成oldoperator状态
            if (m_list_historyapolygon.Count() < 1)
                return;
            HistoryApolygon hap = m_list_historyapolygon[m_operator_currentid];

            foreach (DParticle dp in m_list_baseobject)
            {
                if (hap.APolygonID == dp.ID)
                {
                    dp.Operator = hap.OldOperator;
                }
            }

            if (m_operator_currentid != 0)
            {
                m_operator_currentid = m_operator_currentid - 1;
            }
        }

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

        //测试回头去掉
        public void test_selected()
        {
            m_OTSIncAReportFun.GetSelectedParticleList_ForDrawDistrbutionImageAndBSE();
        }


        /// <summary>
        /// 是否进行矩形多选操作
        /// </summary>
        public void MultiSelect_Rectangle()
        {
            if (m_is_multiselect_ellipse == true)
            {
                m_is_multiselect_ellipse = false;
            }
            m_is_multiselect_rectangle = true;
        }

        /// <summary>
        /// 是否进行圆形多选操作
        /// </summary>
        public void MultiSelect_Ellipse()
        {
            if (m_is_multiselect_rectangle == true)
            {
                m_is_multiselect_rectangle = false;
            }
            m_is_multiselect_ellipse = true;
        }

        /// <summary>
        /// 对选择的多边形进行反选操作
        /// </summary>
        public void ReverSeSelection()
        {
            foreach (DParticle dp in m_list_baseobject)
            {
                if (ParticleOperator.DISPLAY == dp.Operator)
                {
                    dp.Operator = ParticleOperator.SELECTED;
                }
                else if (ParticleOperator.SELECTED == dp.Operator)
                {
                    dp.Operator = ParticleOperator.DISPLAY;
                }
            }

            //将排列图选择的颗粒传送给报告框架中
            SelectParticleListSendToReportFrame();

            this.Invalidate();
        }

        /// <summary>
        /// 取消所有的颗粒的选择状态
        /// </summary>
        public void DeselectAllParticle()
        {
            foreach (DParticle dp in m_list_baseobject)
            {
                if (ParticleOperator.SELECTED == dp.Operator)
                {
                    dp.Operator = ParticleOperator.DISPLAY;
                }
            }

            //将排列图选择的颗粒传送给报告框架中
            SelectParticleListSendToReportFrame();

            this.Invalidate();
        }

        /// <summary>
        /// 禁止多选工具的使用
        /// </summary>
        public void MultiSelect_Ban()
        {
            m_is_multiselect_ellipse = false;
            m_is_multiselect_rectangle = false;
        }

        /// <summary>
        /// 获取小数的位数
        /// </summary>
        /// <param name="in_f_value"></param>
        /// <returns></returns>
        public int GetDecimalDigits(float in_f_value)
        {
            var s = in_f_value.ToString();
            return s.Length - s.IndexOf('.') - 1;
        }

        /// <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>
        /// <param name="a_type">false为显示原bse图像，true为显示带有标准库代表色的图像</param>
        public void ShowMode(string a_type)
        {
            if (a_type == "BSE")
            {
                OriginalBackground = false;
                //bse图时，显示背景图为白色
                m_backrangecolor = Color.White;
                foreach (DParticle ls_dp in m_list_baseobject)
                {
                    foreach (DSegment ls_ds in ls_dp.DSegments)
                    {
                        ls_ds.ShowMode = SegmentShowMode.DRAWPOINT;
                    }
                }
            }
            else if (a_type== "Original")
            {
                OriginalBackground = true;
                foreach (DParticle ls_dp in m_list_baseobject)
                {
                    foreach (DSegment ls_ds in ls_dp.DSegments)
                    {
                        ls_ds.ShowMode = SegmentShowMode.DRAWPOINT;
                    }
                }
            }
            else if(a_type== "原图颗粒分布")
            {
                OriginalBackground = true;
                foreach (DParticle ls_dp in m_list_baseobject)
                {
                    foreach (DSegment ls_ds in ls_dp.DSegments)
                    {
                        ls_ds.ShowMode = SegmentShowMode.DRAWLINE;
                    }
                }
            }

            else
            {
                OriginalBackground = false;
                m_backrangecolor = Color.Gainsboro;
                foreach (DParticle ls_dp in m_list_baseobject)
                {
                    foreach (DSegment ls_ds in ls_dp.DSegments)
                    {
                        ls_ds.ShowMode = SegmentShowMode.DRAWLINE;
                    }
                }
            }
            this.Invalidate();
        }

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

            return icount;
        }

        /// <summary>
        /// 获取所有原图
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        private void GetPic(PaintEventArgs args)
        {
            //将原图读取到内存中
            if (originalImages.Count == 0)
            {
                string path = resultFile.FilePath;
                System.IO.DirectoryInfo theFolder = new System.IO.DirectoryInfo(path + "\\FIELD_FILES");
                foreach (System.IO.FileInfo nextifile in theFolder.GetFiles())
                {
                    if (nextifile.Name.Contains(".bmp") == true || nextifile.Name.Contains(".BMP") == true)
                    {
                        Image image = Image.FromFile(path + "\\FIELD_FILES\\" + nextifile.Name);
                        originalImageNames.Add(nextifile.Name);
                        originalImages.Add(image);
                    }
                }
            }
            //绘制原图的大小和位置
            if (m_list_dfield.Count > 0)
            {
                if (originalImageNames.Count > 0)
                {
                    for (int i = 0; i < originalImageNames.Count; i++)
                    {
                        Size size = new Size();
                        string ImageName = originalImageNames[i].ToString();
                        Image Image = originalImages[i];
                        string result = System.Text.RegularExpressions.Regex.Replace(ImageName, @"[^0-9]+", "");
                        size.Height = (int)m_list_dfield[Convert.ToInt32(result)].Current_Rect.Height;
                        size.Width = (int)m_list_dfield[Convert.ToInt32(result)].Current_Rect.Width;
                        Bitmap bitmap = new Bitmap(Image, size);


                        PointF pointF = new PointF();
                        pointF.X = m_list_dfield[Convert.ToInt32(result)].Current_Rect.X;
                        pointF.Y = m_list_dfield[Convert.ToInt32(result)].Current_Rect.Y;
                        args.Graphics.DrawImage(bitmap, pointF);
                    }
                }
            }
        }

        private void ResetPicturePosition()
        {
            DirectoryInfo info = new DirectoryInfo(resultFile.FilePath + "\\FIELD_FILES");
            int count = info.GetFiles("*.bmp").Length;
            //m_list_dfield.Clear();
            //for (int i=0;i< count;i++)
            //{
            //    m_list_dfield[i].Current_Rect.X
            //}
        }

        
        #endregion

        #region Debug下执行的辅助测试代码
        private void Control_DrawDistrbutionImageAndBSE_MouseDoubleClick(object sender, MouseEventArgs e)
        {
#if DEBUG
            Screen[] screens = Screen.AllScreens;
            string ls_str = "";
            for (int i = 0; i < screens.Count(); i++)
            {
                ls_str = ls_str + "显示器" + (i + 1).ToString() + "  名称:" + screens[i].DeviceName + Environment.NewLine +
                "显示器" + (i + 1).ToString() + "  是否主要显示器:" + screens[i].Primary + Environment.NewLine +
                "显示器" + (i + 1).ToString() + "  WorkingArea:" + screens[i].WorkingArea + Environment.NewLine +
                "显示器" + (i + 1).ToString() + "  Bounds:" + screens[i].Bounds + Environment.NewLine +
                "显示器" + (i + 1).ToString() + "  色深:" + screens[i].BitsPerPixel + Environment.NewLine;
            }

            MessageBox.Show("------------------该段代码主要用来测试程序---------------------" + Environment.NewLine +
                //"当前窗体X:" + this.ParentForm.Location.X.ToString() + "   Y:" + this.ParentForm.Location.Y.ToString() + Environment.NewLine +
                "显示器数量" + Screen.AllScreens.Count().ToString() + Environment.NewLine +
                ls_str +
                "DESKTOP.Width:" + MyPrimaryScreen.DESKTOP.Width + "   DESKTOP.Height:" + MyPrimaryScreen.DESKTOP.Height + Environment.NewLine +
                "DpiX:" + MyPrimaryScreen.DpiX + "   DpiY:" + MyPrimaryScreen.DpiY + Environment.NewLine +
                "ScaleX:" + MyPrimaryScreen.ScaleX + "   ScaleY:" + MyPrimaryScreen.ScaleY + Environment.NewLine +
                "WorkingArea.Width:" + MyPrimaryScreen.WorkingArea.Width + "   WorkingArea.Height:" + MyPrimaryScreen.WorkingArea.Height + Environment.NewLine +
                "this.Width:" + this.Width + "   this.Height:" + this.Height + Environment.NewLine +
                "单像素比:" + m_f_onepixel_size.ToString() + Environment.NewLine +
                "缩放倍数:" + m_f_zoom_record.ToString() + Environment.NewLine +
                "屏幕像素backrectf  x:" + m_backrectf.X.ToString() + "  y:" + m_backrectf.Y.ToString() + "  width:" + m_backrectf.Width.ToString() + "  height:" + m_backrectf.Height.ToString() + Environment.NewLine +
                "屏幕像素oldbackrectf  x:" + m_old_backrectf.X.ToString() + "  y:" + m_old_backrectf.Y.ToString() + "  width:" + m_old_backrectf.Width.ToString() + "  height:" + m_old_backrectf.Height.ToString() + Environment.NewLine +
                "物理像素back_wl_rectf  x:" + m_back_wl_rectf.X.ToString() + "  y:" + m_back_wl_rectf.Y.ToString() + "  width:" + m_back_wl_rectf.Width.ToString() + "  height:" + m_back_wl_rectf.Height.ToString() + Environment.NewLine +
                "单个Field视域屏幕像素宽:" + m_OneField_Screen_BackRectf.Width.ToString() + " 高:" + m_OneField_Screen_BackRectf.Height.ToString() + Environment.NewLine +
                "单个OTS视域屏幕像素宽:" + m_OneField_OTS_Rectf.Width.ToString() + " 高:" + m_OneField_OTS_Rectf.Height.ToString() + Environment.NewLine +
                "屏幕像素backrectf  x:" + m_backrectf.X.ToString() + "  y:" + m_backrectf.Y.ToString() + "  width:" + m_backrectf.Width.ToString() + "  height:" + m_backrectf.Height.ToString() + Environment.NewLine +
                "包含Field数量:" + m_OTSIncAReportFun.m_field_count.ToString() + " Particle数量:" + m_OTSIncAReportFun.m_particle_count.ToString() + Environment.NewLine +
                "正常显示Paticle数量:" + GetParticleNumberByState(ParticleOperator.DISPLAY).ToString() + " 不显示Particel数量:" + GetParticleNumberByState(ParticleOperator.NODISPLAY).ToString() + Environment.NewLine +
                //"删除Particle数量:" + GetParticleNumberByState("删除").ToString() + " 选中Particle数量:" + GetParticleNumberByState("选择").ToString() + Environment.NewLine +
                "加载底层数据用时:" + m_OTSIncAReportFun.m_time_str + Environment.NewLine +
                "组建并计算图像用时:" + m_OTSIncAReportFun.m_time_str2 + Environment.NewLine +
                "---------------------------END----------------------------------"
                );
#endif
        }
        #endregion



    }
}