横纵断面计算

1.Point.cs

    class Point
    {

        public string name;
        public double x;
        public double y;
        public double h;
        public double distance;
        public bool isDatum;


        public Point()
        {
            isDatum = false;
        }
            


    }

2.Profile.cs

    class Profile
    {
        public Point start;
        public Point end;

        public List<Point> totalPoints;

        public List<List<Point>> nearPointsOfInner;

        public double sumS;



        public DataTable InnerInfoToTable()
        {
            DataTable dt = new DataTable();
            if (start == null)
            {
                dt.TableName = "道路纵断面";
            }
            else dt.TableName = start.name + "--" + end.name + "段的横断面";


            dt.Columns.Add("内插点号", typeof(string));
            dt.Columns.Add("X坐标（m）", typeof(double));
            dt.Columns.Add("Y坐标（m）", typeof(double));
            dt.Columns.Add("内插高程（m）", typeof(double));
            dt.Columns.Add("邻近点1", typeof(string));
            dt.Columns.Add("邻近点2", typeof(string));
            dt.Columns.Add("邻近点3", typeof(string));
            dt.Columns.Add("邻近点4", typeof(string));
            dt.Columns.Add("邻近点5", typeof(string));

            int tmp = 0;
            foreach (var a in totalPoints)
            {
                if(!a.isDatum)
                {
                    DataRow dr = dt.NewRow();
                    dr[0] = a.name;
                    dr[1] = a.x;
                    dr[2] = a.y;
                    dr[3] = a.h;

                    dr[4] = nearPointsOfInner[tmp][0].name;
                    dr[5] = nearPointsOfInner[tmp][1].name;
                    dr[6] = nearPointsOfInner[tmp][2].name;
                    dr[7] = nearPointsOfInner[tmp][3].name;
                    dr[8] = nearPointsOfInner[tmp][4].name;
                    dt.Rows.Add(dr);
                    tmp++;
                }

            }

            return dt;
        }

    }

