C#:测绘程序设计的间接平差模型

于 2024-09-07 14:48:15 发布
阅读量202 收藏
点赞数 5
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58362929/article/details/120676916
版权

以此题为例

 先写出误差方程，确定系数矩阵B[i,j]，l[i,j],P[i,j],带入程序运算

说明：以下代码程序运行的数据，数据有单位的均按单位mm处理。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 间接平差
{
    class Program
    {

        //输入函数
        static void InPut(ref int m, ref int n, ref double[,] A)
        {
            Console.WriteLine("输入矩阵的行数列数");
            string r = Console.ReadLine();
            string[] rs = r.Split(' ');
            m = int.Parse(rs[0]);
            n = int.Parse(rs[1]);
            A = new double[m, n];
            Console.WriteLine("矩阵按行输入");
            Console.WriteLine();
            for (int i = 0; i < m; i++)
            {
                string str = Console.ReadLine();
                string[] str1 = str.Split(' ');
                for (int j = 0; j < n; j++)
                {
                    A[i, j] = double.Parse(str1[j]);
                }
            }
        }

        //输出函数
        static void OutPut(ref double[,] M)
        {
            int m = M.GetLength(0);
            int n = M.GetLength(1);
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.Write("{0,12:f4}", M[i, j]);
                }
                Console.WriteLine();
            }
        }
      
        //矩阵转置函数
        static void Transpose_Matrix(ref double[,] ab, ref double[,] ba)
        {
            int p = ab.GetLength(0);
            int q = ab.GetLength(1);
            ba = new double[q, p];
            for (int i = 0; i < q; i++)
            {
                for (int j = 0; j < p; j++)
                    ba[i, j] = ab[j, i];
            }
        }

        //乘法矩阵

        static void Multiplication_Matrix(ref double[,] a, ref double[,] b, ref double[,] ab2)
        {
            ab2 = new double[a.GetLength(0), b.GetLength(1)];
            for (int i = 0; i < a.GetLength(0); i++)
            {
                for (int j = 0; j < b.GetLength(1); j++)
                {
                    for (int k = 0; k < a.GetLength(1); k++)
                    {
                        ab2[i, j] += a[i, k] * b[k, j];
                    }
                }
            }
        }


        //逆矩阵函数
        static void Inverse(ref double[,] Array, ref double[,] NI)
        {
            int m = Array.GetLength(0);
            int n = Array.GetLength(1);
            double[,] array = new double[2 * m + 1, 2 * n + 1];
            for (int k = 0; k < 2 * m + 1; k++)  //初始化数组
            {
                for (int t = 0; t < 2 * n + 1; t++)
                {
                    array[k, t] = 0.00000000;
                }
            }
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    array[i, j] = Array[i, j];
                }
            }
            for (int k = 0; k < m; k++)
            {
                for (int t = n; t <= 2 * n; t++)
                {
                    if ((t - k) == m)
                    {
                        array[k, t] = 1.0;
                    }
                    else
                    {
                        array[k, t] = 0;
                    }
                }
            }
            //得到逆矩阵
            for (int k = 0; k < m; k++)
            {
                if (array[k, k] != 1)
                {
                    double bs = array[k, k];
                    array[k, k] = 1;
                    for (int p = k + 1; p < 2 * n; p++)
                    {
                        array[k, p] /= bs;
                    }
                }
                for (int q = 0; q < m; q++)
                {
                    if (q != k)
                    {
                        double bs = array[q, k];
                        for (int p = 0; p < 2 * n; p++)
                        {
                            array[q, p] -= bs * array[k, p];
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
            }
            NI = new double[m, n];
            for (int x = 0; x < m; x++)
            {
                for (int y = n; y < 2 * n; y++)
                {
                    NI[x, y - n] = array[x, y];
                }
            }
        }
        //矩阵加法
        static void Matrix_Puls(ref double[,] b1, ref double[,] b2, ref double[,] puls)
        {
            int m1 = b1.GetLength(0);
            int n1 = b1.GetLength(1);
            int m2 = b2.GetLength(0);
            int n2 = b2.GetLength(1);
            puls  = new double[m1, n1];
            if (m1 == m2 & n1 == n2)
            {
                for (int i = 0; i < m1; i++)
                {
                    for (int j = 0; j < n1; j++)
                        puls [i, j] = b1[i, j] + b2[i, j];
                }
            }
            else
                Console.WriteLine("两矩阵不能相加");
        }
        //矩阵减法
        static void Matrix_Subtraction(ref double[,] a1, ref double[,] a2, ref double[,] sub)
        {
            int m1 = a1.GetLength(0);
            int n1 = a1.GetLength(1);
            int m2 = a2.GetLength(0);
            int n2 = a2.GetLength(1);
            sub = new double[m1, n1];
            if (m1 == m2 & n1 == n2)
            {
                for (int i = 0; i < m1; i++)
                {
                    for (int j = 0; j < n1; j++)
                        sub [i, j] = a1[i, j] - a2[i, j];
                }
            }
            else
                Console.WriteLine("两矩阵不能相减");
        }
        static void Main(string[] args)
        {
            //函数变量的初始化
            int m = 0,n=0;
            double [,] A = { };
            double [,] M = { };
            double [,] ab = { };
            double [,] ba = { };
            double[,] a = { };
            double[,] b = { };
            double[,] ab2 = { };
            double[,] Arry = { };
            double[,] NI = { };
            double[,] a1 = { };
            double[,] a2 = { };
            double[,] sub = { };
            double[,] b1 = { };
            double[,] b2 = { };
            double[,] plus = { };



            Console.WriteLine("---------------输入B[i,j]矩阵---------------");
            Console.WriteLine();
            InPut(ref m, ref n, ref A);
            double[,] B = { };
            B = A; //B[i,j]矩阵
            Console.WriteLine("---------------B[i,j]--------------");
            Console.WriteLine();
            M = B;
            OutPut(ref M);
            Console.WriteLine("---------------输入l[i,j]矩阵---------------");
            Console.WriteLine();
            InPut(ref m, ref n, ref A);
            double[,] l = { };
            l = A;//l[i,j]矩阵
            Console.WriteLine("---------------l[i,j]---------------");
            Console.WriteLine();
            M = l;
            OutPut(ref M);
            Console.WriteLine("---------------输入P[i,j]矩阵---------------");
            Console.WriteLine();
            InPut(ref m, ref n, ref A);
            double[,] P = { };
            P = A;//P[i,j]矩阵
            Console.WriteLine("---------------P[i,j]----------------");
            Console.WriteLine();
            M = P;
            OutPut(ref M);
            //计算NBB
            double[,] NBB = { };
            ab=B;
            Transpose_Matrix(ref ab, ref ba);
            double[,] BT = { };
            BT = ba;
            a = ba;
            b = P;
            Multiplication_Matrix(ref a, ref b, ref ab2);
            a = ab2;
            b = B;
            Multiplication_Matrix(ref a, ref b, ref ab2);
            NBB = ab2;//NBB[,]矩阵
            Console.WriteLine("---------------NBB[i,j]---------------");
            Console.WriteLine();
            M = NBB;
            OutPut(ref M);
            //计算W[i,j] 矩阵
            a = BT;
            b = P;
            Multiplication_Matrix(ref a, ref b, ref ab2);
            a = ab2;
            b = l;
            Multiplication_Matrix(ref a, ref b, ref ab2);
            double[,] W = { };
            W = ab2;//W[i,j]矩阵
            Console.WriteLine("---------------W[i,j]---------------");
            Console.WriteLine();
            M = W;
            OutPut(ref M);
            //解方程，计算x[i,j]矩阵
            Arry = NBB;
            Inverse(ref Arry, ref NI);
            a = NI;
            b = W;
            Multiplication_Matrix(ref a, ref b, ref ab2);
            double[,] x = { };
            x = ab2;//x[i,j]矩阵
            Console.WriteLine("---------------x[i,j]---------------");
            Console.WriteLine();
            for (int i = 0; i < x.GetLength(0); i++)
            {
                for (int j = 0; j < x.GetLength(1); j++)
                {
                    Console.Write("xˇ{0}={1,15:f5}", i + 1, x[i, j]);
                }
                Console.WriteLine();
            }
            
            //计算改正数
            a = B;
            b = x;
            Multiplication_Matrix(ref a, ref b, ref ab2);
            a1 = ab2;
            a2 = l;
            Matrix_Subtraction(ref a1, ref a2, ref sub);
            double[,] V = { };
            V = sub;//改正数矩阵
            Console.WriteLine("---------------V[i,j]---------------");
            Console.WriteLine();
            for (int i = 0; i < V.GetLength(0); i++)
            {
                for (int j = 0; j < V.GetLength(1); j++)
                {
                    Console.Write("V{0}={1,15:f5}", i + 1, V [i, j]);
                }
                Console.WriteLine();
            }
           
            //计算观测值的平差值矩阵
            Console .WriteLine("---------------输入观测值的矩阵L[i,j]---------------");
            Console .WriteLine();
            InPut(ref m,ref n,ref A);
            double [,] L={};
            L=A;//观测值L[i,j]矩阵
            b1 = L;
            b2 = V;
            Matrix_Puls(ref b1, ref b2, ref plus);
            double[,] LL = { };
            LL = plus;
            Console.WriteLine("---------------Lˇ[i,j]---------------");
            Console.WriteLine();
            for (int i=0;i<LL.GetLength (0);i++)
            {   for (int j=0;j<LL.GetLength (1);j++)
                {
                    Console.Write("Lˇ{0}={1,15:f5}", i + 1, LL[i, j]);
                }
            Console.WriteLine();
            }
        }
    }
}

