测绘程序设计

1.1测绘程序设计的意义

①计算机在现代测绘科学中的广泛应用带来极大便利

方便、快速、准确，可重复性

②测绘软件不通用

测绘相关软件丰富数据计算、制图、遥感影像处理、数字摄影测量、地理信息系统(GIS)、

GPS平差计算等软件。

实际工作遇到的问题千差万别，特定应用需要掌握一门编程语言，设计相应的程序解决

实际问题。

③编写相关专业程序，深化测量知识的过程

2.1类型

C#数据类型分为值类型与引用类型；

①CTS(CommonTypeSystem)公共类型系统

②值类型与引用类型

从概念上看，值类型直接存储其值，而引用类型存储对值的引用;从在内存中的存储位置上

看，值类型变量把数据存储在管中，引用类型变量把数据存储在推中。

③预定义类型

值类型13个：ShortInt类型；Floatdouble类型;char•类型等等

引用类型2个:object类型;string类型

通过加前缀@,使编译器严格按照原样对其编译。

strings=@"hello\nworld";结果输出hello\nworld

2.2变量与常量

变・与内存

每次声明变量时，计算机都会给它分配一块足够大的内存空间，来保存该类型的变量。

相同类型的不同变量总是占据相同大小的内存。

但不同类型的变量需要分配的内存空间就不一样了。这就需要划分类型。

使用变量

使用变量就是声明他们。即给变量指定名称和类型。修饰符-数据类型-标识符publicinti;

标识符

