Cesium根据卫星TLE两行数生成CZML，并模拟卫星扫描

已于 2023-02-14 15:17:22 修改
阅读量3k 收藏 47
点赞数 3
分类专栏： Cesium 文章标签： javascript 前端 vue.js
于 2023-02-14 14:28:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38241330/article/details/129026296
版权
该代码段展示了如何从卫星的TLE轨道数据生成CZML文件，并利用Cesium库创建动态的卫星轨迹。它首先处理输入的起始时间、结束时间和TLE数据，然后计算卫星在特定时间的位置，最后生成表示卫星运动的Cesium实体。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

卫星轨道.gif

1.生成CZML

根据卫星显示的起始时间，终止时间，tle轨道两行数得出czml文件

import moment from "moment";
import julian from "julian";
import * as satellite from "satellite.js";
/*
根据卫星显示的起始时间，终止时间，tle轨道两行数得出czml文件，时间为js的Date对象，tles为对象数组，对象格式为
{
name：xx，
tle1：xx，
tle2：xx
}
*/
export default function tles2czml(startTime, endTime, tles) {
    console.log(endTime);
    console.log(startTime);
    // 计算起始时间和终止时间相隔的分钟数
    let minsInDuration = (endTime.getTime() - startTime.getTime()) / 6000;   //mins
    //设置为开始时间
    let initialTime = moment(startTime.toISOString()).toISOString();
    //设置为结束时间
    endTime = moment(endTime.toISOString()).toISOString();
    // 初始化czml数据，创建场景信息
    let tempCZML = [];
    tempCZML.push({
        "id": "document",
        "name": "CZML Point - Time Dynamic",
        "version": "1.0",
        "clock": {
            "interval": `${initialTime}/${endTime}`,
            "multiplier": 1,
            "range": "LOOP_STOP",
            "step": "SYSTEM_CLOCK"
        }
    },
    )


    // 处理每一个sat
    for (let no = 0; no < tles.length; no++) {
        if (!tles[no].name) {
            console.log("请输入第" + no + 1 + "个卫星的名称");
            return
        };
        if (!tles[no].tle1) {
            console.log("请输入第" + no + 1 + "个卫星的第一个两行数");
            return
        };
        if (!tles[no].tle2) {
            console.log("请输入第" + no + 1 + "个卫星的第二个两行数");
            return
        };
        let sat_name = tles[no].name;
        // 保存位置信息
        let res = [];
        let satrec
        satrec = satellite.twoline2satrec(tles[no].tle1, tles[no].tle2);
        //satrec.no：以弧度/分钟为单位的平均运动，一天有1440分钟，一弧度是0.159155圈
        // to go from RAD/DAY -> REV/DAY: rad * 1440 * 0.159155
        //to go from REV/PER DAY to MINS/REV -> 1440/RevPerDay
        let totalIntervalsInDay = satrec.no * 1440 * 0.159155; //1440 = min && 0.159155 = 1turn
        // 获得运行一圈的分钟数
        let minsPerInterval = 1440 / totalIntervalsInDay; // mins for 1 revolution around earth
        // intervalTime 取起始时间 格式为2008-09-20T12:25:40.104Z
        let intervalTime = moment(startTime.toISOString()).toISOString()


        let leadIntervalArray = [];
        let trailIntervalArray = [];
        console.log("Setting intervals...");
        // 注意：这里之所以要倒过来求leadInterval和trailInterval是因为如果正着求，很有可能在终止时刻卫星并没有运行完一圈，导致轨道只显示一半
        for (let i = minsInDuration; i >= 0; i -= minsPerInterval) {
            if (i <= minsPerInterval) { // intial interval 
                let currentOrbitalInterval = {
                    "interval": `${startTime.toISOString()}/${intervalTime}`,
                    "epoch": `${startTime.toISOString()}`,
                    "number": [
                        0, minsPerInterval * 60,
                        minsPerInterval * 60, 0
                    ]
                }
                let currTrail = {
                    "interval": `${startTime.toISOString()}/${intervalTime}`,
                    "epoch": `${startTime.toISOString()}`,
                    "number": [
                        0, 0,
                        minsPerInterval * 60, minsPerInterval * 60
                    ]
                }
                leadIntervalArray.push(currentOrbitalInterval);
                trailIntervalArray.push(currTrail);
            }
            else {  //not initial so make intervals 
                let previousIntervalTime = moment(intervalTime).add(-minsPerInterval, 'm').toISOString();
                let currentOrbitalInterval = {
                    "interval": `${previousIntervalTime}/${intervalTime}`,
                    "epoch": `${previousIntervalTime}`,
                    "number": [
                        0, minsPerInterval * 60,
                        minsPerInterval * 60, 0
                    ]
                }
                let currTrail = {
                    "interval": `${previousIntervalTime}/${intervalTime}`,
                    "epoch": `${previousIntervalTime}`,
                    "number": [
                        0, 0,
                        minsPerInterval * 60, minsPerInterval * 60
                    ]
                }
                intervalTime = moment(intervalTime).add(-minsPerInterval, 'm').toISOString();
                leadIntervalArray.push(currentOrbitalInterval);
                trailIntervalArray.push(currTrail);
            }
        }
        // Seconds between current time and epoch time
        let sec = (startTime - julian.toDate(satrec.jdsatepoch)) / 1000;
        console.log(startTime, julian.toDate(satrec.jdsatepoch), sec);
        for (let i = sec; i <= sec + minsInDuration * 60; i++) { //每60秒计算一个位置信息，最后采用拉格朗日插值法处理数据
            // 根据当前时间距tle两行数历元时刻的分钟数，计算当前卫星位置和速度
            let positionAndVelocity = satellite.sgp4(satrec, i * 0.0166667); // 0.0166667min = 1sec
            // 地惯坐标系
            let positionEci = positionAndVelocity.position;
            positionEci.x = positionEci.x * 1000;
            positionEci.y = positionEci.y * 1000;
            positionEci.z = positionEci.z * 1000;
            // let velocityEci = positionAndVelocity.velocity;
            // velocityEci.x = velocityEci.x * 1000;
            // velocityEci.y = velocityEci.y * 1000;
            // velocityEci.z = velocityEci.z * 1000;
            res.push(i - sec, positionEci.x, positionEci.y, positionEci.z);
        }
        let initialCZMLProps =
        {
            "id": `${sat_name}`,
            "name": `${sat_name}`,
            "availability": `${initialTime}/${endTime}`,
            "label": {
                "fillColor": {
                    "rgba": [
                        255, 0, 255, 255
                    ]
                },
                "font": "11pt Lucida Console",
                "horizontalOrigin": "LEFT",
                "outlineColor": {
                    "rgba": [
                        0, 0, 0, 255
                    ]
                },
                "outlineWidth": 2,
                "pixelOffset": {
                    "cartesian2": [
                        12, 0
                    ]
                },
                "show": true,
                "style": "FILL_AND_OUTLINE",
                "text": `${sat_name}`,
                "verticalOrigin": "CENTER"
            },
            "path": {
                "show": [
                    {
                        "interval": `${initialTime}/${endTime}`,
                        "boolean": true
                    }
                ],
                "width": 3,
                "material": {
                    "solidColor": {
                        "color": {
                            "rgba": [
                                // 随机生成轨道颜色
                                Math.floor(255 * Math.random(0, 1)), Math.floor(255 * Math.random(0, 1)), Math.floor(255 * Math.random(0, 1)), 255
                            ]
                        }
                    }
                },
                "resolution": 120,
                // The time ahead of the animation time, in seconds, to show the path.
                "leadTime": leadIntervalArray,
                // The time behind the animation time, in seconds, to show the
                "trailTime": trailIntervalArray
            },
            "model": {
                "show": true,
                "gltf": "./data/simple_satellite_low_poly_free.glb",
                "minimumPixelSize": 55,
            },
            "position": {
                // 采用拉格朗日插值法
                "interpolationAlgorithm": "LAGRANGE",
                // 1为线性插值，2为平方插值
                "interpolationDegree": 2,
                // 参考坐标系，地惯坐标系
                "referenceFrame": "INERTIAL",
                "epoch": `${initialTime}`,
                "cartesian": res
            }
        }
        tempCZML.push(initialCZMLProps);
    }
    return tempCZML;
}

