【原创】C#写的水准网平差程序

Matrix类详见http://hi.baidu.com/aragon2/blog/item/1edbba124ab4beecc2ce796e.html?timeStamp=1311046817866，

一个基本的水准平差控制台程序。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace Adjustment
{
    public class LPointClass
    {
        public string PID { get; set; }
        public double H { get; set; }
        public bool IsControlP { get; set; }
    }

    public class LineClass
    {
        public int CZCount { get; set; }
        public LPointClass SP { get; set; }
        public LPointClass EP { get; set; }
        public double dH { get; set; }
        public double Distance { get; set; }
    }

    public class AdjustedPart
    {
        List<LPointClass> AdjustedPoints = new List<LPointClass>();
        public Matrix B { get; set; }
        public Matrix Q { get; set; }
    }

    public class AdjustClass
    {
        public Matrix B { get; set; }
        public Matrix P { get; set; }
        public Matrix l { get; set; }
        public Matrix Q { get; set; }
        public Matrix x { get; set; }
        public Matrix V { get; set; }

        public void LevelAdjust(List<LineClass> CurrentSegments, List<LPointClass> CurrentPoints, List<LPointClass> ControlPoints)
        {
            int n = CurrentSegments.Count;
            int t = CurrentPoints.Count - ControlPoints.Count;
            B = new Matrix(n, t);
            P = new Matrix(n, n);
            l = new Matrix(n, 1);
            List<LPointClass> TPoints = new List<LPointClass>();
            foreach (LPointClass Tp in CurrentPoints)
            {
                if (Tp.IsControlP == false)
                    TPoints.Add(Tp);
            }
            for (int k = 0; k < n; k++)
            {
                int i = Belong(TPoints, CurrentSegments[k].SP.PID);
                int j = Belong(TPoints, CurrentSegments[k].EP.PID);
                P[k, k] = 1.0 / CurrentSegments[k].Distance;
                l[k, 0] = CurrentSegments[k].dH - (CurrentSegments[k].EP.H - CurrentSegments[k].SP.H);
                if (CurrentSegments[k].SP.IsControlP == false)
                    B[k, i] = -1;
                if (CurrentSegments[k].EP.IsControlP == false)
                    B[k, j] = 1;
            }
            Q = (B.Transpose() * P * B).Inverse();
            x = Q * (B.Transpose() * P * l);
            V = B * x - l;
        }

        private static int Belong(List<LPointClass> CurrentPoints, string s)
        {
            foreach (LPointClass TPoint in CurrentPoints)
            {
                if (TPoint.PID == s)
                    return CurrentPoints.IndexOf(TPoint);
            }
            return -1;
        }
    }

    class Program
    {
        public static List<LineClass> CurrentSegments = new List<LineClass>();
        public static List<LPointClass> ControlPoints = new List<LPointClass>();
        public static List<LPointClass> CurrentPoints = new List<LPointClass>();
        public static AdjustClass Adjust = new AdjustClass();

        private static void InputData(List<LPointClass> CurrentPoints, List<LineClass> CurrentSegments)
        {
            StreamReader MyReader = new StreamReader("./Data/Control.txt");
            while (MyReader.EndOfStream != true)
            {
                List<string> TempString = MyReader.ReadLine().Split(' ').ToList<string>();
                TempString.RemoveAll(IsSpace);

                ControlPoints.Add(new LPointClass
                {
                    PID = TempString[0],
                    H = double.Parse(TempString[1]),
                    IsControlP =true
                });
            }
            MyReader.Close();                                                           //输入控制点信息

            MyReader = new StreamReader("./Data/Raw.txt");
            int n = 0;
            while (MyReader.EndOfStream != true)
            {
                n++;
                List<string> TempString = MyReader.ReadLine().Split(' ').ToList<string>();
                TempString.RemoveAll(IsSpace);

                CurrentSegments.Add(new LineClass
                {
                    SP = new LPointClass { PID = TempString[0] },
                    EP = new LPointClass { PID = TempString[1] },
                    dH = double.Parse(TempString[2]),
                    Distance = double.Parse(TempString[3]),
                    CZCount = n
                });
            }
            MyReader.Close();                                                           //输入观测值信息

            foreach (LineClass TLine in CurrentSegments)
            {
                if (Belong(CurrentPoints, TLine.SP.PID) == -1)
                {
                    int Index = Belong(ControlPoints, TLine.SP.PID);
                    if (Index == -1)
                    {
                        CurrentPoints.Add(new LPointClass
                        {
                            PID = TLine.SP.PID,
                            H = -99999.99,
                            IsControlP = false
                        });
                        TLine.SP.H = -99999.99;
                        TLine.SP.IsControlP = false;
                    }
                    else
                    {
                        CurrentPoints.Add(ControlPoints[Index]);
                        TLine.SP = ControlPoints[Index];
                    }
                }
                if (Belong(CurrentPoints, TLine.EP.PID) == -1)
                {
                    int Index = Belong(ControlPoints, TLine.EP.PID);
                    if (Index == -1)
                    {
                        CurrentPoints.Add(new LPointClass
                        {
                            PID = TLine.EP.PID,
                            H = -99999.99,
                            IsControlP = false
                        });
                        TLine.EP.H = -99999.99;
                        TLine.EP.IsControlP = false;
                    }
                    else
                    {
                        CurrentPoints.Add(ControlPoints[Index]);
                        TLine.EP = ControlPoints[Index];
                    }
                }
            }
        }

        private static void CaculateH(List<LPointClass> CurrentPoints, List<LineClass> CurrentSegments)
        {
            int TempNo = 0;

            for (int i = 0; ; i++)
            {
                foreach (LineClass TLine in CurrentSegments)
                {
                    int Ti = Belong(CurrentPoints, TLine.SP.PID);
                    int Tj = Belong(CurrentPoints, TLine.EP.PID);
                    if (CurrentPoints[Ti].H > -99999.99 && CurrentPoints[Tj].H == -99999.99)
                    {
                        CurrentPoints[Tj].H = CurrentPoints[Ti].H + TLine.dH;
                        TempNo++;
                    }
                    else if (CurrentPoints[Ti].H == -99999.99 && CurrentPoints[Tj].H > -99999.99)
                    {
                        CurrentPoints[Ti].H = CurrentPoints[Tj].H - TLine.dH;
                        TempNo++;
                    }
                    TLine.SP = CurrentPoints[Ti];
                    TLine.EP = CurrentPoints[Tj];
                }
                if (TempNo == CurrentPoints.Count - ControlPoints.Count)
                    break;

                if (i > CurrentPoints.Count - ControlPoints.Count)
                    Console.WriteLine("Error!");
            };
        }

        private static int Belong(List<LPointClass> CurrentPoints, string s)
        {
            foreach (LPointClass TPoint in CurrentPoints)
            {
                if (TPoint.PID == s)
                    return CurrentPoints.IndexOf(TPoint);
            }
            return -1;
        }

        private void PrintData()
        { }

        private static bool IsSpace(string s)
        {
            if (s == "")
                return true;
            else return false;
        }

        static void Main(string[] args)
        {
            InputData(CurrentPoints, CurrentSegments);
            CaculateH(CurrentPoints, CurrentSegments);
            AdjustClass MyAdjust = new AdjustClass();
            MyAdjust.LevelAdjust(CurrentSegments, CurrentPoints, ControlPoints);
            Console.ReadLine();
        }
    }
}