精华内容
下载资源
问答
  • 后方交会和前方交会

    2018-02-19 16:25:26
    双像解析摄影测量中的后交-前交解法,常用于已知像片的外方位元素、需...解算过程分为两个阶段:后方交会、前方交会。 思路为利用后方交会计算外方位元素,利用前方交会解算待定地面点坐标。 后方交会的解算过程为:
  • 后方交会

    千次阅读 2016-12-15 09:32:41
    后方交会程序计算完成后,如果显示了定位精度就查看一下该数值。定位精度数值越大,说明点 P 离危险圆越近,定位结果越不可靠。 如何计算后方交会的定位精度,请参考下一章的内容。     第 2 章 ...

    1 计算公式    1

    1.1 计算公式一    1

    1.1.1 角度取法    1

    1.1.2 代码实现    3

    1.2 计算公式二    5

    1.2.1 公式推导    5

    1.2.2 代码实现    6

    1.3 危险圆    7

    2 精度评定    8

     

     

    1 计算公式

    如下图所示,已知ABC三点的坐标,通过测量三个角度α、β、γ即可求出这三个角度顶点P的坐标。此即为后方交会。

    图1.1

    1.1 计算公式一

    1.1.1 角度取法

    上述公式在形式上是十分优美的,但是实际使用一下该公式就会发现一个至关重要的问题被遗漏了——那就是ABC、α、β、γ这六个角度该如何取值?

    下图对角度A、α的取值分四种情况进行了说明:

    图1.2

    上图中,角度A、α的取值遵循两条规则:

    1、正方向规则:角度的增加方向(正方向),与坐标系方位角的增加方向保持一致。具体的就是数学系里角度正方向为逆时针,测量系里角度正方向为顺时针。

    2、起终规则:顶点、起点、终点遵循X,X+1,X+2规则。

    XA时,顶点、起点、终点分别为A,B,C。意味着:角A的起始边为AB,终止边为AC;角α的起始边为PB,终止边为PC

    XB时,顶点、起点、终点分别为B,C,A。意味着:角B的起始边为BC,终止边为BA;角β的起始边为PC,终止边为PA

    XC时,顶点、起点、终点分别为C,A,B。意味着:角C的起始边为CA,终止边为CB;角γ的起始边为PA,终止边为PB

    1.1.2 代码实现

    下面是后方交会计算公式一的C代码实现:

    /******************************************************\

    后方交会计算

    x,y [in] 三个已知点的xy坐标

    HA [in] 三个已知点的水平角观测值,单位:弧度

    XP,YP [out] 待求点 P 的坐标

    \******************************************************/

    void HJ1(double x[3],double y[3],double HA[3],double*XP,double*YP)

    {

    int i = 0;

    int nA = 0;

    int nB = 1;

    int nC = 2;

    double ctg = 0.0;

    double pi_2= 1.5707963267948966192313216916398;

    double P = 0.0; //

    double xp = 0.0;

    double yp = 0.0;

    double sp = 0.0; //权的累加值

    for(i = 0;i < 3;++i)

    {

    ctg = ((x[nB]-x[nA])*(x[nC]-x[nA])+(y[nB]-y[nA])*(y[nC]-y[nA]))

    / ((x[nB]-x[nA])*(y[nC]-y[nA])-(x[nC]-x[nA])*(y[nB]-y[nA]));

    P = 1.0 / (ctg + tan(pi_2 + HA[nC] - HA[nB]));

    xp += x[i] * P;

    yp += y[i] * P;

    sp += P;

    if(++nA > 2) { nA = 0; }

    if(++nB > 2) { nB = 0; }

    if(++nC > 2) { nC = 0; }

    }

    if(XP) { *XP = xp / sp; }

    if(YP) { *YP = yp / sp; }

    }

    测试代码如下

    void TestHJ1()

    {

    srand(time(NULL));

    double x[3];

    double y[3];

    double HA[3];

    double xP = rand();

    double yP = rand();

    double HA0 = rand();

    int i;

    for(i = 0;i < 3;++i)

    {

    x[i] = rand();

    y[i] = rand();

    HA[i] = atan2(y[i] - yP,x[i] - xP) + HA0;

    }

    double XP = 0.0;

    double YP = 0.0;

    HJ1(x,y,HA,&XP,&YP);

    double deltaX = XP - xP; //这个数值应该接近于零

    double deltaY = YP - yP; //这个数值应该接近于零

    }

    1.2 计算公式二

    1.2.1 公式推导

    1.2.2 代码实现

    下面是后方交会计算公式二的C代码实现:

    void HJ2(double xA,double yA,double HAa

    ,double xB,double yB,double HAb

    ,double xC,double yC,double HAc

    ,double*XP,double*YP)

    {

    double pi_2= 1.5707963267948966192313216916398;

    double ctg = 0.0;

    ctg = tan(pi_2 - (HAb - HAa));

    double x1 = 0.5 * (xA + xB + (yA - yB) * ctg);

    double y1 = 0.5 * (yA + yB + (xB - xA) * ctg);

    ctg = tan(pi_2 - (HAc - HAa));

    double x2 = 0.5 * (xA + xC + (yA - yC) * ctg);

    double y2 = 0.5 * (yA + yC + (xC - xA) * ctg);

    double k = 2.0*(yA*(x2-x1)+xA*(y1-y2)+x1*y2-x2*y1)

    / ((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

    if(XP) { *XP = xA + k * (y2 - y1); }

    if(YP) { *YP = yA + k * (x1 - x2); }

    }

    测试代码如下

    void TestHJ2()

    {

    srand(time(NULL));

    double xA = rand();

    double yA = rand();

    double xB = rand();

    double yB = rand();

    double xC = rand();

    double yC = rand();

    double xP = rand();

    double yP = rand();

    double HA0 = rand();

    double HAa = atan2(yA - yP,xA - xP) + HA0;

    double HAb = atan2(yB - yP,xB - xP) + HA0;

    double HAc = atan2(yC - yP,xC - xP) + HA0;

    double XP = 0.0;

    double YP = 0.0;

    HJ2(xA,yA,HAa,xB,yB,HAb,xC,yC,HAc,&XP,&YP);

    double deltaX = XP - xP; //这个数值应该接近于零

    double deltaY = YP - yP; //这个数值应该接近于零

    }

    1.3 危险圆

    推导公式二时,若两个圆心O1O2重合,会是个什么情况?

    此时,这两个圆都会通过ABC三点,点P会在这个圆上。显然这个圆就是三角形ABC的外接圆。点P在这个圆的任何位置都能保证三个夹角为α、β、γ。

    外业测量时,点P落在危险圆附近的情况一定要避免。这里介绍两种规避方法:

    1、点P尽量要在三角形ABC的内部;

    2、后方交会程序计算完成后,如果显示了定位精度就查看一下该数值。定位精度数值越大,说明点P离危险圆越近,定位结果越不可靠。

    如何计算后方交会的定位精度,请参考下一章的内容。

     

     

    2 精度评定

    展开全文
  • 后方交会_前方交会

    2015-09-05 20:51:45
    用C#实现的摄影测量后方交会和前方交会的整体代码,利用网络的样例数据已验证代码没问题,请大家免费下载
  • 空间后方交会

    2018-05-24 17:31:49
    空间后方交会 C++代码 中国地质大学(武汉)课程设计 亲测可用
  • 后方交会算法

    2016-05-23 16:06:11
    摄影测量学的后方交会和前方交会的算法。
  • 后方交会 课程设计 多片后方交会 附上程序结果和精度评定
  • 后方交会VB

    2013-12-26 22:04:45
    后方交会后方交会、便于编写。使用简单,便于使用,使用便捷
  • 交会定点(前方交会、测边交会、后方交会)程序C++代码

    一、设计思路

    1.新建一个Function.h文件,在其中声明二维坐标结构体、角度转换函数、方位角计算函数、两点间距离计算函数和三个定点交会函数,并在新建一个Function.cpp文件对函数进行定义(Function.cpp文件中要加入#include "Function.h");

    2.在CExercise_4Dlg.cpp文件头处添加 #include "Function.h"

    3.计算按钮消息响应函数对交会定点计算函数的调用:

    iMethod==1,调用前方交会函数;

    iMethod==2,调用测边交会函数;

    iMethod==3,调用后方交会函数。

    二、主要代码

    // function.h : 头文件
    #pragma once
    struct Point2D    //定义二维坐标结构体
    {
            double X;
            double Y;
    };
    double Dms_TO_Rad(double dDms);                         //度分秒转化为弧度制
    double Distance(struct Point2D &A,struct Point2D &B);   //计算两点间的距离
    double Azimuth(struct Point2D &A,struct Point2D &B);    //计算方位角
    struct Point2D ForwardIntersection(struct Point2D &A,struct Point2D &B,double Alpha,double Betta);
    //前方交会定点计算
    struct Point2D LinearIntersection(struct Point2D &A,struct Point2D &B,double Dap,double Dbp);
    //测边交会定点计算
    struct Point2D ResctionIntersection(struct Point2D &A,struct Point2D &B,struct Point2D &C,double Alpha,double Betta,double Gamma);
    //后方交会定点计算
    // function.cpp : 实现文件
    #include "StdAfx.h"
    #include "Function.h"
    #include "math.h"
     
    const double PI=4.0*atan(1.0);
     
     
    double Dms_TO_Rad(double dDms)
    {
            double dRad;
            int iDegree,iMin;
            double dSec;
            iDegree=int(dDms);
            iMin=int((dDms-iDegree)*100);
            dSec=((dDms-iDegree)*100-iMin)*100;
            dDms=iDegree+double(iMin)/60+dSec/3600;
            dRad=dDms/180*PI;
            return dRad;
    }
    double Distance(struct Point2D &A,struct Point2D &B)
    {
            double dDistance=0;
            dDistance=sqrt((A.X-B.X)*(A.X-B.X)+(A.Y-B.Y)*(A.Y-B.Y));
            return dDistance;
    }
    double Azimuth(struct Point2D &A,struct Point2D &B)
    {
            // TODO: 在此添加控件通知处理程序代码
     
            double dAzimuth=0;                     //方位角
            double dx=B.X-A.X;                     //X坐标增量
            double dy=B.Y-A.Y;                     //Y坐标增量
     
            if (dx>0)
            {
                    if (dy>0)
                    {
                            dAzimuth=atan(dy/dx);
                    }
                    else if(dy<0)
                    {
                            dAzimuth=atan(dy/dx)+PI*2;
                    }
                    else
                            dAzimuth=0;
            }
            else if (dx<0)
            {
                    if(dy>0)
                    {
                            dAzimuth=atan(dy/dx)+PI;
                    }
                    else if(dy<0)
                    {
                            dAzimuth=atan(dy/dx)+PI;
                    }
                    else
                            dAzimuth=PI;
            }
            else
            {
                    if(dy>0)
                            dAzimuth=PI/2;
                    else if(dy<0)
                            dAzimuth=3*PI/2;
            }
            return dAzimuth;
    }
    struct Point2D ForwardIntersection(struct Point2D &A,struct Point2D &B,double Alpha,double Betta)
    {
            struct Point2D P;
            //将度分秒转化为弧度制
            double dA=Dms_TO_Rad(Alpha);
            double dB=Dms_TO_Rad(Betta);
            //计算A,B角余切值
            double dCotA=1/tan(dA);
            double dCotB=1/tan(dB);
            //计算前方交会定位值
            P.X=((A.X*dCotB+B.X*dCotA)+(B.Y-A.Y))/(dCotA+dCotB);
            P.Y=((A.Y*dCotB+B.Y*dCotA)+(A.X-B.X))/(dCotA+dCotB);
            return P;
    }
    struct Point2D LinearIntersection(struct Point2D &A,struct Point2D &B,double Dap,double Dbp)
    {
            struct Point2D P;
            double Dab;                            //三角形AB边长
            Dab=Distance(A,B);
            double alpha_ab;                       //三角形AB方位角
            alpha_ab=Azimuth(A,B);
            double Angle_A;                        //三角形内角A
            Angle_A=acos((Dab*Dab+Dap*Dap-Dbp*Dbp)/(2*Dab*Dap));
            double alpha_ap=alpha_ab-Angle_A;
     
            P.X=A.X+Dap*cos(alpha_ap);
            P.Y=A.Y+Dap*sin(alpha_ap);
            return P;
    }
    struct Point2D ResctionIntersection(struct Point2D &A,struct Point2D &B,struct Point2D &C,double Alpha,double Betta,double Gamma)
    {
            struct Point2D P;
            double dA;                             //三角形内角A
            double dB;                             //三角形内角B
            double dC;                             //三角形内角C
            double a;                              //三角形边长a
            double b;                              //三角形边长b
            double c;                              //三角形边长c
     
            a=Distance(C,B);
            b=Distance(C,A);
            c=Distance(B,A);
            dA=acos((b*b+c*c-a*a)/(2*b*c));
            dB=acos((a*a+c*c-b*b)/(2*a*c));
            dC=acos((b*b+a*a-c*c)/(2*b*a));
     
            double C_TEMP;                        //定义判断是否在危险圆附近的判断变量
            double B_TEMP;
            double A_TEMP;
     
            C_TEMP=Alpha+Betta+dC;
            B_TEMP=Alpha+Gamma+dB;
            A_TEMP=Betta+Gamma+dA;
     
            if ((C_TEMP>170)&&C_TEMP<190||
                    (B_TEMP>170)&&B_TEMP<190||
                    (B_TEMP>170)&&B_TEMP<190)
            {
                    P.X=-1;
                    P.Y=-1;
                    return P;                         //坐标是(-1,-1)则在危险圆附近
            }
     
            double Alpha_Rad=Dms_TO_Rad(Alpha);   //度分秒转化为弧度
            double Betta_Rad=Dms_TO_Rad(Betta);
            double Gamma_Rad=Dms_TO_Rad(Gamma);
     
            double pa=(tan(Alpha_Rad)*tan(dA))/(tan(Alpha_Rad)-tan(dA));
            double pb=(tan(Betta_Rad)*tan(dB))/(tan(Betta_Rad)-tan(dB));
            double pc=(tan(Gamma_Rad)*tan(dC))/(tan(Gamma_Rad)-tan(dC));
     
            P.X=(pa*A.X+pb*B.X+pc*C.X)/(pa+pb+pc);
            P.Y=(pa*A.Y+pb*B.Y+pc*C.Y)/(pa+pb+pc);
            return P;
    }
    // Exercise_4Dlg.h : 头文件
    // CExercise_4Dlg 对话框
    class CExercise_4Dlg : public CDialog
    {
    public:
            //前方交会控件变量
            double dXA_F;
            double dYA_F;
            double dXB_F;
            double dYB_F;
            double dAlpha_F;
            double dBetta_F;
            double dXP_F;
            double dYP_F;
            //测边交会控件变量
            double dXA_L;
            double dYA_L;
            double dXB_L;
            double dYB_L;
            double dDap_L;
            double dDbp_L;
            double dXP_L;
            double dYP_L;
            //后方交会空间变量
            double dXA_R;
            double dYA_R;
            double dXB_R;
            double dYB_R;
            double dXC_R;
            double dYC_R;
            double dXP_R;
            double dYP_R;
            double dAlpha_R;
            double dBetta_R;
            double dGamma_R;
            int iMethod;                          //交会定点类型代号
            afx_msg void OnBnClickedBtnCal();     //计算按钮
            afx_msg void OnBnClickedBtnClear();   //重置编辑框数据
            afx_msg void OnBnClickedCancel();     //退出对话框
            void ForwardIntersection(double XA,double YA,double XB,double YB,double Alpha,double Betta,double &XP,double &YP);
            //前方交会定点计算
            void LinearIntersection(double XA,double YA,double XB,double YB,double Dap,double Dbp,double &XP,double &YP);
            //测边交会定点计算
            void ResctionIntersection(double XA,double YA,double XB,double YB,double XC,double YC,double Alpha,double Betta,double Gamma,double &XP,double &YP);
            //后方交会定点计算
    };
    // Exercise_4Dlg.cpp : 实现文件
    #include "stdafx.h"
    #include "Exercise_4.h"
    #include "Exercise_4Dlg.h"
    #include "Function.h"
    CExercise_4Dlg::CExercise_4Dlg(CWnd* pParent /*=NULL*/)
            : CDialog(CExercise_4Dlg::IDD, pParent)
            , dXA_F(116.942)     //构造函数中给定变量初始值
            , dYA_F(683.295)
            , dXB_F(522.909)
            , dYB_F(794.647)
            , dAlpha_F(59.1042)
            , dBetta_F(56.3254)
            , dXP_F(398.151)
            , dYP_F(413.249)
            , dXA_L(1807.041)
            , dYA_L(719.853)
            , dXB_L(1646.382)
            , dYB_L(830.660)
            , dDap_L(105.983)
            , dDbp_L(159.648)
            , dXP_L(1805.957)
            , dYP_L(825.830)
            , dXA_R(840.134)
            , dYA_R(844.422)
            , dXB_R(1001.542)
            , dYB_R(1620.616)
            , dXC_R(659.191)
            , dYC_R(1282.629)
            , dXP_R(503.702)
            , dYP_R(1500.075)
            , dAlpha_R(-68.0237)
            , dBetta_R(-8.2414)
            , dGamma_R(76.2651)
            , iMethod(1)
    {
            m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    }
    void CExercise_4Dlg::OnBnClickedBtnCal()
    {
            // TODO: 在此添加控件通知处理程序代码
            UpdateData(TRUE);
     
            struct Point2D A,B,C,P;
            //定义个二维结构体变量存放A,B,C,P坐标
     
            if (iMethod==1)
            {
                    A.X=dXA_F;
                    A.Y=dYA_F;
                    B.X=dXB_F;
                    B.Y=dYB_F;
                    P=ForwardIntersection(A,B,dAlpha_F,dBetta_F);
                    //调用前方交会定点计算函数
                    dXP_F=P.X;
                    dYP_F=P.Y;
            }
            else if (iMethod==2)
            {
                    A.X=dXA_L;
                    A.Y=dYA_L;
                    B.X=dXB_L;
                    B.Y=dYB_L;
                    P=LinearIntersection(A,B,dDap_L,dDbp_L);
                    //调用测边交会定点计算函数
                    dXP_L=P.X;
                    dYP_L=P.Y;
            }
            else if (iMethod==3)
            {
                    A.X=dXA_R;
                    A.Y=dYA_R;
                    B.X=dXB_R;
                    B.Y=dYB_R;
                    C.X=dXC_R;
                    C.Y=dYC_R;
                    P=ResctionIntersection(A,B,C,dAlpha_R,dBetta_R,dGamma_R);
                    //调用后方交会定点计算函数
     
                    dXP_R=P.X;
                    dYP_R=P.Y;
                    if ((dXP_R==-1)&&(dXP_R=-1))
                    {
                            MessageBox(_T("在危险圆附近"));
                    }
            }
            else
                    MessageBox(_T("代号输入有误"));
     
            UpdateData(FALSE);
    }

    三、运行结果

    展开全文
  • 基于VC6.0开发的摄影测量空间前方交会空间后方交会程序。
  • gps-后方交会

    2018-01-04 11:45:11
    用C++语言编写,用gps-后方交会法计算待定坐标的小程序
  • 后方交会程序

    2015-12-22 18:50:51
    在matlab下完成的后方交会,代码是最原始的,不过需要自己写一个旋转矩阵的代码,因为文档调用了
  • C#+VS2017编写,完整项目,打开即用。包括前方交会和后方交会,可视化界面,表格存放数据。
  • 单片空间后方交会

    2014-09-17 16:04:58
    单片空间后方交会。本代码可实现单片空间后方交会
  • 利用C语言实现摄影测量中的前方交会与后方交会,而且非常好用,
  • matlab 后方交会

    2014-12-15 08:27:56
    matlab 单像后方交会 基础代码 是一个摄影测量课后练习题的代码 了解基本原理
  • 前方交会、测边交会、后方交会计算程序,供参考,如有不足之处还请指出。
  • 后方交会C++程序

    2016-10-11 15:51:06
    后方交会计算代码,包含示例控制点坐标文件
  • 摄影测量后方交会

    2019-03-17 21:35:08
    摄影测量后方交会,按照后方交会的正常流程实现,并附有测试数据。
  • 空间后方交会代码

    2016-10-07 16:29:06
    摄影测量中空间后方交会的程序,可以直接运行,C++书写的
  • 本程序给出了摄影测量学中常见后方交会、前方交会的MFC实现方法,除此之外还给出了特征点提取和同名点匹配过程。希望对你们学习有所启发和帮助!
  • matlab单向后方交会

    2016-09-02 16:27:14
    摄影测量的单片后方交会程序,第一次编,可能有些地方要修改。
  • 用C++编程实现的数字摄影测量里面的单片空间后方交会的代码

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,098
精华内容 1,239
关键字:

后方交会