OTS/OTSIncAMeasureApp/5-OTSMeasureStatuImageFun/Control_XRayTable.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using System.Collections;
using OTSPeriodicTable;

namespace OTSIncAGraph.Controls
{
    /// <summary>
    /// 能谱图类
    /// </summary>
    
    public partial class Control_XRayTable : UserControl
    {
        #region 变量定义
        //定义两个能量值线,用来显示使用
        float[] m_f_show1 = new float[2000];
        float[] m_f_show2 = new float[2000];

        //用来保存实际传入的xray值数，用该数据转换成显示的值
        uint[] m_search_xray = new uint[2000];
        uint[] m_analysis_xray = new uint[2000];

        List<TwoPoint> m_list_twopoint1 = new List<TwoPoint>();
        List<TwoPoint> m_list_twopoint2 = new List<TwoPoint>();

        //记录鼠标所在位置
        Point m_mouse_point = new Point();

        //字体
        Font m_thisfont = new Font("微软雅黑", 8, FontStyle.Regular);
        Font m_thisfont_bold = new Font("微软雅黑", 8, FontStyle.Bold);

        //下标尺分界位置
        float m_f_rulerX_location = 165;

        //下坐标尺设定参数
        float m_i_smalkd = 5;//5像素一个小刻度
        float m_i_bigkd = 25;//25像素一个大刻度
        float m_i_smallkd_number = 200;//小刻度的个数
        float m_i_bigkd_number = 40;//大刻度的个数

        float m_i_draw_start = 33;//整个界面绘制的起始点
        float m_i_draw_end = 1004;//整个界面绘制的边界


        //float m_Y_draw_start = 0;//Y轴的起始点
        //float m_Y_draw_Lenght = 10;//Y轴的刻度长度
        float m_Y_draw_TopDiff = 20;//Y轴距离顶部距离
        float m_Y_MaxValue = 0;//Y轴显示的最大刻度长度
        float m_Y_draw_end = 200;//整个界面绘制的边界高
        float m_i_rightdrawlabellocation_x = 850;//右上角要显示文字的位置
        float m_i_rightdrawlabellocation_y = 5;//右上角要显示文字的位置
        uint m_Y_Value = 50;//Y轴大刻度包含像素数
        SolidBrush m_this_sb = new SolidBrush(Color.Black);//画刷
        SolidBrush m_this_sb_blue = new SolidBrush(Color.Blue);//
        Pen m_this_p = new Pen(Color.Black, 0.5f);           //画笔的颜色
        Pen m_this_p_blue = new Pen(Color.DimGray, 0.5f);       //画笔的颜色 , 分析xray的颜色
        Pen m_mousemove_p = new Pen(Color.PowderBlue, 0.1f);//鼠标移动画的竖线的画笔颜色

        float m_kml_fz_top = 0;       //计算KML峰值记录最高点变量

        float m_xraytopixel_multiple = 40; //比如，从xray0-6000的值，转到显示像素中0-150的比例倍数

        float m_xraysum2 = 0;             //xray计数总和2
        List<Periodic> m_list_periodic;   //元素周期表,相关数据，窗体加载时初始化，然后用来计算使用
        List<KMLFPoint> m_list_kmlfpoint;   //KML峰值，对应的位置和元素名

        //属性相关变量，用来显示使用
        private bool m_b_show_searchxray = false;          //是否绘制搜索xray线,不再显示搜索xray，只显示分析xray
        private bool m_b_show_analysisxray = true;        //设置是否绘制分析xray线
        private string m_goodname = "";                   //夹杂物名称
        private string m_goodchinesename = "";            //夹杂物的中文名称
        private string m_stdname = "";                    //标准名称
        private List<ShowElementInfo> m_list_showelementinfo = null;//需要显示的元素信息列表
        private string m_GBinfostr = "";                    //国标信息显示

        float m_f_zl = 0.5f;      //2000个数据放到1000个像素中计算出的增量

        float m_f_kmlfzpd_max = 30;//KML峰值上界限，进行记数的值,峰值判断的界限，需要按峰值最高值，和
        float m_f_kmlfzpd_mix = 5;//KML峰值下界限
        #endregion

        #region 属性相关