变量名首字符必须是字母、下划线(1')或“@”；

其后字符必须是字母、下划线或数字；

切忌使用C#关键字。如果需要使用，须在标识符前边加上“@”(如©abstract)。

命名变量的一些约定：

给变量分配有意义的名称；

命名类和方法时使用PascalCase样式，命名变量使用camelCase样式；

不要通过大小写的不同来区分变量。

初始化变量

注意初始值要与声明的类型相一致decimalbankBalance=34.50;//错误

可以通过附加后缀来指定数值类型decimalbankBalance=34.50M;//正确

可以使用的后缀：U无符号L长整型UL无符号长整型F浮点型D双精度型M十进制

常量

声明常量时必须对其赋值constfloatpi=3.14f

2.3类型转换

显式转换方式：

Convert.Tolnt32xint.Parse,int.TryParse,(int)四者都可以解释为将类型转换为int,那

它们的区别是什么呢？

Convert.Tolnt32与int.Parse较为类似，实际上Convert.Tolnt32内部调用了int.Parse:

Convert.Tolnt32参数为null时，返回0;

int.Parse参数为null时，抛出异常。

Convert.Tolnt32参数为""时，抛出异常；

Int.Parse参数为""时,抛出异常。

Convert.Tolnt32可以转换的类型较多；

int.Parse只能转换数字类型的字符串。

3.1方位角算法

方位角计算

{

Console.WriteLine("PleaseEnterXI

doubleXI=Convert.ToDouble(Console.ReadLine());

Console.WriteLine("PleaseEnterY1

doubleY1=Convert.ToDouble(Consolc.ReadLine());

Console.WriteLine(uPleaseEnterX2:");

doubleX2=Convert.ToDouble(Console.ReadLine());

Console.WrileLine("PleaseEnterY2:u);

doubleY2=Convcrt.ToDouble(Console.ReadLine());

doubledetX=X2-X1;

doubledexY=Y2-Yl;

doublefwj;

if(Math.Abs(detX)<0.0000001)

(

if(dexY>0)

fwj=90;

else

fwj=270;

)

else

fwj=dexY/detX;

fwj=Malh.Atan(fwj);

fwj=fwj*180/Math.PI;

if(detX<0)

fwj=fwj+180;

elseif(dexY<0)〃若detY>0,fwj没做处理，fwj二fwj

fwj=fwj+360;

)

Console.WrileLine(Hfwjoftwopointis\n{0}",fwj);

Consolc.ReadKeyO;

}

3.2字符串的处理

GetLength获得指定维度的长度IndexOf返回指定值第一次出现的索引值

Lengh获取元素个数

<string>.Trim()可以使用这个命令删除其他字符只要在一个char数组中指定这些字符即可;

<string>.PadLeft()<string>.PadRight()他们可以在字符串左边或者右边添加空格，使字符串

达到指定长度。

myString="Aligned";myString=myString.PadLeft(10);〃补3个空格

4.1函数构成

C#中函数的参数有4种类型：

值参数，不含任何修饰符;引用型参数，以ref修饰符声明。

输出参数，以out修饰符声明;数组型参数，以params修饰符声明

Ref关键字

classProgram

(

staticvoidMain(stringOargs)

inta=3;

intb=5;

change(refa,refb);

Console.WriteLine(na={0},b={1}",a,b);

}

staticvoidchange(refinta1,refintb1)

(

intt;t=a1;a1=b1;b1=t;

)

)

Out关键字

staticvoidMain(string[]args)

{

Console.WriteLine(nout参数输出*');

inta,b;

UseOut(outa,outb);

H

Console.WriteLine("调用UseOut函数后返回主程序：a={0}5b={1},a,b);

Console.ReadLine();

}

privatestaticvoidUseOut(outintx,outinty)

{

inttemp;

x=20;

y=30;

Console.WriteLine("\n函数内交换前x={0},y={1}'\x,y);

temp=x;x=y;

y=temp;

Console.WriteLine("\n函数内交换后x={0},y={1}'\x,y);

)

Param关键字

classProgram

(

staticintMax(paramsin"Age)

(

inttemp=0;

for(inti=0;i<Age.Length;i++)

{

if(temp<Age[i])

temp=Age[i];

)

returntemp;

)

staticvoidMain(string[]args)

(

intmaxAge=Max(18,23,19,22,27);

Console.WriteLine(nthemaxofageis:{0}",maxAge);

)

)

4.2常用的测量函数设计

坐标正算

classProgram

(

staticvoidMain(string[]args)

(

doubleXa=2.5;doubleYa=2.5;doubleS=12.34;

doubleA=1.2;doubleXi=0;doubleYi=0;

CalCoord(Xa,Ya,S,A,refXi,refYi);

Console.WriteLine("坐标x={0}y={1}H,Xi,Yi);

Console.ReadKey();

)

staticprivatevoidCalCoord(doubleXa,doubleYa,doubleS,double

A,refdoubleXi,refdoubleYi)

(

Xi=Xa+S*Math.Cos(A);

Yi=Ya+S*Math.Cos(A);

)

)

Ref也可以改为out关键字，结果相同，若不加ref/out结果错误，或用定义一个结构体

classProgram

structpPoint

(

publicdoubleX;

publicdoubleY;

)

staticvoidMain(string[]args)

(

doubleXa=2.5;doubleYa=2.5;doubleS=12.34;doubleA=1.2;

pPointp=CalCoord(Xa,Ya,S,A);

Console.WriteLine("坐标x={0}y={1}n,p.X,p.Y);

Console.ReadKey();

)

staticprivatepPointCalCoord(doubleXa,doubleYa,doubleS,doubleA)

(

pPointp;

p.X=Xa+S*Math.Cos(A);

p.Y=Ya+S*Math.Cos(A);

returnp;

)

方位角推算

classProgram

staticvoidMain(stringOargs)

(

inti=0;

do

{

Console.WriteLine("输入方位角:

stringstr=Console.ReadLine();

Console.WriteLine("输入转折角：”)；

doublezzj=Convert.ToDouble(Console.ReadLine());

doubleA=Azm(DmsToRad(str),DmsToRad(zzj.ToString()));

Console.WriteLine(RadToDms(A));

Console.WriteLine(”0继续，1退出”)；

i=Convert.Tolnt32(Console.ReadLine());

Console.ReadKey();

}

while(i==0);

)

staticdoubleAzm(doublea,doublejiao)

returnTo2Pi(a+jiao+Math.PI);

)

staticdoubleTo2Pi(doubleradAngle)

(

radAngle=radAngle-Math.Truncate(radAngle/(Math.PI*2))*Math.PI

if(radAngle<0)

radAngle+=Math.PI*2;

returnradAngle;

)

staticdoubleDmsToRad(stringdms)

(

inti=dms.lndexOf(".,,);

if(i>0)

(

doubledu=Convert.ToDouble(dms.Substring^,i));

doublefen=Convert.ToDouble(dms.Substring(i+1,2));

doublemiao=Convert.ToDouble(dms.Substring(i+3,2));

du=du+fen/60+miao/3600;

returnTransR(du);

}

else

returnTransR(Convert.ToDouble(dms));

)

publicstaticdoubleTransR(doubledu)

(

returndu*Math.PI/180;

)

staticdoubleRadToDms(doubleradA)

(

radA=TransD(radA);

doubledu=Math.Truncate(radA);

doublefen=Math.Truncate((radA-du)*60);

doublemiao=(radA-du-fen/60.0)*3600;

returndu+fen/100+miao/10000;

)

staticdoubleTransD(doublehu)

(

returnhu*180/Math.PI;

)

4.3投影换带(不考，有兴趣自己看看)

4.4异常处理

代码中的错误主要分为两种，一种是语法错误，另一种是逻辑错误。

5.1C#文件系统数据

读取文件

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

usingSystem.IO;

namespaceConsoleApplicationl

{

classProgram

(

staticvoidMain(stringQargs)

(

FileStreamfs=newFileStream(@”f:\测绘程序设计.txt”，FileMode.Open);

StreamReadersr=newStreamReader(fs);

stringMyString=sr.ReadLine();

Console.WriteLine(MyString);

MyString=sr.ReadLine();

Console.WriteLine(MyString);

sr.Close();

Console.ReadKey();

)

)

}

写入文件

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

usingSystem.IO;

namespaceConsoleApplicationl

{

classProgram

(

staticvoidMain(string[]args)

(

FileStreamfs=newFileStream(@"f:\测绘程序设计.txt”,

FileMode.OpenOrCreate);

StreamWritersw=newStreamWriter(fs);

sw.WriteLine("测绘程序设计”);

sw.Write(54);

sw.Write("学时)

sw.Close();

)

)

)

类和对象(看看就好)

构造器(构造函数)是一个特殊的方法，用于执行类的实例的初始化，创建对象，它在创建

对象时自动运行。

一个类的构造函数与类名相同

创建对象的根本途径是构造器，通过new关键字来调用某个类的构造器即可创建这个类的

实例。Rectangularobj=newRectangular();

通过对象名打点来调用对象的属性和方法就是对对象的操作。

调用属性：obj.width=20;调用方法：obj.getArea();

File类的一些常用的静态方法。

方法说明

Copy()将文件从源位置复制到目标位置

Create()在指定路径上创建文件

Delete()删除文件

Open()返回指定路径上的FileStream对象

Move()将指定文件移动到新位置

Directory类的一些常用的静态方法

方法说明

CreateDirectory()创建具有指定路径的目录

Delete()删除指定的目录及其中的所有文件

GetDirectories()返回表示指定目录下的目录名的String对象数组

GetFiles()返回在指定目录中的文件名的string对象数组

Move()将指定目录移到新位置。

〃通过File.Create。获取FileStream对象

FileStreamfs=File.Create(@"d:\123.txt");

//通过File.Open。获取FileStream对象

FileStreamfs2=File.Open(@"d:\123.txt*',FileMode.OpenOrCreate,

FileAccess.ReadWrite,FileShare.None);

〃得到一个只读权限的FileStream对象

FileStreamreadOnlyStream=File.OpenRead(@"d:\123.txt");

〃得到一个只写权限的FileStream对象

FileStreamwriteOnlyStream=File.OpenWrite(@"d:\123.txt");

〃得到一个StreamReader对象

StreamReadersreader=File.OpenText(@"d:\123.txt'*);

〃得到一个StreamWMter对象

StreamWriterswriter=File.CreateText(@"d:\123.txt");

StreamWriterswriterAppend=File.AppendText(@"d:\123.txt'*);

实习作业

在程序中输入一个文件夹路径，读取该文件夹下所有文本文档。

根据文本文档第一行的值，判断所要进行的操作。

1,大地坐标转换为高斯平面直角坐标；2-＞高斯平面坐标转换为大地坐标；3-＞高斯平面坐

标转换为高斯平面坐标

将结果存入到指定文件夹下，在文件末尾写入自己的名字和学号（要求为.txt格式）

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

usingSystem.IO;

namespaceConsoleApplicationl

{

classProgram

{

staticvoidMain（string[]args）

（

〃获取文件夹路径

string[]fs=Directory.GetFiles（@"f:\测绘程序设计"）；

Console.WriteLine（"进行哪种运算:"）;

Console.WriteLine（”1.大地坐标转换为高斯平面直角坐标2.高斯平面坐标转

换为大地坐标3.高斯平面坐标转换为高斯平面坐标）

〃读取f:\测绘程序设计下所有文档

FileStreamfs1=File.Open（@"f:\测绘程序设计\1.txt",

FileMode.OpenOrCreate）;

StreamReadersr1=newStreamReader（fs1）;

stringmystringl=sr1.ReadLine();

FileStreamfs2=File.Open(@Hf:\测绘程序设计\2.txf,

FileMode.OpenOrCreate);

StreamReadersr2=newStreamReader(fs2);

stringmystring2=sr2.ReadLine();

FileStreamfs3=File.Open(@nf:\测绘程序设计\3.txt”,

FileMode.OpenOrCreate);

StreamReadersr3=newStreamReader(fs3);

stringmystring3=sr3.ReadLine();

〃椭球参数

doublea=6378245;

doublef=298.3;

〃坐标转换

stringi=Convert.ToString(Console.ReadLine());

intt=0;

if(i==mystring1)

(

doublex;

doubley;

stringmystring4=sr1.ReadLine();

Console.WriteLine(,,{0},,,mystring4);

stringmystring5=sr1.ReadLine();

Console.WriteLine("{0}”,mystring5);

double[]s=newdouble[2];

intn=mystring5.IndexOf

s[0]=Convert.ToDouble(mystring5.Substring(0,n));

s[1]=Convert.ToDouble(mystring5.Substring(n+1));

doublej=0;

do

(

j=(s[1]-(6*t-3));

t++；

)

while(Math.Abs(j)>3);

doubleB=s[0];

doubleL=j;

prmrePrm=Ecd(a,f);

GaussZs(B,L,rePrm,outx,outy);

Console.WriteLine("平面上的坐标x:{0}y:{1}H,x,y);

〃输出姓名学号

StreamWriterrs=newStreamWriter(fs1);

rs.WriteLine("孙汝星20114776");

rs.Close();

)

elseif(i==mystring2)

{

doubleB;

doubleL;

stringmystring6=sr2.ReadLine();

Console.WriteLine("{0}”,mystring6);

stringmystring7=sr2.ReadLine();

Console.WriteLine(n{0}",mystring7);

double[]p=newdouble[5];

intnn=mystring7.IndexOf(n,n);

p[0]=Convert.ToDouble(mystring7.Substring(0,nn));

p[1]=Convert.ToDouble(mystring7.Substring(nn+1));

p[2]=p[1]/1000000;

Console.WriteLine(p[2]);

p[3]=p[1]%1000000/1000000;

Console.WriteLine(p[3]);

p[4]=p[2]-p[3];

Console.WriteLine(“带号{0}”,p[4]);

doublex=p[O];//-pp[4]*100000;

doubley=p[1]-p[4]*1000000-500000;

prmrePrem=Ecd(a,f);

GaussFs(outB,outL,rePrem,x,y);

Console.WriteLine(n平面上的坐标b:{0}RadToDms(B),

RadToDms(L)+6*p[4]-3);

StreamWriterrs1=newStreamWriter(fs2);

rs1.WriteLine(“孙汝星20114776");

rs1.Close();

)

elseif(i==mystring3)

doubleB;

doubleL;

stringmystring8=sr3.ReadLine();

Console.WriteLine("{0}”,mystring8);

stringmystring9=sr3.ReadLine();

Console.WriteLine("{0}”,mystring9);

double[]m=newdouble[5];

intnnn=mystring9.IndexOf

m[0]=Convert.ToDouble(mystring9.Substring(0,nnn));

m[1]=Convert.ToDouble(mystring9.Substring(nnn+1));

m[2]=m[1]/1000000;

m[3]=m[1]%1000000/1000000;

m[4]=m[2]-m[3];

Console.WriteLine("带号{0「m[4]);

doublex=m[0];

doubley=m[1]-m[4]*1000000-500000;

prmrePrem=Ecd(a,f);

GaussFs(outB,outL,rePrem,x,y);

Console.WriteLine("平面上的坐标b:{0}RadToDms(B),

RadToDms(L)+6*m[4]-3);

Console.WriteLinef'RadToDms(L){0}n,RadToDms(L));

Console.WriteLine("输入带号”)；

intap=int.Parse(Console.ReadLine());

doubleq;

q=ap*6-3;

doublew;

w=RadToDms(L)+6*m[4]-3-q;

Console.WriteLine("{0}带经度{1}纬度{2}“，ap,w,RadToDms(B));

doublex1;

doubley1;

doubleB1=RadToDms(B);

doubleL1=w;

prmrePrm=Ecd(a,f);

GaussZs(B1,L1,rePrm,outx1,outy1);

if(ap>20)

{

Console.WriteLinef'平面上的坐标x:{0}y:{1}H,

x1,(ap-20)*500000-y1);

)

if(ap<=20)

(

Console.WriteLine("平面上的坐标x:{0}y:{1}H,x1,

y1-(20-ap)*50000);

)

StreamWriterrs2=newStreamWriter(fs3);

rs2.WriteLine("孙汝星201147761');

rs2.Close();

}

Console.ReadKey();

)

//<summary>

///高斯涉及参数结构

Ill</summary>

publicstructprm

(

publicdoubleTa;

publicdoubleTb;

publicdoubleTc;

publicdoubleTd;

publicdoubleTe;

publicdoubleTet;

publicdoubleAO;

publicdoubleBO;

publicdoubleCO;

publicdoubleDO;

publicdoubleEO;

publicdoubleTe2;

publicdoubleTe4;

publicdoubleTe6;

publicdoubleTe8;

)

publicstaticprmEcd(doublea,doublef)

prmnewPrm=newprm();

newPrm.Ta=a;

newPrm.Tb=a-a/f;

newPrm.Tc=Math.Pow(newPrm.Ta,2)/newPrm.Tb;

newPrm.Td=Math.Pow(newPrm.Tb,2)/newPrm.Ta;

newPrm.Te=Math.Sqrt((newPrm.Ta*newPrm.Ta-newPrm.Tb*

newPrm.Tb)/(newPrm.Ta*newPrm.Ta));

newPrm.Tet=Math.Sqrt((newPrm.Ta*newPrm.Ta-newPrm.Tb*

newPrm.Tb)/(newPrm.Tb*newPrm.Tb));

newPrm.Te2=Math.Pow(newPrm.Te,2);

newPrm.Te4=Math.Pow(newPrm.Te,4);

newPrm.Te6=Math.Pow(newPrm.Te,6);

newPrm.Te8=Math.Pow(newPrm.Te,8);

newPrm.AO=1+3d/4d*newPrm.Te2+45d/64d*newPrm.Te4+175d/

256d*newPrm.Te6+11025d/16384d*newPrm.Te8;

newPrm.BO=3d/4d*newPrm.Te2+45d/64d*newPrm.Te4+175d/

256d*newPrm.Te6+11025d/16384d*newPrm.Te8;

newPrm.CO=15d/32d*newPrm.Te4+175d/384d*newPrm.Te6+

3675d/8192d*newPrm.Te8;

newPrm.DO=35d/96d*newPrm.Te6+735d/2048d*newPrm.Te8;

newPrm.EO=315d/1024d*newPrm.Te8;

returnnewPrm;

)

publicstaticvoidGaussZs(doubleb,doubleI,prmgaussPrm,outdoublex,out

doubley)

(

doubleXh=Xl(b,gaussPrm);

doubleSinB=Math.Sin(b);

doubleCosB=Math.Cos(b);

doubleCosB2=Math.Pow(CosB,2);

doubleCosB3=Math.Pow(CosB,3);

doubleCosB4=Math.Pow(CosB,4);

doubleCosB5=Math.Pow(CosB,5);

doubleg=gaussPrm.Tet*CosB;

doubleg2=Math.Pow(g,2);

doubleg4=Math.Pow(g,4);

doubleN=gaussPrm.Tc/Math.Sqrt(1d+g2);

doubleI2=Math.Pow(l,2);

doubleI4=Math,Pow(l,4);

doubleI6=Math.Pow(l,6);

doublet=Math.Tan(b);

doublet2=Math.Pow(t,2);

doublet4=Math.Pow(t,4);

x=Xh+N/2d*SinB*CosB*12+N/24d*SinB*CosB3*(5d-12+9d*

g2+4d*g4)*14+N/720d*SinB*CosB5*(61d-58d*t2+14+270d*g2-330d*g2*

t2)*I6;

y=N*CosB*1*(1+CosB2*I2*(1-12+g2)/6d+CosB4*l4*(5-18*t2

+t4+14*g2-58*t2*g2)/120d);

}

publicstaticdoubleXl(doubleb,prmgaussPrm)

(

doubleSinB=Math.Sin(b);doubleCosB=Math.Cos(b);

doubleSinB3=Math.Pow(SinB,3);

doubleSinB5=Math.Pow(SinB,5);

doubleSinB7=Math.Pow(SinB,7);

returngaussPrm.Td*(gaussPrm.AO*b-gaussPrm.BO*SinB*CosB-

gaussPrm.CO*SinB3*CosB-gaussPrm.DO*SinB5*CosB-gaussPrm.EO*SinB7*

CosB);

)

publicstaticvoidGaussFs(outdoubleb,outdoubleI,prmnewPrm,doublex,

doubley)

doublebF=Bfc(x,newPrm);

doubleSinBf=Math.Sin(bF);

doubleCosBf=Math.Cos(bF);

doublegf=newPrm.Tet*CosBf;

doublegf2=Math.Pow(gf,2);

doublegf4=Math.Pow(gf,4);

doubleNf=newPrm.Tc/Math.Sqrt(1+gf2);

doubleNf2=Math.Pow(Nf,2);

doubleNf3=Math.Pow(Nf,3);

doubleNf4=Math.Pow(Nf,4);

doubleNf5=Math.Pow(Nf,5);

doubleNf6=Math.Pow(Nf,6);

doubletf=Math.Tan(bF);

doubletf2=Math.Pow(tf,2);

doubletf4=Math.Pow(tf,4);

l=1d/(Nf*CosBf)*y-(1+2*tf2+gf2)/(6*Nf3*CosBf)*Math.Pow(y,3)

+(5+28*tf2+24*tf4+6*gf2+8*gf2*tf2)/(120*Nf5*CosBf)*Math.Pow(y,5);

b=bF-(tf*(1+gf2))/(24*Nf2)*Math.Pow(y,2)+(tf*(5+3*tf2+6*gf2

-6*tf2*gf2-3*gf4+9*gf4*tf4))/(24*Nf4)*Math.Pow(y,4)-(tf*(61+90*tf2+45

*tf4+107*gf2+162*gf2*tf2+45*gf2*tf4))/(720*Nf6)*Math.Pow(y,6);

)

publicstaticdoubleDmsToRad(stringdmsA)

(

intp=dmsA.lndexOf(',.n);

if(P>0)

(

doubleDegree=Convert,ToDouble(dmsA.Substring(0,p));

stringstr=dmsA.Substring(p+1);

doubleM=Convert.ToDouble(str,Substnng(0,2));

doubleS=Convert.ToDouble(str.Substring(2,2));

doubledu=(Degree+M/60.0+S/3600.0);

returnTransR(du);

}

else

{

returnTransR(Convert.ToDouble(dmsA));

)

)

publicstaticdoubleTransR(doubledu)

returndu*Math.PI/180.0;

}

publicstaticdoubleRadToDms(doubleradA)

(

radA=TransD(radA);

doubledu=Math.Truncate(radA);

doublefen=Math.Truncate((radA-du)*60);

doublemiao=((radA-du)*60-fen)*60;

returndu+fen/100+miao/10000;

)

staticdoubleTransD(doublehu)

(

returnhu*180/Math.PI;

)

publicstaticdoubleBfc(doublex,prmnewPrm)

(

doublebfO;

bfO=x/newPrm.A0;

inti=0;

while(i<10000)

doubleSinBf=Math.Sin(bfO);

doubleCosBf=Math.Cos(bfO);

doubleSinBf3=Math.Pow(SinBf,3);

doubleSinBf5=Math.Pow(SinBf,5);

doubleSinBf7=Math.Pow(SinBf,7);

doubleBF=(x/newPrm.Td+CosBf*(newPrm.BO*SinBf+

newPrm.CO*SinBf3+newPrm.DO*SinBf5+newPrm.EO*SinBf7))/newPrm.AO;

if(Math.Abs(BF-bfO)<0.0000000001)

returnBF;

bfO=BF;

return-1;

6.1矩阵的基本运算

矩阵加减程序设计

publicstaticboolMatrixPlus(double[,]a,double[,]b,outdouble[,]c)

intm=a.GetLength(O);

intn=a.GetLength(l);

intml=b.GetLength(O);

intn1=b.GetLength(l);

c=newdouble[m,n];

if(m==ml&&n==n1)

{

for(inti=0;i<m;i++)

(

for(intj=0;j<n;j++)

(

c[i,j]=a[i,j]+b[i,j];

)

}

returntrue;

)

else

(

returnfalse;

)

)

矩阵转置程序设计

publicstaticvoidMatrixTrans(double[,]a,outdoublef,]c)

intm=a.GetLength(O);

intn=a.GetLength(l);

c=newdouble[n,m];

for(inti=0;i<m;i++)

(

for(intj=0;j<n;j++)

{

c[j,i]=a[i,j];

)

)

)

矩阵相乘程序设计

publicstaticboolMatrixMulti(double[,]a,double[,]b,outdouble[,]c)

(

c=newdouble[m,n1];

if(n==m1)

(

for(inti=0;i<m;i++)

for(intj=0;j<n1;j++)

for(intk=0;k<n;k++)

c[ij]+=a[i,k]*b[k,j];

}

}

)

returntrue;

}

else

(

returnfalse;

)

)

高斯投影

namespace高斯投影

(

classProgram

{

publicstaticvoidMain(stringQargs)

doublea=6378245;

doublef=298.3;

Console.WMteLine("进行哪种运算:1.正算(经差)2.反算3.正算(经度)4.

换带计算)

inti=Convert.Tolnt16(Console.ReadLine());

if(i==1)

(

doublex;

doubley;

doubleB=17.33557339;

doubleL=2.15521159;

gaosi.prmrePrm=gaosi.Ecd(a,f);

gaosi.GaussZs(B,L,rePrm,outx,outy);

Console.WriteLine("平面上的坐标x:{0}y:{1}",x,y);

)

elseif(i==2)

(

doubleB;

doubleL;

doublex=1944359;

doubley=240455.4563;

gaosi.prmrePrem=gaosi.Ecd(a,f);

gaosi.GaussFs(outB,outL,rePrem,x,y);

Console.WriteLine(n平面上的坐标b:{0}l:{1}",gaosi.RadToDms

(B),gaosi.RadToDms(L));

}

elseif(i==3)

{

doubleB=17.33557339;

doubleL=119.15521159;

doublex;

doubley;

intN=Convert.Tolnt32(Math.Truncate(L+3)/6);

doubleL0=6*N-3;

gaosi.prmrePrem=gaosi.Ecd(a,f);

gaosi.GaussZs(B,L,L0,rePrem,outx,outy);

Console.WriteLine("平面上的坐标x:{0}y:{1}'\x,y);

}elseif(i==4)

(

doubleB;

doubleL;

doublex=1944359;

doubley=20740455.4563;

y=Convert.ToDouble(y.ToString().Substring(2))-500000;

gaosi.prmrePrem=gaosi.Ecd(a,f);

gaosi.GaussFs(outB,outL,rePrem,x,y);

intN=Convert.Tolnt32(y.ToString().Substring(0,2));

〃6度带

intL0=6*N-3;

doubleB1=gaosi.RadToDms(B);

doubleL1=gaosi.RadToDms(L)+L0;

Console.WriteLine("平面上的坐标b:{0}l:{1}",B1,L1);

〃3度带

//doubleL0=3*N;

//Console.WriteLine("平面上的坐标b:{0}l:{1}n,gaosi.RadToDms

(B),gaosi.RadToDms(L)+L0);

doublex1;

doubley1;

gaosi.GaussZs(B1,L1,L0+6,rePrem,outx1,outy1);

Console.WriteLine("平面上的坐标x: