精华内容
下载资源
问答
  • 坐标转换四参数解算

    千次阅读 2018-12-28 22:34:00
    分享一个前段时间项目中遇到的一个姿势点,就是求解平面坐标四参数转换转换参数;当时学渣小编还是花了些时间研究,其实原理很Easy,过程也很Easy,理解起来更Easy。废话不多说,下面开整  已知:  转换坐标...

      分享一个前段时间项目中遇到的一个姿势点,就是求解平面坐标四参数转换的转换参数;当时学渣小编还是花了些时间研究,其实原理很Easy,过程也很Easy,理解起来更Easy。废话不多说,下面开整

      已知:

      转换前坐标点(x1,y1),转换后坐标点(x2,y2);

       二维四参数转换模型:

      

     

      求解:平移参数、旋转参数、尺度参数。

      开始求解:

       Step1:为了简化计算公式,我们先设定:

      

         以上转换模型公式表达为:

       

      Step2:经过矩阵运算变化,将我们要求解的参数变换到同一个矩阵中:

      

       Step3:利用间接平差法得到以下计算公式:

      

      Step4:计算旋转参数和尺度参数:

      

       至此,我们要求解的参数已经全部计算出来了,很Easy吧。

         当然实际生产中,我们的坐标是坐标点对,可以结合上述计算公式利用最小二乘法来进行计算,同时也可以计算误差。

     

    转载于:https://www.cnblogs.com/mohanchen/p/10193248.html

    展开全文
  • 基于二维四参数模型的坐标转换

    千次阅读 2018-09-21 10:25:37
    前言  前段时间数据工程测绘部领导找到我,需要一个坐标转换工具。自2018年7月1号起,国家全面启动CGCS2000坐标系,以前的54坐标系,80坐标系都要转成2000坐标... GIS专业的我,对于坐标转换原理、思路还是以前在...

        前言

        前段时间数据工程测绘部领导找到我,需要一个坐标转换工具。自2018年7月1号起,国家全面启动CGCS2000坐标系,以前的54坐标系,80坐标系都要转成2000坐标。测绘部曾花5万块钱临时购买了一个转换工具,但后期更高精度坐标转换还需要费用。网上也有一些坐标转换的小工具,但是,只能支持单点或简单txt格式的转换。

         GIS专业的我,对于坐标转换原理、思路还是以前在学校的时候学的,于是,我开始网上搜索,布尔莎模型、二维7参数模型、二维四参数模型,高斯正算、高斯反算、最小二乘法。。。结合国家下发的《80T2000坐标转换》方案,以及网上能找到的资料,历时2个月,坐标转换工具终于完成,自己也小有成就感。

        工具包括二维四参数转换,和布尔莎七参数转换等。转换结果跟网上多个转换工具比较,结果高度一致,精度远高出国家要求转换精度。由于,要经常验证各种数据精度,基于让我自己使用便捷的原则,哪里不爽改哪里,经过不断完善,参数计算转换使用便捷,验证方便。现将四参数转换过程、实现思路、结果验证,以及遇到的问题分享出来,供大家学习!布尔莎七参数转换,将在后期整理后发出。

        界面

        先上个二维四参数计算的界面,示例中数据为54转80,平均残差0.04,如果是80转2000,转换精度更高。

     

      该参数计算还支持导入参数验证残差,导入参数0,即可验证不使用转换参数的情况,残差在50m左右。

        遇到的问题

    1.x y 的困惑

        当我第一次把工具交到数据工程部领导时,还比较满意,但是也提了两点,其中一点,他说到“我干了测试这么多年,始终分不清XY,主要是很多工具对XY的定义不一样!”,在他的建议下,我把XY坐标换成了,北坐标和东坐标,这样一来,测绘人员就可以很清楚的做区分了。

    2.都是带号的错

       刚开始计算的转换参数跟南方CASS工具有一定的差别,纵偏移-500m左右,但是我带入四参数模型发现残差很小,满足转换精度。我把南方CASS计算的参数代入,残差却很大。我用Coord工具验证,计算结果跟我计算的几乎完全一致。

        百思不得其解,后来经过反复实验,才发现是带号的问题。南方CASS工具计算的时候去掉了带号,我把带号去掉后,转换参数就一致了。在后面的计算及转换中,我都将带号做了处理。

      参数计算

    四参数转换模型比较简单,如下:

    但是要根据模型,求得四参数的值,就需要将模型变形成下面这种形式:

    将该模型用计算机表示,代码如下:

    然后利用要用最小二乘法求解,即可。最小二乘法即几次矩阵变换,转置,求逆等,形式比较固定,大家可以网上去查。

      坐标转换

       计算出四参数后,带入模型就可以进行坐标转换了,该模型适合小区域、大比例尺下坐标转换。ArcGIS并不支持四参数转换,需要将Geometry中坐标带入模型逐点转换。

    小结

        二维四参数坐标转换的核心是构造出求解矩阵,然后最小二乘法求解。先写这么多了,后期敬请关注!

     

     

     

     

    展开全文
  • 四参数转换公式为: 根据最小二乘原理,构造条件方程: 设a = mcosa-1, b=msina,有: 等价表达: 其中,,, 解得X后,求m和α:

    四参数的转换公式为:

    \begin{bmatrix} x_{2}\\ y_{2} \end{bmatrix}= \begin{bmatrix} \Delta x\\ \Delta y \end{bmatrix}+ m\begin{bmatrix} cos\alpha &-sin\alpha \\ sin\alpha & cos\alpha \end{bmatrix}\begin{bmatrix} x_{1}\\ y_{1} \end{bmatrix}

    构造条件方程:

    \begin{bmatrix} x_{2}\\ y_{2} \end{bmatrix} - \begin{bmatrix} x_{1}\\ y_{1} \end{bmatrix}= \begin{bmatrix} \Delta x\\ \Delta y \end{bmatrix}+ \begin{bmatrix} mcos\alpha &-msin\alpha \\ msin\alpha & mcos\alpha \end{bmatrix}\begin{bmatrix} x_{1}\\ y_{1} \end{bmatrix}-\begin{bmatrix} 1 &0 \\ 0 & 1 \end{bmatrix}\begin{bmatrix} x_{1}\\ y_{1} \end{bmatrix}\Rightarrow

    \begin{bmatrix} x_{2}\\ y_{2} \end{bmatrix} - \begin{bmatrix} x_{1}\\ y_{1} \end{bmatrix}= \begin{bmatrix} \Delta x\\ \Delta y \end{bmatrix}+ \begin{bmatrix} mcos\alpha -1 &-msin\alpha \\ msin\alpha & mcos\alpha -1\end{bmatrix}\begin{bmatrix} x_{1}\\ y_{1} \end{bmatrix}

    a = mcosa-1, b=msina,有:

    \begin{bmatrix} x_{2}\\ y_{2} \end{bmatrix} - \begin{bmatrix} x_{1}\\y_{1} \end{bmatrix} =\begin{bmatrix} \Delta x\\ \Delta y\ \end{bmatrix} + \begin{bmatrix} a & -b\\ b & a \end{bmatrix}\begin{bmatrix} x_{1}\\ y_{1} \end{bmatrix} \Rightarrow \begin{bmatrix} x_{2}\\ y_{2} \end{bmatrix} - \begin{bmatrix} x_{1}\\y_{1} \end{bmatrix} =\begin{bmatrix} \Delta x\\ \Delta y \end{bmatrix} + \begin{bmatrix} x_{1} & -y_{1}\\ y_{1} & x_{1} \end{bmatrix}\begin{bmatrix} a\\b \end{bmatrix}

    等价表达:

      \begin{bmatrix} x_{2}\\ y_{2} \end{bmatrix} - \begin{bmatrix} x_{1}\\y_{1} \end{bmatrix} = \begin{bmatrix} 1&0&x_{1}&-y_{1}\\0&1&y_{1}&x_{1} \end{bmatrix}\begin{bmatrix} \Delta x \\ \Delta y \\a\\b\end{bmatrix}

    其中,Li=\begin{bmatrix} x_{2i}\\ y_{2i} \end{bmatrix} - \begin{bmatrix} x_{1i}\\y_{1i} \end{bmatrix}Bi=\begin{bmatrix} 1 &0& x_{1i} &-y_{1i} \\ 0 &1 &y_{1i} & x_{1i} \end{bmatrix}X=\begin{bmatrix} \Delta x\\ \Delta y \\ a \\ b\end{bmatrix}

    即:

    L=\begin{bmatrix} x_{21}-x_{11}\\ y_{21} -y_{11}\\...\\ x_{2i}-x_{1i}\\ y_{2i} -y_{1i}\\ ...\\ x_{2n}-x_{1n}\\ y_{2n} -y_{1n} \end{bmatrix},B=\begin{bmatrix} 1 &0& x_{11} &-y_{11} \\ 0 &1 &y_{11} & x_{11} \\ &&... \\ 1 &0& x_{1i} &-y_{1i} \\ 0 &1 &y_{1i} & x_{1i} \\ &&...\\ 1 &0& x_{1n} &-y_{1n} \\ 0 &1 &y_{1n} & x_{1n} \\ \end{bmatrix},X=\begin{bmatrix} \Delta x\\ \Delta y \\ a \\ b\end{bmatrix}P=\begin{bmatrix} 1& 0 &0 &0 \\ 0 & 1 & 0 &0 \\ 0 & 0 & 1&0 \\ 0 &0 &0 & 1 \end{bmatrix}

    根据最小二乘原理计算X:

    X=(B^TPB)^-^1B^TPL

    解得X后,可知ab,可解得m和α:

    \left\{\begin{matrix}a = m\cos \alpha-1\\ b = m\sin \alpha \end{matrix}\right \Rightarrow \left\{\begin{matrix} \sin \alpha/\cos \alpha = b/(a +1) \\ (a+1)^2 + b^2 = m^2(\cos ^2 \alpha +\sin^2 \alpha) \end{matrix}\right. \Rightarrow \left\{\begin{matrix} \alpha = \arctan[b/(a+1)] \\ m = \sqrt{(a+1)^2+b^2} \end{matrix}\right.

    展开全文
  • 2020/6/25 开了此篇博客,用于贴源码(实际上原理博客中的代码已经很全了),这篇博客只是为了方便以后复制 粘贴 一、原理 见于博客: https://blog.csdn.net/Gou_Hailong/article/details/105362474 二、源码 ...

    【日志】
    2020/6/25 开了此篇博客,用于贴源码(实际上原理博客中的代码已经很全了),这篇博客只是为了方便以后复制 粘贴

    一、原理

    见于博客:

    https://blog.csdn.net/Gou_Hailong/article/details/105362474

    二、源码

    源码结构图:
    在这里插入图片描述

    整个源码:

    	class zbTransfer
        {
            /*此函数用于求d的n次方,因为用Math.Pow()太累赘
             */ 
            public static double P(double d, double n)
            {
                return Math.Pow(d, n);
            }
            /*此函数用于求象限角
             */ 
            public static double arctan(double dx, double dy)
            {
                double angle = 0;
                if(dx==0)
                {
                    if(dy>0) angle=Math.PI*0.5;
                    else     angle=Math.PI*1.5;
                    return angle;
                }
                angle = Math.Atan2(Math.Abs(dy), Math.Abs(dx));
                if (dx < 0)
                {
                    if (dy < 0) angle = Math.PI + angle;
                    else        angle = Math.PI - angle;
                }
                else if (dy < 0) angle = 2 * Math.PI - angle;
                return angle;
            }
            /*此函数用于求四参数的近似值,
             * 输入:po=源坐标,pt=目标坐标
             * 输出:
             * 0 尺度因子
             * 1 旋转角度
             * 2 x平移参数
             * 3 y平移参数
             */ 
            public static double[] Get_Four_JS(Point po1, Point po2, Point pt1, Point pt2)
            {
                double[] JS = new double[4];
                double dx = po1.x - po2.x, dy = po1.y - po2.y;
                double dX = pt1.x - pt2.x, dY = pt1.y - pt2.y;
                double s = Math.Sqrt(dx * dx + dy * dy);
                double S = Math.Sqrt(dX * dX + dY * dY);
                double A = arctan(dX, dY);
                double a = arctan(dx, dy);
                JS[0] = s / S;
                JS[1] = A - a;
                JS[2] = pt1.x - po1.x;
                JS[3] = pt1.y - po1.y;
                return JS;
            }
            /* 此函数用于求取平面四参数 用到坐标重心化
              * 输入:po是源坐标,pt是目标坐标
              * 输出:resultMat是结果矩阵数组
              *     第一个矩阵 X      是所求的四参数
              *     第二个矩阵 V      是改正数,可以算内符合精度
              *     第三个矩阵 Sigma2 是验后单位权中误差的平方
              *     第四个矩阵 ZX     是源/目重心[po.x,po,y,pt.x,pt.y]
              */
            public static Matrix[] Get_Four(Point[] po1, Point[] pt1)
            {
                int n = pt1.Length, n1 = po1.Length;
                int r = 2 * n - 4;//多余观测数
                Point[] po = Point.ZXH(po1);//坐标重心化
                Point[] pt = Point.ZXH(pt1);
                double[] JS = Get_Four_JS(po[0], po[n - 1], pt[0], pt[n - 1]);//求近似
                double Dx = JS[2] ,
                    Dy = JS[3],
                    m = JS[0],
                    Sita = JS[1];
                Matrix[] resultMat = new Matrix[4];
                Matrix B = new Matrix(2 * n, 4); ;
                Matrix P = new Matrix(2 * n); P.MakeUnitMatrix(2 * n);//默认权矩阵为单位阵
                Matrix L = new Matrix(2 * n, 1);
                Matrix X1 = new Matrix(4, 1);//参数
                while (true)
                {
                    for (int i = 0; i < n; i++)
                    {//根据近似参数求观测值
                        double a = Math.Cos(Sita) * po[i].x + Math.Sin(Sita) * po[i].y,
                            b = -Math.Sin(Sita) * po[i].x + Math.Cos(Sita) * po[i].y,
                            X = Dx + a * m,
                            Y = Dy - b * m;
                        B[2 * i, 0] = 1;
                        B[2 * i, 1] = 0;
                        B[2 * i, 2] = a;
                        B[2 * i, 3] = b * m;
                        B[2 * i + 1, 0] = 0;
                        B[2 * i + 1, 1] = 1;
                        B[2 * i + 1, 2] = b;
                        B[2 * i + 1, 3] = -a * m;
                        L[2 * i, 0] = pt[i].x - X;
                        L[2 * i + 1, 0] = pt[i].y - Y;
                    }
                    Matrix Nbb = B.Transpose() * P * B;
                    Nbb.InvertGaussJordan();
                    X1 = Nbb * B.Transpose() * P * L;
                    X1.Eps = 1e-6;
                    if (X1.Equals(0))
                        break;
                    Dx += X1[0, 0];
                    Dy += X1[1, 0];
                    m += X1[2, 0];
                    Sita += X1[3, 0];
                }           
                Matrix V = B * X1 - L;
                Matrix Sigma2 = V.Transpose() * P * V;//验后单位权中误差
                Sigma2[0, 0] /= r;
    
                Matrix ZX = new Matrix(4, 1);//重心矩阵
                ZX[0, 0] = po[n1].x; ZX[1, 0] = po[n1].y;
                ZX[2, 0] = pt[n].x; ZX[3, 0] = pt[n].y;
    
                resultMat[0] = X1;
                resultMat[1] = V;
                resultMat[2] = Sigma2;
                resultMat[3] = ZX;
                return resultMat;
            }
            /* 此函数用于求取平面四参数 未用到坐标重心化,实际上是舍去了正形变换的高阶项
              * 输入:po是源坐标,pt是目标坐标,可选参数n 取前n(>=2)点平差
              * 输出:resultMat是结果矩阵数组
              *     第一个矩阵 X      是所求的四参数
              *     第二个矩阵 V      是改正数,可以算内符合精度
              *     第三个矩阵 Sigma2 是验后单位权中误差的平方
              */
            public static Matrix[] Get_Four1(Point[] po, Point[] pt,int n=0)
            {
                if(n==0) n = pt.Length;
                int r = 2 * n - 4;//多余观测数
                Matrix[] resultMat = new Matrix[3];
                Matrix B = new Matrix(2 * n, 4); ;
                Matrix P = new Matrix(2 * n); P.MakeUnitMatrix(2 * n);//默认权矩阵为单位阵
                Matrix L = new Matrix(2 * n, 1);
                Matrix X = new Matrix(4, 1);//参数
                for (int i = 0; i < n; i++)
                {
                    double x = po[i].x, y = po[i].y;
                    double x1 = pt[i].x, y1 = pt[i].y;
                    B[2 * i, 0] = 1;
                    B[2 * i, 1] = 0;
                    B[2 * i, 2] = x;
                    B[2 * i, 3] = -y;
                    B[2 * i + 1, 0] = 0;
                    B[2 * i + 1, 1] = 1;
                    B[2 * i + 1, 2] = y;
                    B[2 * i + 1, 3] = x;
                    L[2 * i, 0] = x1;
                    L[2 * i + 1, 0] = y1;
                }
                
                Matrix Nbb = B.Transpose() * P * B;
                Nbb.InvertGaussJordan();
                X = Nbb * B.Transpose() * P * L;
                Matrix V = B * X - L;
                Matrix Sigma2 = V.Transpose() * P * V;//验后单位权中误差
                if (r != 0) Sigma2[0, 0] /= r;
                else Sigma2[0, 0] = 0;
    
                resultMat[0] = X;
                resultMat[1] = V;
                resultMat[2] = Sigma2;
                return resultMat;
            }
            /* 此函数用于四参数坐标转换,对应函数为 Get_Four1
              * 输入:po是源坐标; M 是用四参数求取函数得到的矩阵数组
              * 输出:pt是目标坐标
              */
            public static Point[] zbTrans4(Point[] po, Matrix[] M)
            {
                int n=po.Length;
                Point[] pt = new Point[n];
                Matrix X = M[0];
                Matrix B = new Matrix(2, 4);
                Matrix Pt;
                for (int i = 0; i < n; i++)
                {
                    double x = po[i].x, y = po[i].y;
                    B[0, 0] = 1;
                    B[0, 1] = 0;
                    B[0, 2] = x;
                    B[0, 3] = -y;
                    B[1, 0] = 0;
                    B[1, 1] = 1;
                    B[1, 2] = y;
                    B[1, 3] = x;
                    Pt = B * X;
                    pt[i] = new Point(Pt[0, 0], Pt[1, 0]);
                }
                return pt;
            }
            /* 此函数用正形变换求取平面四参数 用到坐标重心化
              * 输入:po是源坐标,pt是目标坐标
              * 输出:resultMat是结果矩阵数组
              *     第一个矩阵 X      是所求的参数
              *     第二个矩阵 V      是改正数,可以算内符合精度
              *     第三个矩阵 Sigma2 是验后单位权中误差的平方
              *     第四个矩阵 ZX     是源/目重心[po.x,po,y,pt.x,pt.y]
              */
            public static Matrix[] Get_Four_ZX(Point[] po1, Point[] pt1)
            {
                int n = pt1.Length, n1 = po1.Length;
                Point[] po = Point.ZXH(po1);//坐标重心化
                Point[] pt = Point.ZXH(pt1);
                int r = 2 * n - 10;//冗余度
                Matrix[] resultMat = new Matrix[4];
    
                Matrix[] JS = Get_Four1(po, pt, 2); Matrix C = JS[0];
                double p0 = C[0, 0],//前四个参数的近似值
                    q0 = C[1, 0],
                    p1 = C[2, 0],
                    q1 = C[3, 0];
                Matrix B = new Matrix(2 * n, 10);
                Matrix L = new Matrix(2 * n, 1);
                for (int i = 0; i < n; i++)
                {
                    double x = po[i].x, y = po[i].y;
                    double x1 = pt[i].x, y1 = pt[i].y;
                    B[2 * i, 0] = 1;
                    B[2 * i, 1] = 0;
                    B[2 * i, 2] = x;
                    B[2 * i, 3] = -y;
                    B[2 * i, 4] = P(x, 2) - P(y, 2);
                    B[2 * i, 5] = -2 * x * y;
                    B[2 * i, 6] = P(x, 3) - 3 * x * P(y, 2);
                    B[2 * i, 7] = P(y, 3) - 3 * P(x, 2) * y;
                    B[2 * i, 8] = P(x, 4) - 6 * P(x, 2) * P(y, 2) + P(y, 4);
                    B[2 * i, 9] = 4 * x * P(y, 3) - 4 * P(x, 3) * y;
                    B[2 * i + 1, 0] = 0;
                    B[2 * i + 1, 1] = 1;
                    B[2 * i + 1, 2] = y;
                    B[2 * i + 1, 3] = x;
                    B[2 * i + 1, 4] = 2 * x * y;
                    B[2 * i + 1, 5] = P(x, 2) - P(y, 2);
                    B[2 * i + 1, 6] = 3 * P(x, 2) * y - P(y, 3);
                    B[2 * i + 1, 7] = P(x, 3) - 3 * x * P(y, 2);
                    B[2 * i + 1, 8] = 4 * P(x, 3) * y - 4 * x * P(y, 3);
                    B[2 * i + 1, 9] = P(x, 4) - 6 * P(x, 2) * P(y, 2) + P(y, 4);
                    L[2 * i, 0] = x1 - p0 - x * p1 + y * q1;
                    L[2 * i + 1, 0] = y1 - q0 - y * p1 - x * q1;
                }
                Matrix Nbb = B.Transpose() * B;
                Nbb.InvertGaussJordan();
                Matrix X = Nbb * B.Transpose() * L;
                Matrix Xp = X;
                while (true)
                {
                    p0 += X[0, 0];
                    q0 += X[1, 0];
                    p1 += X[2, 0];
                    q1 += X[3, 0];
                    for (int i = 0; i < n; i++)
                    {
                        double x = po[i].x, y = po[i].y;
                        double x1 = pt[i].x, y1 = pt[i].y;
                        L[2 * i, 0] = x1 - p0 - x * p1 + y * q1;
                        L[2 * i + 1, 0] = y1 - q0 - y * p1 - x * q1;
                    }
                    X = Nbb * B.Transpose() * L;
                    X.Eps = 1e-6;
                    if (X.Equals(Xp)) break;
                    Xp = X;
                }
                Matrix V = B * X - L;
                X[0,0]+=p0;
                X[1,0]+=q0;
                X[2,0]+=p1;
                X[3,0]+=q1;
                Matrix ZX=new Matrix(4,1);//重心矩阵
                ZX[0,0]=po[n1].x; ZX[1,0]=po[n1].y;
                ZX[2,0]=pt[n].x; ZX[3,0]=pt[n].y;
    
                Matrix Sigma2 = V.Transpose() * V;//延后单位权中误差
                if (r != 0) Sigma2[0, 0] /= r;
                else Sigma2[0, 0] = 0;
                resultMat[0] = X;
                resultMat[1] = V;
                resultMat[2] = Sigma2;
                resultMat[3] = ZX;
                return resultMat;
            }
            /* 此函数用于平面坐标转换,对应函数为 Get_Four_ZX
              * 输入:po是源坐标; M 是用正形参数求取函数得到的矩阵数组
              * 输出:pt是目标坐标
              */
            public static Point[] zbTrans_ZX(Point[] po, Matrix[] M)
            {
                int n=po.Length;
                Point[] pt = new Point[n];
                Matrix X = M[0];
                Matrix ZX=M[3];
                Matrix B = new Matrix(2, 10);
                Matrix Pt;
                Point po_ZX = new Point(ZX[0, 0], ZX[1, 0]);
                Point pt_ZX = new Point(ZX[2, 0], ZX[3, 0]);
                for (int j = 0; j < n; j++)
                {
                    int i = 0;
                    double x = po[j].x - po_ZX.x, y = po[j].y - po_ZX.y;
                    B[2 * i, 0] = 1;
                    B[2 * i, 1] = 0;
                    B[2 * i, 2] = x;
                    B[2 * i, 3] = -y;
                    B[2 * i, 4] = P(x, 2) - P(y, 2);
                    B[2 * i, 5] = -2 * x * y;
                    B[2 * i, 6] = P(x, 3) - 3 * x * P(y, 2);
                    B[2 * i, 7] = P(y, 3) - 3 * P(x, 2) * y;
                    B[2 * i, 8] = P(x, 4) - 6 * P(x, 2) * P(y, 2) + P(y, 4);
                    B[2 * i, 9] = 4 * x * P(y, 3) - 4 * P(x, 3) * y;
                    B[2 * i + 1, 0] = 0;
                    B[2 * i + 1, 1] = 1;
                    B[2 * i + 1, 2] = y;
                    B[2 * i + 1, 3] = x;
                    B[2 * i + 1, 4] = 2 * x * y;
                    B[2 * i + 1, 5] = P(x, 2) - P(y, 2);
                    B[2 * i + 1, 6] = 3 * P(x, 2) * y - P(y, 3);
                    B[2 * i + 1, 7] = P(x, 3) - 3 * x * P(y, 2);
                    B[2 * i + 1, 8] = 4 * P(x, 3) * y - 4 * x * P(y, 3);
                    B[2 * i + 1, 9] = P(x, 4) - 6 * P(x, 2) * P(y, 2) + P(y, 4);
                    Pt = B * X;
                    pt[j] = new Point(Pt[0, 0]+pt_ZX.x, Pt[1, 0]+pt_ZX.y);
                }
                return pt;
            }
    
            /* 此函数用于求取空间面七参数 未用到坐标重心化
              * 输入:po是源坐标,pt是目标坐标
              * 输出:resultMat是结果矩阵数组
              *     第一个矩阵 X      是所求的七参数
              *     第二个矩阵 V      是改正数,可以算内符合精度
              *     第三个矩阵 Sigma2 是验后单位权中误差的平方
              */
            public static Matrix[] Get_Seven(Point[] po, Point[] pt)
            {
                int n = pt.Length;
                int r = 3 * n - 7;//多余观测数
                Matrix[] resultMat = new Matrix[3];
                Matrix B = new Matrix(3 * n, 7);
                Matrix L = new Matrix(3 * n, 1);
                for (int i = 0; i < n; i++)
                {
                    B[3 * i, 0] = 1;
                    B[3 * i, 1] = 0;
                    B[3 * i, 2] = 0;
                    B[3 * i, 3] = 0;
                    B[3 * i, 4] = -po[i].z;
                    B[3 * i, 5] = po[i].y;
                    B[3 * i, 6] = po[i].x;
                    B[3 * i + 1, 0] = 0;
                    B[3 * i + 1, 1] = 1;
                    B[3 * i + 1, 2] = 0;
                    B[3 * i + 1, 3] = po[i].z;
                    B[3 * i + 1, 4] = 0;
                    B[3 * i + 1, 5] = -po[i].x;
                    B[3 * i + 1, 6] = po[i].y;
                    B[3 * i + 2, 0] = 0;
                    B[3 * i + 2, 1] = 0;
                    B[3 * i + 2, 2] = 1;
                    B[3 * i + 2, 3] = -po[i].y;
                    B[3 * i + 2, 4] = po[i].x;
                    B[3 * i + 2, 5] = 0;
                    B[3 * i + 2, 6] = po[i].z;
                    L[3 * i, 0] = pt[i].x;
                    L[3 * i + 1, 0] = pt[i].y;
                    L[3 * i + 2, 0] = pt[i].z;
                }
                Matrix Nbb = B.Transpose() * B;
                Nbb.InvertGaussJordan();
                Matrix X = Nbb * B.Transpose() * L;
                Matrix V = B * X - L;
                Matrix Sigma2 = V.Transpose() * V;//验后单位权中误差
                resultMat[0] = X;
                resultMat[1] = V;
                resultMat[2] = Sigma2;
                return resultMat;            
            }
            /* 此函数用于七参数坐标转换,对应函数为 Get_Seven
              * 输入:po是源坐标; M 是用七参数求取函数得到的矩阵数组
              * 输出:pt是目标坐标
              */
            public static Point[] zbTrans7(Point[] po, Matrix[] M)
            {
                int n=po.Length;
                Point[] pt = new Point[n];
                Matrix X = M[0];
                Matrix B = new Matrix(3, 7);
                Matrix Pt;
                for (int i = 0; i < n; i++)
                {
                    B[0, 0] = 1;
                    B[0, 1] = 0;
                    B[0, 2] = 0;
                    B[0, 3] = 0;
                    B[0, 4] = -po[i].z;
                    B[0, 5] = po[i].y;
                    B[0, 6] = po[i].x;
                    B[0 + 1, 0] = 0;
                    B[0 + 1, 1] = 1;
                    B[1, 2] = 0;
                    B[1, 3] = po[i].z;
                    B[1, 4] = 0;
                    B[1, 5] = -po[i].x;
                    B[1, 6] = po[i].y;
                    B[2, 0] = 0;
                    B[2, 1] = 0;
                    B[2, 2] = 1;
                    B[2, 3] = -po[i].y;
                    B[2, 4] = po[i].x;
                    B[2, 5] = 0;
                    B[2, 6] = po[i].z;
                    Pt = B * X;
                    pt[i] = new Point(Pt[0, 0], Pt[1, 0], Pt[2, 0]);
                }
                return pt;
            }
            /* 此函数用于求取空间六参数 未用到坐标重心化
              * 输入:po是源坐标,pt是目标坐标
              * 输出:resultMat是结果矩阵数组
              *     第一个矩阵 X      是所求的六参数
              *     第二个矩阵 V      是改正数,可以算内符合精度
              *     第三个矩阵 Sigma2 是验后单位权中误差的平方
              */
            public static Matrix[] Get_Six2(Point[] po, Point[] pt)
            {
                int n = pt.Length;
                int r = 3 * n - 6;//多余观测数
                Matrix[] resultMat = new Matrix[3];
                Matrix B = new Matrix(3 * n, 6);
                Matrix L = new Matrix(3 * n, 1);
                for (int i = 0; i < n; i++)
                {
                    B[3 * i, 0] = 1;
                    B[3 * i, 1] = 0;
                    B[3 * i, 2] = 0;
                    B[3 * i, 3] = 0;
                    B[3 * i, 4] = -po[i].z;
                    B[3 * i, 5] = po[i].y;
                    B[3 * i + 1, 0] = 0;
                    B[3 * i + 1, 1] = 1;
                    B[3 * i + 1, 2] = 0;
                    B[3 * i + 1, 3] = po[i].z;
                    B[3 * i + 1, 4] = 0;
                    B[3 * i + 1, 5] = -po[i].x;
                    B[3 * i + 2, 0] = 0;
                    B[3 * i + 2, 1] = 0;
                    B[3 * i + 2, 2] = 1;
                    B[3 * i + 2, 3] = -po[i].y;
                    B[3 * i + 2, 4] = po[i].x;
                    B[3 * i + 2, 5] = 0;
                    L[3 * i, 0] = pt[i].x - po[i].x;
                    L[1, 0] = pt[i].y - po[i].y;
                    L[2, 0] = pt[i].z - po[i].z;
                }
                Matrix Nbb = B.Transpose() * B;
                Nbb.InvertGaussJordan();
                Matrix X = Nbb * B.Transpose() * L;
                Matrix V = B * X - L;
                Matrix Sigma2 = V.Transpose() * V;//验后单位权中误差
                resultMat[0] = X;
                resultMat[1] = V;
                resultMat[2] = Sigma2;
                return resultMat; 
            }
        }
    

    其所依附的类有:

    点类:https://blog.csdn.net/Gou_Hailong/article/details/88989274
    矩阵类:https://blog.csdn.net/Gou_Hailong/article/details/98451032

    三、使用示例

    			string fp41 = @"4_目标坐标.txt";
                string fp42 = @"4_源坐标.txt";
                string fp71 = @"7_目标坐标.txt";
                string fp72 = @"7_源坐标.txt";
                Point[] pt41 = Read.T2Po(fp41, 1);
                Point[] pt42 = Read.T2Po(fp42, 1);
                Point[] pt71 = Read.T2Po(fp71, 1);
                Point[] pt72 = Read.T2Po(fp72, 1);
                Matrix[] M1 = zbTransfer.Get_Four1(pt42, pt41);
                Point[] pt1 = zbTransfer.zbTrans4(pt42, M1);
                Matrix[] M2 = zbTransfer.Get_Four_ZX(pt42, pt41);
                Point[] pt2 = zbTransfer.zbTrans_ZX(pt42, M2);
                Matrix[] M3 = zbTransfer.Get_Seven(pt72, pt71);
                Point[] pt3 = zbTransfer.zbTrans7(pt72, M3);
                Console.WriteLine("4 源坐标  目标坐标  4参数转换回来的坐标  正形转换回来的坐标");
                for (int i = 0; i < 3; i++)
                {           
                    pt42[i].show();
                    pt41[i].show();
                    pt1[i].show();
                    pt2[i].show();
                    Console.WriteLine();
                }
                Console.WriteLine(); Console.WriteLine();
                for (int i = 0; i < 3; i++)
                {
                    Console.WriteLine("7 源坐标  目标坐标  7参数转换回来的坐标");
                    pt72[i].show();
                    pt71[i].show();
                    pt3[i].show();
                    Console.WriteLine();
                }
    
                Console.Read();
    

    实验数据:
    1、4_目标坐标.txt

    C001	21931.9510	117563.2290
    C002	20258.3930	157719.6140
    C003	27506.2170	96237.6310
    C004	43210.8240	101659.4900
    C005	40794.8930	96636.5750
    C006	46285.3610	99141.3600
    

    2、4_源坐标.txt

    C001	2496657.8200	508202.6170
    C002	2495670.3700	548381.3700
    C003	2501866.9930	486785.1140
    C004	2517661.7700	491937.9080
    C005	2515160.4250	486957.0340
    C006	2520692.8250	489367.6570
    C007	2505545.9250	510742.4980
    C008	2516906.7870	511422.9130
    C009	2524169.6050	522970.7390
    C010	2490588.8900	505566.3760
    

    3、7_目标坐标.txt

    GPS04	-1964642.8359	4484908.5860	4075486.8981
    GPS30	-1967082.7160	4490541.6460	4068048.1509
    GPS18	-1958106.3701	4482074.1789	4082054.3211
    GPS22	-1958396.9949	4485396.4450	  4077966.2971
    GPS27	-1953364.4591	4481502.6550	4084942.2649
    GPS26	-1957928.7551	4492765.3050	4070011.5630
    

    4、7_源坐标.txt

    GPS04	-1964734.9635	4484768.5466	4075386.7697
    GPS30	-1967174.8023	4490401.5079	4067948.1663
    GPS18	-1958198.6099	4481934.1931	4081954.0888
    GPS22	-1958489.2289	4485256.3985	4077866.1343
    GPS27	-1953456.7885	4481362.6794	4084841.9629
    GPS26	-1958020.9950	4492625.1514	4069911.5369
    

    结果:

    Reading Point.txt...
    Reading Point.txt Over!
    Reading Point.txt...
    Reading Point.txt Over!
    Reading Point.txt...
    Reading Point.txt Over!
    Reading Point.txt...
    Reading Point.txt Over!
    4 源坐标  目标坐标  4参数转换回来的坐标  正形转换回来的坐标
    X 2496657.820,   Y 508202.617,   Z 0.000,   Name C001
    X 21931.951,   Y 117563.229,   Z 0.000,   Name C001
    X 21931.952,   Y 117563.229,   Z 0.000,   Name 0
    X 21931.951,   Y 117563.229,   Z 0.000,   Name 0
    
    X 2495670.370,   Y 548381.370,   Z 0.000,   Name C002
    X 20258.393,   Y 157719.614,   Z 0.000,   Name C002
    X 20258.393,   Y 157719.614,   Z 0.000,   Name 0
    X 20258.393,   Y 157719.614,   Z 0.000,   Name 0
    
    X 2501866.993,   Y 486785.114,   Z 0.000,   Name C003
    X 27506.217,   Y 96237.631,   Z 0.000,   Name C003
    X 27506.217,   Y 96237.630,   Z 0.000,   Name 0
    X 27506.217,   Y 96237.631,   Z 0.000,   Name 0
    
    
    
    7 源坐标  目标坐标  7参数转换回来的坐标
    X -1964734.964,   Y 4484768.547,   Z 4075386.770,   Name GPS04
    X -1964642.836,   Y 4484908.586,   Z 4075486.898,   Name GPS04
    X -1964642.838,   Y 4484908.584,   Z 4075486.895,   Name 0
    
    7 源坐标  目标坐标  7参数转换回来的坐标
    X -1967174.802,   Y 4490401.508,   Z 4067948.166,   Name GPS30
    X -1967082.716,   Y 4490541.646,   Z 4068048.151,   Name GPS30
    X -1967082.717,   Y 4490541.639,   Z 4068048.157,   Name 0
    
    7 源坐标  目标坐标  7参数转换回来的坐标
    X -1958198.610,   Y 4481934.193,   Z 4081954.089,   Name GPS18
    X -1958106.370,   Y 4482074.179,   Z 4082054.321,   Name GPS18
    X -1958106.370,   Y 4482074.181,   Z 4082054.330,   Name 0
    
    展开全文
  • 功能:根据相似变换原理利用四参数(赫尔默特法)转换两个平面坐标系。 1、数学模型: 采用最小二乘法建立平面坐标系统转换公式(参见《浙江测绘》2002(1)吉渊明“采用最小二乘法建立平面坐标系统转换公式”)
  • 根据不同参考椭球和相同参考椭球的坐标转换原理,论述了利用VC++编制不同坐标系统转换和坐标换带软件编制过程的关键技术、软件功能,利用VC++语言定义了相应的结构体和不同的类,实现了不同参考椭球情况下七参数、...
  • GIS 四参数 七参数

    千次阅读 2015-08-27 17:25:25
    四参数,对两个不同的二维平面直角坐标系进行转换,有四个未知参数。 七参数,对两个不同的三维空间直角坐标系进行转换,有七个未知参数。 以下链接对四参数和七参数有一个易懂的描述: 测绘里面的四参数和七参数...
  • 车载终端使用四参数模型将WGS-84坐标转换成当地坐标,同时结合航位推算技术实现组合定位导航。系统在现有基础上改进监控中心平台功能,实现整体功能配置更加合理。最后结合银行运钞车对该系统应用加以说明,并进行...
  • GPS测量原理及应用 知识总结

    千次阅读 多人点赞 2019-12-21 14:33:16
    GPS GPS 第一章 1. 北斗的优势及应用 ...3. 坐标系统之间的转换 4. 时间系统 判断 第三章 1. 卫星的无赦运动,确定开普勒轨道方程,要知道参数 2. GPS卫星星历 第章 1. GPS卫星的导航电文 2. GPS信号...
  • RT矩阵变换,属于刚体转换,旋转矩阵具体分为世界坐标系如何分别绕x,y,z三个轴旋转多少度后坐标系方向与摄像机坐标系一致,平移矩阵则对应世界坐标系原点需如何平移至相机坐标系原点.opencv标定后每图的旋转/平移参数都...
  • 标定相机参数的实现(Python+Opencv)

    千次阅读 2020-04-07 17:01:32
    文章目录一、相机标定原理二、张正友标定法简介三、标定流程、标定板的制作五、 实现相机标定5.1实现代码5.2实现结果六、 实验小结 一、相机标定原理 现实生活中的物体都处于三维世界坐标系中,当我们的照相机进行...
  • 相机标定理论及matlab实现

    千次阅读 2020-07-28 20:57:02
    为了介绍相机标定技术及原理,定量地描述相机成像过程,需要引入坐标系,而相机标定的实质即是求解各个坐标系之间的转换关系。 像素坐标系 相机采集到的图像通过模数转换和离散采样之后得到数字图像。每一幅...
  • 棋盘格标定

    千次阅读 2020-04-07 21:52:04
    一、原理二、相机参数2.1计算单应性矩阵H2.2计算内参数矩阵2.3计算外参数矩阵三、代码及实现3.1代码3.2图片集3.3结果展示、出现的错误及解决 一、原理 相机标定是我们相机拍摄的物体都处于三维世界坐标系中,而...
  • 第一次看到“逆向工程”这个词是在2001年的《机械工程学报》上的一篇文章中,主要是讲用三坐标测量仪测量产品中各个部件的三维尺寸并在计算机中快速建模、进而反推其设计思想和基本设计原则。第一次使用逆向工程工具...
  • 7.1.3 色彩和坐标 199 7.2 绘制图形 201 7.2.1 画笔和画刷 209 7.2.2 绘制像素点 212 7.2.3 绘制图形 212 7.2.4 绘图模式 217 7.3 创建和使用位图 218 7.3.1 一个使用位图的时钟例子 218 7.3.2 创建和使用位图 229 ...
  • 7.1.3 色彩和坐标 199 7.2 绘制图形 201 7.2.1 画笔和画刷 209 7.2.2 绘制像素点 212 7.2.3 绘制图形 212 7.2.4 绘图模式 217 7.3 创建和使用位图 218 7.3.1 一个使用位图的时钟例子 218 7.3.2 创建和使用位图 229 ...
  • 7.1.3 色彩和坐标 199 7.2 绘制图形 201 7.2.1 画笔和画刷 209 7.2.2 绘制像素点 212 7.2.3 绘制图形 212 7.2.4 绘图模式 217 7.3 创建和使用位图 218 7.3.1 一个使用位图的时钟例子 218 7.3.2 创建和使用位图 229 ...
  • 输出上也变了,不再是直线参数的,这个函数输出的直接就是直线点的坐标位置,这样可以省去一系列for循环中的由参数空间到图像的实际坐标点的转换。 api指令: cv2.HoughLinesP(dst, lines, 1, CV_PI/180, 50, ...
  • 精通DirectX.3D图形与动画程序设计.pdf

    热门讨论 2013-02-17 16:40:18
    第二部分介绍了direct3d程序设计的相关高级技术,包括多层纹理映射、纹理坐标自动生成与变换、环境映射、凹凸纹理映射、立体纹理、纹理压缩、.x文件格式分析、网格模型优化、层次细节网格模型、增强网格模型、蒙皮...
  • 3.3.2 主流gpu的性能参数比较 103 3.4 本章小结 104 第4章 着色语言shading language 105 4.1 着色语言概述 105 4.2 着色语言基础 106 4.2.1 数据类型概述 106 4.2.2 数据类型的基本使用 110 ...
  • 部分 实用技术篇 第24章 DXUT控件 24.1 DXUT控件介绍 24.2 DXUT控件使用示例程序 24.3 小结 第25章 广告板技术与十字交叉纹理 25.1 广告板技术 25.1.1 广告板技术介绍 25.1.2 广告板技术示例程序 25.2 十字...
  • 部分 实用技术篇 第24章 DXUT控件 24.1 DXUT控件介绍 24.2 DXUT控件使用示例程序 24.3 小结 第25章 广告板技术与十字交叉纹理 25.1 广告板技术 25.1.1 广告板技术介绍 25.1.2 广告板技术示例程序 25.2 十字...
  • 部分 实用技术篇 第24章 DXUT控件 24.1 DXUT控件介绍 24.2 DXUT控件使用示例程序 24.3 小结 第25章 广告板技术与十字交叉纹理 25.1 广告板技术 25.1.1 广告板技术介绍 25.1.2 广告板技术示例程序 25.2 十字...
  • 《Android自定义组件开发详解》

    千次下载 热门讨论 2016-02-27 14:24:23
    3.3 坐标转换 69 3.4 剪切区(Clip) 73 3.5 案例:指针走动的手表 82 3.6 练习作业 88 第章 双缓存技术 89 4.1 双缓存 89 4.2 在屏幕上绘制曲线 90 4.3 在屏幕上绘制矩形 99 4.4 案例:绘图App 104 4.4.1 绘图...
  • 格式、线型或点型的设置、颜色的设置、文本的添加及输入(含标题、特殊文本等)、坐标的设置; 2、子图的意义及用法; 3、了解其它绘图函数的特点及使用。 第章 MatLab的程序设计 1、掌握MatLab两种M文件的特点、...
  • 类的编写与应用,构造与析构函数,函数的重载,类的继承,函数覆盖,基类与派生类的构造函数、析构函数先后调用顺序,如何在派生类构造函数中向基类的构造函数传递参数,this成员变量,类型转换的内幕,虚拟函数与...
  • 课程分个大章节 初级篇,中级篇,进阶篇,高级篇 初级篇内容:编写一个完整的,简单的外挂 C++的数据类型:Byte,Word,DWORD,int,float API函数的调mouse_event,GetWindowRect,SetCursorPos,FindWindow,...
  • 1.1.2 机电能量转换 1.1.3 电磁转矩的生成 1.1.4 电磁转矩的控制 1.2 直、交流电机的电磁转矩 1.2.1 直流电机的电磁转矩 1.2.2 三相同步电机的电磁转矩 1.2.3 三相感应电机的电磁转矩 1.3 空间矢量 ...

空空如也

空空如也

1 2 3 4
收藏数 71
精华内容 28
关键字:

四参数坐标转换原理