        /// <summary>
        /// 显示国标分类相关信息
        /// </summary>
        public string GBInfoStr
        {
            get { return m_GBinfostr; }
            set { m_GBinfostr = value; }
        }

        /// <summary>
        /// 设置是否绘制搜索Xray,默认为显示
        /// </summary>
        public bool ShowSearchXray
        {
            get { return m_b_show_searchxray; }
            set { m_b_show_searchxray = value; }
        }

        /// <summary>
        /// 显示当前夹杂物的名称
        /// </summary>
        public string GoodName
        {
            get { return m_goodname; }
            set { m_goodname = value; }
        }

        /// <summary>
        /// 显示当前夹杂物的中文名称
        /// </summary>
        public string GoodChineseName
        {
            get { return m_goodchinesename; }
            set { m_goodchinesename = value; }
        }

        /// <summary>
        /// 显示当前能谱物品的测试标准名
        /// </summary>
        public string STDName
        {
            get { return m_stdname; }
            set { m_stdname = value; }
        }

        /// <summary>
        /// 显示元素列表相关信息
        /// </summary>
        public List<ShowElementInfo> List_ShowElementInfo
        {
            get { return m_list_showelementinfo; }
            set { m_list_showelementinfo = value; }
        }

        /// <summary>
        /// 设置是否绘制分析Xray,默认为显示
        /// </summary>
        public bool ShowAnalysisXray
        {
            get { return m_b_show_analysisxray; }
            set { m_b_show_analysisxray = value; }
        }
        #endregion

        #region 构造函数
        public Control_XRayTable()
        {
            InitializeComponent();
        }

      

        /// <summary>
        /// 需要确定下来倍数后，从xray最大值6000,转换成显示最大值150的比例转换
        /// </summary>
        /// <param name="in_value"></param>
        /// <returns></returns>
        private float GetValueByRatio(uint in_value)
        {
            return in_value / m_xraytopixel_multiple;
        }