入参（此示例为两个参数）

const tles = [
  {
    name: "QingHe1",
    tle1: "1 25544U 98067A   20199.03008672 -.00000576  00000-0 -22221-5 0  9991",
    tle2: "2 25544  51.6440 200.7619 0001412 122.6206 338.3473 15.49512746236640",
  },
  {
    name: "NAVSTAR 76 (USA 266)",
    tle1: "41328U 16007A   19049.49277110  .00000017  00000-0  00000+0 0  9993",
    tle2: "2 25544  51.6440 200.7619 0001412 122.6206 338.3473 15.49512742 41328  54.8247 195.6929 0027216 214.4209 145.3559  2.00553553 22229",
  },
];
const startTime = new Date("2023-02-14T08:00:00");
const endTime = new Date("2023-02-14T13:10:00");
const czml = tles2czml(startTime, endTime, tles);

2.根据生成的CZML获取卫星的时间和位置，生成Entity实体

import * as Cesium from "cesium";
export default function scanning(viewer,czml){
    const cylinderEntity = viewer.entities.add({
    name: "Red cone",
    position: Cesium.Cartesian3.fromDegrees(-105.0, 40.0, 200000.0),
    cylinder: {
      length: 400000.0,
      topRadius: 0.0,
      bottomRadius: 200000.0,
      material: Cesium.Color.RED.withAlpha(0.5),
    },
  });
  var property;
  viewer.dataSources
    .add(Cesium.CzmlDataSource.load(czml))
    .then(function (dataSource) {
    var satellite = dataSource.entities.getById("QingHe1");
      property = new Cesium.SampledPositionProperty();
      for (var ind = 0; ind < 292; ind++) {
        var time = Cesium.JulianDate.addSeconds(
          viewer.clock.currentTime,
          300 * ind,
          new Cesium.JulianDate()
        );
        var position = satellite.position.getValue(time);
        console.log(position);
        if (position) {
          var cartographic =
            Cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
          var lat = Cesium.Math.toDegrees(cartographic.latitude),
            lng = Cesium.Math.toDegrees(cartographic.longitude),
            hei = cartographic.height / 1.9;
          property.addSample(
            time,
            Cesium.Cartesian3.fromDegrees(lng, lat, hei)
          );
        }
      }


      cylinderEntity.position = property;
      cylinderEntity.position.setInterpolationOptions({
        //设定位置的插值算法
        interpolationDegree: 5,
        interpolationAlgorithm: Cesium.LagrangePolynomialApproximation,
      });


    //   viewer.clock.onTick.addEventListener(function (clock) {
    //     if (property) {
    //       var time = clock.currentTime;
    //       var val = property.getValue(clock.currentTime);
    //       // console.log(val);
    //     }
    //   });
    });
}

