return a+b*0.01+c*0.0001+angle*0.0001;
}


// ************************************平面網平差計算*********************************************
// ************************************平面網點結構定義*******************************************
struct XYP{
	char name[20];                  // 點名
      double X;                     // x坐標值
	  double Y;                     // y坐標值
	  double X0;                    // x坐標近似值
	  double Y0;                    // y坐標近似值
      double mX;                    // x坐標中誤差
	  double mY;                    // y坐標中誤差
	  double mp;                    // 點位中誤差
	  double E;                     // 誤差橢圓長半軸 
	  double F;                     // 誤差橢圓短半軸
	  double T;                     // 誤差橢圓長半軸方向  
	  int fixed;                    // 是否控制點（控制點為1;未知點為0）
	  int i;                        // 點號（0-->allpnum-1）
};

//*****************************對點的"=="的重載***************************************************
int operator ==(XYP &a,XYP &b)
{
	
    if(strnicmp(b.name,a.name,20))
     return 1;                 
     else return 0;
}
 
//***********************************平面網觀測值結構*********************************************
struct obser{
      XYP *startp;                  // 觀測值起點指針
      XYP *endp;                    // 觀測值終點指針
      double dist;                  // 距離觀測值
	  double dist0;                 // 近似距離
	  double angle;                 // 方向觀測值
      double A;                     // 觀測值方位角
	  double A0;                    // 近似方位角 
	  double m0;                    // 觀測值平差值精度 
	  int i;                        // 測站的觀測值序號
      int sti;                      // 測站序號
	  int style;                    // 角度測量=1；距離測量=2;固定方位角=3；固定邊長=4 
};

//******************************平面網測站結構****************************************************
struct stat{
      XYP *stp;
	  int obnum;                    //　測站觀測值總數　
	  int disnum;                   //　測站距離觀測值個數
	  int aglnum;                   //　測站方向觀測值個數　　　　　
	  int i;                        //　測站序號  
};
//********************************平面網結構******************************************************
struct XYnet{
      char netname[40];             //  網名
      int allpnum;                  //  總點數
	  int fixpnum;                  //  控制點個數
	  int statnum;                  //  測站數
	  int obnum;                    //  觀測值總數
	  int fixdisn;                  //  固定邊長個數
	  int fixafn;                   //  固定方位角個數
	  int anglenum;                 //  方向觀測值總數
	  int distnum;                  //  距離觀測值總數
      double mangle;                //  驗前方向觀測值誤差
	  double msa;                   //  距離誤差加常數
	  double msb;                   //  距離誤差乘常數
	  stat st[MAX];                 //  定義平面網測站結構 
	  XYP Pt[MAX];                  //  平面網點結構
	  obser L[MAX];                 //  平面網觀測值結構
	  adj aa;                       //  平面網平差結構
};

//************************* 坐標反算距離**********************************************************
double dist(XYP &a,XYP &b)        
{
	if(a.X!=-PI && b.X!=-PI)
   	return sqrt((b.X-a.X)*(b.X-a.X)+(b.Y-a.Y)*(b.Y-a.Y));
  if(a.X0!=-PI && b.X0!=-PI)
	return sqrt((b.X0-a.X0)*(b.X0-a.X0)+(b.Y0-a.Y0)*(b.Y0-a.Y0));
     return -PI;
}


//************************* 坐標反算方位角********************************************************
double afa(XYP &a,XYP &b)                    
{
     if(a.X!=-PI && b.X!=-PI)
  {
	  double d=dist(a,b);
	  double t=acos((b.X-a.X)/d);
      if(b.Y-a.Y<0.0) t=2.0*PI-t;
      return t;
  }
   if(a.X0!=-PI && b.X0!=-PI)
  {
	  double d=dist(a,b);
	  double t=acos((b.X0-a.X0)/d);
      if(b.Y0-a.Y0<0.0) t=2.0*PI-t;
      return t;
  }
  return -PI;
}