        /// <summary>
        /// 设置搜索xray和分析xray值到，记录变量中，及转换成显示变量中，用来供XrayTable显示及计算使用
        /// </summary>
        /// <param name="search_xray"></param>
        /// <param name="analysis_xray"></param>
        public void SetXRayShowLineValue(uint[] search_xray,uint[] analysis_xray,List<ShowElementInfo> in_list_showelementinfo)
        {
            //重新加载时，对当前的宽度等重新加载并计算
            m_i_draw_end = this.Width;
            m_i_smalkd = (m_i_draw_end - 4) / m_i_smallkd_number;//按宽度重新计算小刻度的长度 -4是有4像素的边框差
            m_i_bigkd = (m_i_draw_end - 4) / m_i_bigkd_number;   //按宽度重新计算大刻度的长度


            #region 重新初始化相关全局变量
            m_list_periodic = CListPeriodic.GetListPeriodic();
            m_list_kmlfpoint = new List<KMLFPoint>();
            m_f_show2 = new float[2000];

            //用来保存实际传入的xray值数，用该数据转换成显示的值
            m_analysis_xray = new uint[2000];
            m_list_twopoint2 = new List<TwoPoint>();
            m_list_showelementinfo = new List<ShowElementInfo>();
            //初始化xray之和为0,之后开始进行求和计算
            m_xraysum2 = 0;
            //重新初始化高度比例尺
            m_xraytopixel_multiple = 0;
            //标准库名
            m_stdname = "无";
            #endregion
            //校验数据错误，防止空数据
            if (analysis_xray.Count() == 0)
            {
                return;
            }
            //再防止全数据为0
            uint ls_u_jcwl = 0;
            for (int i = 0; i < analysis_xray.Count(); i++)
            {
                if (analysis_xray[i] > ls_u_jcwl)
                    ls_u_jcwl = analysis_xray[i];
            }
            if (ls_u_jcwl == 0)
            {
                return;
            }
            //比例尺，要根据传入的数据，自动进行计算的
            //逻辑那就应该是取最大的xray得到的值，加一点，然后除以我可以显示的像素分辨率，得到的倍数，后面都用这个倍数进行计算

            //取出最大的xray值,计算倍数---------------------------------------------------
            uint max_xra = 0;
            for (int i = 0; i < analysis_xray.Length; i++)
            {
                if (max_xra < analysis_xray[i])
                {
                    max_xra = analysis_xray[i];
                }
            }
            //用最大的值除以可用来显示的像素，得到倍数
            m_xraytopixel_multiple = (float)(Convert.ToDouble(max_xra) / Convert.ToDouble(150));
            //如果长度不是2000的话，不操作
            if (analysis_xray.Length == 2000)
            {
                //保存实际传入的值
                m_analysis_xray = analysis_xray;
                for (int i = 0; i < analysis_xray.Length; i++)
                {
                    //这里按比例进行转换
                    m_f_show2[i] = GetValueByRatio( analysis_xray[i]);
                    m_xraysum2 = m_xraysum2 + analysis_xray[i];
                }
            }

            //生成xray对应的绘制线段
            float old_value = m_f_rulerX_location - 2;//从基础线-2的位置上进行绘制
                                                    //float f_zl = 0.5f;//坐标值的增量，以小数做为增量的值,,,,这个坐标的增量应该根据实际的显示长度进行修改
                                                    //当1000个像素时显示2000个数据，需要2000/1000=0.5f
                                                    //0.5f就是2000个数据需要放到1000个像素中的计算系数
                                                    
            double ls_width = m_i_draw_end;//改成固定值,整个绘制浪线的总长
            double ls_cs = 2000;
            m_f_zl = (float)(ls_width / ls_cs);

            //计算KML峰值判定的上标值与下标值
            GetKMLFPD_MAXANDMIN(m_analysis_xray);

            old_value = m_f_rulerX_location - 2;
            for (int i = 0; i < m_f_show2.Length; i++)
            {
                TwoPoint tp = new TwoPoint();
                tp.pf1.X = i * m_f_zl + m_i_draw_start;
                tp.pf1.Y = old_value;

                tp.pf2.X = i * m_f_zl + m_f_zl + m_i_draw_start;
                tp.pf2.Y = m_f_rulerX_location - 2 - m_f_show2[i];
                tp.value = m_analysis_xray[i];
                tp.kmlf_value = (float)(Convert.ToDouble(i) / Convert.ToDouble(100));

                //重新实现计算峰值上显示元素的计算方法
                //CalcKMLFPoint(tp);

                old_value = m_f_rulerX_location - 2 - m_f_show2[i];

                m_list_twopoint2.Add(tp);
            }

            //重新实现的计算峰值上显示元素的计算方法
            CalcKMLFPoint(in_list_showelementinfo);

            m_list_showelementinfo = in_list_showelementinfo;

            this.Invalidate();
        }

        /// <summary>
        /// 根据传入的2000个峰值点，计算出有效参与计算的峰值判定高点，和低点，两个点
        /// </summary>
        /// <param name="in_xray"></param>
        /// <returns></returns>
        private void GetKMLFPD_MAXANDMIN(uint[] in_xray)
        {
            float f_lsmax = 0;
            //方法是，按50%为高点，10%为低点
            for (int i = 0; i < in_xray.Count(); i++)
            {
                if (f_lsmax < in_xray[i])
                {
                    f_lsmax = in_xray[i];
                }
            }

            m_f_kmlfzpd_max = (float)(f_lsmax * 0.3);//最顶点的峰
            m_f_kmlfzpd_mix = (float)(f_lsmax * 0.1);
            return ;
        }

