wgs84坐标系转化为中国大地坐标CGCS2000 / 3-degree Gauss-Kruger CM 120E

最新推荐文章于 2024-06-06 21:30:00 发布
最新推荐文章于 2024-06-06 21:30:00 发布
阅读量3.9k 收藏 18
点赞数
分类专栏： 坐标系 文章标签： r语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k0307x1990y/article/details/121035475
版权

gps角分秒格式经纬度转double经纬度：getPosition方法

 

private static String getPosition(String position){
        String[] degree = position.split("\\°");
        if(degree.length == 1){
            return position;
        }
        String d = degree[0];
        String[] one = degree[1].split("\\′");
        String a = one[0];
        if(!a.contains(".")){
            if(a.substring(0,1).equals("0")){
                a = a.substring(1);
            }
        }else if(a.contains(".") && a.split("\\.").length > 1){
            a = a.substring(1);
        }
        String[] two = one[1].split("\\″");
        String b= two[0];
        if(!b.contains(".")){
            if(b.substring(0,1).equals("0")){
                b = b.substring(1);
            }
        }else if(b.contains(".") && b.split("\\.").length > 1){
            if(b.substring(0,1).equals("0")){
                b = b.substring(1);
            }
        }
        BigDecimal fen = new BigDecimal(a);
        BigDecimal miao = new BigDecimal(b);
        BigDecimal du = new BigDecimal(d);
//		float f = Float.valueOf(a)+ Float.valueOf(Float.valueOf(b)/60);
//		float du = Float.valueOf(f/60)+Float.valueOf(d);
        BigDecimal add = fen.add(miao.divide(new BigDecimal("60"),6, BigDecimal.ROUND_HALF_UP)).divide(new BigDecimal("60"),6, BigDecimal.ROUND_HALF_UP).add(du);
        return String.valueOf(add);
    }

wgs84转CGCS2000 / 3-degree Gauss-Kruger CM 120E方法：getXY

/**
     *
     * @param B 纬度
     * @param L  经度
     * @param degree 角度
     * @return
     */
    public  static String getXY(double B, double L, double degree) {
        double[] xy = new double[]{0.0D, 0.0D};
        double a = 6378137.0D;
        double b = 6356752.314245179D;
        double e = 0.081819190842621D;
        double eC = 0.0820944379496957D;
        double L0 = 0.0D;
        int n;
        if (degree == 6.0D) {
            n = (int)Math.round((L + degree / (double)2) / degree);
            L0 = degree * (double)n - degree / (double)2;
        } else {
            n = (int)Math.round(L / degree);
            L0 = degree * (double)n;
        }

        double radB = B * 3.141592653589793D / (double)180;
        double radL = L * 3.141592653589793D / (double)180;
        double deltaL = (L - L0) * 3.141592653589793D / (double)180;
        double N = a * a / b / Math.sqrt((double)1 + eC * eC * Math.cos(radB) * Math.cos(radB));
        double C1 = 1.0D + 0.75D * e * e + 0.703125D * Math.pow(e, 4.0D) + 0.68359375D * Math.pow(e, 6.0D) + 0.67291259765625D * Math.pow(e, 8.0D);
        double C2 = 0.75D * e * e + 0.9375D * Math.pow(e, 4.0D) + 1.025390625D * Math.pow(e, 6.0D) + 1.07666015625D * Math.pow(e, 8.0D);
        double C3 = 0.234375D * Math.pow(e, 4.0D) + 0.41015625D * Math.pow(e, 6.0D) + 0.538330078125D * Math.pow(e, 8.0D);
        double C4 = 0.068359375D * Math.pow(e, 6.0D) + 0.15380859375D * Math.pow(e, 8.0D);
        double C5 = 0.00240325927734375D * Math.pow(e, 8.0D);
        double t = Math.tan(radB);
        double eta = eC * Math.cos(radB);
        double X = a * ((double)1 - e * e) * (C1 * radB - C2 * Math.sin((double)2 * radB) / (double)2 + C3 * Math.sin((double)4 * radB) / (double)4 - C4 * Math.sin((double)6 * radB) / (double)6 + C5 * Math.sin((double)8 * radB));
        xy[0] = X + N * Math.sin(radB) * Math.cos(radB) * Math.pow(deltaL, 2.0D) * ((double)1 + Math.pow(deltaL * Math.cos(radB), 2.0D) * ((double)5 - t * t + (double)9 * eta * eta + (double)4 * Math.pow(eta, 4.0D)) / (double)12 + Math.pow(deltaL * Math.cos(radB), 4.0D) * ((double)61 - (double)58 * t * t + Math.pow(t, 4.0D)) / (double)360) / (double)2;
        xy[1] = N * deltaL * Math.cos(radB) * ((double)1 + Math.pow(deltaL * Math.cos(radB), 2.0D) * ((double)1 - t * t + eta * eta) / (double)6 + Math.pow(deltaL * Math.cos(radB), 4.0D) * ((double)5 - (double)18 * t * t + Math.pow(t, 4.0D) - (double)14 * eta * eta - (double)58 * eta * eta * t * t) / (double)120) + (double)500000;
        return "纬度Y:"+xy[0]+"---经度X"+xy[1];
    }