3.DataCenter.cs

    class DataCenter
    {
        public List<Point> datumPoints;//道路关键点
        public List<Point> orgPoints;//读入的高程点
        public double RDH; //参考高程点

        public Profile vertical;//道路纵断面对象
        public List<Profile> hoz;//道路横断面对象的集合

        public List<Point> test;

        public bool dataFlag;//标志用户操作的变量
        public bool hozFlag;
        public bool verFlag;
        public int focus;

        public DataCenter()
        {
            datumPoints = new List<Point>();
            orgPoints = new List<Point>();
            vertical = new Profile();
            hoz = new List<Profile>();

            test = new List<Point>();
            dataFlag = false;
            hozFlag = false;
            verFlag = false;
            focus = -1;
        }



        /// <summary>
        /// 将原始点整合成数据表
        /// </summary>
        /// <returns></returns>
        public DataTable orgPointsToTable()
        {
            DataTable dt = new DataTable();
            dt.Columns.Add("点名", typeof(string ));
            dt.Columns.Add("X坐标(m)",typeof(double ));
            dt.Columns.Add("Y坐标(m)", typeof(double));
            dt.Columns.Add("H(m)", typeof(double));

            foreach (var point in orgPoints )
            {
                DataRow dr = dt.NewRow();
                dr["点名"] = point.name;
                dr["X坐标(m)"] = point.x;
                dr["Y坐标(m)"] = point.y;
                dr["H(m)"] = point.h;
                dt.Rows.Add(dr);
            }
            return dt;

        }


        /// <summary>
        /// 输出计算报告
        /// </summary>
        /// <returns></returns>
        public string GetReport()
        {
            string str = "";
            str += "---------------------------------------------------计算报告---------------------------------------------------";
            str += "\r\n";
            str += "\r\n";
            str += "\r\n";
            str += "\r\n";
            str += "---------------------------------第一部分：基本算法---------------------------------";
            str += "\r\n";
            str += "\r\n";
            str += "1.1 测试点A、B的坐标方位角：" + Algorithm.RadToDMS(Algorithm.CalAngle(test[0], test[1]));
            str += "\r\n";
            str += "\r\n";

            List<Point> tmpNear ;
            double tmp= Algorithm.GetInnerH(datumPoints[1], orgPoints, 5, out tmpNear);
            str += "1.2 K1点的内插高程：" + tmp.ToString("f3")+"m";
            str += "\r\n";
            str += "临近点点号   距离";
            str += "\r\n";
            for (int i = 0; i < tmpNear.Count; i++)
            {
                str += tmpNear[i].name + "   " + tmpNear[i].distance.ToString("f3");
                str += "\r\n";
            }
            str += "\r\n";
            str += "\r\n";


            str += "1.3 以K0，K1点为两个端点的梯形面积：" + Algorithm.CalS(datumPoints[0],datumPoints[1],RDH).ToString("f3") + "平方米";
            str += "\r\n";
            str += "\r\n";
            str += "\r\n";
            str += "\r\n";

            str += "---------------------------------第二部分：纵断面计算---------------------------------";
            str += "\r\n";
            str += "\r\n";
            str += "2.1 线路总长度：" + vertical.totalPoints.Last().distance.ToString("f3") + "m";
            str += "\r\n";
            str += "\r\n";
            str += "2.2 内插点坐标及高程：";
            str += "\r\n";
            str += "内插点号    X坐标（m）    Y坐标（m）    内插高程（m）";
            str += "\r\n";
            foreach (var a in vertical.totalPoints)
            {
                if (!a.isDatum)
                {
                    str += a.name + "   " + a.x.ToString("f3").PadRight(12, ' ') + a.y.ToString("f3").PadRight(12, ' ') + a.h.ToString("f3").PadRight(12, ' ');
                    str += "\r\n";
                }

            }
            str += "\r\n";
            str += "\r\n";
            str += "2.3 纵断面面积：" + vertical.sumS.ToString("f3") + "平方米";
            str += "\r\n";
            str += "\r\n";
            str += "\r\n";
            str += "\r\n";

            str += "---------------------------------第三部分：横断面计算---------------------------------";
            str += "\r\n";
            str += "\r\n";

            foreach (var a in hoz)
            {

                str += "**********************  "+a.start.name + "--" + a.end.name + "路线的横断面信息  **********************";
                str += "\r\n";
                str += "\r\n";

                foreach (var b in a.totalPoints)
                {
                    if(b.isDatum)
                    {
                        str += "横断面中心点坐标：" + "X:" + b.x.ToString("f3") + "   " + "Y:" + b.y.ToString("f3")+ "   " + "H:" + b.h.ToString("f3");
                    }
                }

                str += "\r\n";
                str += "\r\n";
                str += "横断面面积：" + a.sumS.ToString("f3") + "平方米";

                str += "\r\n";
                str += "\r\n";
                str += "横断面上内插点信息：";
                str += "\r\n";
                str += "内插点号".PadRight(6,' ')+ "X坐标（m）".PadRight(9, ' ') + "Y坐标".PadRight(9, ' ') + "内插高程（m）".PadRight(15, ' ') +"邻近的5个点的点号";
                str += "\r\n";
                int ind = 0;
                foreach (var b in a.totalPoints)
                {
                    
                    if (!b.isDatum)
                    {

                        str += b.name.PadRight(12, ' ') + b.x.ToString("f3").PadRight(14, ' ') + b.y.ToString("f3").PadRight(14, ' ') + b.h.ToString("f3").PadRight(16, ' ');

                        for (int i = 0; i < a.nearPointsOfInner[ind].Count; i++)
                        {
                            str += a.nearPointsOfInner[ind][i].name + "  ";
                        }
                        str += "\r\n";
                        ind ++;
                    }
                }
                str += "\r\n";
                str += "\r\n";
                str += "\r\n";
                str += "\r\n";

            }

            return str;
        }


    }