        /// <summary>
        /// 根据传入的值，及获取的范围，来判断，该值大概为是什么元素的
        /// </summary>
        /// <param name="kml_value">传入的峰值</param>
        /// <param name="f_rect">范围</param>
        /// <returns></returns>
        private string GetElementNameByKMLRange(float kml_value, float f_rect)
        {
            string str_ret = "";
            float ls_f_sx1 = 0;
            float ls_f_sx2 = 0;
            float ls_f_sx3 = 0;
            for (int i = 0; i < m_list_periodic.Count(); i++)
            {
                //先对三个值进行转换，转出应有的值
                if (m_list_periodic[i].K_Peak != "" && m_list_periodic[i].K_Peak != "-")
                {
                    ls_f_sx1 = (float)Convert.ToDouble(m_list_periodic[i].K_Peak);
                }
                if (m_list_periodic[i].L_Peak != "" && m_list_periodic[i].L_Peak != "-")
                {
                    ls_f_sx2 = (float)Convert.ToDouble(m_list_periodic[i].L_Peak);
                }
                if (m_list_periodic[i].M_Peak != "" && m_list_periodic[i].M_Peak != "-")
                {
                    ls_f_sx3 = (float)Convert.ToDouble(m_list_periodic[i].M_Peak);
                }

                //然后再对该值进行判断，如果在范围内，则判断为该元素
                if (kml_value >= (ls_f_sx1 - f_rect) && kml_value < (ls_f_sx1 + f_rect))
                {
                    str_ret = m_list_periodic[i].Symbol;
                    break;
                }
                if (kml_value >= (ls_f_sx2 - f_rect) && kml_value < (ls_f_sx2 + f_rect))
                {
                    str_ret = m_list_periodic[i].Symbol ;
                    break;
                }
                if (kml_value >= (ls_f_sx3 - f_rect) && kml_value < (ls_f_sx3 + f_rect))
                {
                    str_ret = m_list_periodic[i].Symbol;
                    break;
                }
            }

            return str_ret;
        }


        /// <summary>
        /// 在循环遍历中，计算KML峰值中心点
        /// </summary>
        /// <param name="tp"></param>
        private void CalcKMLFPoint(TwoPoint tp)
        {
            //大于平均点值 max时,开始记录,2018-10-23重新实现
            if (tp.value > m_f_kmlfzpd_max)
            {
                m_kml_fz_top = tp.kmlf_value;
            }
            else if( tp.value < m_f_kmlfzpd_mix && m_kml_fz_top != 0)//平均小于平均峰值 min时，结束记录,并将峰值保存，记录峰值元素
            {
                //构造KML峰值list对象
                KMLFPoint ls_lkmfpoint = new KMLFPoint();
                ls_lkmfpoint.kml_x = m_kml_fz_top;

                //查找出该峰值是什么元素的, 待完成
                ls_lkmfpoint.ysm = GetElementNameByKMLRange(m_kml_fz_top, 0.2f);

                //将该峰值保存到峰值上
                m_list_kmlfpoint.Add(ls_lkmfpoint);
                m_Y_MaxValue = m_kml_fz_top;
                m_kml_fz_top = 0;
            }

            #region 该方法先保留，待重写观察效果
            ////当峰值大于了 某值，判定值,同时，记录峰起点值是0时,为记录峰值开始
            //if (tp.value >= f_kmlfzpd_mix && kml_fz_start == 0)
            //{
            //    kml_fz_start = tp.kmlf_value;//记录峰值起点
            //}
            //else
            //{
            //    //记录该阶段最高的峰值
            //    if (kml_fz_top < tp.kmlf_value)
            //        kml_fz_top = tp.kmlf_value;

            //    //这里又记录的结束点，如果判断到了结束点，那么就用开始点和结束点，来计算峰值的中心位置在哪
            //    if (tp.value < f_kmlfzpd_mix && kml_fz_start != 0)
            //    {
            //        //说明已经在峰值结束后，的区间了
            //        //保存峰值end
            //        kml_fz_end = tp.kmlf_value;//记录峰值结束点

            //        //计算峰值中心点,起点+(结束点-起点=起止段长)/2，就是起点+半段长，为峰值中心
            //        kml_fz_start = kml_fz_start + (kml_fz_end - kml_fz_start) / 2;

            //        //构造KML峰值list对象
            //        KMLFPoint ls_lkmfpoint = new KMLFPoint();
            //        //ls_lkmfpoint.kml_x = kml_fz_start;//不再使用中间阶段
            //        ls_lkmfpoint.kml_x = kml_fz_top;

            //        //查找出该峰值是什么元素的, 待完成
            //        ls_lkmfpoint.ysm = GetElementNameByKMLRange(kml_fz_start, 0.2f);
            //        //ls_lkmfpoint.ysm = "元素名";

            //        //将该峰值保存到峰值上
            //        m_list_kmlfpoint.Add(ls_lkmfpoint);

            //        //最后再将记录kml峰值的起和止，都新初始化一下
            //        kml_fz_start = 0;
            //        kml_fz_end = 0;
            //        kml_fz_top = 0;
            //    }
            //}
            #endregion
        }

