中南大学测绘程序课程设计代码

(1)ClzControlPoint头文件

class ClzControlPoint

{

public:

ClzControlPoint();

~ClzControlPoint();

double X;

double Y;

CString strPointID;

int state;

int flg;

double dE;

double dF;

double dQ;

double dMx;

double dMy;

double dMk;

};

ClzControlPoint源文件

#pragma once

#include"stdafx.h"

#include"ClzControlPoint.h"

ClzControlPoint::ClzControlPoint() {

X = 0;

Y = 0;

strPointID = _T("");

flg = 0;

state = 0;

dE = 0;

dF = 0;

dQ = 0;

dMx=0;

dMy=0;

dMk=0;

}

ClzControlPoint::~ClzControlPoint() {

}

(2)ClzDistObs头文件

class ClzDistObs

{

public:

ClzDistObs();

~ClzDistObs();

public:

ClzControlPoint *cpStart, *cpEnd;

double dDist;

};

ClzDistObs源文件

#include"stdafx.h"

#include"ClzDistObs.h"

ClzDistObs::ClzDistObs()

{

dDist = 0;

cpStart = NULL;

cpEnd = NULL;

}

ClzDistObs::~ClzDistObs()

{

cpStart = NULL;

cpEnd = NULL;

}

(3)ClzAngleObs头文件

class ClzAngleObs

{

public:

ClzAngleObs();

~ClzAngleObs();

public:

ClzControlPoint *cpStation;

ClzControlPoint *cpEnd;

Angle ObsAngle;

};

ClzAngleObs源文件

#include"stdafx.h"

#include"ClzAngleObs.h"

ClzAngleObs::ClzAngleObs()

{

cpStation = NULL;

cpEnd = NULL;

ObsAngle = 0;

}

}

ClzAngleObs::~ClzAngleObs()

{

cpStation=NULL;

cpEnd=NULL;

}

(4)ClzControlNetAdjust头文件

#pragma once

#include"ClzControlPoint.h"

#include"ClzAngleObs.h"

#include"ClzDistObs.h"

#include"Matrix.h"

#include"Angle.h"

class ClzControlNetAdjust

{

public:

ClzControlNetAdjust();

~ClzControlNetAdjust();

private:

ClzControlPoint * m_pUnknowPoint;

int m_iUnknowPointCount;

ClzControlPoint * m_pKnowPoint;

int m_iKnowPointCount;

ClzAngleObs * m_pAngleObs;

int m_iAngleObsCount;

ClzDistObs * m_pDistObs;

int m_iDistObsCount;

public:

double Anglesigma;

double Distsigma;

int m_iStationCount;

bool LoadObsData(const CString& strFileName);

void CoordinateEstimates();

void SetAnglesigmaD(double Asigma,double Dsigma,double count);

void ErrorEllipseDraw(CDC * pDC, CRect& rect);

void CalculateErrorEquations(const CString& strFileName); private:

ClzControlPoint* SearchKnownPointUsingID(CString strID);

ClzControlPoint* SearchUnknownPointUsingID(CString strID);

void SetKnowPointSize(int size);

void SetUnknowPointSize(int size);

void SetAngleObsSize(int size);

void SetDistObsSize(int size);

CString* SplitString(CString str, char split, int iSubStrs);

ClzControlPoint* SearchPointUsingID(CString strPointID);

Angle Azimuth(double dX1, double My1, double dX2, double My2);

double HDist(ClzControlPoint* cpStation1, ClzControlPoint* cpEnd1);

Angle ZeroAngle(ClzAngleObs AngleObs);

void FormErrorEquations(CMatrix &B, CMatrix &f);

void ComAngleObsEff(ClzAngleObs AngleObs ,double& Fi, double& Ci, double& Di, double& Ck, double& Dk);

void ComDistObsEff(ClzDistObs DistObs, double& Fi, double& Ci, double& Di, double& Ck, double& Dk);

void FixedWeight(CMatrix &p);

void GetMaxXY(double& dx, double& dy,double& minx,double& maxy);

void OutMatrixToFile(const CMatrix& mat, CStdioFile& SF);

}

ClzControlNetAdjust源文件

#include"stdafx.h"

#include"ClzControlNetAdujst.h"