//**********************************兩方向交會近似坐標計算****************************************
int XY0ang(obser &a1,obser &a2)           // 兩方向交會近似坐標計算
{  
	if(a1.A0==-PI || a2.A0 ==-PI || a1.A0==a2.A0 )  return 0; 
	if(d_h(a1.A0)==d_h(a2.A0)+PI || d_h(a1.A0)==d_h(a2.A0)-PI) return 0;
    if(a1.dist!=-PI || a1.dist0!=-PI || a2.dist!=-PI || a2.dist0!=-PI) return 0; 

	double k,B[MAX][MAX],A[MAX][MAX],L[MAX][1],X[MAX][1];
	if(a1.startp==a2.startp && a1.startp->X0==-PI && a1.endp->X0!=-PI && a2.endp->X0!=-PI)
    {
        
			k=tan(d_h(a1.A0));
		    A[0][0]=k;A[0][1]=-1;
		    L[0][0]=k*a1.endp->X0-a1.endp->Y0;
		  k=tan(d_h(a2.A0));
        A[1][0]=k;A[1][1]=-1;
		L[1][0]=k*a2.endp->X0-a2.endp->Y0;
        inverse(A,B,2);
        AXB(B,L,X,2,2);
		a1.startp->X0=X[0][0];
		a1.startp->Y0=X[1][0];
//		cout<<"XY0ang****1   "<<endl;
		return 1;
	}
/*
    if(a1.endp==a2.endp && a1.startp->X0!=-PI && a2.startp->X0!=-PI && a1.endp->X0==-PI)
   {
		k=tan(d_h(a1.A0));
		A[0][0]=-k;A[0][1]=1;
		L[0][0]=-(k*a1.startp->X0-a1.startp->Y0);
        k=tan(d_h(a2.A0));
        A[1][0]=-k;A[1][1]=1;
		L[1][0]=-(k*a2.startp->X0-a2.startp->Y0);
       	inverse(A,B,2);
//		cout<<"XY0ang****3   "<<endl;

        AXB(B,L,X,2,2);
		a1.endp->X0=X[0][0];
		a1.endp->Y0=X[1][0];
			return 1;
	}
  
   	 if(a1.startp==a2.endp && a1.startp->X0==-PI && a1.endp->X0!=-PI && a2.startp->X0!=-PI)
    {
		k=tan(d_h(a1.A0));
		A[0][0]=k;A[0][1]=-1;
		L[0][0]=k*a1.endp->X0-a1.endp->Y0;
        k=tan(d_h(a2.A0));
        A[1][0]=-k;A[1][1]=1;
		L[1][0]=-(k*a2.startp->X0-a2.startp->Y0);
        inverse(A,B,2);
        AXB(B,L,X,2,2);
		a1.startp->X0=X[0][0];
		a1.startp->Y0=X[1][0];
//			cout<<"XY0ang****3   "<<endl;
		return 1;
	}
	
   if(a1.endp==a2.startp && a1.endp->X0==-PI && a1.startp->X0!=-PI && a2.endp->X0!=-PI)
    {
		k=tan(d_h(a1.A0));
		A[0][0]=-k;A[0][1]=1;
		L[0][0]=-(k*a1.startp->X0-a1.startp->Y0);
        k=tan(d_h(a2.A0));
        A[1][0]=k;A[1][1]=-1;
		L[1][0]=k*a2.endp->X0-a2.endp->Y0;
        inverse(A,B,2);
        AXB(B,L,X,2,2);
		a1.endp->X0=X[0][0];
		a1.endp->Y0=X[1][0];
	//			cout<<"XY0ang****4   "<<endl;
		return 1;
	}*/	
    return 0;
}
//**********************************三邊交會法計算近似坐標****************************************
int XY0dist(obser &a,obser &b,obser &c) // 三邊交會法計算近似坐標
{  
	if(a.dist0==-PI || b.dist0==-PI || c.dist0==-PI )  return 0; 
	if(a.startp!=b.startp || a.startp!=c.startp || b.startp!=c.startp) return 0;
    if(a.endp==b.endp || a.endp==c.endp || b.endp==c.endp) return 0;
	if(a.endp->X0==-PI || b.endp->X0==-PI || c.endp->X0==-PI || a.startp->X0!=-PI) return 0;
    double a1=afa(*(a.endp),*(b.endp))-afa(*(a.endp),*(c.endp));	
	if(fabs(a1)<0.2*PI || fabs(fabs(a1)-PI)<0.2) return 0;
	double B[MAX][MAX],A[MAX][MAX],L[MAX][1],X[MAX][1];

		    A[0][0]=a.endp->X0-b.endp->X0;  A[0][1]=a.endp->Y0-b.endp->Y0;
		    L[0][0]=(-a.dist0*a.dist0+b.dist0*b.dist0+a.endp->X0*a.endp->X0
				-b.endp->X0*b.endp->X0+a.endp->Y0*a.endp->Y0-b.endp->Y0*b.endp->Y0)/2.0;
		
            A[1][0]=a.endp->X0-c.endp->X0;  A[1][1]=a.endp->Y0-c.endp->Y0;
		    L[1][0]=(-a.dist0*a.dist0+c.dist0*c.dist0+a.endp->X0*a.endp->X0
				-c.endp->X0*c.endp->X0+a.endp->Y0*a.endp->Y0-c.endp->Y0*c.endp->Y0)/2.0;
        inverse(A,B,2);
        AXB(B,L,X,2,2);
		a.startp->X0=X[0][0];
		a.startp->Y0=X[1][0];
//  	cout<<"XY0dist****1   "<<endl;
		return 1;
}
//***********************************坐標正算法近似坐標計算***************************************