运行结果如下

仅供参考，如有错误，敬请斧正。

十万毫升.
关注
C#水准网间接平差简单程序
qq_61874665的博客
06-09 1681
C#水准网间接平差
测绘程序设计——坐标正反算(C#)
最新发布
m0_58301791的博客
01-10 2405
若已知A点坐标（200，200）B点坐标（250，250），Xab=50、Yab=50，则tan a=1；若已知A点坐标（200，200）AB两点的距离100，AB两点的坐标方位角为45°；坐标方位角正算是由A点的坐标AB两点间的距离和方位角，来推算B点的坐标。坐标方位角反算是由两点的坐标，来推算AB两点的坐标方位角。若Xab>0,Yab0，Yab>0所以Aab=45°。若Xab
平差课程设计报告（水准网间接平差程序和代码）
12-30
测绘工程专业的平差课程报告，是关于间接平差水准网的，，，里面有程序和报告。。。。
C#水准网间接平差.zip
04-26
1、根据观测值程序自动列B矩阵； 2、自动计算参数估计值 3、程序实现自动定权生成P矩阵； 4、计算平差值及精度评价
间接平差计算代码
07-07
里面包括了间接平差设计步骤以及相关代码，矩阵计算代码
利用C#编写一个水准测量近似平差程序
Zj1638的博客
08-01 6648
利用 C#编写一个水准测量近似平差程序
利用C#编写一个附和闭合导线平差程序
Zj1638的博客
07-06 6381
利用C#编写一个附和闭合导线平差程序
c c#附和导线平差程序设计实习报告
10-20
《C#实现附和导线平差程序设计实习报告》 在现代测绘技术的快速发展下，测量数据处理的方法日益多样化，其中附和导线平差是常见的一种。本报告主要探讨如何利用C#编程语言来设计一个附和导线近似平差程序，满足高效...
平差计算C代码
12-16
3环14节点16段环状管网平差计算C程序，课程联系，可供参考
间接平差编程
11-15
平差解算，完整代码。利用vc编程完成间接平差解算！
一些常用的测量程序（c#）
03-31
交会，坐标正反算，坐标转换，三角高程平差，纵断面计算
工程测绘程序
02-14
工程测量5800正反算及隧道超欠挖最终版程序
基于C#的导线平差程序设计
05-05
为解决NET平台下导线数据处理问题,文中以C#为开发语言,使用近似平差模型,开发导线平差程序。使用文献[9]附合导线观测数据,将程序处理结果和文献处理结果对比表明:1程序计算结果中方位角闭合差、方位角闭合差限差、角度改正数、导线全长相对闭合差均与原表一致;2、3、4号点计算坐标或与原表一致或相差0.001 m。2程序中针对平差解算引入并拓展了四舍五入算法,将弧度保留八位有效数字,较好地解决了平差过程中由于数据迭代运算导致的数据丢失问题。3以.NET平台为基础开发的平差程序可以直接与.NET平台下GIS软件的二次开发交互;程序实现了数据录入、平差解算、详细计算过程及计算结果输出等功能。
matlab测量平差实验报告,测量平差实习心得精选三篇
weixin_34538771的博客
03-18 891
测量平差是什么来的？测量平差是德国数学家高斯于1821~1823年在汉诺威弧度测量的三角网平差中首次应用，以后经过许多科学家的不断完善，下面是学习啦带来的测量平差实习心得体会，仅供参考。测量平差实习心得一为期两周的实习在不断地学习、尝试、修正的过程中圆满结束了。这次实习让我对许多问题有了深刻的认识。我认识到编程的重要性，认识到自学能力的重要性，认识到从书本到实践还有很长一段路要走。熟练掌握一门或多...
《测量程序设计与数据处理大赛实训》课程教学大纲.pdf
06-27
2. **简易测量程序设计**：包括坐标方位角计算、解析交会计算、间接平差计算和三角高程、水准测量的近似平差计算。这些内容要求学生能综合应用C#语言，理解和实现不同测量任务的算法。 3. **高程控制网平差程序设计...
空间后方交会程序
07-15
6. **代码结构**：一个清晰的C#程序会包含多个类和方法，如DataReader类用于读取文件，Camera类表示相机模型，Point类表示地面点，平差方法作为独立的函数。注释应详细解释各个部分的作用，帮助初学者理解代码逻辑。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值