测试代码:

public static void main(String[] args) {
        //度分秒格式坐标转double格式
        double x = Double.parseDouble(getPosition("119°40′07.673544″"));
        double y = Double.parseDouble(getPosition("32°11′26.493186″"));
        System.out.println(x);
        System.out.println(y);
        //wgs84转大地2000
        System.out.println(GetXY(y,x,3.0));
    }

打印信息：

下面再附上中国大地坐标CGCS2000 / 3-degree Gauss-Kruger CM 120E坐标系转化为wgs84：

package com.example.androiddaggerstudy.lat;
import org.jetbrains.annotations.NotNull;
import kotlin.jvm.internal.Intrinsics;
/**
 * 版权：渤海新能 版权所有
 *
 * @author feiWang
 * 版本：1.5
 * 创建日期：2020/10/16
 * 描述：AndroidDaggerStudy
 * E-mail : 1276998208@qq.com
 * CSDN:https://blog.csdn.net/m0_37667770/article
 * GitHub:https://github.com/luhenchang
 */
public class JavaRtkUtils {
    private  double p = 206264.80624709636D;
    @NotNull
    public  Tuple xyTowgs84(double x, double y, double L0) {
        double a = 6378137.0D;
        double efang = 0.0066943799901413D;
        double e2fang = 0.0067394967422764D;
        y = y - (double)500000;
        double m0 = 0.0D;
        double m2 = 0.0D;
        double m4 = 0.0D;
        double m6 = 0.0D;
        double m8 = 0.0D;
        m0 = a * ((double)1 - efang);
        m2 = 1.5D * efang * m0;
        m4 = efang * m2 * 5.0D / 4.0D;
        m6 = efang * m4 * 7.0D / 6.0D;
        m8 = efang * m6 * 9.0D / 8.0D;
        double a0 = 0.0D;
        double a2 = 0.0D;
        double a4 = 0.0D;
        double a6 = 0.0D;
        double a8 = 0.0D;
        a0 = m0 + m2 / 2.0D + m4 * 3.0D / 8.0D + m6 * 5.0D / 16.0D + m8 * 35.0D / 128.0D;
        a2 = m2 / 2.0D + m4 / 2.0D + m6 * 15.0D / 32.0D + m8 * 7.0D / 16.0D;
        a4 = m4 / 8.0D + m6 * 3.0D / 16.0D + m8 * 7.0D / 32.0D;
        a6 = m6 / 32.0D + m8 / 16.0D;
        a8 = m8 / 128.0D;
        double FBf = 0.0D;
        double Bf0 = x / a0;

        for(double Bf1 = 0.0D; Bf0 - Bf1 >= 1.0E-4D; Bf0 = (x - FBf) / a0) {
            Bf1 = Bf0;
            FBf = -a2 * Math.sin((double)2 * Bf0) / (double)2 + a4 * Math.sin((double)4 * Bf0) / (double)4 - a6 * Math.sin((double)6 * Bf0) / (double)6 + a8 * Math.sin((double)8 * Bf0) / (double)8;
        }

        double Wf = Math.sqrt((double)1 - efang * Math.sin(Bf0) * Math.sin(Bf0));
        double Nf = a / Wf;
        double Mf = a * ((double)1 - efang) / Math.pow(Wf, 3.0D);
        double nffang = e2fang * Math.cos(Bf0) * Math.cos(Bf0);
        double tf = Math.tan(Bf0);
        double B = Bf0 - tf * y * y / ((double)2 * Mf * Nf) + tf * ((double)5 + (double)3 * tf * tf + nffang - (double)9 * nffang * tf * tf) * Math.pow(y, 4.0D) / ((double)24 * Mf * Math.pow(Nf, 3.0D)) - tf * ((double)61 + (double)90 * tf * tf + (double)45 * Math.pow(tf, 4.0D)) * Math.pow(y, 6.0D) / ((double)720 * Mf * Math.pow(Nf, 5.0D));
        double l = y / (Nf * Math.cos(Bf0)) - ((double)1 + (double)2 * tf * tf + nffang) * Math.pow(y, 3.0D) / ((double)6 * Math.pow(Nf, 3.0D) * Math.cos(Bf0)) + ((double)5 + (double)28 * tf * tf + (double)24 * Math.pow(tf, 4.0D)) * Math.pow(y, 5.0D) / ((double)120 * Math.pow(Nf, 5.0D) * Math.cos(Bf0));
        double L = l + L0;
        double[] array_B = this.rad2dms(B);
        double[] array_L = this.rad2dms(L);
        double Bdec = this.dms2dec(array_B);
        double Ldec = this.dms2dec(array_L);
        return new Tuple(Bdec, Ldec);
    }
    public  double gaussLongToDegreen(double B, double L, int N) {
        double L00 = (double)Math.round(L / (double)3) * (double)3;
        return L00 / (double)180 * 3.1415926D;
    }
    @NotNull
    public  double[] rad2dms(double rad) {
        double[] a = new double[]{0.0D, 0.0D, 0.0D};
        double dms = rad * p;
        a[0] = Math.floor(dms / 3600.0D);
        a[1] = Math.floor((dms - a[0] * (double)3600) / 60.0D);
        a[2] = (double)((int)Math.floor(dms - a[0] * (double)3600)) - a[1] * (double)60;
        return a;
    }