4.Algorithm.cs

    class Algorithm
    {
        /// <summary>
        /// 计算内插高程
        /// </summary>
        /// <param name="a">内插点</param>
        /// <param name="orgPoints">原始高程点集</param>
        /// <param name="n">搜索点数</param>
        /// <param name="nearPoints">返回的邻近点</param>
        /// <returns>内插高程</returns>
        public static double GetInnerH(Point a, List<Point> orgPoints, int n, out List<Point> nearPoints)
        {
            List<Point> tmpPoints = new List<Point>();
            orgPoints.ForEach(o => tmpPoints.Add(o));//深拷贝一份数据

            for (int i = 0; i < tmpPoints.Count; i++)
            {//计算每个点与目标点的移除同名点，防止报错

                tmpPoints[i].distance = CalDistance(tmpPoints[i], a);
                if (a.name == tmpPoints[i].name)
                {
                    tmpPoints.Remove(tmpPoints[i]);
                    i--;
                }
            }

            tmpPoints = tmpPoints.OrderBy(o => o.distance).ToList();//按距离值从小到大排序

            double tmp1 = 0;
            double tmp2 = 0;
            nearPoints = new List<Point>();
            for (int i = 0; i < n; i++)
            {
                tmp1 += tmpPoints[i].h / tmpPoints[i].distance;
                tmp2 += 1.0 / tmpPoints[i].distance;
                nearPoints.Add(tmpPoints[i]);

            }
            return tmp1 / tmp2;
        }


        /// <summary>
        /// 计算梯形面积
        /// </summary>
        /// <param name="a">左上角点</param>
        /// <param name="b">右上角点</param>
        /// <param name="RDH">参考高程</param>
        /// <returns>梯形面积</returns>
        public static double CalS(Point a, Point b, double RDH)
        {
            double d = CalDistance(a, b);
            double s = d * (a.h + b.h - 2 * RDH) / 2;
            return s;
        }


        /// <summary>
        /// 计算直线方位角
        /// </summary>
        /// <param name="start">起点</param>
        /// <param name="end">终点</param>
        /// <returns>方位角</returns>
        public static double CalAngle(Point start, Point end)
        {
            double dx = end.x - start.x;
            double dy = end.y - start.y;

            double angle = 0;
            if (dx > 0 && dy > 0)
            {//第一象限

                angle = Math.Atan(Math.Abs(dy / dx));
            }
            else if (dx < 0 && dy > 0)
            {//第二象限
                angle = Math.PI - Math.Atan(Math.Abs(dy / dx));
            }
            else if (dx < 0 && dy < 0)
            {//第三象限
                angle = Math.PI + Math.Atan(Math.Abs(dy / dx));
            }
            else if (dx > 0 && dy < 0)
            {//第四象限
                angle = 2 * Math.PI - Math.Atan(Math.Abs(dy / dx));
            }
            else if (dx == 0)
            {
                if (dy > 0)
                {
                    angle = Math.PI / 2;
                }
                else angle = 3 * Math.PI / 2;
            }
            else if (dy == 0)
            {
                if (dx < 0)
                {
                    angle = Math.PI;
                }

            }
            return angle;
        }


        /// <summary>
        /// 计算两点间距离
        /// </summary>
        /// <param name="start">起点</param>
        /// <param name="end">终点</param>
        /// <returns>距离</returns>
        public static double CalDistance(Point start, Point end)
        {
            return Math.Sqrt(Math.Pow((end.x - start.x), 2) + Math.Pow((end.y - start.y), 2));
        }


        /// <summary>
        /// 计算纵断面上的所有点
        /// </summary>
        /// <param name="datumPoints">道路关键点</param>
        /// <param name="orgPoints">原始高程点集</param>
        /// <param name="deta">内插距离</param>
        /// <param name="n">搜索点数</param>
        /// <param name="nearPoints">返回的内插点邻近点</param>
        /// <returns>纵断面上的所有点</returns>
        public static List<Point> GetVerticalPoints(List<Point> datumPoints, List<Point> orgPoints, double deta, int n, out List<List<Point>> nearPoints)
        {
            nearPoints = new List<List<Point>>();
            List<Point> totalPoints = new List<Point>();

            Point start = datumPoints[0];
            start.distance = 0;
            totalPoints.Add(start);

            double sumD = 0;//道路行程
            double innerLC = deta;//内插点的里程，初始值不为0

            int ind = 1;


            for (int i = 0; i < datumPoints.Count - 1; i++)
            {
                Point now = datumPoints[i];
                Point next = datumPoints[i + 1];

                double angle = CalAngle(now, next);
                double dist = CalDistance(now, next);
                sumD += dist;

                next.distance = sumD;

                double startLC = now.distance;
                
                while ((innerLC - startLC) < dist)
                {//内插点处于这段直线上时
                    double Li = innerLC - startLC;

                    Point tmp = new Point();
                    tmp.distance = innerLC;
                    tmp.name = "inner" + ind.ToString();//内插点的名字
                    tmp.x = now.x + Li * Math.Cos(angle);//计算内插点的x，y坐标
                    tmp.y = now.y + Li * Math.Sin(angle);

                    List<Point> tmpNear;
                    tmp.h = GetInnerH(tmp, orgPoints, n, out tmpNear);//得到内插高程和临近点
                    nearPoints.Add(tmpNear);
                    totalPoints.Add(tmp);

                    innerLC += deta;
                    ind++;
                }

                totalPoints.Add(next);
            }
            return totalPoints;

        }


        /// <summary>
        /// 计算某一横断面上的所有点
        /// </summary>
        /// <param name="start">该段路线的起点</param>
        /// <param name="end">该段路线的终点</param>
        /// <param name="orgPoints">原始高程点集</param>
        /// <param name="deta">内插距离</param>
        /// <param name="n">搜索点数</param>
        /// <param name="num">单侧的内插数量</param>
        /// <param name="nearPoints">返回的内插点邻近点</param>
        /// <returns></returns>
        public static List<Point> GetHozPoints(Point start, Point end, List<Point> orgPoints, double deta, int n, int num, out List<List<Point>> nearPoints)
        {
            List<Point> totalPoints = new List<Point>();
            nearPoints = new List<List<Point>>();
            List<Point> tmpList;

            Point middle = new Point();
            middle.isDatum = true;
            middle.x = (start.x + end.x) / 2;
            middle.y = (start.y + end.y) / 2;
            middle.h = GetInnerH(middle, orgPoints, n, out tmpList);

            double angle = CalAngle(start, end);
            angle = angle + Math.PI / 2;
            if (angle > 2 * Math.PI) angle = angle - 2 * Math.PI;//得到角度


            int nameInd = 1;
            for (int i = -num; i <= num; i++)
            {
                if (i == 0)
                {
                    totalPoints.Add(middle);

                }
                else
                {
                    Point tmp = new Point();//新建内插点

                    tmp.distance = deta * i;
                    tmp.name = "inner" + nameInd.ToString();
                    tmp.x = middle.x + i * deta * Math.Cos(angle);//计算内插点的x，y坐标
                    tmp.y = middle.y + i * deta * Math.Sin(angle);


                    List<Point> tmpNear = new List<Point>();
                    tmp.h = GetInnerH(tmp, orgPoints, n, out tmpNear);//得到内插高程和临近点

                    nearPoints.Add(tmpNear);
                    totalPoints.Add(tmp);
                    nameInd++;
                }
            }

            return totalPoints;

        }


        public static string RadToDMS(double a)
        {
            double tmpD = a * 180 / Math.PI;
            int d = (int)tmpD;
            double tmpS = (tmpD - d) * 3600;
            int m = (int)(tmpS / 60);
            double s = tmpS - m * 60;
            string str = d.ToString() + "°" + m.ToString() +"′"+ s.ToString("f4").PadLeft(7,'0')+"″";
            return str;
        }


    }