#include

#include"math.h"

const double PI =atan(1.0)*4.0;

const double EPSILON = 1.0E-12;

const double R0 = 206265;

ClzControlNetAdjust::ClzControlNetAdjust()

{

m_pUnknowPoint=NULL;

m_iUnknowPointCount=0;

m_pKnowPoint=NULL;

m_iKnowPointCount=0;

m_pAngleObs=NULL;

m_iAngleObsCount=0;

m_pDistObs=NULL;

m_iDistObsCount = 0;

Anglesigma=0;

Distsigma=0;

m_iStationCount=0;

}

ClzControlNetAdjust::~ClzControlNetAdjust()

{

delete[] m_pUnknowPoint;

m_pUnknowPoint = NULL;

delete[] m_pKnowPoint;

m_pKnowPoint = NULL;

delete[] m_pAngleObs;

m_pAngleObs = NULL;

delete[] m_pDistObs;

m_pDistObs = NULL;

}

void ClzControlNetAdjust::SetKnowPointSize(int size) {

if (m_pKnowPoint != NULL)

{ delete[] m_pKnowPoint;

m_pKnowPoint = NULL;

m_iKnowPointCount=0; }

m_iKnowPointCount = size;

m_pKnowPoint = new ClzControlPoint[size];

}

void ClzControlNetAdjust::SetUnknowPointSize(int size) {

if (m_pUnknowPoint != NULL)

{

delete[] m_pUnknowPoint;

m_pUnknowPoint = NULL;

m_iUnknowPointCount = 0;

}

m_iUnknowPointCount = size;

m_pUnknowPoint = new ClzControlPoint[size];

}

void ClzControlNetAdjust::SetAngleObsSize(int size)

{

if (m_pAngleObs!=NULL)

{

delete[] m_pAngleObs;

m_pAngleObs = NULL;

m_iAngleObsCount = 0;

}

m_iAngleObsCount = size;

m_pAngleObs = new ClzAngleObs[size];

}

void ClzControlNetAdjust::SetDistObsSize(int size)

{

if (m_pDistObs!=NULL)

{

delete[] m_pDistObs;

m_pDistObs = NULL;

m_iDistObsCount = 0;

}

m_iDistObsCount = size;

m_pDistObs = new ClzDistObs[size];

}

CString* ClzControlNetAdjust::SplitString(CString str, char split, int iSubStrs)

{

int iPos = 0; //分割符位置

int iNums = 0; //分割符的总数

CString strTemp = str;

CString strRight;

//先计算子字符串的数量

while (iPos != -1)

{

iPos = strTemp.Find(split);

if (iPos == -1)

{

break;

}

strRight = strTemp.Mid(iPos + 1, str.GetLength());

strTemp = strRight;

iNums++;

}

if (iNums == 0) //没有找到分割符

{

//子字符串数就是字符串本身

iSubStrs = 1;

return NULL;

}

//子字符串数组

iSubStrs = iNums + 1; //子串的数量 = 分割符数量 + 1

CString* pStrSplit;

pStrSplit = new CString[iSubStrs];

strTemp = str;

CString strLeft;

for (int i = 0; i < iNums; i++)

{

iPos = strTemp.Find(split);

//左子串

strLeft = strTemp.Left(iPos);

//右子串

strRight = strTemp.Mid(iPos + 1, strTemp.GetLength());

strTemp = strRight;

pStrSplit[i] = strLeft;

}

pStrSplit[iNums] = strTemp;

return pStrSplit;

}

ClzControlPoint* ClzControlNetAdjust::SearchKnownPointUsingID(CString strID)

