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

using OTSIncAReportApp.SysMgrTools;
using OTSIncAReportGraph.Class;
using OTSRptPeriodicTable;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace OTSIncAReportGraph.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 = 170;

        //下坐标尺设定参数
        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 = 0;                                       //整个界面绘制的起始点
        float m_i_draw_end = 1004;                                      //整个界面绘制的边界

        float m_Y_draw_TopDiff = 15;                                    //Y轴距离顶部距离
        float m_Y_MaxValue = 0;                                         //Y轴显示的最大刻度长度

        float m_i_rightdrawlabellocation_x = 850;                       //右上角要显示文字的位置
        float m_i_rightdrawlabellocation_y = 5;                         //右上角要显示文字的位置

        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峰值下界限

        string m_ParticleInfo = "";                                    //颗粒相关信息
        #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 MaterialName
        {
            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; }
        }

        /// <summary>
        /// 显示颗粒相关信息
        /// </summary>
        public string ParticleInfo
        {
            get { return m_ParticleInfo; }
            set { m_ParticleInfo = 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;
        }

        public void SetParticleInfo(string a_ParticleInfo)
        {
            m_ParticleInfo = a_ParticleInfo;
        }

        /// <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_show1 = new float[2000];
            m_f_show2 = new float[2000];

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

            m_list_twopoint1 = new List<TwoPoint>();
            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;
                tp.pf1.Y = old_value;

                tp.pf2.X = i * m_f_zl + m_f_zl;
                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].SX1 != "" && m_list_periodic[i].SX1 != "-")
                {
                    ls_f_sx1 = (float)Convert.ToDouble(m_list_periodic[i].SX1);
                }
                if (m_list_periodic[i].SX2 != "" && m_list_periodic[i].SX2 != "-")
                {
                    ls_f_sx2 = (float)Convert.ToDouble(m_list_periodic[i].SX2);
                }
                if (m_list_periodic[i].SX3 != "" && m_list_periodic[i].SX3 != "-")
                {
                    ls_f_sx3 = (float)Convert.ToDouble(m_list_periodic[i].SX3);
                }

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

        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;
                ls_lkmfpoint.lml_x = (float)in_list_showelementinfo[i].dLF;
                //将该峰值保存到峰值上
                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);
            }

            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


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

            #region 绘制波浪线及线上文字--------------------------------------------------------------------------------------
            if (m_b_show_searchxray == true)
            {
                //画波浪线----第一条线
                for (int i = 0; i < m_list_twopoint1.Count(); i++)
                {
                    PointF ls_pf1 = m_list_twopoint1[i].pf1;
                    ls_pf1.X = ls_pf1.X * f_js_width;
                    PointF ls_pf2 = m_list_twopoint1[i].pf2;
                    ls_pf2.X = ls_pf2.X * f_js_width;

                    g.DrawLine(m_this_p, ls_pf1, ls_pf2);

           

                }
            }
            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 / 20)), m_f_rulerX_location / 3 + i_py, f_js_width * (m_list_kmlfpoint[i].kml_x * (m_i_draw_end / 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 / 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 / 20) - out_testsizef.Width / 2), m_f_rulerX_location / 3 - 20 + i_py));

                    if (m_list_kmlfpoint[i].lml_x != 0)
                    {
                        //绘制竖线
                        g.DrawLine(new Pen(Color.Wheat, 0.5f), f_js_width * (m_list_kmlfpoint[i].lml_x * (m_i_draw_end / 20)), m_f_rulerX_location / 3 + i_py, f_js_width * (m_list_kmlfpoint[i].lml_x * (m_i_draw_end / 20)), m_f_rulerX_location - 3);
                        //输出文字，并将字输出到线的上面
                        SizeF out_testsizef2 = g.MeasureString(m_list_kmlfpoint[i].ysm, m_thisfont);
                        PointF ut_test_pointF2 = 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].lml_x * (m_i_draw_end / 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].lml_x * (m_i_draw_end / 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;
           
            //国际化
            Language lan = new 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)
            {
                //make it 100%
                double sumpercentage = 0;
                for (int i = 0; i < m_list_showelementinfo.Count; i++)
                {
                    sumpercentage += m_list_showelementinfo[i].Percentage;
                
                }
                for (int i = 0; i < m_list_showelementinfo.Count; i++)
                {
                    m_list_showelementinfo[i].percentageIn100 = m_list_showelementinfo[i].Percentage / sumpercentage * 100;

                }



               
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < m_list_showelementinfo.Count; i++)
                {
                    sb.Append(m_list_showelementinfo[i].ElementName);
                    sb.Append("(");
                    sb.Append(m_list_showelementinfo[i].Percentage.ToString("0.00)"));
                }
                sb.Append("\n");
                sb.Append(m_ParticleInfo);
                string str_element = sb.ToString();
                SizeF out_testsizef = g.MeasureString(str_element, m_thisfont);

          
                PointF ls_pt = new PointF(m_i_rightdrawlabellocation_x , m_i_rightdrawlabellocation_y + 60);

                ls_pt.X = (ls_pt.X - out_testsizef.Width/2-10) ;
                
                g.DrawString(str_element, m_thisfont, new SolidBrush(DrawFunction.GetColorByNumber( 1)), ls_pt);
               
            }
          
            #endregion //------------------------------------------------------------------------------------------------------------------

        }
        #endregion

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

}