3.无两行数情况下输入开始时间和结束时间生成模拟轨道（非真实卫星轨迹）

import * as Cesium from "cesium";
var arrStates = [];
var start, stop, viewer;
export default function simulation(v, startTime, endTime) {
    viewer = v
    // start = new Cesium.JulianDate.fromDate(new Date()); // 获取当前时间 这不是国内的时间
    start = new Cesium.JulianDate.fromDate(startTime); // 获取当前时间 这不是国内的时间
    stop = new Cesium.JulianDate.fromDate(endTime); // 获取当前时间 这不是国内的时间
    console.log(start);
    const sec = stop.secondsOfDay - start.secondsOfDay
    // start = Cesium.JulianDate.addHours(start, 8, new Cesium.JulianDate()); // 添加八小时，得到我们东八区的北京时间
    // stop = Cesium.JulianDate.addHours(stop, 8, new Cesium.JulianDate()); // 设置一个结束时间，意思是360秒之后时间结束


    viewer.clock.startTime = start.clone(); // 给cesium时间轴设置开始的时间，也就是上边的东八区时间
    viewer.clock.stopTime = stop.clone(); // 设置cesium时间轴设置结束的时间
    viewer.clock.currentTime = start.clone(); // 设置cesium时间轴设置当前的时间
    viewer.clock.clockRange = Cesium.ClockRange.LOOP_STOP; // 时间结束了，再继续重复来一遍
    //时间变化来控制速度 // 时间速率，数字越大时间过的越快
    viewer.clock.multiplier = 2;
    //给时间线设置边界
    viewer.timeline.zoomTo(start, stop);


    arrStates = [];
    getRandState(arrStates, 1, sec);
    startFunc();
}
function mySatePosition() {
    this.lon = 0;
    this.lat = 0;
    this.hei = 700000; //卫星高度
    this.phei = 700000 / 2; //轨道高度
    this.time = 0;
}
function computeCirclularFlight(source, panduan) {
    var property = new Cesium.SampledPositionProperty();
    if (panduan == 1) {
        //卫星位置
        for (var i = 0; i < source.length; i++) {
            var time = Cesium.JulianDate.addSeconds(
                start,
                source[i].time,
                new Cesium.JulianDate()
            );
            var position = Cesium.Cartesian3.fromDegrees(
                source[i].lon,
                source[i].lat,
                source[i].hei
            );
            // 添加位置，和时间对应
            property.addSample(time, position);
        }
    } else if (panduan == 2) {
        //轨道位置
        for (var i = 0; i < source.length; i++) {
            var time = Cesium.JulianDate.addSeconds(
                start,
                source[i].time,
                new Cesium.JulianDate()
            );
            var position = Cesium.Cartesian3.fromDegrees(
                source[i].lon,
                source[i].lat,
                source[i].phei
            );
            // 添加位置，和时间对应
            property.addSample(time, position);
        }
    }
    return property;
}