5.FileHelper.cs

    class FileHelper
    {

        /// <summary>
        /// 打开Txt文本文件
        /// </summary>
        /// <param name="filepath">文件路径</param>
        /// <returns>用特定字符分割得到的字符串集合</returns>
        public static  List<string[]> OpenTxt(string filepath)
        {
            List<string[]> strs = new List<string[]>();
            FileStream fs = new FileStream(filepath ,FileMode.Open ,FileAccess.Read );
            StreamReader sr = new StreamReader(fs);
            while (!sr.EndOfStream)
            {
                string[] str = sr.ReadLine().Split(new char[] { ',','，',' '},StringSplitOptions.RemoveEmptyEntries );
                strs.Add(str);

            }
            return strs;
            
        }


        /// <summary>
        /// 保存字符串到txt文件
        /// </summary>
        /// <param name="filepath">文件路径</param>
        /// <param name="Outstring">需要保存的字符串</param>
        public static void SaveTxt(string filepath, string Outstring)
        {
            StreamWriter sw = new StreamWriter(filepath);
            sw.WriteLine(Outstring ,true );
        }


        /// <summary>
        /// 保存多张数据表到excel工作簿
        /// </summary>
        /// <param name="filepath">文件路径</param>
        /// <param name="set">数据表集合</param>
        public static void SaveXls(string filepath, DataSet set)
        {
            Excel.Application excel = new Excel.Application();
            excel.Visible = false;
            excel.DisplayAlerts = false;

            Excel.Workbook wb1 = excel.Workbooks.Add(System.Reflection.Missing.Value );

            for (int i = 0; i < set.Tables .Count ; i++)
            {
                Excel.Worksheet ws = wb1.Worksheets.Add(System.Reflection.Missing .Value );
                ws.Name = set.Tables[i].TableName;
                
                int rowcount = set.Tables[i].Rows.Count;
                int columncount = set.Tables[i].Columns.Count;

                Excel.Range range;

                
                for (int j = 0; j < columncount ; j++)
                {//添加表头
                    ws.Cells[1, j + 1] = set.Tables[i].Columns[j].ColumnName;

                    range = (Excel.Range)ws.Cells[1, j + 1];
                    range.Font.Color = ColorTranslator.ToOle(Color.Black  );
                    range.Font.Size = 10;
                    range.Font.Bold = false;
                    range.Font.Name = "宋体";
                    range.Interior.Color = ColorTranslator.ToOle(Color.Green  );
                    range .HorizontalAlignment =Excel.XlHAlign .xlHAlignCenter ;
                    range.EntireColumn.AutoFit();
                }

                for (int a = 0; a < rowcount ; a++)
                {
                    for (int b = 0; b < columncount ; b++)
                    {
                        ws.Cells[a + 2, b + 1] = set.Tables[i].Rows[a][b];

                    }

                    
                }
                range = (Excel.Range)ws.Rows["2:" + (rowcount + 1), Type.Missing];

                range.Font.Color = ColorTranslator.ToOle(Color.Black );
                range.Font.Name = "宋体";
                range.Font.Bold = false;
                range.Font.Size = 8;
                range.HorizontalAlignment = Excel.XlHAlign.xlHAlignCenter;
                range.EntireRow.AutoFit();

            }
            wb1.SaveCopyAs(filepath );
            wb1.Close();
            excel.Quit();
        }
    }