// 坐標正算
int zheng(obser &a)
{
  if(a.startp->X0==-PI && a.endp->X0==-PI || a.startp->X0!=-PI && a.endp->X0!=-PI 
	  || a.dist0==-PI || a.A0==-PI) 
	  return 0;
 if(a.startp->X0!=-PI && a.endp->X0==-PI) 
 {
	 a.endp->X0=a.startp->X0+cos(d_h(a.A0))*a.dist0;                     // 要求方位角為弧度制
     a.endp->Y0=a.startp->Y0+sin(d_h(a.A0))*a.dist0;
     return 1;
 }

 if(a.startp->X0==-PI && a.endp->X0!=-PI) 
 {
	 a.startp->X0=a.endp->X0-cos(d_h(a.A0))*a.dist0;                     // 要求方位角為弧度制
     a.startp->Y0=a.endp->Y0-sin(d_h(a.A0))*a.dist0;
     return 1;
 }
   return 0;
}
//*********************************角度后方交會法計算近似坐標*************************************

//角度后方交會法計算近似坐標
int houj(obser &a,obser &b,obser &c)
{ 
 if(a.startp!=b.startp || a.startp!=c.startp || b.startp!=c.startp) return 0;
  if(a.endp->X0==-PI || b.endp->X0==-PI || c.endp->X0==-PI) return 0; 
  if(a.angle==-PI || b.angle==-PI || c.angle==-PI) return 0;
  if(a.A0!=-PI || b.A0!=-PI || c.A0!=-PI || a.startp->X0!=-PI) return 0;
// add code here...
 obser L1,L2,L0;
 int i=0;
  if(i<a.i) {i=a.i; L2=a;} if(i<b.i) {i=b.i;L2=b;} if(i<c.i) {i=c.i; L2=c;}
   i=1000000;
  if(i>a.i) {i=a.i; L0=a;} if(i>b.i) {i=b.i; L0=b;} if(i>c.i) {i=c.i; L0=c;}
  if((a.i==L0.i || a.i==L2.i) && (b.i==L0.i || b.i==L2.i))  L1=c;
  if((a.i==L0.i || a.i==L2.i) && (c.i==L0.i || c.i==L2.i))  L1=b;
  if((b.i==L0.i || b.i==L2.i) && (c.i==L0.i || c.i==L2.i))  L1=a;
  double A,B,C,af,bt,B1,B2; 
    B=afa(*(L1.endp),*(L0.endp))-afa(*(L1.endp),*(L2.endp));   //弧度
	A=afa(*(L0.endp),*(L2.endp))-afa(*(L0.endp),*(L1.endp));   //弧度
    C=afa(*(L2.endp),*(L1.endp))-afa(*(L2.endp),*(L0.endp));   //弧度
	B=fabs(B); if(B>PI) B=2*PI-B;
    A=fabs(A); if(A>PI) A=2*PI-A;
	C=fabs(C); if(C>PI) C=2*PI-C;
	
	af=d_h(L1.angle)-d_h(L0.angle);     //弧度

	if(af>PI) af=2*PI-af;
	bt=d_h(L2.angle)-d_h(L1.angle);     //弧度
	if(bt>PI) bt=2*PI-bt;
  
	B1=atan((1/tan(A)-1/tan(bt))/(1-1/tan(A)/tan(af)-1/tan(B)*(1/tan(af)+1/tan(bt))));
    if(B1<0)B1+=PI;
	B2=atan((1/tan(C)-1/tan(af))/(1-1/tan(C)/tan(bt)-1/tan(B)*(1/tan(af)+1/tan(bt))));
	if(B2<0)B2+=PI;
//	cout<<h_d(B1+B2-B)<<endl;
    L1.A0=h_d(afa(*(L1.endp),*(L0.endp))-B1+PI);
    if(L1.A0>360) L1.A0=h_d(d_h(L1.A0)-2*PI);
	double dd=d_h(L1.angle)-d_h(L1.A0);
	L0.A0=h_d(d_h(L0.angle)-dd);  
    L2.A0=h_d(d_h(L2.angle)-dd);
    
    XY0ang(L0,L1);
//    cout<<L0.startp->X0<<"    "<<L0.startp->Y0<<endl;
	 
	return 1;
}