{

for (int i = 0; i

{

if (strID == m_pKnowPoint[i].strPointID)

{

return &m_pKnowPoint[i];

}

}

return NULL;

}

ClzControlPoint*

ClzControlNetAdjust::SearchUnknownPointUsingID(CString strID)

{

for (int i = 0; i

{

if (strID == m_pUnknowPoint[i].strPointID)

{

return &m_pUnknowPoint[i];

}

}

return NULL;

}

ClzControlPoint* ClzControlNetAdjust::SearchPointUsingID(CString strPointID)

{

ClzControlPoint* pCP = NULL;

pCP = SearchKnownPointUsingID(strPointID);

if (pCP == NULL)

{

pCP = SearchUnknownPointUsingID(strPointID);

}

return pCP;

}

Angle ClzControlNetAdjust::Azimuth(double dX1, double dY1, double dX2, double dY2)

{

Angle A;

int sgn;

if (dY2 - dY1+EPSILON >= 0)

{

sgn = 1;

}

else sgn = -1;

A(RAD)= PI - sgn*PI / 2 - atan((dX2 - dX1) / (dY2 - dY1 + EPSILON));

return A;

}

double ClzControlNetAdjust::HDist(ClzControlPoint* cpStation1, ClzControlPoint* cpEnd1)

{

double dDist;

dDist = sqrt((cpStation1->X - cpEnd1->X)*(cpStation1->X - cpEnd1->X) + (cpStation1->Y - cpEnd1->Y)*(cpStation1->Y- cpEnd1->Y));

return dDist;

}

Angle ClzControlNetAdjust::ZeroAngle(ClzAngleObs AngleObs)

{

Angle ZeroAlf;

for (int i = 0; i < m_iAngleObsCount; i++)

{

if((m_pAngleObs[i].cpStation->strPointID == AngleObs.cpStation->strPointID) && m_pAngleObs[i].ObsAngle(DMS)-0.000000 < EPSILON)

{

ZeroAlf = Azimuth(m_pAngleObs[i].cpStation->X, m_pAngleObs[i].cpStation->Y, m_pAngleObs[i].cpEnd->X, m_pAngleObs[i].cpEnd->Y);

}

}

return ZeroAlf;

}

void ClzControlNetAdjust::FormErrorEquations(CMatrix &B, CMatrix &f) {

int iObsCount, iUnknownCount;

iObsCount = m_iAngleObsCount + m_iDistObsCount;

iUnknownCount = m_iStationCount + m_iUnknowPointCount * 2;

B.SetSize(iObsCount, iUnknownCount);

f.SetSize(iObsCount, 1);

for (int i = 0; i < iObsCount;i++)

for (int j = 0; j < iUnknownCount; j++)

{

B(i, j) = 0;

}

for (int i = 0; i < iObsCount; i++)

{

f(i, 0) = 0;

}

//方向值误差方程

int StationNum = 1;

int tmpi = 1;

for (int i = 0; i < m_iAngleObsCount;i++)

{

double fi, ci, di, ck, dk;

ComAngleObsEff(m_pAngleObs[i],fi,ci,di,ck,dk);

if(m_pAngleObs[i].cpStation->strPointID != m_pAngleObs[tmpi].cpStation->strPointID

)

StationNum++;

B(i, m_iUnknowPointCount * 2 - 1 + StationNum) = -1;

tmpi = i;

for (int j = 0; j < m_iUnknowPointCount; j++)

{

if(m_pAngleObs[i].cpStation->strPointID == m_pUnknowPoint[j].strPointID)

{

B(i, 2 * j) = ci;

B(i, 2 * j + 1) = di;

}

if(m_pAngleObs[i].cpEnd->strPointID == m_pUnknowPoint[j].strPointID)

{

B(i, 2 * j) = ck;

B(i, 2 * j + 1) = dk;

}

}

f(i, 0) = fi;

}

//距离观测误差方程

for (int i = 0; i < m_iDistObsCount; i++)

{

double fi, ci, di, ck, dk;

ComDistObsEff(m_pDistObs[i],fi,ci,di,ck,dk);

for (int j = 0; j < m_iUnknowPointCount; j++)

{

if(m_pDistObs[i].cpStart->strPointID == m_pUnknowPoint[j].strPointID)

{

B(i+m_iAngleObsCount, 2 * j) = ci;

B(i+m_iAngleObsCount, 2 * j + 1) = di;

}

if(m_pDistObs[i].cpEnd->strPointID == m_pUnknowPoint[j].strPointID)

{

B(i + m_iAngleObsCount, 2 * j) = ck;

B(i + m_iAngleObsCount, 2 * j + 1) = dk;

}

}

f(i+m_iAngleObsCount, 0) = fi;

}

}

void ClzControlNetAdjust::ComAngleObsEff(ClzAngleObs AngleObs, double& Fi, double& Ci, double& Di, double& Ck, double& Dk)

{

double dXik, dYik,dSik;

dXik = AngleObs.cpEnd->X - AngleObs.cpStation->X;

dYik = AngleObs.cpEnd->Y - AngleObs.cpStation->Y;

dSik = HDist(AngleObs.cpStation, AngleObs.cpEnd);

Angle Aziik;

Aziik = Azimuth(AngleObs.cpStation->X, AngleObs.cpStation->Y, AngleObs.cpEnd->X, AngleObs.cpEnd->Y );

double a, b;

a = R0*dYik / (dSik*dSik * 1000.0);

b =- R0*dXik / (dSik*dSik * 1000.0);

Ci = a;

Di = b;

Ck = -a;

Dk = -b;

Angle Zero;

Zero = ZeroAngle(AngleObs);

double L0;

L0 = Aziik(RAD) - Zero(RAD);

if (L0 < 0)

L0 =L0+2*PI;

Fi = AngleObs.ObsAngle(RAD) - L0;

Fi = Fi*R0 ;;//常数项单位改为秒

}

void ClzControlNetAdjust::ComDistObsEff(ClzDistObs DistObs, double& Fi, double& Ci, double& Di, double& Ck, double& Dk)

{

double dSik;

dSik = HDist(DistObs.cpStart, DistObs.cpEnd);

double c, d;

c = (DistObs.cpEnd->X - DistObs.cpStart->X) / dSik;

d = (DistObs.cpEnd->Y - DistObs.cpStart->Y) / dSik;

Ci = -c;

Di = -d;

Ck = c;

Dk = d;

Fi = (DistObs.dDist - dSik)*1000;

}

void ClzControlNetAdjust::OutMatrixToFile(const CMatrix& mat, CStdioFile& SF)

{

CString strLine, strTmp;

for (int i = 0; i

{

strLine.Empty();

for (int j = 0; j

{

strTmp.Format(_T("%.4f "), mat(i, j));

strLine = strLine + strTmp;

}

SF.WriteString(strLine + _T("\r\n"));

}

}

void ClzControlNetAdjust::FixedWeight(CMatrix &p)

{

int iCount = m_iAngleObsCount + m_iDistObsCount;

p.SetSize(iCount, iCount);

p.Unit();

for (int i = m_iAngleObsCount ; i < iCount; i++)

{

p(i, i) = Anglesigma*Anglesigma / (Distsigma*Distsigma*m_pDistObs[i-m_iAngleObsCount].dDist/1000);

}

}

//控制网主函数

void ClzControlNetAdjust::CalculateErrorEquations(const CString& strFileName)

{

CStdioFile sf;

CString strLine;

setlocale(LC_ALL, "");

if(!sf.Open(strFileName, CFile::modeCreate| CFile::modeWrite))return;

strLine.Format(_T("概算后坐标\n"));

sf.WriteString(strLine);

strLine.Format(_T("未知点个数：%d\n"), m_iUnknowPointCount);

sf.WriteString(strLine);

for (int i = 0; i < m_iUnknowPointCount; i++)

{

strLine.Format(_T("%s，%.4f,%.4f\n"), m_pUnknowPoint[i].strPointID, m_pUnknowPoint[i].X,

m_pUnknowPoint[i].Y);

sf.WriteString(strLine);

}

CMatrix B, v, x, f, p;

CMatrix Nbb, fe;

double max = 0;

do{

FormErrorEquations(B, f);

FixedWeight(p);

Nbb = ~B*p*B;

fe = ~B*p*f;

x = Nbb.Inv()*fe;

v = B*x - f;

for (int i = 0; i < m_iUnknowPointCount; i++)

{

m_pUnknowPoint[i].X = m_pUnknowPoint[i].X + x(2 * i, 0) / 1000;

m_pUnknowPoint[i].Y = m_pUnknowPoint[i].Y + x(2 * i + 1, 0) / 1000;

i;

}

max++;

} while (max<5);

CMatrix Qxx;

Qxx = Nbb.Inv();

sf.WriteString(_T("矩阵B\n"));

OutMatrixToFile(B, sf);

sf.WriteString(_T("矩阵f\n"));

OutMatrixToFile(f, sf);

sf.WriteString(_T("矩阵权阵p\n"));

OutMatrixToFile(p, sf);

sf.WriteString(_T("矩阵Qxx\n"));

OutMatrixToFile(Qxx, sf);

double dVzero = 0;

for (int i = 0; i < m_iAngleObsCount; i++)

{

if (m_pAngleObs[i].ObsAngle(DMS) - 0.000000 < EPSILON)

{

dVzero = v(i, 0);

}

v(i, 0) -= dVzero;

}

CMatrix r(1,1);

r = ~v*p*v;

double r0;//单位权中误差

r0 = sqrt(r(0, 0) / (m_iAngleObsCount + m_iDistObsCount - 2 * m_iUnknowPointCount-m_iStationCount ));

strLine.Format(_T("单位权中误差:%.4f\n"),r0);

sf.WriteString(strLine);

for (int i = 0; i < m_iUnknowPointCount; i++)

{

m_pUnknowPoint[i].dMx = r0*sqrt(Qxx(2 * i, 2 * i));

m_pUnknowPoint[i].dMy = r0*sqrt(Qxx(2 * i+1, 2 * i+1));

m_pUnknowPoint[i].dMk = sqrt((m_pUnknowPoint[i].dMx*m_pUnknowPoint[i].dMx + m_pUnknowPoint[i].dMy*m_pUnknowPoint[i].dMy));

m_pUnknowPoint[i].dQ = atan(2*Qxx(2*i,2*i+1)/(Qxx(2*i,2*i)-Qxx(2*i+1,2*i+1))) / 2.0;

m_pUnknowPoint[i].dE = r0*sqrt((Qxx(2 * i, 2 * i) + Qxx(2 * i, 2 * i + 1)*tan(m_pUnknowPoint[i].dQ)));

m_pUnknowPoint[i].dF = r0*sqrt((Qxx(2 * i, 2 * i) + Qxx(2 * i, 2 * i + 1)*tan(m_pUnknowPoint[i].dQ+PI/2)));

/*double K = sqrt((Qxx(2 * i, 2 * i) - Qxx(2 * i + 1, 2 * i + 1))*(Qxx(2 * i, 2 * i) - Qxx(2 * i + 1, 2 * i + 1))

+ 4 * Qxx(2 * i, 2 * i + 1)*Qxx(2 * i, 2 * i + 1));

double Qe = (Qxx(2 * i, 2 * i) + Qxx(2 * i, 2 * i + 1) + K)/2;

double Qf = (Qxx(2 * i, 2 * i) + Qxx(2 * i, 2 * i + 1) -K) / 2;

m_pUnknowPoint[i].dE = r0*sqrt(Qe);

m_pUnknowPoint[i].dF = r0*sqrt(Qf);

m_pUnknowPoint[i].dQ = atan((Qe - Qxx(2 * i, 2 * i)) / Qxx(2 * i, 2 * i + 1));*/

if (m_pUnknowPoint[i].dQ < 0)

m_pUnknowPoint[i].dQ += PI;

}

//写各矩阵

strLine.Format(_T(" 方向观测成果表\n"));

sf.WriteString(strLine);

strLine.Format(_T("测站------站准------方向值（DMS）------改正数(S)-------平差后值\n"));

sf.WriteString(strLine);

for (int i = 0; i < m_iAngleObsCount; i++)

{

strLine.Format(_T("%s, %s, %.6f, %.2f, %.6f\n "), m_pAngleObs[i].cpStation->strPointID, m_pAngleObs[i].cpEnd->strPointID,

m_pAngleObs[i].ObsAngle(DMS), v(i, 0), m_pAngleObs[i].ObsAngle(DMS) + v(i, 0) / 10000);

sf.WriteString(strLine);

}

strLine.Format(_T(" 距离观测成果表\n"));

sf.WriteString(strLine);

strLine.Format(_T("测站------站准------距离（m）------改正数(m)-------平差后值(m)-------方位角（DMS）\n"));

sf.WriteString(strLine);

Angle *Azi;

Azi = new Angle[m_iDistObsCount];

for (int i = 0; i < m_iDistObsCount; i++)

{

Azi[i] = Azimuth(m_pDistObs[i].cpStart->X, m_pDistObs[i].cpStart->Y

, m_pDistObs[i].cpEnd->X, m_pDistObs[i].cpEnd->Y);

strLine.Format(_T("%s, %s, %.4f, %.4f, %.4f, %.6f \n"), m_pDistObs[i].cpStart->strPointID,

m_pDistObs[i].cpEnd->strPointID,

m_pDistObs[i].dDist, v(m_iAngleObsCount + i, 0)/1000,

m_pDistObs[i].dDist + v(m_iAngleObsCount + i, 0)/1000,

Azi[i](DMS));

sf.WriteString(strLine);

}

strLine.Format(_T("平面点位误差表\n"));

sf.WriteString(strLine);

strLine.Format(_T("点号------长轴E------短轴F------方位角（DMS）

-------点位精度Mk\n"));

sf.WriteString(strLine);

for (int i = 0; i < m_iUnknowPointCount; i++)

{

double dQ = 0, Azi = m_pUnknowPoint[i].dQ * 180 / PI;

int d, s, m;

d = int(Azi);

s = int((Azi - d )*60);

m = ((Azi- d)*60 - s)*60;

dQ = d + double(s) / 100 + m /10000;

strLine.Format(_T("%s, %.4f, %.4f, %.6f, %.4f, \n"),

m_pUnknowPoint[i].strPointID, m_pUnknowPoint[i].dE/1000,

m_pUnknowPoint[i].dF/1000, dQ, m_pUnknowPoint[i].dMk/1000);

sf.WriteString(strLine);

}

strLine.Format(_T(" 控制点成果表\n"));

sf.WriteString(strLine);

strLine.Format(_T("点号------X--------------Y-------\n"));

sf.WriteString(strLine);

for (int i = 0; i < m_iKnowPointCount; i++)

{

strLine.Format(_T("%s, %.4f, %.4f\n"),

m_pKnowPoint[i].strPointID, m_pKnowPoint[i].X

, m_pKnowPoint[i].Y);

sf.WriteString(strLine);

}

for (int i = 0; i

{

strLine.Format(_T("%s, %.4f, %.4f\n"),

m_pUnknowPoint[i].strPointID, m_pUnknowPoint[i].X

, m_pUnknowPoint[i].Y);

sf.WriteString(strLine);

}

sf.Close();

}

void ClzControlNetAdjust::GetMaxXY(double& dx, double& dy,double&

minx,double& maxy)

{

double Maxx = m_pKnowPoint[0].X;

double Maxy = m_pKnowPoint[0].Y;

double Minx = m_pKnowPoint[0].X;

double Miny = m_pKnowPoint[0].Y;

for (int i = 0; i < m_iKnowPointCount; i++)

{

if (Maxx < m_pKnowPoint[i].X)

{

Maxx = m_pKnowPoint[i].X;

}

if (Maxy < m_pKnowPoint[i].Y)

{

Maxy = m_pKnowPoint[i].Y;

}

if (Minx>m_pKnowPoint[i].X)

{

Minx = m_pKnowPoint[i].X;

}

if (Miny>m_pKnowPoint[i].Y)

{

Miny = m_pKnowPoint[i].Y;

}

}

for (int i = 0; i < m_iUnknowPointCount; i++) {

if (Maxx < m_pUnknowPoint[i].X)

{

Maxx = m_pUnknowPoint[i].X;

}

if (Maxy < m_pUnknowPoint[i].Y)

{

Maxy = m_pUnknowPoint[i].Y;

}

if (Minx>m_pUnknowPoint[i].X)

{

Minx = m_pUnknowPoint[i].X;

}

if (Miny>m_pUnknowPoint[i].Y)

{

Miny = m_pUnknowPoint[i].Y;

}

}

dx = Maxx-Minx;

dy = Maxy-Miny;

minx = Minx;

maxy = Maxy;

}

bool ClzControlNetAdjust::LoadObsData(const CString& strFileName) {

CStdioFile lz;

if (!lz.Open(strFileName, CFile::modeRead))return false;

CString strLine;

//读取已知数据

lz.ReadString(strLine);

SetKnowPointSize(_ttoi(strLine));

int n = 0;

for (int i = 0; i < m_iKnowPointCount; i++)

{

lz.ReadString(strLine);

CString* pstrData = SplitString(strLine, ',', n);

m_pKnowPoint[i].strPointID = pstrData[0];

m_pKnowPoint[i].X = _tstof(pstrData[1]);

m_pKnowPoint[i].Y = _tstof(pstrData[2]);

m_pKnowPoint[i].state = 1;

m_pKnowPoint[i].flg = 1;

delete[] pstrData;

pstrData = NULL;

}

//读取未知数据

lz.ReadString(strLine);

SetUnknowPointSize(_ttoi(strLine));

for (int i = 0; i < m_iUnknowPointCount; i++)

{

lz.ReadString(strLine);

CString* pstrData = SplitString(strLine, ',', n);

m_pUnknowPoint[i].strPointID = pstrData[0];

m_pUnknowPoint[i].state = 2;

m_pUnknowPoint[i].flg = 2;

delete[] pstrData;

pstrData = NULL;

}

//读取距离观测数据

lz.ReadString(strLine);

SetDistObsSize(_ttoi(strLine));

for (int i = 0; i < m_iDistObsCount; i++)

{

lz.ReadString(strLine);

CString* pstrData = SplitString(strLine, ',', n);

m_pDistObs[i].cpStart = SearchPointUsingID(pstrData[0]);

m_pDistObs[i].cpEnd = SearchPointUsingID(pstrData[1]);

m_pDistObs[i].dDist = _tstof(pstrData[2]);

delete[] pstrData;

pstrData = NULL;

}

//读取方向观测数据

lz.ReadString(strLine);

SetAngleObsSize(_ttoi(strLine));

for (int i = 0; i < m_iAngleObsCount; i++)

{

lz.ReadString(strLine);

CString* pstrData = SplitString(strLine, ',', n);

m_pAngleObs[i].cpStation = SearchPointUsingID(pstrData[0]);

m_pAngleObs[i].cpEnd = SearchPointUsingID(pstrData[1]);

m_pAngleObs[i].ObsAngle = Angle(_tstof(pstrData[2]), DMS);

delete[] pstrData;

pstrData = NULL;

}

lz.Close();

return true;

}

void ClzControlNetAdjust::CoordinateEstimates()

{

if(m_iKnowPointCount == 0 || m_iAngleObsCount == 0 || m_iDistObsCount == 0 || m_iUnknowPointCount == 0)return;

int iCount = 0;

int IsCoordinateEstimate = 0;

if (IsCoordinateEstimate == 0)

{

do

{

for (int i = 0; i

{

if(m_pAngleObs[i].cpStation->state == 1 && m_pAngleObs[i].cpEnd->state == 1)

{

for (int j = 0; j

{

if(m_pAngleObs[j].cpStation->strPointID == m_pAngleObs[i].cpStation->strPointID&&

m_pAngleObs[j].cpEnd->state == 2)

{

Angle ARF = m_pAngleObs[j].ObsAngle - m_pAngleObs[i].ObsAngle;

Angle ARF0 = Azimuth(m_pAngleObs[i].cpStation->X, m_pAngleObs[i].cpStation->Y,

m_pAngleObs[i].cpEnd->X,

m_pAngleObs[i].cpEnd->Y);

double ARF1 = ARF0(RAD) + ARF(RAD);

double dDist;

for (int k = 0; k

{

if ((m_pDistObs[k].cpStart->strPointID == m_pAngleObs[j].cpStation->strPointID

&&m_pDistObs[k].cpEnd->strPointID == m_pAngleObs[j].cpEnd->strPointID) ||

(m_pDistObs[k].cpStart->strPointID == m_pAngleObs[j].cpEnd->strPointID

&&m_pDistObs[k].cpEnd->strPointID == m_pAngleObs[j].cpStation->strPointID))

{

dDist = m_pDistObs[k].dDist;

}

}

m_pAngleObs[j].cpEnd->X = m_pAngleObs[j].cpStation->X + dDist*cos(ARF1);

m_pAngleObs[j].cpEnd->Y = m_pAngleObs[j].cpStation->Y + dDist*sin(ARF1);

m_pAngleObs[j].cpEnd->state = 1;