function getRandState(brr, count, sec) {
    for (var m = 0; m < count; m++) {
        var arr = [];
        var t1 = Math.floor(Math.random() * sec);
        var t2 = Math.floor(Math.random() * sec);
        for (var i = t1; i <= sec + t1; i += 30) {
            var aaa = new mySatePosition();
            aaa.lon = t2;
            aaa.lat = i;
            aaa.time = i - t1;
            arr.push(aaa);
        }
        brr.push(arr);
    }
    console.log(brr);
}


function getStatePath(aaa) {
    console.log(aaa);
    console.log(viewer);


    var entity_ty1p = computeCirclularFlight(aaa, 2);
    var entity_ty1 = viewer.entities.add({
        availability: new Cesium.TimeIntervalCollection([
            new Cesium.TimeInterval({
                start: start,
                stop: stop,
            }),
        ]),
        position: entity_ty1p, //轨道高度
        orientation: new Cesium.VelocityOrientationProperty(entity_ty1p),
        cylinder: {
            HeightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
            length: 700000,
            topRadius: 0,
            bottomRadius: 900000 / 2,
            // material: Cesium.Color.RED.withAlpha(.4),
            // outline: !0,
            numberOfVerticalLines: 0,
            // outlineColor: Cesium.Color.RED.withAlpha(.8),
            material: Cesium.Color.fromBytes(35, 170, 242, 80),
        },
    });


    entity_ty1.position.setInterpolationOptions({
        interpolationDegree: 5,
        interpolationAlgorithm: Cesium.LagrangePolynomialApproximation,
    });


    var entity1p = computeCirclularFlight(aaa, 1);
    //创建实体
    var entity1 = viewer.entities.add({
        // 将实体availability设置为与模拟时间相同的时间间隔。
        availability: new Cesium.TimeIntervalCollection([
            new Cesium.TimeInterval({
                start: start,
                stop: stop,
            }),
        ]),
        position: entity1p, //计算实体位置属性
        //基于位置移动自动计算方向.
        orientation: new Cesium.VelocityOrientationProperty(entity1p),
        //加载飞机模型
        model: {
            uri: "./data/simple_satellite_low_poly_free.glb",
            scale: 30000,
        },
        //路径
        path: {
            resolution: 1,
            material: new Cesium.PolylineGlowMaterialProperty({
                glowPower: 0.1,
                color: Cesium.Color.PINK,
            }),
            width: 5,
        },
    });


    //差值器
    entity1.position.setInterpolationOptions({
        interpolationDegree: 5,
        interpolationAlgorithm: Cesium.LagrangePolynomialApproximation,
    });
}