        private void CalcKMLFPoint(List<ShowElementInfo> in_list_showelementinfo)
        {
            for (int i = 0; i < in_list_showelementinfo.Count; i++)
            {
                KMLFPoint ls_lkmfpoint = new KMLFPoint();
                ls_lkmfpoint.ysm = in_list_showelementinfo[i].ElementName;
                //ls_lkmfpoint.kml_x = (float)(in_list_showelementinfo[i].dKF * 1000 / 20);
                ls_lkmfpoint.kml_x = (float)in_list_showelementinfo[i].dKF;

                //将该峰值保存到峰值上
                m_list_kmlfpoint.Add(ls_lkmfpoint);
            }
        }

        private void Control_XRayTable_Load(object sender, EventArgs e)
        {
            #region 设置背景透明及开启双缓冲
            //设置Style支持透明背景色
            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);

            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true); // 禁止擦除背景.
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true); // 双缓冲
            this.BackColor = Color.FromArgb(180, 255, 255, 255);
            #endregion

            //初始化变量，如果不初始化会在设计模式下报错
            m_list_showelementinfo = new List<ShowElementInfo>();
        }
        #endregion

        #region 绘制事件
        protected override void OnPaint(PaintEventArgs e)
        {
            Graphics g = e.Graphics;

            DrawXrayImage(g);
        }

        /// <summary>
        /// 封装绘制能谱数据方法
        /// </summary>
        /// <param name="g"></param>
        protected void DrawXrayImage(Graphics g)
        {
            #region //绘制标尺表盘部份----------------------------------------------------------------------------------------------

            //宽度比的缩放基数
            float f_js_width = 1;//经过考虑，先定为1,为固定的像素进行绘制
            #region 绘制下面的标尺
            //x轴标尺的线
            g.DrawLine(m_this_p, m_i_draw_start, m_f_rulerX_location, m_i_draw_end * f_js_width, m_f_rulerX_location);


            ////200个小刻度
            //for (int i = 0; i < m_i_smallkd_number; i++)
            //{
            //    g.DrawLine(m_this_p, m_i_draw_start + (i * m_i_smalkd * f_js_width), m_f_rulerX_location, m_i_draw_start + (i * m_i_smalkd * f_js_width), m_f_rulerX_location + 5);
            //}
            //y轴标尺的线
            g.DrawLine(m_this_p, m_i_draw_start, m_f_rulerX_location, m_i_draw_start, -m_Y_draw_end + m_Y_draw_TopDiff + m_f_rulerX_location + 20);
            int i_count = 0;
            //40个大刻度
            for (int i = 0; i < m_i_bigkd_number; i++)
            {
                g.DrawLine(m_this_p, m_i_draw_start + (i * m_i_bigkd * f_js_width), m_f_rulerX_location, m_i_draw_start + (i * m_i_bigkd * f_js_width), m_f_rulerX_location + 10);
                //每隔两刻度增长写字
                if (i % 2 == 0)
                {
                    i_count++;
                    g.DrawString((i_count - 1).ToString(), m_thisfont_bold, m_this_sb, m_i_draw_start + (i * m_i_bigkd * f_js_width) + 1, m_f_rulerX_location + 10);
                }
            }

            //补充输入文字，为了美观
            //g.DrawString("kv", m_thisfont_bold, m_this_sb, 8, m_f_rulerX_location + 10);
            #endregion

            #region 绘制x-ray线的边框
            //x-ray画线的左边线
            g.DrawLine(m_this_p, m_i_draw_start, m_i_draw_start + m_Y_draw_TopDiff, m_i_draw_start * f_js_width, m_f_rulerX_location - 2);
            //x-ray画线的底盘
            //g.DrawLine(m_this_p, m_i_draw_start, m_f_rulerX_location - 2, m_i_draw_end* f_js_width, m_f_rulerX_location - 2);
            #endregion

            #region 图谱Y轴最高刻度
            int m_Y_Value_Count = (int)Math.Floor(m_xraytopixel_multiple * 150 / 25);
            m_Y_Value = (uint)(m_Y_Value_Count / 4) * 25;
            if (m_Y_Value == 0)
            {
                m_Y_Value = (uint)Math.Floor(m_xraytopixel_multiple * 150 / 2);
            }
            if (m_xraytopixel_multiple != 0)
            {
                //纵坐标
                for (int i = 0; i < 30; i++)
                {
                    if (i * m_Y_Value <= m_xraytopixel_multiple * 150)
                    {
                        g.DrawLine(m_this_p, m_i_draw_start, m_f_rulerX_location - (i * GetValueByRatio(m_Y_Value) * f_js_width), m_i_draw_start + 3, m_f_rulerX_location - (i * GetValueByRatio(m_Y_Value) * f_js_width));
                        int aa = i * Convert.ToInt16(m_Y_Value);
                        g.DrawString(aa.ToString(), m_thisfont_bold, m_this_sb, m_i_draw_start - 10 - ((aa.ToString().Length - 1) * 6), m_f_rulerX_location - (i * GetValueByRatio(m_Y_Value) * f_js_width) - 7);
                    }
                }
            }
            #endregion

            #endregion //--------------------------------------------------------------------------------------------------------

            #region 绘制波浪线及线上文字--------------------------------------------------------------------------------------
            if (m_b_show_analysisxray == true)
            {
                //画波浪线----第二条线
                for (int i = 0; i < m_list_twopoint2.Count(); i++)
                {
                    PointF ls_pf1_2 = m_list_twopoint2[i].pf1;
                    ls_pf1_2.X = ls_pf1_2.X * f_js_width;
                    PointF ls_pf2_2 = m_list_twopoint2[i].pf2;
                    ls_pf2_2.X = ls_pf2_2.X * f_js_width;

                    g.DrawLine(m_this_p_blue, ls_pf1_2, ls_pf2_2);

                    //找到最高值再输出的方式
                    //if (list_twopoint2[i].pf2.Y < 60)
                    //{
                    //    g.DrawString(list_twopoint2[i].value.ToString() + "@ev", thisfont_bold, this_sb_blue, list_twopoint2[i].pf2.X + 3, list_twopoint2[i].pf2.Y);
                    //}
                }
            }

            #endregion //----------------------------------------------------------------------------------------------------------------

            #region //绘制峰值上的线-----------------------------------------------------------------------------------------------
            if (m_list_kmlfpoint != null)
            {
                for (int i = 0; i < m_list_kmlfpoint.Count(); i++)
                {
                    //为了让元素标签不在同一高度显示，为了美观，也是防止会重叠，所以这里计算一下
                    int i_py = 0;//设置元素标签的偏移
                    if (i % 2 == 1)
                        i_py = 0;
                    else
                        i_py = 20;

                    //先把峰值上的文字去掉，因为这里与底层分析出的结果不太一致，为了不产生疑问所以这里去掉

                    //绘制竖线
                    g.DrawLine(new Pen(Color.Wheat, 0.5f), f_js_width * (m_list_kmlfpoint[i].kml_x * ((m_i_draw_end- m_i_draw_start) / 20) ), m_f_rulerX_location / 3 + i_py, f_js_width * (m_list_kmlfpoint[i].kml_x * ((m_i_draw_end - m_i_draw_start) / 20) ), m_f_rulerX_location - 3);
                    //输出文字，并将字输出到线的上面
                    SizeF out_testsizef = g.MeasureString(m_list_kmlfpoint[i].ysm, m_thisfont);
                    PointF ut_test_pointF = new PointF(m_mouse_point.X - (out_testsizef.Width / 2), 2);
                    g.FillRectangle(Brushes.Goldenrod, new RectangleF(new PointF(f_js_width * (m_list_kmlfpoint[i].kml_x * ((m_i_draw_end - m_i_draw_start) / 20) - out_testsizef.Width / 2), m_f_rulerX_location / 3 - 20 + i_py), out_testsizef));
                    g.DrawString(m_list_kmlfpoint[i].ysm,
                        m_thisfont_bold,
                        m_this_sb,
                        new PointF(f_js_width * (m_list_kmlfpoint[i].kml_x * ((m_i_draw_end - m_i_draw_start) / 20) - out_testsizef.Width / 2), m_f_rulerX_location / 3 - 20 + i_py));
                }
            }
            #endregion 

            #region 绘制鼠标移动显示的线及线上文字---------------------------------------------------------------------------------------
            //再绘制鼠标所在位置的竖线---------------------第一条线
            g.DrawLine(m_mousemove_p, m_mouse_point.X , m_i_draw_start, m_mouse_point.X, m_f_rulerX_location - 3);

            string ls_label_str = "";
            for (int i = 0; i < m_list_twopoint2.Count(); i++)
            {
                //判断要按条件进行显示，值大于200才进行显示，用循环i的位置进行判断，在不变动这些数组时，这种写法是正确的
                if (m_analysis_xray[i] > m_f_kmlfzpd_mix)
                {
                    //用绘线线段，的起始点与鼠标当前位置进行对应上的话，那么就进行取kmlf值，进行显示
                    if (Convert.ToInt32(m_list_twopoint2[i].pf1.X * f_js_width) == m_mouse_point.X)
                    {
                        ls_label_str = m_list_twopoint2[i].kmlf_value.ToString();
                    }
                    if (Convert.ToInt32(m_list_twopoint2[i].pf2.X * f_js_width) == m_mouse_point.X)
                    {
                        ls_label_str = m_list_twopoint2[i].kmlf_value.ToString();
                    }
                }
            }
            if (ls_label_str != "")
                ls_label_str = Convert.ToDouble(ls_label_str).ToString("0.000");//显示浮点数，为了美观

            //绘制鼠标竖线上的定位文字
            SizeF sizeF = g.MeasureString(ls_label_str, m_thisfont);
            PointF pointF = new PointF(m_mouse_point.X - (sizeF.Width / 2), 2);
            g.FillRectangle(Brushes.SkyBlue, new RectangleF(pointF, sizeF));
            g.DrawString(ls_label_str, m_thisfont_bold, m_this_sb, pointF);
            #endregion

            #region //右上角输出文字设置-------------------------------------------------------------------------------------------------
            m_i_rightdrawlabellocation_x = m_i_draw_end * f_js_width - 260;
            //国标
            //g.DrawString("国标:", m_thisfont, m_this_sb, new PointF(m_i_rightdrawlabellocation_x, m_i_rightdrawlabellocation_y));
            //
            //国际化
            OTSCommon.Language lan = new OTSCommon.Language();
            Hashtable table = lan.GetNameTable("Control_XRayTable");
            string str1 = table["str1"].ToString();
            string str2 = table["str2"].ToString();
            g.DrawString(str1, m_thisfont, m_this_sb, new PointF(m_i_rightdrawlabellocation_x, m_i_rightdrawlabellocation_y + 20));
            //g.DrawString("高度比例尺:", m_thisfont, m_this_sb, new PointF(m_i_rightdrawlabellocation_x, m_i_rightdrawlabellocation_y + 20));
            g.DrawString(str2, m_thisfont, m_this_sb, new PointF(m_i_rightdrawlabellocation_x, m_i_rightdrawlabellocation_y + 40));

            //显示国标相关信息
            g.DrawString(m_GBinfostr, m_thisfont_bold, m_this_sb, new PointF(m_i_rightdrawlabellocation_x, m_i_rightdrawlabellocation_y));
            //计算值显示,计数率
            g.DrawString(m_xraysum2.ToString(), m_thisfont_bold, m_this_sb, new PointF(m_i_rightdrawlabellocation_x + 50, m_i_rightdrawlabellocation_y + 20));
            //高度比例尺值显示
            //g.DrawString(m_xraytopixel_multiple.ToString("0.0"), m_thisfont_bold, m_this_sb, new PointF(m_i_rightdrawlabellocation_x + 50, m_i_rightdrawlabellocation_y + 20));
            //物质名显示
            g.DrawString(m_goodname, m_thisfont_bold, m_this_sb, new PointF(m_i_rightdrawlabellocation_x + 50, m_i_rightdrawlabellocation_y + 40));

            //show element list information,using the elementlist number to make sure width,number take width 25 growth
            if (m_list_showelementinfo != null)
            {
                PointF ls_pt = new PointF(m_i_rightdrawlabellocation_x - (m_list_showelementinfo.Count * 25 - 60), m_i_rightdrawlabellocation_y + 60);
                for (int i = 0; i < m_list_showelementinfo.Count; i++)
                {
                    string str_element = "" + m_list_showelementinfo[i].ElementName + "(" + m_list_showelementinfo[i].Percentage.ToString("0.00") + ")";
                    SizeF out_testsizef = g.MeasureString(str_element, m_thisfont);
                    g.DrawString(str_element, m_thisfont, new SolidBrush(GetColorByNumber(i + 1)), ls_pt);
                    ls_pt.X = ls_pt.X + out_testsizef.Width + 2;
                }
            }
            //标准库显示
            //g.DrawString("标准来自: "+m_stdname, m_thisfont, m_this_sb_blue, new PointF(m_i_rightdrawlabellocation_x + 10, m_i_rightdrawlabellocation_y + 80));
            #endregion //------------------------------------------------------------------------------------------------------------------

        }
        #endregion
        public static Color GetColorByNumber(int number)
        {
            Color ret_color = new Color();
            switch (number)
            {
                case 1:
                    ret_color = Color.Blue;
                    break;
                case 2:
                    ret_color = Color.Brown;
                    break;
                case 3:
                    ret_color = Color.LimeGreen;
                    break;
                case 13:
                    ret_color = Color.Cyan;
                    break;
                case 4:
                    ret_color = Color.DarkBlue;
                    break;
                case 5:
                    ret_color = Color.Red;
                    break;
                case 6:
                    ret_color = Color.SaddleBrown;
                    break;
                case 7:
                    ret_color = Color.DimGray;
                    break;
                case 8:
                    ret_color = Color.Navy;
                    break;
                case 9:
                    ret_color = Color.Peru;
                    break;
                case 10:
                    ret_color = Color.Red;
                    break;
                case 11:
                    ret_color = Color.SeaGreen;
                    break;
                case 12:
                    ret_color = Color.MintCream;
                    break;
                case 14:
                    ret_color = Color.PaleTurquoise;
                    break;
                case 15:
                    ret_color = Color.SeaShell;
                    break;
                case 16:
                    ret_color = Color.Snow;
                    break;
                case 17:
                    ret_color = Color.WhiteSmoke;
                    break;

                default:
                    ret_color = Color.White;
                    break;
            }

            return ret_color;
        }
        #region 导出绘制的XRay能谱方法
        /// <summary>
        /// 导出能谱的图像截图Bitmap对象
        /// </summary>
        /// <param name="in_str_path"></param>
        /// <returns></returns>
        public Bitmap ExportXRayImage()
        {
            Bitmap ret_bmp = new Bitmap(this.Width, this.Height);
            //Graphics g = this.CreateGraphics();

            //g.DrawImage(ret_bmp, new Point(0, 0));
            //DrawXrayImage(g);

            //Bitmap image = new Bitmap(this.Width, this.Height);
            this.DrawToBitmap(ret_bmp, new Rectangle(0, 0, this.Width, this.Height));

            return ret_bmp;
        }



        #endregion

        #region 鼠标移动事件
        protected override void OnMouseMove(MouseEventArgs e)
        {
            //记录鼠标移动到的点，用来绘制用
            m_mouse_point = new Point(e.X, e.Y);
            this.Invalidate();
        }
        #endregion

    }

    #region 用来显示连接线封装的类
    /// <summary>
    /// 封装两个点的一个类
    /// </summary>
    [Serializable]
    public class TwoPoint
    {
        public PointF pf1;
        public PointF pf2;
        public float value;
        public float kmlf_value;
    }

    /// <summary>
    /// 记录显示的KML峰值类，分别记录kml峰值的x坐标，和峰值对应的一左一右的元素名
    /// </summary>
    [Serializable]
    public class KMLFPoint
    {
        public float kml_x;
        public float lml_x;
        public string ysm;
    }

    /// <summary>
    /// show x-ray info with element list,the element information class
    /// </summary>
    [Serializable]
    public class ShowElementInfo
    {
        public string ElementName;
        public double Percentage;//实际能谱返回的质量百分比
        public double dKF;//K峰,元素周期表中固定值
        public double dLF;//L峰
        public double percentageIn100;//归一化后的百分比
    }
    #endregion

}