    public  double dms2dec(@NotNull double[] dms) {
        Intrinsics.checkNotNullParameter(dms, "dms");
        double dec = 0.0D;
        dec = dms[0] + dms[1] / 60.0D + dms[2] / 3600.0D;
        return dec;
    }

    @NotNull
    public  Tuple GetXY(double B, double L, double degree) {
        double[] xy = new double[]{0.0D, 0.0D};
        double a = 6378137.0D;
        double b = 6356752.314245179D;
        double e = 0.081819190842621D;
        double eC = 0.0820944379496957D;
        double L0 = 0.0D;
        int n;
        if (degree == 6.0D) {
            n = (int)Math.round((L + degree / (double)2) / degree);
            L0 = degree * (double)n - degree / (double)2;
        } else {
            n = (int)Math.round(L / degree);
            L0 = degree * (double)n;
        }

        double radB = B * 3.141592653589793D / (double)180;
        double radL = L * 3.141592653589793D / (double)180;
        double deltaL = (L - L0) * 3.141592653589793D / (double)180;
        double N = a * a / b / Math.sqrt((double)1 + eC * eC * Math.cos(radB) * Math.cos(radB));
        double C1 = 1.0D + 0.75D * e * e + 0.703125D * Math.pow(e, 4.0D) + 0.68359375D * Math.pow(e, 6.0D) + 0.67291259765625D * Math.pow(e, 8.0D);
        double C2 = 0.75D * e * e + 0.9375D * Math.pow(e, 4.0D) + 1.025390625D * Math.pow(e, 6.0D) + 1.07666015625D * Math.pow(e, 8.0D);
        double C3 = 0.234375D * Math.pow(e, 4.0D) + 0.41015625D * Math.pow(e, 6.0D) + 0.538330078125D * Math.pow(e, 8.0D);
        double C4 = 0.068359375D * Math.pow(e, 6.0D) + 0.15380859375D * Math.pow(e, 8.0D);
        double C5 = 0.00240325927734375D * Math.pow(e, 8.0D);
        double t = Math.tan(radB);
        double eta = eC * Math.cos(radB);
        double X = a * ((double)1 - e * e) * (C1 * radB - C2 * Math.sin((double)2 * radB) / (double)2 + C3 * Math.sin((double)4 * radB) / (double)4 - C4 * Math.sin((double)6 * radB) / (double)6 + C5 * Math.sin((double)8 * radB));
        xy[0] = X + N * Math.sin(radB) * Math.cos(radB) * Math.pow(deltaL, 2.0D) * ((double)1 + Math.pow(deltaL * Math.cos(radB), 2.0D) * ((double)5 - t * t + (double)9 * eta * eta + (double)4 * Math.pow(eta, 4.0D)) / (double)12 + Math.pow(deltaL * Math.cos(radB), 4.0D) * ((double)61 - (double)58 * t * t + Math.pow(t, 4.0D)) / (double)360) / (double)2;
        xy[1] = N * deltaL * Math.cos(radB) * ((double)1 + Math.pow(deltaL * Math.cos(radB), 2.0D) * ((double)1 - t * t + eta * eta) / (double)6 + Math.pow(deltaL * Math.cos(radB), 4.0D) * ((double)5 - (double)18 * t * t + Math.pow(t, 4.0D) - (double)14 * eta * eta - (double)58 * eta * eta * t * t) / (double)120) + (double)500000;
        return new Tuple(xy[0], xy[1]);
    }

}