//**************************鍵盤輸入未知點近似坐標************************************************
void kinXY0(XYnet &a)     // 鍵盤輸入未知點近似坐標
{
for(int i=a.fixpnum;i<a.allpnum;i++)
{
  cout<<a.Pt[i].name<<" x0= ";cin>>a.Pt[i].X0;cout<<endl;
  cout<<a.Pt[i].name<<" y0= ";cin>>a.Pt[i].Y0;cout<<endl;
}

}
//****************************文件輸入未知點近似坐標**********************************************
int finXY0(XYnet &a,char *XY0filename)      // 文件輸入未知點近似坐標
{
// add code here
	return 1;

}
//****************************************逐測站近似方位角推算************************************
void statangc(XYnet &a)
{
	int n1=0;
	int n=a.obnum+a.fixafn+a.fixdisn;
	   for(int i=0;i<a.statnum;i++) // 逐測站
		   {
			   for(int j=n1;j<n1+a.st[i].aglnum;j++) //  測站首觀測值的序號 
			  {
		       if(a.L[j].A0!=-PI)
			   {
			     double df=d_h(a.L[j].angle)-d_h(a.L[j].A0);
			     for(int k=j-a.L[j].i;k<j-a.L[j].i+a.st[a.L[j].sti].aglnum;k++) 
				 if(a.L[k].A0==-PI)
				 {
				   if(d_h(a.L[k].angle)-df>=0) a.L[k].A0=h_d(d_h(a.L[k].angle)-df);
				   if(d_h(a.L[k].angle)-df>=2*PI) a.L[k].A0=h_d(d_h(a.L[k].angle)-df-2*PI); 
				   if(d_h(a.L[k].angle)-df<0) a.L[k].A0=h_d(d_h(a.L[k].angle)-df+2.0*PI);
		          
				   for(int k1=0;k1<n;k1++)            //  已知近似方位角的傳遞
				   {
				     if(a.L[k1].A0==-PI && a.L[k1].startp==a.L[k].endp 
						 && a.L[k1].endp==a.L[k].startp)
					    if(d_h(a.L[k].A0)-PI>=0) a.L[k1].A0=h_d(d_h(a.L[k].A0)-PI);
						 else a.L[k1].A0=h_d(d_h(a.L[k].A0)+PI);
				     if(a.L[k1].A0==-PI && a.L[k1].startp==a.L[k].startp 
						 && a.L[k1].endp==a.L[k].endp)
					      a.L[k1].A0=a.L[k].A0;
				   }
				  break;
				 }
			   }
			  }
		      n1+=a.st[i].disnum+a.st[i].aglnum;      //  下一個測站
}}
//****************************************???三角形結構*******************************************
 struct Triangle              
{
  XYP p1;
  XYP p2;
  XYP p3;
  double p1ang;
  double p2ang;
  double p3ang;
  double d12;
  double d13;
  double d23;
  double adajian180;
};
//************************無定向導線計算未知點的近似坐標******************************************
int Udxdsetx0y0(XYnet &a)      // 用于三角網控制點不相鄰且無方向觀測情況  
{ 
// add code here
	int obi,flag;
	for(int i=0;i<a.obnum;i++)
     if(a.L[i].startp->fixed==1 && a.L[i].endp->fixed || a.L[i].A0!=-PI) return 0;
// 1號以上控制點近似坐標歸零    
	 for(i=1;i<a.fixpnum;i++)
			a.Pt[i].X0=a.Pt[i].Y0=-PI;
// 起始邊確定	
	 for(i=0;i<a.obnum;i++)
		if(a.L[i].startp->i==0 && a.L[i].endp->fixed==0 
			||a.L[i].startp->fixed==0 && a.L[i].endp->i==0) { obi=i;break;}
// 假設方位角與邊長	 
		if(a.L[obi].A0==-PI)a.L[obi].A0=0;
        if(a.L[obi].dist0==-PI)a.L[obi].dist0=1;
		XYP end;
		zheng(a.L[obi]);
// 假設方位角計算		
		do{flag=0;
			statangc(a);
			for(int i=0;i<a.obnum;i++)
				if(a.L[i].A0==-PI){flag=1;break;}
		}while(flag==1);
// 假設近似坐標計算 
		flag=0;      
		do{
		for(int i=0;i<a.obnum-1;i++)
	    for(int j=i+1;j<a.obnum;j++)
	     	XY0ang(a.L[i],a.L[j]);