6.Draw.cs

    class Draw
    {

        /// <summary>
        /// 绘制断面示意图
        /// </summary>
        /// <param name="myChart">Chart控件</param>
        /// <param name="totalPoints">剖面上所有点的集合</param>
        public static void DrawProfile(Chart myChart,List<Point >totalPoints)
        {
            
            myChart.ChartAreas.Clear();//清除Chart控件内容
            myChart.Series.Clear();

            ChartArea area = new ChartArea();
            area.Name = "断面图绘制";
            area.AxisX.Title = "距离(m)";
            area.AxisY.Title = "高程(m)";

            double maxX = totalPoints.Max(o=>o.distance );//寻找最大外包矩形区域
            double minX = totalPoints.Min(o => o.distance);
            double maxY = totalPoints.Max(o => o.h);
            double minY = totalPoints.Min(o => o.h);

            #region 新建Chartarea
            area.AxisX.Maximum = maxX + (maxX - minX) / totalPoints.Count;
            if (minX < 0)
                area.AxisX.Minimum = minX - (maxX - minX) / totalPoints.Count;
            else
                area.AxisX.Minimum = 0;
            area.AxisY.Maximum = maxY + (maxY - minY) / totalPoints.Count;
            if (minY < 0)
                area.AxisY.Minimum = minY - (maxY - minY) / totalPoints.Count;
            else
                area.AxisY.Minimum = 0;
            ControlScale(area ,myChart.Width ,myChart.Height );//控制Chart缩放比例
            area.AxisX.LabelStyle.Format = "f3";
            area.AxisY.LabelStyle.Format = "f3";
            myChart.ChartAreas.Add(area );
            #endregion

            #region 新建区域Series
            Series areaSeri = new Series();
            areaSeri.Name = "断面";
            areaSeri.IsVisibleInLegend = false;
            areaSeri.ChartArea = area.Name;
            areaSeri.ChartType = SeriesChartType.Area;
            areaSeri.MarkerColor = System.Drawing.Color.Green;

            foreach (var point in totalPoints )
            {
                DataPoint newpo = new DataPoint();
                newpo.SetValueXY(point .distance ,point .h);
                areaSeri.Points.Add(newpo);
            }
            myChart.Series.Add(areaSeri);

            #endregion

            #region 新建基准点Series
            Series datumSeri = new Series();
            datumSeri.Name = "基准点";
            datumSeri.ChartArea = area.Name;

            datumSeri.ChartType = SeriesChartType.Point;
            datumSeri.MarkerColor = System.Drawing.Color.Orange;
            datumSeri.MarkerSize = 10;
            datumSeri.MarkerStyle = MarkerStyle.Square;
            foreach (var point in totalPoints )
            {
                if (point.isDatum)
                {
                    DataPoint tmp = new DataPoint();
                    tmp.Label = point.name;
                    tmp.SetValueXY(point.distance, point.h);
                    datumSeri.Points.Add(tmp);
                }
            }
            myChart.Series.Add(datumSeri );

            #endregion

            #region 新建内插点Series
            Series innerSer = new Series();
            innerSer.Name = "内插点";
            innerSer.ChartArea = area.Name;
            innerSer.ChartType = SeriesChartType.Point;
            innerSer.MarkerColor = System.Drawing.Color.Yellow ;
            innerSer.MarkerSize = 8;

        
            innerSer.MarkerStyle = MarkerStyle.Triangle;

            foreach (var point in totalPoints)
            {
                if (!point.isDatum)
                {
                    DataPoint datapo = new DataPoint();
            
                    datapo.SetValueXY(point.distance, point.h);
                    innerSer.Points.Add(datapo);
                }
            }
            myChart.Series.Add(innerSer);

            #endregion

            myChart.DataBind();
        }



        /// <summary>
        /// 使图形保持真实比例
        /// </summary>
        /// <param name="area">画图区域</param>
        /// <param name="wid">Chart控件宽度</param>
        /// <param name="hei">Chart控件高度</param>
        public static void ControlScale(ChartArea area,int wid,int hei)
        {
            double maxX = area.AxisX.Maximum;//搜索得到外包矩形区域
            double minX = area.AxisX.Minimum;
            double maxY = area.AxisY.Maximum;
            double minY = area.AxisY.Minimum;

            double rHoz = (maxX - minX) / wid;//纵向拉伸率
            double rVer = (maxY - minY) / hei;//横向拉伸率

            double r = Math.Max(rHoz,rVer );

            ElementPosition positon = new ElementPosition();

            if (r == rHoz)//水平方向铺满，垂直方向上下移动
            {
                positon.Width = 100;
                positon.Height = (float)(100 * rVer / r);
                positon.X = 0;
                positon.Y = (100 - positon.Height) / 2;


            }
            else//纵向铺满，左右方向移动
            {
                positon.Height = 100;
                positon.Width = (float)(100 * (rHoz / r));
                positon.Y = 0;
                positon.X = (100 - positon.Width) / 2;
            }

            area.Position = positon;
        }
    }