那些乐趣
关注
  • 0
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
大地2000坐标(CGCS2000).prj文件(包括地理和投影分带）
02-19
国家大地2000坐标的prj文件，包括地理和投影分带所有的CGCS2000坐标文件
坐标转换 matlab WGS84-CGCS2000 界面软件 矩阵数组
07-13
matlab 矩阵数组 # 坐标转换Matlab-GUI ...实现WGS84-CGCS2000坐标转换 #### 使用说明 1. csv存储坐标转换数据样本 2. .f文件是gui界面文件 3. .m文件是代码文件 三个底层函数 myfunc_ xyz2blh blh2xyz
java实现CGS2000大地坐标和WGS84经纬度坐标互转，亲测准确
gis_zhouda的博客
11-18 1万+
WGS84转CGS2000 中央子午线需要根据实际设置，参数为经度，纬度，输出值为经度（x），纬度（y） public static Point WGS84ToCGS2000(double longitude, double latitude)//参数 经度，纬度 { Point pt = null; double[] output = new double[2]; double longitude1,latitude1, longitu
WGS84地理坐标系和CGCS2000坐标相互转换
qq_33804688的博客
09-01 1万+
1.以下位代码直接调用就可以，中央子午线需要查看网址经纬度中央子午线对照表。需要geotools和opengis和kotlin需要的jar包。下载链接：https://pan.baidu.com/s/1AZnt3YHk9CyofYdvgLRaHQ 提取码：ak47 /* * To change this license header, choose License Headers in Project Properties. * To change this template file, ch...
Java实现经纬度坐标转换
最新发布
Charge8的博客
06-06 1119
Java实现经纬度坐标转换
【Java】WGS84转2000国家大地坐标系(CGCS2000)
inaUI的博客
01-17 2294
引用Eclipse在github上的一个开源项目。1. pom.xml引入依赖。2. 转换工具类定义。
各坐标系转换，百度、高德、wgs84、cgcs2000坐标系互转
热门推荐
阳光
03-13 1万+
首先申明：转换方法都是网上找的，但是都不全，整理了一下 其中wgs84、cgcs2000互转结果有差异，也就是完全还原不了 先附上百度、高德、wgs84互转方法 js /** * Created by Wandergis on 2015/7/8. * 提供了百度坐标（BD09）、国测局坐标（火星坐标，GCJ02）、和WGS84坐标系之间的转换 */ //UMD魔法代码 // if the module has no dependencies, the above pattern can be
GIS数据格式坐标转换（地球坐标WGS84、GCJ-02、火星坐标、百度坐标BD-09、国家大地坐标系CGCS2000）
漏刻有时数据可视化大屏（PHP&ECHARTS智能化开源软件系统）
02-12 1万+
地理信息系统 (GIS) 是一个创建、管理、分析和绘制所有类型数据的系统。GIS 将数据连接到地图，将位置数据（事物所在位置）与所有类型的描述性信息（事物在该位置的情况）集成到一起。这可以为适用于自然科学和几乎所有行业的制图和分析提供基础。GIS 帮助用户了解模式、关系和地理环境。其优势包括改善沟通、提高效率以及更好地管理和决策。解决使用百度webAPI坐标转换时的问题：X→GPS根据法律规定，不支持将任何类型的坐标转换为GPS坐标；
CSDN-0017-20221107-J2000与WGS84坐标系转换-CoordTransInerToFix.zip
11-19
3. 应用场景：不同的应用场景可能对坐标系的需求不同，例如GPS定位通常需要WGS84，而天文观测则倾向于J2000。 总的来说，WGS84和J2000坐标系的转换是地球科学和空间技术中的重要概念，理解并掌握这种转换对于正确...
java 地心坐标系（ECEF）和WGS-84坐标系（WGS84）互转的实现
08-25
WGS-84（World Geodetic System 1984）则是一种大地坐标系，基于地球椭球模型，用于全球定位系统（GPS）和其他导航系统。WGS-84坐标由经度、纬度和海拔高度组成。 在Java中，实现ECEF到WGS-84的转换通常涉及到椭球...
七参数坐标转换工具（可在WGS84、北京54、西安80、CGCS2000坐标系中任意两个转换）
08-13
4. CGCS2000（China Geodetic Coordinate System 2000）：是中国在2000年推出的新一代大地坐标系统，基于2000年中国地球重力场模型，提供更高精度的位置服务，是当前中国官方推荐的坐标系。 七参数坐标转换涉及三个...
ArcGIS Runtime API for Java使用示例：CGCS2000转WGS84和BD09
12-11
利用ArcGIS Runtime API for Java把空间数据从CGCS2000转WGS84和BD09。提供了完整的环境构建和代码示例。开箱即用，并对构建运行环境的操作步骤提供离线和在线两种方式。
百度(bd09),火星(GCJ-02),大地(wgs84)坐标系转换
11-09
Java实现windows与Linux平台上的百度坐标系,火星坐标系与大地坐标系之间的相互转换,有不能布署成功的请在线私我
投影转换：从WGS84到CGCS2000
12-17
栅格影像WGS84转CGCS2000坐标
坐标转换wgs84转cgcs2000.zip
09-10
坐标转换wgs84转cgcs2000 软件
java进制转换经纬度,经纬度WGS84地理坐标系转换成CGCS2000坐标系步骤.docx
weixin_33602515的博客
03-16 1620
经纬度WGS84地理坐标系转换成CGCS2000坐标系步骤基于ArcGIS中进行操作供大家参考学习文末有该文档的下载方式1、 将图层从奥维中导出成shp文件，2、 打开arcgis-arcmap3、地理处理-arctoolbox-数据管理工具-投影和变换-要素-投影4、WGS84坐标转换为地理坐标系-world-ITRF20005、打开ArcCatalog，找到上一步中已经成ITRF2000坐标系...
使用Arcmap将WGS84坐标转换成国家大地坐标系2000
samLi0620的博客
11-05 1万+
使用Arcmap将WGS84坐标转换成国家大地坐标系2000
WGS84 坐标系转到J2000坐标系
hit5067的博客
05-16 1万+
在wgs84 坐标系转到J2000 坐标系 主要 涉及到坐标的相互转换。一般给定的WGS坐标为 给定时刻的 t ,BLH。 具体转换茹下 step1 WGS 84 转换到协议地球坐标系。 function XYZ = wgs842xyz(BLH) %UNTITLED2 大地坐标系转北天东坐标系 % 此处显示详细说明 thita 为当地恒星时 ae = 6378137; %wgs84坐标系场半轴 ee = 0.00669437999013 ; %第一偏心率 %ee=0.006694379..
WGS84坐标系转CGCS2000坐标系
07-27
WGS84坐标系和CGCS2000坐标系都是地球上常用的大地坐标系，它们之间的转换可以通过坐标转换参数来实现。具体的转换方法如下： 1. 使用WGS84坐标系的经纬度数据，首先需要将经纬度转换为大地坐标系中的地心坐标系，即将经纬度转换为地心经纬度（geocentric latitude）。这可以通过以下公式实现： φ' = arctan((1 - f) * tan(φ)) 其中，φ为待转换的纬度，f为椭球的扁率。 2. 将地心经纬度转换为CGCS2000坐标系中的地心坐标系。这可以通过使用不同椭球体参数计算得到。 3. 最后，将地心坐标系转换为CGCS2000坐标系的大地坐标系。这可以通过使用七参数转换或者七参数模型来实现。 需要注意的是，七参数转换模型是一种常用的转换方法，但在具体应用中可能会有一些误差。如果需要更高精度的转换，可以使用更复杂的转换模型或者采用其他方法。 总结起来，WGS84坐标系转换为CGCS2000坐标系的步骤包括将经纬度转换为地心经纬度，然后再转换为地心坐标系，最后再转换为CGCS2000的大地坐标系。具体的转换参数和公式可以根据实际需求进行选择和计算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值