实验一：编写单片空间后方交会程序
摄影测量学单像空间后方交会编程实习报告(精品资料).doc
【最新整理，下载后即可编辑】摄影测量学单像空间后方交会编程实习报告班级：130x姓名：xx学号：2013302590xxx指导老师：李欣一、实习目的通过对提供的数据进行计算，输出像片的外方位元素并评定精度。
深入理解单像空间后方交会的思想，体会在有多余观测情况下，用最小二乘平差方法编程实现解求影像外方位元素的过程。
通过尝试编程实现加强编程处理问题的能力和对实习内容的理解，通过对实验结果的分析，增强综合运用所学知识解决实际问题的能力。
了解摄影测量平差的基本过程，掌握空间后方交会的定义和实现算法。
二、实习内容根据学习的单像空间后方交会的知识，用程序设计语言（C++或C语言）编写一个完整的单像空间后方交会程序，通过对提供的数据进行计算，输出像片的外方位元素并评定精度。
三、实习数据已知航摄仪的内方位元素：fk =153.24mm，x=y=0，摄影比例尺为1:15000；4个地面控制点的地面坐标及其对应像点的像片坐标：四、实习原理如果我们知道每幅影像的6个外方位元素，就能确定被摄物体与航摄影像的关系。
因此，如何获取影像的外方位元素，一直是摄影测量工作者所探讨的问题。
可采取的方法有：利用雷达、全球定位系统（GPS）、惯性导航系统（INS）以及星相摄影机来获取影像的外方位元素；也可以利用影像覆盖范围内一定数量的控制点的空间坐标与摄影坐标，根据共线条件方程，反求该影像的外方位元素，这种方法称为单幅影像的空间后方交会。
单像空间后方交会的基本思想是：以单幅影像为基础，从该影像所覆盖地面范围内若干控制点的已知地面坐标和相应点的像坐标量测值出发，根据共线条件方程，解求该影像在航空摄影时刻的外方位元素Xs,Ys,Zs,ϕ,ω,κ。
五、 实习流程1. 获取已知数据。
从摄影资料中查取影像比例尺1/m ，平均摄影距离（航空摄影的航高、内方位元素x 0，y 0，f ；获取控制点的空间坐标X t ，Y t ，Z t 。
2. 量测控制点的像点坐标并进行必要的影像坐标系统误差改正，得到像点坐标。
单片空间后方交会程序设计
单片空间后方交会程序设计
1 目的
用程序设计语言（VC或者VB）编写一个完整的单片空间后方交会程序，通过对提供的试验数据进行计算，输出像片的外方位元素并评定精度。
本实验的目的在于让学生深入理解单片空间后方交会的原理，体会在有多余观测情况下，用最小二乘平差方法编程实现解求影像外方位元素的过程。
通过上机调试程序加强动手能力的培养，通过对实验结果的分析，增强学生综合运用所学知识解决实际问题的能力。
2. 内容
利用一定数量的地面控制点，根据共线条件方程求解像片外方位元素。
3. 数据准备
已知航摄仪的内方位元素：f
k =153.24mm，x
=y
=0.0mm，摄影比例尺为1:50000；
4个地面控制点的地面坐标及其对应像点的像片坐标：
4. 操作步骤
上机调试程序并打印结果。
单像空间后方交会实习报告
单像空间后方交会实习报告一、实习目的单像空间后方交会是摄影测量中确定像片外方位元素的重要方法。
通过本次实习，旨在深入理解单像空间后方交会的基本原理和计算过程，熟练掌握相关软件的操作，提高对摄影测量数据处理的实践能力，并培养解决实际问题的思维和方法。
二、实习原理单像空间后方交会的目的是利用像片上的像点坐标以及相应的地面控制点坐标，通过数学模型求解像片的外方位元素（三个线元素 Xs、Ys、Zs 和三个角元素φ、ω、κ）。
其基本原理基于共线条件方程，即摄影中心、像点和相应的地面点位于同一条直线上。
共线条件方程可以表示为：＼＼begin{align}x x_0&＝ f\frac{a_1(X X_s) ＋ b_1(Y Y_s) ＋ c_1(Z Z_s)｝｛a_3(X X_s) ＋ b_3(Y Y_s) ＋ c_3(Z Z_s)｝＼＼y y_0&＝ f\frac{a_2(X X_s) ＋ b_2(Y Y_s) ＋ c_2(Z Z_s)｝｛a_3(X X_s) ＋ b_3(Y Y_s) ＋ c_3(Z Z_s)｝＼end{align}＼其中，＼（（x,y)＼）为像点坐标，＼（（x_0,y_0)＼）为主点坐标，＼（f\）为摄影机焦距，＼（（X,Y,Z)＼）为地面点的物方空间坐标，＼（（X_s,Y_s,Z_s)＼）为摄影中心的物方空间坐标，＼（（a_1,b_1,c_1)，（a_2,b_2,c_2)，（a_3,b_3,c_3)＼）为由角元素φ、ω、κ 构成的旋转矩阵的元素。
三、实习数据本次实习使用了一组航空像片，像片比例尺为 1:5000，焦距为152mm，像主点坐标为\（（x_0,y_0)＝（5000mm,5000mm)＼）。
同时，提供了 6 个均匀分布在像片范围内的地面控制点的物方空间坐标和像点坐标。
四、实习步骤1、数据准备整理地面控制点的物方空间坐标和像点坐标，确保数据的准确性。
输入像片的基本参数，如像主点坐标、焦距等。
编写单片空间后方交会程序实习一
实验一 编写单片空间后方交会程序
一、实验目的
用程序设计语言（Visual C++或者C 语言、matlab 语言）编写一个完整的单片空间后方交会程序，通过对提供的试验数据进行计算，输出像片的外方位元素并评定精度。
本实验的目的在于让学生深入理解单片空间后方交会的原理，体会在有多余观测情况下，用最小二乘平差方法编程实现解求影像外方位元素的过程。
通过上机调试程序加强动手能力的培养，通过对实验结果的分析，增强学生综合运用所学知识解决实际问题的能力。
二、实验内容与要求
利用一定数量的地面控制点，根据共线条件方程求解像片外方位元素。
三、实验原理
根据摄影过程的几何反转原理。
四、实验数据准备
﹡ 已知航摄仪的内方位元素0,24.15300===y x mm f （摄影比例尺为1:50000）； ﹡ 4个地面控制点的地面坐标及其对应像点的像片坐标：
1．每人必须独立上机操作；
2．实验前认真复习单片空间后方交会的有关内容。
六、实验报告
原理、实验步骤及程序框图
上机调试程序并打印结果。
摄影测量学后方交会matlab实习报告
摄影测量原理单张影像后方交会实习目录一实习目的 (3)二实习原理 (3)1. 间接平差 (3)2. 共线方程 (3)3. 单向空间后方交会 (4)三计算流程 (4)1. 求解步骤 (4)2.计算机框图 (4)四程序实现 (5)五结果分析 (6)1.外方位元素 (6)2.误差 (6)3.旋转矩阵R (7)六实习体会 (7)1. 平台的选择 (7)2.问题的解决 (7)3.心得体会 (8)七代码展示 (8)一实习目的为了增强同学们对后方交会公式的理解，培养同学们对迭代循环编程的熟悉感，本次摄影测量课间实习内容定为用C语言或其他程序编写单片空间后方交会程序，最终输出像点坐标、地面坐标、单位权中误差、外方位元素及其精度。
已知四对点的影像坐标和地面坐标如下。
内方位元素fk=153.24mm，x0=y0=0。
本次实习，我使用了matlab2014进行后方交会程序实现。
结果与参考答案一致，精度良好。
二实习原理题干中有四个控制点在地面摄影测量坐标系中的坐标和对应的像点坐标，由此可列出8个误差方程，存在2个多余观测（n=2）。
故可利用间接平差的最小二乘法则求解。
由于共线方程是非线性函数模型，为了方便计算，需要将其“线性化”。
但如果仅取泰勒级数展开式的一次项，未知数的近似值改正是不精确的。
因此必须采用迭代趋近法计算，直到外方位元素的改正值小于限差。
1.间接平差间接平差为平差计算最常用的方法。
在确定多个未知量的最或然值时，选择它们之间不存在任何条件关系的独立量作为未知量组成用未知量表达测量的函数关系、列出误差方程式，按最小二乘法原理求得未知量的最或然值的平差方法。
在一个间接平差问题中，当所选的独立参数X个数与必要观测值t个数相等时，可将每个观测值表达成这t个参数的函数，组成观测方程。
函数模型为：L = BX + d。
2.共线方程共线方程是中心投影构像的数学基础，也是各种摄影测量处理方法的重要理论基础。
式中：x，y 为像点的像平面坐标；x0，y0，f 为影像的内方位元素；XS，YS，ZS 为摄站点的物方空间坐标；XA，YA，ZA 为物方点的物方空间坐标；ai，bi，ci （i = 1,2,3）为影像的3 个外方位角元素组成的9 个方向余弦。
摄影测量学空间后方交会实验报告
摄影测量学实验报告实验一、单像空间后方交会学院：建测学院班级：测绘082姓名：肖澎学号： 15一．实验目的1.深入了解单像空间后方交会的计算过程；2.加强空间后方交会基本公式和误差方程式，法线方程式的记忆；3.通过上机调试程序加强动手能力的培养。
二．实验原理以单幅影像为基础，从该影像所覆盖地面范围内若干控制点和相应点的像坐标量测值出发，根据共线条件方程，求解该影像在航空摄影时刻的相片外方位元素。
三．实验内容1.程序图框图2.实验数据（1）已知航摄仪内方位元素f＝153.24mm，Xo＝Yo＝0。
限差0.1秒（2）已知4对点的影像坐标和地面坐标：3.实验程序using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace ConsoleApplication3{class Program{static void Main(){//输入比例尺，主距，参与平参点的个数Console.WriteLine("请输入比例尺分母m：\r");string m1 = Console.ReadLine();double m = (double)Convert.ToSingle(m1);Console.WriteLine("请输入主距f：\r");string f1 = Console.ReadLine();double f = (double)Convert.ToSingle(f1);Console.WriteLine("请输入参与平差控制点的个数n：\r");string n1 = Console.ReadLine();int n = (int)Convert.ToSingle(n1);//像点坐标的输入代码double[] arr1 = new double[2 * n];//1.像点x坐标的输入for (int i = 0; i < n; i++){Console.WriteLine("请输入已进行系统误差改正的像点坐标的x{0}值：\r", i+1);string u = Console.ReadLine();for (int j = 0; j < n; j += 2){arr1[j] = (double)Convert.ToSingle(u);}}//2.像点y坐标的输入for (int i = 0; i < n; i++){Console.WriteLine("请输入已进行系统误差改正的像点坐标的y{0}值：\r", i+1);string v = Console.ReadLine();for (int j = 1; j < n; j += 2){arr1[j] = (double)Convert.ToSingle(v);}}//控制点的坐标输入代码double[,] arr2 = new double[n, 3];//1.控制点X坐标的输入for (int j = 0; j < n; j++){Console.WriteLine("请输入控制点在地面摄影测量坐标系的坐标的X{0}值：\r", j+1);string u = Console.ReadLine();arr2[j , 0] = (double)Convert.ToSingle(u);}//2.控制点Y坐标的输入for (int k = 0; k < n; k++){Console.WriteLine("请输入控制点在地面摄影测量坐标系的坐标的Y{0}值：\r", k+1);string v = Console.ReadLine();arr2[k , 1] = (double)Convert.ToSingle(v);}//3.控制点Z坐标的输入for (int p =0; p < n; p++){Console.WriteLine("请输入控制点在地面摄影测量坐标系的坐标的Z{0}值：\r", p+1);string w = Console.ReadLine();arr2[p , 2] = (double)Convert.ToSingle(w);}//确定外方位元素的初始值//1.确定Xs的初始值：double Xs0 = 0;double sumx = 0;for (int j = 0; j < n; j++){double h = arr2[j, 0];sumx += h;}Xs0 = sumx / n;//2.确定Ys的初始值：double Ys0 = 0;double sumy = 0;for (int j = 0; j < n; j++){double h = arr2[j, 1];sumy += h;}Ys0 = sumy / n;//3.确定Zs的初始值：double Zs0 = 0;double sumz = 0;for (int j = 0; j <= n - 1; j++){double h = arr2[j, 2];sumz += h;}Zs0 = sumz / n;doubleΦ0 = 0;doubleΨ0 = 0;double K0 = 0;Console.WriteLine("Xs0,Ys0,Zs0,Φ0,Ψ0,K0的值分别是：{0},{1},{2},{3},{4},{5}", Xs0, Ys0, Zs0, 0, 0, 0);//用三个角元素的初始值按（3-4-5）计算各方向余弦值，组成旋转矩阵,此时的旋转矩阵为单位矩阵I：double[,] arr3 = new double[3, 3];for (int i = 0; i < 3; i++)arr3[i, i] = 1;}double a1 = arr3[0, 0]; double a2 = arr3[0, 1]; double a3 = arr3[0, 2];double b1 = arr3[1, 0]; double b2 = arr3[1, 1]; double b3 = arr3[1, 2];double c1 = arr3[2, 0]; double c2 = arr3[2, 1]; double c3 = arr3[2, 2];/*利用线元素的初始值和控制点的地面坐标，代入共线方程（3-5-2），* 逐点计算像点坐标的近似值*///1.定义存放像点近似值的数组double[] arr4 = new double[2 * n];//----------近似值矩阵//2.逐点像点坐标计算近似值//a.计算像点的x坐标近似值（x）for (int i = 0; i < 2 * n; i += 2){for (int j = 0; j < n; j++){arr4[i] = -f * (a1 * (arr2[j, 0] - Xs0) + b1 * (arr2[j, 1] - Ys0) + c1 * (arr2[j, 2] - Zs0)) / (a3 * (arr2[j, 0] - Xs0) + b3 * (arr2[j, 1] - Ys0) + c3 * (arr2[j, 2] - Zs0)); }}//b.计算像点的y坐标近似值（y）for (int i = 1; i < 2 * n; i += 2){for (int j = 0; j < n; j++){arr4[i] = -f * (a2 * (arr2[j, 0] - Xs0) + b2 * (arr2[j, 1] - Ys0) + c2 * (arr2[j, 2] - Zs0)) / (a3 * (arr2[j, 0] - Xs0) + b3 * (arr2[j, 1] - Ys0) + c3 * (arr2[j, 2] - Zs0)); }}//逐点计算误差方程式的系数和常数项，组成误差方程：double[,] arr5 = new double[2 * n, 6]; //------------系数矩阵（A）//1.计算dXs的系数for (int i = 0; i < 2 * n; i += 2){arr5[i, 0] = -1 / m; //-f/H == -1/m}//2.计算dYs的系数for (int i = 1; i < 2 * n; i += 2){arr5[i, 1] = -1 / m; //-f/H == -1/m}//3.a.计算误差方程式Vx中dZs的系数for (int i = 0; i < 2 * n; i += 2)arr5[i, 2] = -arr1[i] / m * f;}//3.b.计算误差方程式Vy中dZs的系数for (int i = 1; i < 2 * n; i += 2){arr5[i, 2] = -arr1[i] / m * f;}//4.a.计算误差方程式Vx中dΦ的系数for (int i = 0; i < 2 * n; i += 2){arr5[i, 3] = -f * (1 + arr1[i] * arr1[i] / f * f);}//4.a.计算误差方程式Vy中dΦ的系数for (int i = 1; i < 2 * n; i += 2){arr5[i, 3] = -arr1[i - 1] * arr1[i] / f;}//5.a.计算误差方程式Vx中dΨ的系数for (int i = 0; i < 2 * n; i += 2){arr5[i, 4] = -arr1[i] * arr1[i + 1] / f;}//5.b.计算误差方程式Vy中dΨ的系数for (int i = 1; i < 2 * n; i += 2){arr5[i, 4] = -f * (1 + arr1[i] * arr1[i] / f * f);}//6.a.计算误差方程式Vx中dk的系数for (int i = 0; i < 2 * n; i += 2){arr5[i, 5] = arr1[i + 1];}//6.b.计算误差方程式Vy中dk的系数for (int i = 1; i < 2 * n; i += 2){arr5[i, 5] = -arr1[i - 1];}//定义外方位元素组成的数组double[] arr6 = new double[6];//--------------------外方位元素改正数矩阵（X）//定义常数项元素组成的数组double[] arr7 = new double[2 * n];//-----------------常数矩阵（L）//计算lx的值for (int i = 0; i < 2 * n; i += 2)arr7[i] = arr1[i] - arr4[i]; //将近似值矩阵的元素代入}//计算ly的值for (int i = 1; i <= 2 * (n - 1); i += 2){arr7[i] = arr1[i] - arr4[i]; //将近似值矩阵的元素代入}/* 对于所有像点的坐标观测值，一般认为是等精度量测，所以权阵P为单位阵.所以X=(ATA)-1ATL *///1.计算ATdouble[,] arr5T = new double[6, 2 * n];for (int i = 0; i < 6; i++){for (int j = 0; j < 2 * n; j++){arr5T[i, j] = arr5[j, i];}}//A的转置与A的乘积,存放在arr5AA中double[,] arr5AA = new double[6, 6];for (int i = 0; i < 6; i++){for (int j = 0; j < 6; j++){arr5AA[i, j] = 0;for (int l = 0; l < 2 * n; l++){arr5AA[i, j] += arr5T[i, l] * arr5[l, j];}}}nijuzhen(arr5AA);//arr5AA经过求逆后变成原矩阵的逆矩阵//arr5AA * arr5T存在arr5AARATdouble[,] arr5AARAT = new double[6, 2 * n];for (int i = 0; i < 6; i++){for (int j = 0; j < 2 * n; j++){arr5AARAT[i, j] = 0;for (int p = 0; p < 6; p++){arr5AARAT[i, j] += arr5AA[i, p] * arr5T[p, j];}}}//计算arr5AARAT x L，存在arrX中double[] arrX = new double[6];for (int i = 0; i < 6; i++){for (int j = 0; j < 1; j++){arrX[i] = 0;for (int vv = 0; vv < 6; vv++){arrX[i] += arr5AARAT[i, vv] * arr7[vv];}}}//计算外方位元素值double Xs, Ys, Zs, Φ, Ψ, K;Xs = Xs0 + arrX[0];Ys = Ys0 + arrX[1];Zs = Zs0 + arrX[2];Φ = Φ0 + arrX[3];Ψ = Ψ0 + arrX[4];K = K0 + arrX[5];for (int i = 0; i <= 2; i++){Xs += arrX[0];Ys += arrX[1];Zs += arrX[2];Φ += arrX[3];Ψ += arrX[4];K += arrX[5];}Console.WriteLine("Xs,Ys,Zs,Φ,Ψ,K的值分别是：{0},{1},{2},{3},{4},{5}", Xs0, Ys0, Zs0, Φ, Ψ, K);Console.Read();}//求arr5AA的逆矩public static double[,] nijuzhen(double[,] a) {double[,] B = new double[6, 6];int i, j, k;int row = 0;int col = 0;double max, temp;int[] p = new int[6];for (i = 0; i < 6; i++){p[i] = i;B[i, i] = 1;}for (k = 0; k < 6; k++){//找主元max = 0; row = col = i;for (i = k; i < 6; i++){for (j = k; j < 6; j++){temp = Math.Abs(a[i, j]);if (max < temp){max = temp;row = i;col = j;}}}//交换行列，将主元调整到k行k列上if (row != k){for (j = 0; j < 6; j++){temp = a[row, j];a[row, j] = a[k, j];a[k, j] = temp;temp = B[row, j];B[row, j] = B[k, j];B[k, j] = temp;i = p[row]; p[row] = p[k]; p[k] = i; }if (col != k){for (i = 0; i < 6; i++){temp = a[i, col];a[i, col] = a[i, k];a[i, k] = temp;}}//处理for (j = k + 1; j < 6; j++){a[k, j] /= a[k, k];}for (j = 0; j < 6; j++){B[k, j] /= a[k, k];a[k, k] = 1;}for (j = k + 1; j < 6; j++){for (i = 0; j < k; i++){a[i, j] -= a[i, k] * a[k, j];}for (i = k + 1; i < 6; i++){a[i, j] -= a[i, k] * a[k, j];}}for (j = 0; j < 6; j++){for (i = 0; i < k; i++){B[i, j] -= a[i, k] * B[k, j];}for (i = k + 1; i < 6; i++){B[i, j] -= a[i, k] * B[k, j];}for (i = 0; i < 6; i++) {a[i, k] = 0;a[k, k] = 1;}}//恢复行列次序for (j = 0; j < 6; j++){for (i = 0; i < 6; i++) {a[p[i], j] = B[i, j]; }}for (i = 0; i < 6; i++){for (j = 0; j < 6; j++) {a[i, j] = a[i, j];}}return a;}4．实验结果四．实验总结此次实验让我深入了解单像空间后方交会的计算过程，加强了对空间后方交会基本公式和误差方程式，法线方程式的记忆。
简述单像空间后方交会的程序设计步骤
简述单像空间后方交会的程序设计步骤摘要：一、单像空间后方交会概念阐述二、单像空间后方交会程序设计目的三、单像空间后方交会程序设计步骤1.数据准备2.建立中心投影几何模型3.求解像片外方位元素4.评定精度四、实验意义及能力培养正文：单像空间后方交会是一种基于摄影测量原理的算法，通过计算影像的外方位元素，实现对影像的定位和测量。
在已知地面上若干点的地面坐标和对应像点的像片坐标的情况下，利用共线条件方程求解像片外方位元素。
以下详细介绍单像空间后方交会的程序设计步骤：一、单像空间后方交会概念阐述单像空间后方交会是指在影像覆盖范围内，根据一定数量的分布合理的地面控制点（已知其像点和地面点的坐标），利用共线条件方程求解像片外方位元素的过程。
它是摄影测量中一种基础的算法，为后续复杂算法的演进提供了基础。
二、单像空间后方交会程序设计目的单像空间后方交会程序设计的目的是让学生深入理解单片空间后方交会的原理，通过上机调试程序加强动手能力的培养，通过对实验结果的分析，增强学生综合运用所学知识解决实际问题的能力。
三、单像空间后方交会程序设计步骤1.数据准备：已知航摄仪的内方位元素，摄影比例尺，以及地面控制点的地面坐标和对应像点的像片坐标。
2.建立中心投影几何模型：根据针孔相机模型，建立中心投影的几何模型，包括物空间坐标系、像空间坐标系和摄影坐标系。
3.求解像片外方位元素：利用共线条件方程，通过最小二乘平差方法求解像片的外方位元素。
4.评定精度：根据实验数据，评定求解得到的像片外方位元素的精度。
四、实验意义及能力培养单像空间后方交会实验有助于学生掌握摄影测量基本原理，了解单像空间后方交会的计算过程，提高动手实践能力。
通过实验，学生可以深入理解线性代数和微分学在摄影测量中的应用，为后续学习提供更扎实的基础。
此外，实验还可以培养学生的解决问题的能力和综合运用所学知识的能力，为未来从事相关领域工作打下坚实基础。
综上所述，单像空间后方交会是一种重要的摄影测量方法，通过程序设计实现对影像的定位和测量。
摄影测量学单像空间后方交会程序设计作业
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace 单像空间后方交会{class Program{static void Main(string[] args){int x0, y0, i, j; double f, m;Console.Write("请输入像片比例尺：");m = double.Parse(Console.ReadLine());Console.Write("请输入像片的内方位元素x0:");//均以毫米为单位x0 = int.Parse(Console.ReadLine());Console.Write("请输入像片的内方位元素y0:");y0 = int.Parse(Console.ReadLine());Console.Write("请输入摄影机主距f:");f = double.Parse(Console.ReadLine());Console.WriteLine();//输入坐标数据double[,] zuobiao = new double[4, 5];for (i = 0; i < 4; i++){for (j = 0; j < 5; j++){if (j < 3){Console.Write("请输入第{0}个点的第{1}个地面坐标：", i + 1, j + 1);zuobiao[i, j] =double.Parse(Console.ReadLine());}else{Console.Write("请输入第{0}个点的第{1}个像点坐标：", i + 1, j - 2);zuobiao[i, j] =double.Parse(Console.ReadLine());}} Console.WriteLine();}//归算像点坐标for (i = 0; i < 4; i++){for (j = 3; j < 5; j++){if (j == 3)zuobiao[i, j] = zuobiao[i, j] - x0;elsezuobiao[i, j] = zuobiao[i, j] - y0;}}//计算和确定初值double zs0 = m * f, xs0 = 0, ys0 = 0;for (i = 0; i < 4; i++){xs0 = xs0 + zuobiao[i, 0];ys0 = ys0 + zuobiao[i, 1];}xs0 = xs0 / 4;ys0 = ys0 / 4;//逐点计算误差方程系数double[,] xishu = new double[8, 6];for (i = 0; i < 8; i += 2){double x, y;x = zuobiao[i / 2, 3]; y = zuobiao[i / 2, 4];xishu[i, 0] = xishu[i + 1, 1] = -1 / m; xishu[i, 1] = xishu[i + 1, 0] = 0; xishu[i, 2] = -x / (m * f); xishu[i, 3] = -f * (1 + x * x / (f * f));xishu[i, 4] = xishu[i + 1, 3] = -x * y / f; xishu[i, 5] = y; xishu[i + 1, 2] = -y / (m * f); xishu[i + 1, 4] = -f * (1 + y * y / (f * f)); xishu[i + 1, 5] = -x;}//计算逆阵double[,] dMatrix =matrixChe(matrixTrans(xishu), xishu);double[,] dReturn = ReverseMatrix(dMatrix, 6);Console.WriteLine("逆矩阵为：");if (dReturn != null){matrixOut(dReturn);}//求解过程double phi0 = 0, omega0 = 0, kappa0 = 0; int q = 0;double[,] r = new double[3, 3];double[,] jinsi = new double[4, 2];double[] chazhi = new double[8];double[] jieguo = new double[6];double[,] zhong = matrixChe(dReturn,matrixTrans(xishu));do{ //计算旋转矩阵rr[0, 0] = Math.Cos(phi0) * Math.Cos(kappa0) - Math.Sin(phi0) * Math.Sin(omega0) * Math.Sin(kappa0);r[0, 1] = -Math.Cos(phi0) * Math.Sin(kappa0) - Math.Sin(phi0) * Math.Sin(omega0) * Math.Cos(kappa0);r[0, 2] = -Math.Sin(phi0) * Math.Cos(omega0);r[1, 0] = Math.Cos(omega0) * Math.Sin(kappa0);r[1, 1] = Math.Cos(omega0) * Math.Cos(kappa0);r[1, 2] = -Math.Sin(omega0);r[2, 0] = Math.Sin(phi0) * Math.Cos(kappa0) + Math.Cos(phi0) * Math.Sin(omega0) * Math.Sin(kappa0);r[2, 1] = -Math.Sin(phi0) * Math.Sin(kappa0) + Math.Cos(phi0) * Math.Sin(omega0) * Math.Cos(kappa0);r[2, 2] = Math.Cos(phi0) * Math.Cos(omega0);//计算x,y的近似值for (i = 0; i < 4; i++){jinsi[i, 0] = -f * (r[0, 0] * (zuobiao[i, 0] - xs0) + r[1, 0] * (zuobiao[i, 1] - ys0) + r[2, 0] * (zuobiao[i, 2] - zs0)) / (r[0, 2] * (zuobiao[i, 0] - xs0) + r[1, 2] * (zuobiao[i, 1] - ys0) + r[2, 2] * (zuobiao[i, 2] - zs0));jinsi[i, 1] = -f * (r[0, 1] * (zuobiao[i, 0] - xs0) + r[1, 1] * (zuobiao[i, 1] - ys0) + r[2, 1] * (zuobiao[i, 2] - zs0)) / (r[0, 2] * (zuobiao[i, 0] - xs0) + r[1, 2] * (zuobiao[i, 1] - ys0) + r[2, 2] * (zuobiao[i, 2] - zs0));}for (i = 0; i < 8; i += 2){chazhi[i] = zuobiao[i / 2, 3] - jinsi[i / 2, 0];chazhi[i + 1] = zuobiao[i / 2, 4] - jinsi[i / 2, 1];}for (i = 0; i < zhong.GetLength(0); i++){double k = 0;for (j = 0; j < zhong.GetLength(1); j++){k = k + zhong[i, j] * chazhi[j];}jieguo[i] = k;}//求新的近似值xs0 += jieguo[0]; ys0 += jieguo[1]; zs0 += jieguo[2];phi0 += jieguo[3]; omega0 += jieguo[4]; kappa0 += jieguo[5];q++;if (q > 1000)break;} while ((Math.Abs(jieguo[0]) > 0.020 ||Math.Abs(jieguo[1]) > 0.020) || Math.Abs(jieguo[2]) > 0.020);Console.WriteLine("共进行了{0}次运算", q);Console.WriteLine("旋转矩阵为");matrixOut(r);for (i = 0; i < jieguo.GetLength(0); i++){Console.Write("第{0}个外方位元素为：{1}", i + 1, jieguo[i]);}}//矩阵转置public static double[,] matrixTrans(double[,] X){double[,] A = X;double[,] C = new double[A.GetLength(1),A.GetLength(0)];for (int i = 0; i < A.GetLength(1); i++)for (int j = 0; j < A.GetLength(0); j++){C[i, j] = A[j, i];}return C;}//矩阵输出public static void matrixOut(double[,] X){double[,] C = X;for (int i = 0; i < C.GetLength(0); i++){for (int j = 0; j < C.GetLength(1); j++){Console.Write(" {0}", C[i, j]);}Console.Write("\n");}}//二维矩阵相乘public static double[,] matrixChe(double[,] X, double[,] Y){int i, j, n; double m;double[,] C = X; double[,] D = Y;double[,] E = new double[C.GetLength(0),C.GetLength(0)];for (i = 0; i < C.GetLength(0); i++){for (n = 0; n < C.GetLength(0); n++){m = 0;for (j = 0; j < C.GetLength(1); j++){m = m + C[i, j] * D[j, n];}E[i, n] = m;}}return E;}//计算行列式的值public static double MatrixValue(double[,] MatrixList, int Level){double[,] dMatrix = new double[Level, Level];for (int i = 0; i < Level; i++)for (int j = 0; j < Level; j++)dMatrix[i, j] = MatrixList[i, j];double c, x;int k = 1;for (int i = 0, j = 0; i < Level && j < Level; i++, j++){if (dMatrix[i, j] == 0){int m = i;for (; dMatrix[m, j] == 0; m++) ;if (m == Level)return 0;else{for (int n = j; n < Level; n++){c = dMatrix[i, n];dMatrix[i, n] = dMatrix[m, n];dMatrix[m, n] = c;}k *= (-1);}}for (int s = Level - 1; s > i; s--){x = dMatrix[s, j];for (int t = j; t < Level; t++)dMatrix[s, t] -= dMatrix[i, t] * (x / dMatrix[i, j]);}}double sn = 1;for (int i = 0; i < Level; i++){if (dMatrix[i, i] != 0)sn *= dMatrix[i, i];elsereturn 0;}return k * sn;}//计算逆阵public static double[,] ReverseMatrix(double[,] dMatrix, int Level){double dMatrixValue = MatrixValue(dMatrix, Level);if (dMatrixValue == 0) return null;double[,] dReverseMatrix = new double[Level, 2 * Level];double x, c;for (int i = 0; i < Level; i++){for (int j = 0; j < 2 * Level; j++){if (j < Level)dReverseMatrix[i, j] = dMatrix[i, j];elsedReverseMatrix[i, j] = 0;}dReverseMatrix[i, Level + i] = 1;}for (int i = 0, j = 0; i < Level && j < Level; i++, j++){if (dReverseMatrix[i, j] == 0){int m = i;for (; dMatrix[m, j] == 0; m++) ;if (m == Level)return null;else{for (int n = j; n < 2 * Level; n++)dReverseMatrix[i, n] += dReverseMatrix[m, n];}}x = dReverseMatrix[i, j];if (x != 1){for (int n = j; n < 2 * Level; n++)if (dReverseMatrix[i, n] != 0)dReverseMatrix[i, n] /= x;}for (int s = Level - 1; s > i; s--){x = dReverseMatrix[s, j];for (int t = j; t < 2 * Level; t++)dReverseMatrix[s, t] -= (dReverseMatrix[i, t] * x);}}for (int i = Level - 2; i >= 0; i--){for (int j = i + 1; j < Level; j++)if (dReverseMatrix[i, j] != 0){c = dReverseMatrix[i, j];for (int n = j; n < 2 * Level; n++)dReverseMatrix[i, n] -= (c * dReverseMatrix[j, n]);}}double[,] dReturn = new double[Level, Level];for (int i = 0; i < Level; i++)for (int j = 0; j < Level; j++)dReturn[i, j] = dReverseMatrix[i, j + Level];return dReturn;}}}。
单向后方交会实验报告C
单向后方交会实验报告C++实验报告班级：测绘一班学号:日期：2016.5.5目录一、计算原理 (3)二、算法流程 (4)三、源程序 (5)四、计算结果 (13)五、结果分析 (13)六、心得体会 (13)一、计算原理已知条件摄影机主距f=153.24mm，x0=0.01mm，y0=0.02mm, 像片比例尺为1:40000，有四对点的像点坐标与相应的地面坐标如下表。
以单像空间后方交会方法，求解该像片的外方位元素。
二、算法流程（1）获取已知数据。
从航摄资料中差取平均航高与摄影机主距；获取控制点的地面测量坐标并转换为地面摄影坐标。
（2）量测控制点的像点坐标并作系统误差改正。
（3）确定未知数的初始值。
在竖直摄影且地面控制点大体对称分布的情况下，按如下方法确定初始值，即X0SX?，Yn0SY?，Zn0S?mf?1?Z n?0??0??0?0（4）用三个角元素的初始值按下式，计算各个方向余弦值，组成旋转矩阵Ra1?cos?cos??sin?sin?sin?a2??cos?sin??sin?sin?cos?a3??sin?cos?b1?cos?sin?b 2?cos?cos?b3??sin?c1?sin?cos??cos?sin?sin?c2??sin?sin??cos?sin?cos?c3?cos?cos?（5）逐点计算像点坐标的近似值。
利用未知数的近似值和控制点的地面坐标；带入共线方程式，逐点近似像点坐标的近似值（x）、（y）。
（6）逐点计算误差方程式的系数和常数项，组成误差方程式。
（7）计算法方程的系数矩阵ATA和常数项ALL，组成法方程式。
（8）解法方程，求得外方位元素的改正数dXS、dYS、dZS、d?、d?、d?。
（9）用前次迭代取得的近似值，加本次迭代的改正数，计算外方位元素的新值。
KK?1KKK?1KXS?XS?dXS,YSK?YSK?1?dYSK,ZS?ZS?dZS?K??K?1?d?K,?K??K?1?d?K,?K??K?1?d?K（10）将求得的外方位元素改正数与规定的限差比较，若小于限差，则迭代结束。
(完整word版)单像空间后方交会程序报告
单像空间后方交会程序报告指导老师：刘老师班级：测绘 101姓名：尚锋学号：19号1、应用程序的主进口部分的代码：using System;using System.Collections.Generic;using System.Linq;using System.Windows.Forms;namespace 单像空间后方交会{static class Program{///<summary>///应用程序的主进口点。
///</summary>[ STAThread]static void Main(){Application .EnableVisualStyles();Application .SetCompatibleTextRenderingDefault( false );Application .Run( new Form1());}}}2、方法解算类（通用）部分的代码：using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace 单像空间后方交会{class Tongyong{struct image_point // 一个像点结构，包括像点坐标和地面点坐标{public double x;public double y;public double X;public double Y;public double Z; }private private private private private private private private private private private private private publicdouble f;// 主距double u;//u 为外方向元素，下边 5个同样double w;double k;double Xs;double Ys;double Zs;image_point [] p = new image_point [4];// 四个控制点double [] R = new double [9]; // 旋转矩阵double [] a = new double [8];// 像点坐标近似值double [,] A =new double [8, 6];// 偏差方程式系数double [] L = new double [8];// 偏差方程式常数项int count = 0;// 统计代次数Tongyong( double g, double [] q)// 结构函数，初始化各变量 , 单位 m{f = g;for ( int i = 0; i < 4; i++){int j = i * 5;p[i].x = q[j];p[i].y = q[j + 1];p[i].X = q[j + 2];p[i].Y = q[j + 3];p[i].Z = q[j + 4];}double ave = 0, sum = 0;for ( int i = 0; i < 3; i++)// 求比率尺分母{for ( int j = i + 1; j < 4; j++){sum += Math.Pow(p[i].Y - p[j].Y, 2)) / + Math.Pow(p[i].y - p[j].y, 2));} Math.Sqrt(Math.Pow(p[i].X - p[j].X, 2) + Math.Sqrt( Math.Pow(p[i].x - p[j].x, 2)}ave = sum / 6;u = 0;// 给定外方向元素的初始值w = 0;k = 0;Xs = (p[0].X + p[1].X + p[2].X + p[3].X) / 4; , 角度均设置为0//Xs 为四个控制点 X的均匀值，Ys近似Ys = (p[0].Y + p[1].Y + p[2].Y + p[3].Y) / 4;Zs = (p[0].Z + p[1].Z + p[2].Z + p[3].Z) / 4 + ave * f;}private double sin( double m) // 正弦，为简化而写 , 下同{return Math.Sin(m);}private double cos( double m){return Math.Cos(m);}private void calcos()// 计算旋转矩阵{R[0] = cos(u) * cos(k) - sin(u) * sin(w) * sin(k);R[1] = -cos(u) * sin(k) - sin(u) * sin(w) * cos(k);R[2] = -sin(u) * cos(w);R[3] = cos(w) * sin(k);R[4] = cos(w) * cos(k);R[5] = -sin(w);R[6] = sin(u) * cos(k) + cos(u) * sin(w) * sin(k);R[7] = cos(u) * sin(w) * cos(k) - sin(u) * sin(k);R[8] = cos(u) * cos(w);}private void calabout() // 像点坐标的近似值{int i;for (i = 0; i < 4; i++){a[2 * i] = -f * (R[0] * (p[i].X - Xs) + R[3] * (p[i].Y-Ys) + R[6] * (p[i].Z - Zs)) / (R[2] * (p[i].X - Xs) + R[5] * (p[i].Y-Ys) + R[8] * (p[i].Z - Zs));a[2* i + 1] = -f * (R[1] * (p[i].X - Xs) + R[4] * (p[i].Y -Ys) + R[7] * (p[i].Z - Zs)) / (R[2] * (p[i].X - Xs) + R[5] * (p[i].Y-Ys) + R[8] * (p[i].Z - Zs));}}private void calxx() // 偏差方程式的系数和常数项{int for i;(i = 0; i < 4; i++) // 系数{double z = R[2] * (p[i].X - Xs) + R[5] * (p[i].Y - Ys) + R[8] * (p[i].Z - Zs);int n = i * 2;A[n, 0] = (R[0] * f + R[2] * p[i].x) / z;A[n, 1] = (R[3] * f + R[5] * p[i].x) / z;A[n, 2] = (R[6] * f + R[8] * p[i].x) / z;A[n, 3] = p[i].y * sin(w) - f * cos(w) * cos(k) - p[i].x/f * (p[i].x * cos(w) * cos(k) - p[i].y * cos(w) * sin(k)); A[n,4] = -f * sin(k) - p[i].x / f * (p[i].x * sin(k) +p[i].y * cos(k));A[n, 5] = p[i].y;A[n + 1, 0] = (R[1] * f + R[2] * p[i].y) / z;A[n + 1, 1] = (R[4] * f + R[5] * p[i].y) / z;A[n + 1, 2] = (R[7] * f + R[8] * p[i].y) / z;A[n + 1, 3] = -p[i].x * sin(w) + f * cos(w) * sin(k) -p[i].x / f * (p[i].x * cos(w) * cos(k) - p[i].y * sin(k) * cos(w));A[n + 1, 4] = -f * cos(k) - p[i].y / f * (p[i].x * sin(k) + p[i].y * cos(k));A[n + 1, 5] = -p[i].x;}for (i = 0; i < 4; i++)// 常数项{L[2 * i] = p[i].x - a[2 * i];L[2 * i + 1] = p[i].y - a[2 * i + 1];}}private double calAdd(){double [,] temp =new double [6, 6];//A 的转置与 A相乘的积double [,] ANew = new double [6, 8];//A 的转置double [] t =new double [6];//A 的转置与 L相乘的积double [] X = new double [6];// 更正数int i, j, n;for (i = 0; i < 8; i++)// 求A的转置 ANew{for (j = 0; j < 6; j++){ANew[j, i] = A[i, j];}}for (i = 0; i < 6; i++)// 求A的转置与 A相乘的积 temp {for (j = 0; j < 6; j++){temp[i, j] = 0;for (n = 0; n < 8; n++){temp[i, j] += ANew[i, n] * A[n, j];}}}MATINV(temp);//temp for (i = 0; i < 6; i++) 的逆，保留在自己矩阵中// 求A的转置与 L的乘积 t{t[i] = 0;for (j = 0; j < 8; j++){t[i] += ANew[i, j] * L[j];}}for (i = 0; i < 6; i++)// 求更正数 X{X[i] = 0;for (j = 0; j < 6; j++){X[i] += temp[i, j] * t[j];}}Xs += X[0];// 外方向元素初始值加上更正数Ys += X[1];Zs += X[2];u += X[3];w += X[4];k += X[5];return maxone(X);// 返回判断条件 , 最大的更正数的值}public void makeSure() // 计算流程控制函数{calcos();calabout();calxx();double VALUE = calAdd();count++;while (VALUE > 0.00001)// 迭代至最大更正数为止{calcos();calabout();calxx();VALUE = calAdd();count++;}}private void MATINV(double [,] c) // 求6阶矩阵的逆{int i, j, h, m;const int n = 6;double l;double [,] q = new double [n, 12];for (i = 0; i < n; i++) // 结构高斯矩阵{for (j = 0; j < n; j++){q[i, j] = c[i, j];}}for (i = 0; i < n; i++) // 单位矩阵{{for (j = n; j < 12; j++)if (i + 6 == j)q[i, j] = 1;elseq[i, j] = 0;}}for (h = 0, m = 0; m < n - 1; m++, h++)// 消去对角线以下的数据{for (i = m + 1; i < n; i++){if(q[i, h] == 0d)continue ;l = q[m, h] / q[i, h];for (j = 0; j < 12; j++){q[i, j] *= l;q[i, j] -= q[m, j];}}}for (h = n - 1, m = n - 1; m > 0; m--, h--)//消去对角线以上的数据{for (i = m - 1; i >= 0; i--){if(q[i, h] == 0d)continue ;l = q[m, h] / q[i, h];for (j = 0; j < 12; j++){q[i, j] *= l;q[i, j] -= q[m, j];}}}for (i = 0; i < n; i++)// 将对角线上数据化为 1{l = 1.0 / q[i, i];for (j = 0; j < 12; j++){q[i, j] *= l;}}for (i = 0; i < n; i++)// 提取逆矩阵{for (j = 0; j < n; j++){c[i, j] = q[i, j + 6];}}}private double maxone(double [] Arr)// 返回六个元素中的最大值{double [] ARR =new double [6];for ( int i = 0; i < 6; i++){ARR[i] = Arr[i];if (ARR[i] < 0d)// 取正ARR[i] = -ARR[i];}Array .Sort(ARR, 0, 6);return ARR[5];}public int COUNT{get{return count;}}public double U {get{return u;}}public double W {get{return w;}}public double K {get{return k;}}public double XS {get{return Xs;}}public double YS {get{return Ys;}}public double ZS {get{return Zs;}}}3、窗体一部分的代码：using System;using System.Collections.Generic;using ponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Windows.Forms;using System.Diagnostics;using System.Data.OleDb;using System.IO;namespace 单像空间后方交会{public partial class Form1 : Form {private private double [] data= double f = 0;new double [20];// 主距// 保留表中的数据public Form1(){InitializeComponent();}private void Form1_Load( object sender, EventArgs e) {//TODO: 这行代码将数据加载到表“ database1DataSet1.data ”中。
空间后方交会程序
一． 实验目的： 掌握摄影测量空间后方交会的原理，利用计算机编程语言实现空间后方交会外方位元素的解算。
二． 仪器用具及已知数据文件： 计算机windows xp 系统，编程软件（VISUAL C++6.0），地面控制点在摄影测量坐标系中的坐标及其像点坐标文件shuju.txt 。
三． 实验内容：单张影像的空间后方交会：利用已知地面控制点数据及相应像点坐标根据共线方程反求影像的外方位元素。
数学模型：共线条件方程式： )(3)(3)(3)(1)(1)(1Zs Z c Ys Y b Xs X a Zs Z c Ys Y b Xs X a f x -+-+--+-+--= )(3)(3)(3)(2)(2)(2Zs Z c Ys Y b Xs X a Zs Z c Ys Y b Xs X a f y -+-+--+-+--= 求解过程： （1）获取已知数据。
从航摄资料中查取平均航高与摄影机主距；获取控制点的地面测量坐标并转换为地面摄影测量坐标。
（2）量测控制点的像点坐标并做系统改正。
（3）确定未知数的初始值。
在竖直摄影且地面控制点大致分布均匀的情况下，按如下方法确定初始值，即： n X X S ∑=0,n Y Y S ∑=0,n Z mf Z S ∑=0 φ =ω=κ=0 式中；m 为摄影比例尺分母；n 为控制点个数。
（4）用三个角元素的初始值，计算个方向余弦，组成旋转矩阵R 。
（5）逐点计算像点坐标的近似值。
利用未知数的近似值和控制点的地面坐标代入共线方程式，逐点计算像点坐标的近似值（x ）、（y ）。
（6）逐点计算误差方程式的系数和常数项，组成误差方程式。
（7）计算法方程的系数矩阵A A T 和常数项l A T ，组成法方程式。
（8）解法方程，求得外方位元素的改正数dXs ,S dY ，s dZ ，d φ,d ω,d κ。
（9）用前次迭代取得的近似值，加本次迭代的改正数，计算外方位元素的新值。
单像空间后方交会
摄影测量学实习报告遥感07011班吴倩200732590254一、实习目的1.掌握空间后方交会的定义和实现算法(1)定义：空间后方交会是以单幅影像为基础，从该影像所覆盖地面范围内若干控制点的已知地面坐标和相应点的像坐标量测值出发，根据共线条件方程，解求该影像在航空摄影时刻的外方位元素Xs，Ys，Zs，φ，ω，κ。
(2)算法：由于每一对像方和物方共轭点可列出2个方程，因此若有3个已知地面坐标的控制点，则可列出6个方程，解求6个外方位元素的改正数△Xs，△Ys，△Zs，△φ，△ω，△κ。
实际应用中为了提高解算精度，常有多余观测方程，通常是在影像的四个角上选取4个或均匀地选择更多的地面控制点，因而要用最小二乘平差方法进行计算。
2.了解摄影测量平差的基本过程(1)获取已知数据。
从摄影资料中查取影像比例尺1/m，平均摄影距离（航空摄影的航高）、内方位元素x0，y0，f；获取控制点的空间坐标Xt，Yt，Zt。
(2)量测控制点的像点坐标并进行必要的影像坐标系统误差改正，得到像点坐标。
(3)确定未知数的初始值。
单像空间后方交会必须给出待定参数的初始值，在竖直航空摄影且地面控制点大体对称分布的情况下，Xs0和Ys0为均值，Zs0为航高，φ、ω、κ的初值都设为0。
或者κ的初值可在航迹图上找出或根据控制点坐标通过坐标正反变换求出。
(4)计算旋转矩阵R。
利用角元素近似值计算方向余弦值，组成R阵。
(5)逐点计算像点坐标的近似值。
利用未知数的近似值按共线条件式计算控制点像点坐标的近似值（x），(y)。
(6)逐点计算误差方程式的系数和常数项，组成误差方程式。
(7)计算法方程的系数矩阵ATA与常数项ATL，组成法方程式。
(8)解求外方位元素。
根据法方程，解求外方位元素改正数，并与相应的近似值求和，得到外方位元素新的近似值。
(9)检查计算是否收敛。
将所求得的外方位元素的改正数与规定的限差比较，通常对φ，ω，κ的改正数△φ，△ω，△κ给予限差，通常为0.1′，当3个改正数均小于0.1′时，迭代结束。
实习一 单张影像空间后方交会程序设计
实习一单张影像空间后方交会程序设计一、实习目的
学生通过编写程序实现单张影像空间后方交会计算，掌握非线性方程线性化的过程、相应数据读入与存储的方法以及迭代计算的特点，为该门课程的学习打下好的基础。
二、实习内容
根据实习要求及试验数据实现单张影像空间后方交会的计算，并将最后计算得到的旋转矩阵及外方位元素输出。
图１空间后方交会程序流程图
三、预备知识
1、熟悉一门编程语言；
2、分析已有数据的特点；
3、弄清矩阵的存储与操作方法；
4、矩阵的运算模块（函数）可直接在相关资料上查找并直接使用。
四、实习步骤
已有的控制点像点坐标及物方坐标可通过输入界面进行输入，已可定义成文本文件由程序读取文本文件；定义变量和数组来存储数据；最终计算结果的输出（可输出为文本文件）。
实习结束后提交每人提交一份实习报告。
五、思考题
1、矩阵在计算机中是怎样存储的？怎样实现对矩阵中每个元素的操作（读取与存储）？
2、单张影像空间后方交会计算时在什么条件下迭代结束？
六、实验数据
已知航摄仪的内方位元素：f=153.24mm，x0=y0=0.0mm，摄影比例尺为1:50000；4个地面控制点的地面坐标及其对应像点的像片坐标如下表。
单向空间后方交会matlab编程
%读取包含点号的像点坐标、控制点坐标分别到矩阵IP、CP%IP=load(,f:1)；CP=load(,f:,)；%删除像点坐标、控制点坐标矩阵中的点号列％IP(:,1 冃];cp(：,i)=n；%像片大小％H 二4008;W=5344;IP1=IP(:J卜W/2;¥IP2=H/2.|P(:,2);IP=[IP1JP2];%焦距％fx=；%内方位元素％x0=;yo=；%畸变参数％kl=;k2=;pl=；p2=;%外方位元素初值％Xs=3000;Ys=-100;Zs=100;Phi=0;Omega=0;Kappa=0;Im=size(IF>l);2);AIP=zeros(m/L=zeros(2*m,l)；A=zeros(2*m,6);X=ones(6l);zl)>=l ^(64)>=while X(4,l)>=| |X(5f%旋转矩阵的系数％al=cos(Phi)*cos(Kappa)-sin(Phi)*sin(Omega)*sin(Kappa); a2=-cos(Phi)*sin(Kappa)-sin(Phi)*sin(Omega)*cos(Kappa); a3=-sin(Phi)*cos(Omega);bl=cos(Omega)*sin(Kappa);b2=cos(Omega)*cos(Kappa);b3=・sin(Omega);cl=sin(Phi)*cos(Kappa)+cos(Phi)*sin(Omega)*sin(Kappa); c2=-sin(Phi)*sin(Kappa)+cos(Phi)*sin(0mega)*cos(Kappa); c3=cos(Phi)*cos(Omega);for i=l:m%求像点坐标常数项％r=sqrt((IP(iz l)-xO)A2+(IP(i/2)-yO)A2);Dx=(IP(i/l)-xO)*(kl*(r A2)+k2*(r A4))+pl*(r A2+2*((IP(i/l)-xO)A2))+2*p2*(IP(i/l)-xO)*(IP(i/2)-yO);Dy=(IP(i/2)-yO)*(kl*(r A2)+k2*(r A4))+p2*(r A2+2*((IP(i/2)-yO)A2))+2*pl*(IP(i/l)-xO)*(IP(i/2)-yO);X-=al*(CP(i/l)-Xs)+bl*(CP(i/2)-Ys)+cl*(CP(i/3)-Zs);Y-=a2*(CP(i/l)-Xs)+b2*(CP(i/2)-Ys)+c2*(CP(i/3)-Zs);Z-=a3*(CP(i/l)-Xs)+b3*(CP(i/2)-Ys)+c3*(CP(i/3)-Zs);%求像点坐标的近似值％AIP(izl)=-fx*X JZ_+Dx+xO;AIP(i,2)=-fy*YVZ_+Dy+yO;%求误差方程式系数％all=(al*fx+a3#IP(i/l))/Z_;al2=(bl*fx+b3*IP(i/l))/Z」(al3=(cl*fx+c3*IP(i/l))/Z_;al4=sin(Omega)*IP(i/2)-(IP(i/l)*(IP(i/l)*cos(Kappa)-IP(i/2)*sin(Kappa))/fx+fx*cos(Kappa))*cos(Om ega)；al5=-fx*sin(Kappa)-IP(i/l)*(IP(i/l)*sin(Kappa)+IP(i/2)*cos(Kappa))/fx;al6=IP(i，2);a21=(a2*fy+a3*IP(i/2))/ZJa22=(b2*fy+b3*IP(iz2))/Zja23=(c2*fy+c3*IP(iz2))/Za24=-sin(Omega)*IP(i/l)-(IP(i/2)*(IP(i/l)*cos(Kappa)-IP(i/2)*sin(Kappa))/fy-fy*sin(Kappa))*cos{Om ega);a25=-fy*cos(Kappa)-IP(i/2)*(IP(i/l)*sin(Kappa)+IP(i/2)*cos(Kappa))/fy;a26=-IP(U); %求常数项％L(2*i-l/l)=IP(i,l)-AIP(i/l)；L(2*i,l)=IP(i/2)-AIP(i,2); %求误差方程式系数阵％A(2*i-l,l)=all;A(2*i-l,2)=al2;A(2*i-13)=al3;A(2*i-l,4)=al4;A(2*i-l,5)=al5;A(2*i-l,6)=al6; AA(2*i4)=a21;A(2*iz2)=a22;A(2*b3)=a23;A(2*i,4)=a24;A(2*b5)=a25;A(2*i,6)=a26;end%求改正数％X=pinv(A,*A)*A,*L;%求真值％Xs=Xs+X(l,l)；Ys=Ys+X(2,l);Zs=Zs+X(3,l);Phi 二Phi+X(4J);Omega=Omega +X(5,1);Kappa=Kappa +X(6,1)；end%求误差矩阵％V=A*X-L;%精度评泄％>mO=abs(sqrt(V,*V/(2*m-6))); Q二inv(A 忖A);mi=mO*sqrt(Q);%{fpri ntf('%.6f\n\A);%%fprintf(,\n,)；%fprintf('%.6f\n%.6f\n%.6f\n%.6f\ n%.6f\n%.6f\n,/Xs/Ys/Zs/Phi,Omega/Kappa);fprintfCXn1)；%fprintf(,%.6f\n\L);% %fprintf(,\n,);%%fprintf(,%.6f\n\V);% %fprintf('\n1);%fprintf('%・6f\n：mi);。
空间后方交会C++程序代码
摄影测量后方交会程序（c/c++）输入数据截图：结果截图：程序源代码（其中的矩阵求逆在前面已经有了，链接）：#include <stdio.h>#include <stdlib.h>#include <math.h>const double PRECISION=1e-5;typedef double DOUBLE[5];int InputData(int &Num, DOUBLE *&Data,double &m,double &f);int Resection(const int &Num,const DOUBLE *&Data,const double &m,const double &f);int InverseMatrix(double *matrix,const int &row);int main(int argc, char* argv[]){DOUBLE *Data=NULL;int Num;double f(0),m(0);if(InputData(Num,Data,m,f)){if (Data!=NULL){delete []Data;}return 1;}if(Resection(Num,Data,m,f)){if (Data!=NULL){delete []Data;}return 1;}if (Data!=NULL){delete []Data;}printf("解算完毕...\n");do{printf("计算结果保存于\"结果.txt\"文件中\n""请选择操作（输入P打开结果数据，R打开原始数据，其它退出程序）：");fflush(stdin); //刷新输入流char order=getchar();if ('P'==order || 'p'==order){system("结果.txt");}else if ('R'==order || 'r'==order){system("data.txt");}elsebreak;system("cls");}while(1);system("PAUSE");return 0;}/***********************************************函数名：InputData*函数介绍：从文件（data.txt）中读取数据,*文件格式如下：*点数 m(未知写作0)* 内方位元素(f x0 y0)*编号 x y X Y Z*下面是一个实例：4 0153.24 0 01 -86.15 -68.99 36589.41 25273.32 2195.172 -53.40 82.21 37631.08 31324.51 728.693 -14.78 -76.63 39100.97 24934.98 2386.504 10.46 64.43 40426.54 30319.81 757.31*参数：(in/out)Num(点数)，*(in/out)Data(存放数据),m,f,x0,y0*返回值：int ，0成功，1文件打开失败，2控制点个*数不足，3文件格式错误*作者：vcrs*完成时间：09-10-4**********************************************/int InputData(int &Num, DOUBLE *&Data,double &m,double &f) {double x0,y0;FILE *fp_input;if (!(fp_input=fopen("data.txt","r"))){return 1;}fscanf(fp_input,"%d%lf",&Num,&m);if (Num<4){return 2;}fscanf(fp_input,"%lf%lf%lf",&f,&x0,&y0);f/=1000;if (m<0 || f<0){return 3;}Data=new DOUBLE[Num];double *temp= new double[Num-1];double scale=0;int i;for (i=0;i<Num;i++){//读取数据，忽略编号if(fscanf(fp_input,"%*d%lf%lf%lf%lf%lf",&Data[i][0],&Data[i][1],&Data[i][2],&Data[i][3],&Data[i][4])!=5){return 3;}//单位换算成mData[i][0]/=1000.0;Data[i][1]/=1000.0;}//如果m未知则归算其值if (0==m){for (i=0;i<Num-1;i++){temp[i]=(Data[i][2]-Data[i+1][2])/(Data[i][0]-Data[i+1][0])+ (Data[i][3]-Data[i+1][3])/(Data[i][1]-Data[i+1][1]);scale+=temp[i]/2.0;}m=scale/(Num-1);}fclose(fp_input);delete []temp;return 0;}/***********************************************函数名：MatrixMul*函数介绍：求两个矩阵的积,*参数：Jz1(第一个矩阵),row(第一个矩阵行数),*Jz2(第二个矩阵),row(第二个矩阵列数),com(第一个*矩阵列数),(out)JgJz(存放结果矩阵)*返回值：void*作者：vcrs*完成时间：09-10-4**********************************************/void MatrixMul(double *Jz1,const int &row,double *Jz2,const int &line,const int &com,double *JgJz){for (int i=0;i<row;i++){for (int j=0;j<line;j++){double temp=0;for (int k=0;k<com;k++){temp+=*(Jz1+i*com+k)*(*(Jz2+k*line+j));}*(JgJz+i*line+j)=temp;}}}/***********************************************函数名：OutPut*函数介绍：向结果.txt文件输出数据*参数：Q协因数阵，m精度，m0单位权中误差，6个外*方位元素，旋转矩阵*返回值：int，0成功，1失败*作者：vcrs*完成时间：09-10-4**********************************************/int OutPut(const double *&Q,const double *&m,const double &m0, const double &Xs,const double &Ys,const double &Zs,const double &Phi,const double &Omega,const double &Kappa,const double *R){FILE *fp_out;if (!(fp_out=fopen("结果.txt","w"))){return 1;}FILE *fp_input;if (!(fp_input=fopen("data.txt","r"))){return 1;}fprintf(fp_out,"**************************************""**************************************""**************************************""*********************************\n");fprintf(fp_out,"\n空间后方交会程序(C\\C++)\n遥感信息工程学院\n班级：""00000\n学号：0000000\n姓名：vcrs\n\n");fprintf(fp_out,"**************************************""**************************************""**************************************""*********************************\n");fprintf(fp_out,"已知数据：\n\n已知点数：");int num;double temp,x,y;fscanf(fp_input,"%d%lf",&num,&temp);fprintf(fp_out,"%d\n",num);fprintf(fp_out,"摄影比例尺（0表示其值位置）：");fprintf(fp_out,"%10.0lf\n",temp);fprintf(fp_out,"内方位元素(f x0 y0)：");fscanf(fp_input,"%lf%lf%lf",&temp,&x,&y);fprintf(fp_out,"%10lf\t%10lf\t%10lf\n",temp,x,y);for (int i=0;i<num;i++){double temp[5];fscanf(fp_input,"%*d%lf%lf%lf%lf%lf",&temp[0],&temp[1],&temp[2],&temp[3],&temp[4]);fprintf(fp_out,"%3d\t%10lf\t%10lf\t%10lf\t%10lf\t%10lf\n", i+1,temp[0],temp[1],temp[2],temp[3],temp[4]);}fclose(fp_input);fprintf(fp_out,"**************************************""**************************************""*********************************\n");fprintf(fp_out,"计算结果如下：\n\n外方位元素：\n"); fprintf(fp_out,"\tXs=%10lf\n",Xs);fprintf(fp_out,"\tYs=%10lf\n",Ys);fprintf(fp_out,"\tZs=%10lf\n",Zs);fprintf(fp_out,"\tPhi=%10lf\n",Phi);fprintf(fp_out,"\tOmega=%10lf\n",Omega);fprintf(fp_out,"\tKappa=%10lf\n\n",Kappa);fprintf(fp_out,"旋转矩阵：\n");for (i=0;i<3;i++){fprintf(fp_out,"\t");for (int j=0;j<3;j++){fprintf(fp_out,"%10lf\t",*(R+i*3+j));}fprintf(fp_out,"\n");}fprintf(fp_out,"\n单位权中误差：%10lf\n\n",m0);fprintf(fp_out,"协因数阵：\n");for (i=0;i<6;i++){fprintf(fp_out,"\t");for (int j=0;j<6;j++){fprintf(fp_out,"%20lf\t",*(Q+i*6+j));}fprintf(fp_out,"\n");}fprintf(fp_out,"\n外方位元素精度：");for (i=0;i<6;i++){fprintf(fp_out,"%10lf\t",m[i]);}fprintf(fp_out,"\n");fprintf(fp_out,"**************************************""**************************************""*********************************\n");fclose(fp_out);return 0;}/***********************************************函数名：Resection*函数介绍：计算*参数：Num(点数)，Data(数据)，m,,f(焦距),x0,y0*返回值：int，0成功，其它失败*作者：vcrs*完成时间：09-10-4**********************************************/int Resection(const int &Num,const DOUBLE *&Data,const double &m, const double &f){double Xs=0,Ys=0,Zs=0;int i,j;//设置初始值for (i=0;i<Num;i++){Xs+=Data[i][2];Ys+=Data[i][3];}Xs/=Num;Ys/=Num;Zs=m*f;double Phi(0),Omega(0),Kappa(0);double R[3][3]={0.0};double *L=new double[2*Num];typedef double Double6[6];Double6 *A=new Double6[2*Num];double *AT=new double[2*Num*6];double *ATA=new double[6*6];double *ATL=new double[6];double *Xg=new double[6];//迭代计算do{//旋转矩阵R[0][0]=cos(Phi)*cos(Kappa)-sin(Phi)*sin(Omega)*sin(Kappa);R[0][1]=-cos(Phi)*sin(Kappa)-sin(Phi)*sin(Omega)*cos(Kappa);R[0][2]=-sin(Phi)*cos(Omega);R[1][0]=cos(Omega)*sin(Kappa);R[1][1]=cos(Omega)*cos(Kappa);R[1][2]=-sin(Omega);R[2][0]=sin(Phi)*cos(Kappa)+cos(Phi)*sin(Omega)*sin(Kappa);R[2][1]=-sin(Phi)*sin(Kappa)+cos(Phi)*sin(Omega)*cos(Kappa);R[2][2]=cos(Phi)*cos(Omega);for (i=0;i<Num;i++){double X=R[0][0]*(Data[i][2]-Xs)+R[1][0]*(Data[i][3]-Ys)+ R[2][0]*(Data[i][4]-Zs);double Y=R[0][1]*(Data[i][2]-Xs)+R[1][1]*(Data[i][3]-Ys)+ R[2][1]*(Data[i][4]-Zs);double Z=R[0][2]*(Data[i][2]-Xs)+R[1][2]*(Data[i][3]-Ys)+ R[2][2]*(Data[i][4]-Zs);double xxx,yyy;xxx=-f*X/Z;yyy=-f*Y/Z;//常数项L[2*i]=Data[i][0]-(-f*X/Z);L[2*i+1]=Data[i][1]-(-f*Y/Z);A[2*i][0]=(R[0][0]*f+R[0][2]*(xxx))/Z;A[2*i][1]=(R[1][0]*f+R[1][2]*(xxx))/Z;A[2*i][2]=(R[2][0]*f+R[2][2]*(xxx))/Z;A[2*i][3]=(yyy)*sin(Omega)-(((xxx)/f)*((xxx)*cos(Kappa)-(yyy)*sin(Kappa))+f*cos(Kappa))*cos(Omega);A[2*i][4]=-f*sin(Kappa)-((xxx)/f)*((xxx)*sin(Kappa)+(yyy)*cos(Kappa));A[2*i][5]=(yyy);A[2*i+1][0]=(R[0][1]*f+R[0][2]*(yyy))/Z;A[2*i+1][1]=(R[1][1]*f+R[1][2]*(yyy))/Z;A[2*i+1][2]=(R[2][1]*f+R[2][2]*(yyy))/Z;A[2*i+1][3]=-(xxx)*sin(Omega)-(((yyy)/f)*((xxx)*cos(Kappa)-(yyy)*sin(Kappa))-f*sin(Kappa))*cos(Omega);A[2*i+1][4]=-f*cos(Kappa)-((yyy)/f)*((xxx)*sin(Kappa)+(yyy)*cos(Kappa));A[2*i+1][5]=-(xxx);}//求矩阵A的转置矩阵ATfor (i=0;i<2*Num;i++){for (j=0;j<6;j++){*(AT+j*2*Num+i)=A[i][j];}}//求ATAMatrixMul(AT,6,&A[0][0],6,2*Num,ATA);if(InverseMatrix(ATA,6))return 1;MatrixMul(AT,6,L,1,2*Num,ATL);MatrixMul(ATA,6,ATL,1,6,Xg);Xs+=Xg[0];Ys+=Xg[1];Zs+=Xg[2];Phi+=Xg[3];Omega+=Xg[4];Kappa+=Xg[5];} while(fabs(Xg[0])>=PRECISION ||fabs(Xg[1])>=PRECISION || fabs(Xg[2])>=PRECISION ||fabs(Xg[3])>=PRECISION ||fabs(Xg[4])>=PRECISION || (Xg[5])>=PRECISION);//注：协因数阵，旋转矩阵等计算本应该使用最后外方位元素值，//由于变换很小忽略double *Q=ATA;double *V=new double[2*Num];MatrixMul(&A[0][0],2*Num,Xg,1,6,V);double VTV=0;for(i=0;i<2*Num;i++){V[i]-=L[i];VTV+=V[i]*V[i];}double m0=sqrt(VTV/(2*Num-6));double *mm=new double[6];for (i=0;i<6;i++){mm[i]=sqrt(*(Q+i*6+i))*m0;}OutPut(Q,mm,m0,Xs,Ys,Zs,Phi,Omega,Kappa,&R[0][0]);delete []L;delete []A;delete []AT;delete []ATA;delete []ATL;delete []Xg;delete []mm;delete []V;return 0;}void swap(double &a,double &b){double temp=a;a=b;b=temp;}/***********************************************函数名：InverseMatrix*函数介绍：求矩阵的逆（高斯-约当法）*输入参数：(in/out)matrix（矩阵首地址），*（in）row（矩阵阶数）*输出参数：matrix（原矩阵的逆矩阵）*返回值：int ，0成功，1失败*调用函数：swap(double&,double&)*作者：vcrs*完成时间：09-10-4**********************************************/int InverseMatrix(double *matrix,const int &row) {double *m=new double[row*row];double *ptemp,*pt=m;int i,j;ptemp=matrix;for (i=0;i<row;i++)for (j=0;j<row;j++){*pt=*ptemp;ptemp++;pt++;}}int k;int *is=new int[row],*js=new int[row];for (k=0;k<row;k++){double max=0;//全选主元//寻找最大元素for (i=k;i<row;i++){for (j=k;j<row;j++){if (fabs(*(m+i*row+j))>max){max=*(m+i*row+j);is[k]=i;js[k]=j;}}}if (0 == max){return 1;}//行交换if (is[k]!=k){for (i=0;i<row;i++){swap(*(m+k*row+i),*(m+is[k]*row+i));}}//列交换if (js[k]!=k){for (i=0;i<row;i++){swap(*(m+i*row+k),*(m+i*row+js[k]));}}*(m+k*row+k)=1/(*(m+k*row+k));for (j=0;j<row;j++){if (j!=k){*(m+k*row+j)*=*((m+k*row+k));}}for (i=0;i<row;i++){if (i!=k){for (j=0;j<row;j++){if(j!=k){*(m+i*row+j)-=*(m+i*row+k)**(m+k*row+j);}}}}for (i=0;i<row;i++){if(i!=k){*(m+i*row+k)*=-(*(m+k*row+k));}}}int r;//恢复行列for (r=row-1;r>=0;r--){if (js[r]!=r){for (j=0;j<row;j++){swap(*(m+r*row+j),*(m+js[r]*row+j));}}if (is[r]!=r){for (i=0;i<row;i++){swap(*(m+i*row+r),*(m+i*row+is[r]));}}}ptemp=matrix;pt=m;for (i=0;i<row;i++){for (j=0;j<row;j++){*ptemp=*pt;ptemp++;pt++;}}delete []is;delete []js;delete []m;return 0;}。
摄影测量实习报告-单片空间后方交会8页word文档
摄影测量实习报告实习内容:单片空间后方交会编程实习者:李友兵学号:0810050121指导老师:张金平老师实习时间:2019.05.30——2019.06.03一、实习目的与任务此次摄影测量实习主要是要自主编程实现单像空间后方交会，通过已知的内方位元素和控制点像点坐标和地面坐标求解六个外方位元素，在此过程中深入理解单像空间后方交会的原理和对编程的熟悉和理解（我用的是C语言编程），和对时间的合理运用，对知识的综合运用，培养理论的实际运用能力，任务是在一个星期内自主完成。
二、单片空间后方交会理论基础单像空间后方交会：是通过以像点平面坐标为观测值，以控制点坐标为已知值，利用共线条件方程和最小二乘原理，运用间接平差方法，通过迭代求解6个外方位元素。
程序设计的思路与流程三、程序设计的思路与流程（编程框架和步骤）1、根据内方位元素和已知的数据将控制点的框标坐标转换为像平面坐标系坐标：x=x′-x0，y=y′-y02、确定未知数的初始值：角元素初始值κ0=ω0=Φ0=0；线元素初始值Zs0=H=mf，Xs0=(X1+X2+X3+X4)/4,Ys0=（Y1+Y2+Y3+Y4）/43、利用角元素初始值计算方向余弦值组成旋转矩阵Ra1=cosΦ*cosκ-sinΦ*sinω*sinκ,a2=-cosΦ*sinκ-sinΦ*sin ω*cosκ，a3=-sinΦ*cosωb1=cosω*sinκ,b2=cosω*cosκ,b3=-sinωc1=sinΦ*cosκ+cosΦ*sinω*sinκ,c2=-sinΦ*sinκ+cosΦ*sin ω*cosκ,c3=cosΦ*cosω4、逐点计算控制点的像点坐标的近似值，共线方程为:x=(-f*(a1*(X-Xs)+b1*(Y-Ys)+c1*(Z-Zs)))/(a3*(X-Xs)+b3*(Y-Ys) +c3*(Z-Zs))y=(-f*(a2*(X-Xs)+b2*(Y-Ys)+c2*(Z-Zs)))/(a3*(X-Xs)+b3*(Y-Ys) +c3*(Z-Zs))(x)=(-f*(a1*(X-Xs)+b1*(Y-Ys)+c1*(Z-Zs)))/(a3*(X-Xs)+b3*(Y-Y s)+c3*(Z-Zs))(y)=(-f*(a2*(X-Xs)+b2*(Y-Ys)+c2*(Z-Zs)))/(a3*(X-Xs)+b3*(Y-Y s)+c3*(Z-Zs))5、组成误差方程：Vx=a11*dXs+a12*dYs+a13*dZs+a14*dΦ+a15*dω+a16*dκ+(x)-xVy=a21*dXs+a22*dYs+a23*dZs+a24*dΦ+a25*dω+a26*dκ+(y)-y系数求解(是共线方程分别外方位元素求导，是共线方程线性化的系数)：变量代换A= a1*(X-Xs)+b1*(Y-Ys)+c1*(Z-Zs)B= a2*(X-Xs)+b2*(Y-Ys)+c2*(Z-Zs)C= a3*(X-Xs)+b3*(Y-Ys)+c3*(Z-Zs)a11=(a1*f+a3*x)/C,a12=(b1*f+b3*x)/C,a13=(c1*f+c3*f)/C,a14=y *sinω-((x*(x*cosκ-y*sinκ))/f+f*cosκ)cosω,a15=-f*sin κ-(x*(x*sinκ+y*cosκ)/f),a16=ya21=(a2*f+a3*x)/C,a22=(b2*f+b3*x)/C,a23=（c2*f+c3*x）/C,a24=-xsinω-((x*(x*cosκ-y*sinκ))/f-f*sinκ)cosω,a25=-f*cosκ-(y*(x*sinκ+y*cosκ)/f),a26 =-x 误差方程的常系数（是像点坐标观测值与计算的近似值的差值）：lx=x-(x) ,ly=y-(y)6、组成法方程，解求外方位元素改正数X=(A T A)-1A T L(A为误差方程的系数矩阵，L为误差方程的常系数矩阵，通过步骤5求得，此处先求A T A再求矩阵的逆矩阵，解得的改正数加上相应的近似值得到外方位元素新的近似值)7、检查计算是否收敛：将求得的外方位元素改正数与规定的限差比较，大于限差继续迭代，小于限差则终止。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一：编写单片空间后方交会程序
1. 目的
用程序设计语言（Visual C++或者VB 语言）编写一个完整的单片空间后方交会程序(尽量编写为一系列函数或子程序，便于程序重用和程序调用)，通过对提供的试验数据进行计算，输出像片的外方位元素并评定精度。
本实验的目的在于让学生深入理解单片空间后方交会的原理，体会在有多余观测情况下，用最小二乘平差方法编程实现解求影像外方位元素的过程。
通过上机调试程序加强动手能力的培养，通过对实验结果的分析，增强学生综合运用所学知识解决实际问题的能力。
2. 内容
利用一定数量的地面控制点，根据共线条件方程求解像片外方位元素。
3. 数据准备
已知航摄仪的内方位元素：f k
=152.72mm ，x 0=y 0=0.0mm ，摄影比例尺为1:15000；
6个地面控制点的地面坐标及其对应像点的像片坐标：
4. 操作步骤
编程并上机调试程序。
5. 实验报告
给出程序逻辑关系图，主程序、函数或子程序定义，及其调用关系，并打印外方位元素计算及其精度评定结果。
)
()()()()()()()()()
()()(333222333111s s s s s s s s s s s s Z Z c Y Y b X X a Z Z c Y Y b X X a f
y Z Z c Y Y b X X a Z Z c Y Y b X X a f x -+-+--+-+--=-+-+--+-+--=。