7.MainForm.cs

    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
            ControlComboxVisible();
        }

        #region 变量区
        DataCenter data=new DataCenter();
        #endregion

        public void DisRefresh()
        {
            DataViewer.DataSource = data.orgPointsToTable();
        }


        public void ClearData()
        {
            DrawChart.ChartAreas.Clear();
            DrawChart.Series.Clear();
            ReportBox.Clear();
            DataViewer.DataSource = null;
            data = new DataCenter();
        }



        private void openTxtToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.Filter = "文本文件|*.txt|所有文件|*.*";
            try
            {
                if (ofd.ShowDialog() == DialogResult.OK)
                {
                    if (data.dataFlag)
                    {
                        ClearData();
                    }

                    List<string[]> strs = new List<string[]>();
                    strs = FileHelper.OpenTxt(ofd.FileName);
                    int index = 0;
                    foreach (var str in strs)
                    {
                        if (str.Length == 2)
                        {
                            data.RDH = Convert.ToDouble(str[1]);
                        }
                        else if (str.Length == 0 || str.Length == 1)
                            continue;
                        else if (str.Length == 3)
                        {
                          
                            switch (index)
                            {

                                case 0:
                                    {
                                        for (int i = 0; i < str.Length; i++)
                                        {
                                            Point point = new Point();
                                            point.name = str[i];
                                            point.isDatum = true;
                                            data.datumPoints.Add(point);
                                        }
                                    }
                                    break;

                                case 1:
                                    {
                                        Point testA = new Point();
                                        testA.name = str[0];
                                        testA.x = Convert.ToDouble(str[1]);
                                        testA.y = Convert.ToDouble(str[2]);
                                        data.test .Add(testA);
                                    }
                                    break;
                                case 2:
                                    {
                                        Point testB = new Point();
                                        testB.name = str[0];
                                        testB.x = Convert.ToDouble(str[1]);
                                        testB.y = Convert.ToDouble(str[2]);
                                        data.test .Add(testB);

                                    }
                                    break;
                            }
                            index++;
                        }
                        else if (str.Length == 4)
                        {
                            Point point = new Point();
                            point.name = str[0].ToString();
                            point.x = Convert.ToDouble(str[1]);
                            point.y = Convert.ToDouble(str[2]);
                            point.h = Convert.ToDouble(str[3]);
                            data.orgPoints.Add(point);
                        }
                    }
                    data.dataFlag = true;
                    DisRefresh();
                    MessageBox.Show("打开成功", "提示");

                }

                foreach (var point in data.datumPoints )
                {
                    point.x = data.orgPoints.Find(o=>o.name ==point.name).x;
                    point.y = data.orgPoints.Find(o=>o.name ==point .name ).y;
                    point.h = data.orgPoints.Find(o => o.name == point.name).h;

                }
            }
            catch
            {
                MessageBox.Show("打开文件格式数据不匹配，请重新打开","提示");
            }
        }


        private void calHozToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (data.dataFlag)
            {
                if (!data.hozFlag)
                {
                    pCombox.Items.Clear();
                    for (int i = 0; i < data.datumPoints.Count - 1; i++)
                    {
                        string str = data.datumPoints[i].name + "--" + data.datumPoints[i + 1].name;

                        Profile tmp = new Profile();
                        tmp.start = data.datumPoints[i];
                        tmp.end = data.datumPoints[i+1];
                        tmp.totalPoints=Algorithm.GetHozPoints(data.datumPoints[i], data.datumPoints[i + 1], data.orgPoints, 5, 5, 5, out tmp.nearPointsOfInner);


                        double sumS = 0;
                        for (int j = 0; j < tmp.totalPoints.Count-1; j++)
                        {
                            sumS += Algorithm.CalS(tmp.totalPoints[j], tmp.totalPoints[j + 1], data.RDH);

                        }
                        tmp.sumS = sumS;
                        data.hoz.Add(tmp);
                        pCombox.Items.Add(str);
                    }

                    data.hozFlag = true;
                    hozToolStripMenuItem_Click(sender, e);
                    MessageBox.Show("计算完成", "提示");
                }  else MessageBox.Show("计算已完成", "提示");
            }
            else MessageBox.Show("请先打开文件","提示");
        }



        private void calVerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (data.dataFlag)
            {
                if (!data.verFlag)
                {
                    data.vertical.totalPoints = Algorithm.GetVerticalPoints(data.datumPoints, data.orgPoints, 10, 5, out data.vertical.nearPointsOfInner);

                    double sumS = 0;
                    for (int i = 0; i < data.vertical.totalPoints.Count - 1; i++)
                    {
                        sumS += Algorithm.CalS(data.vertical.totalPoints[i], data.vertical.totalPoints[i + 1], data.RDH);

                    }
                    data.vertical.sumS = sumS;
                    data.verFlag = true;
                    verToolStripMenuItem_Click(sender, e);

                    MessageBox.Show("计算完成", "提示");
                }
                else MessageBox.Show("计算已完成", "提示");
            }
            else MessageBox.Show("请先打开文件", "提示");
        }

        private void lookImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
        }



        private void lookReportToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (data.verFlag && data.hozFlag)
            {
                ReportBox.Clear();
                ReportBox.AppendText(data.GetReport());
                pageController.SelectedIndex = 2;
            }
            else MessageBox.Show("请先完成计算", "提示");
        }


        private void hozToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (data.hozFlag)
            {
                Draw.DrawProfile(DrawChart, data.hoz[0].totalPoints);
                pCombox.SelectedIndex = 0;
                pageController.SelectedIndex = 1;
                data.focus = 1;
                ControlComboxVisible();

            }
            else MessageBox.Show("请先完成计算", "提示");
        }


        private void verToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (data.verFlag)
            {
                Draw.DrawProfile(DrawChart, data.vertical.totalPoints);
                pageController.SelectedIndex = 1;
                data.focus = 2;
                ControlComboxVisible();

            }
            else MessageBox.Show("请先计算纵断面", "提示");
        }

        private void MainForm_Load(object sender, EventArgs e)
        {

        }


        private void MainForm_SizeChanged(object sender, EventArgs e)
        {


        }

        private void 文件ToolStripMenuItem_Click(object sender, EventArgs e)
        {

        }

        private void menuStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {

        }




        private void pCombox_SelectedIndexChanged(object sender, EventArgs e)
        {
            int i = pCombox.SelectedIndex;
            Draw.DrawProfile(DrawChart, data.hoz[i].totalPoints);
        }


        /// <summary>
        /// 控制下拉框的可见性
        /// </summary>
        private void ControlComboxVisible()
        {
            if(pageController.SelectedIndex==1)
            {
                if (data.focus == 1)
                {
                    pCombox.Visible = true;
                    pLabel.Visible = true;

                }
                else
                {
                    pCombox.Visible = false;
                    pLabel.Visible = false;
                }

            }
            else
            {
                pCombox.Visible = false;
                pLabel.Visible = false;
            }

        }


        private void pageController_SelectedIndexChanged(object sender, EventArgs e)
        {
            ControlComboxVisible();


        }

        private void saveImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if(DrawChart.Series.Count==3)
            {
                try
                {
                    SaveFileDialog sfd = new SaveFileDialog();
                    sfd.Title = "请选择图片保存的位置";
                    sfd.Filter = "jpg文件|*.jpg";

                    if (sfd.ShowDialog() == DialogResult.OK)
                    {
                        DrawChart.SaveImage(sfd.FileName, System.Windows.Forms.DataVisualization.Charting.ChartImageFormat.Jpeg);
                        MessageBox.Show("保存成功", "提示");

                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "保存失败");
                }

            }

            else MessageBox.Show("当前绘图区无图像", "提示");

        }

        private void saveExcelToolStripMenuItem_Click(object sender, EventArgs e)
        {

            if (data.hozFlag && data.verFlag)
            {
                DataSet ds = new DataSet();
                for (int i = 0; i < data.hoz.Count; i++)
                {
                    DataTable dt = data.hoz[i].InnerInfoToTable();
                    ds.Tables.Add(dt);
                }
                DataTable verDt = data.vertical.InnerInfoToTable();
                ds.Tables.Add(verDt);

                try
                {
                    
                    SaveFileDialog sfd = new SaveFileDialog();
                    sfd.Title = "请选择保存的位置";
                    sfd.Filter = "excel工作簿|*.xls";

                    if (sfd.ShowDialog() == DialogResult.OK)
                    {
                        FileHelper.SaveXls(sfd.FileName, ds);
                        MessageBox.Show("保存成功", "提示");

                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "保存失败");
                }

            }
            else MessageBox.Show("请先完成计算", "提示");
        }

        private void saveTxtToolStripMenuItem_Click(object sender, EventArgs e)
        {

            if (data.hozFlag && data.verFlag)
            {
                lookReportToolStripMenuItem_Click(sender, e);
                try
                {
                    SaveFileDialog sfd = new SaveFileDialog();
                    sfd.Title = "请选择计算报告保存的位置";
                    sfd.Filter = "文本文件|*.txt";

                    if (sfd.ShowDialog() == DialogResult.OK)
                    {
                        FileHelper.SaveTxt(sfd.FileName, ReportBox.Text);
                        MessageBox.Show("保存成功", "提示");

                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "保存失败");
                }

            }
            else MessageBox.Show("请先完成计算", "提示");
        }

        private void helpToolStripMenuItem_Click(object sender, EventArgs e)
        {
            string help = "";
            help += "1. 点击菜单栏文件-打开文件，导入txt格式的横纵断面实测数据。\r\n 2.点击菜单栏功能 - 纵断面计算，软件会计算纵断面的面积，并在“图形”页中绘制纵断面示意图，切换到“图形”页即可查看。\r\n3.点击菜单栏功能 - 横断面计算，软件会计算线路上的所有横断面，并在“图形”页中绘制第一个横断面的示意图，用户可在菜单栏右上角的下拉框中选择感兴趣的横断面进行查看。\r\n4.计算报告显示与输出：完成纵断面计算和横断面计算后，点击菜单栏查看 - 计算报告，即可在“计算报告”页看到计算报告，点击菜单栏文件 - 保存 - 计算报告即可将其另存为txt文件。\r\n5.图像查看及输出：完成纵断面计算和横断面计算后，点击菜单栏查看 - 图形，即可选择查看的断面（如果查看的是横断面，用户可在菜单栏右上角的下拉框中选择感兴趣的横断面进行查看）。点击菜单栏文件 - 保存 - 图形即可将当前绘制的图形输出为jpg文件。\r\n6.断面内插点数据的输出：完成纵断面计算和横断面计算后，点击菜单栏文件 - 保存 - 内插点数据，即可将各个断面上的内插点的相关信息另存为xls工作簿。";
            MessageBox.Show(help, "帮助");

        }
    }