function startFunc() {
    for (var i = 0; i < arrStates.length; i++) {
        getStatePath(arrStates[i]);
    }
}

入参

  /* 模拟卫星，非真实卫星轨迹 */
const startTime = new Date("2023-02-14T13:00:00");
const endTime = new Date("2023-02-14T14:20:00");
simulation(viewer, startTime, endTime);

4.仓库地址

https://github.com/FF926/Cesium/tree/main/TLE2czml

cesium封装实现卫星视锥扫描效果
元仙僧的博客
06-20 2251
卫星视锥效果
DEJA_VU3D - Cesium功能集 之 052-模拟卫星轨道（高空）效果
总得学点什么的博客
06-27 3968
本篇文章我们来介绍基于Cesium模拟实现卫星轨道（高空扫描）效果。包括完整源代码奉上
cesium 卫星轨迹模拟 czml
03-04
详细原理及代码解释：https://mp.csdn.net/postedit/86620777
Cesium 入门教程（基于 vue3）
最新发布
2403_83182682的博客
03-17 2438
Cesium 是一个开源的 JavaScript 库，专门用于创建世界级的三维地球和地图可视化应用。它提供了强大的工具和功能，使开发者能够轻松地在浏览器中展示高分辨率的地形、影像以及三维模型。Cesium 支持多种数据格式，包括但不限于 3D Tiles、GeoJSON 和 glTF，这使得它成为处理地理空间数据的理想选择。无论是构建虚拟地球、城市规划模拟、还是气象数据分析，Cesium 都能提供必要的技术支持。此外，Cesium 还支持时间动态数据，允许用户通过时间轴查看历史数据变化或预测未来趋势。
Cesium——卫星轨迹TLE数据转为CZML并显示（tle2czml）
qq_54653738的博客
03-30 2432
Cesium——卫星轨迹TLE数据转为CZML并显示（tle2czml）
Cesium czml创建卫星轨迹 并模拟卫星扫描
热门推荐
资深三维GIS开发
01-24 1万+
最近一直在弄卫星轨迹的运动，并且模拟卫星扫描； 先晒个结果： 之前做了sgp4模拟卫星轨道，但是那个真实性太差，通过sgp4生成的轨道是不动的，真实的情况下卫星的轨道也是运动的，所以一般来说还得通过czml来生成轨道展示卫星运动； 在未加载扫描功能之前，单独加载czml可以正常展示卫星的运动情况，但后续客户提出了加上扫描功能，以及计算卫星何时过境，在某个时间段内会有哪几颗卫星过境； 先说下...
cesium 卫星环绕扫描
Sakura1998gis的博客
08-15 1607
cesium 卫星环绕扫描
星历数据tle格式，可用SKT生成CZML
05-10
这种格式由两行文本组成，每行43个字符，包含卫星的基本轨道信息，如卫星编号、发射日期、平均速度、轨道周期等。tle格式因其简单和高效而广泛用于快速计算卫星的精确位置。 "SKT"（Satellite Kinematic Toolkit）...
czml卫星轨道文件
03-02
总的来说，CZML卫星轨道文件是Cesium库的核心组成部分，它提供了描述天体运动的强大工具，使得开发者和研究人员能够轻松地在Web环境下模拟和展示卫星和其他天体的轨道。通过理解CZML的结构和使用方法，我们可以创建...
如何在cesium上添加tle卫星轨道数据
02-06
可以使用 Cesium 的 `CzmlDataSource` 类来加载 TLE 卫星轨道数据。首先，您需要准备 TLE 数据，并将其格式化为 CZML 格式。接下来，您可以使用下面的代码将 CZML 数据加载到 Cesium 中： ``` viewer.dataSources....
如何在cesium上加载tle卫星轨道数据
02-06
Cesium是一个基于Web的三维地理信息系统，可以在其上加载TLE(Two-Line Element)格式的卫星轨道数据。 具体步骤如下： 1. 创建一个Cesium的Viewer实例。 2. 定义一个卫星数据源，例如Cesium.CzmlDataSource。 3. ...
基于Cesium+VUE实现模拟卫星轨道（高空）效果组件，完整demo和源代码，代码未加密/未压缩，可直接调用运行
06-27
基于Cesium+VUE实现模拟卫星轨道（高空）效果组件，完整demo和源代码，代码未加密/未压缩，可直接调用运行 文章描述：https://blog.csdn.net/qq_34205305/article/details/125493400 代码不易，略收小费，使用过程中如果有任何问题欢迎在文章下进行评论或者私信，百分百回复哦
Cesium--生成czml
yhyh1234567890的博客
01-04 1465
**Cesium加载czml–制作czml ** 准备：模型gltf，可以通过Revit直接生成gltf格式的模型，需要引入外部插件；2、各分块模型开始加载的时间；3、建筑物的地理坐标位置。 $json1=''; $json2=array(); $json2['id']='document'; $json2['name']='CZML Model'; $json2['version']='1.0'; $json2
[ Cesium ] 根据 TLE 生成 czml 的三种方式
爪白白的个人博客
11-26 3475
文章目录一.使用 python tle2czml 库生成二.手动爬虫三.使用 python requests 库获取四.备注 一.使用 python tle2czml 库生成 import tle2czml tles = '''BEIDOU 2 1 31115U 07011A 21323.16884980 -.00000043 00000-0 00000-0 0 9993 2 31115 51.9034 274.7604 0003928 314.2233 45.7206 1.77
【Cesium】使用TLE轨道两行数计算轨道信息，并生成CZML格式文件
Gua_guagua的博客
09-16 7446
tle2czml方法详解
cesium实现卫星轨迹CZML（已知卫星两行参数）
GIS
07-11 1465
cesium实现卫星轨道
Cesium 模拟卫星扫描
资深三维GIS开发
01-11 1万+
此功能已有一段时间没有维护了，后面重新写了一个。 有疑问可以给我留言或者联系我的q 951973194；感谢大家的关注。 最近一直在弄关于卫星轨道及卫星扫描的功能，但是又没提供轨道的具体坐标，后端也不提供轨道根数计算轨道坐标的接口。没办法，自己翻阅了好多资料，找出了一个比较冷门的方法，通过卫星的两行参数，结合sgp4来模拟出一段时间的轨道坐标；这次就不晒出结合的方法了，只演示下如何模拟卫...
Cesium 卫星轨迹、卫星通信、卫星过境，模拟数据传输。
qq_41400354的博客
02-20 9020
卫星通信，卫星过境判断。动态数据传输，动态雷达
Cesium场景之卫星轨道展示
LLCN的博客
01-27 3856
动画的执行都是与时间有关的，从什么时间开始，到什么时间结束。而Cesium使用了不同于我们js常用的时间规范，需要用到。是指示在 Cesium 中添加或描述对象动画时使用的 Julian Date 格式的时间标签。Julian Date 是以天为单位计数的相对格林尼治标准时间的一种计时法。所以以下代码意思我们以当前时间为基准，6分钟内执行动画。但是速率是10.// 定义开始时间////把js中的时间转换为JulianDate时间,东八区时间// 定义结束时间，360秒后。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值