mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Run the Navara paths without the Cesium SDK, and load it on demand for the features that still build on it
Every Cesium read that a Navara page made was surveyed with the strict acceptance (GEV_QA_CESIUM_TRAP=record). Math on those paths now uses src/geo: screen annotations, weather and wind center readings, cyclone picks, scene data pack polygons and images (new navaraGeometry.js), the awareness subject, the orbit offset of camera verbs, voice frame_overhead, the agent world packet and Directions colours and ground picks. The celestial ring's Sun and Moon come from a bit-identical port of Cesium's Simon1994 model, JulianDate and TEME rotation (src/geo/simon1994.js, julianDate.js, transforms.js); a Cesium globe still applies its ICRF rotation once loaded. Traffic, Street Level, the Nepal event and locator and geo import build on Cesium's math or entity model on either globe; their enable (or the import) now loads the SDK first through src/app/loadCesium.js, synchronously when it is already there. A production page guards the global so a missed read is reported and starts the load. No module reads Cesium while it loads (scripts/check-cesium-load-time.mjs, run by npm test). Cesium.js is still loaded by index.html here.
This commit is contained in:
1 parent
f87da8523e
commit
b8305de14b
58 files changed
+2130
-325
No files matched your search
@@ -16,3 +16,5 @@ export * as transforms from './transforms.js';
|
||||
|
||||
export * as ellipsoidGeodesic from './ellipsoidGeodesic.js';
|
||||
export * as boundingSphere from './boundingSphere.js';
|
||||
export * as julianDate from './julianDate.js';
|
||||
export * as simon1994 from './simon1994.js';
|
||||
@@ -0,0 +1,193 @@
|
||||
// Ported from CesiumJS 1.138 (Apache-2.0) — JulianDate.js
|
||||
//
|
||||
// The part of Cesium's JulianDate that the planetary positions need: a date
|
||||
// as {dayNumber, secondsOfDay} in International Atomic Time (TAI), made from
|
||||
// a JavaScript Date through Cesium's leap second table. The operation order
|
||||
// matches Cesium so the values are bit-identical.
|
||||
|
||||
const SECONDS_PER_DAY = 86400.0;
|
||||
|
||||
// Cesium's JulianDate.leapSeconds: [TAI day, TAI seconds of day, TAI - UTC].
|
||||
const LEAP_SECONDS = [
|
||||
[2441317, 43210.0, 10], // January 1, 1972 00:00:00 UTC
|
||||
[2441499, 43211.0, 11], // July 1, 1972 00:00:00 UTC
|
||||
[2441683, 43212.0, 12], // January 1, 1973 00:00:00 UTC
|
||||
[2442048, 43213.0, 13], // January 1, 1974 00:00:00 UTC
|
||||
[2442413, 43214.0, 14], // January 1, 1975 00:00:00 UTC
|
||||
[2442778, 43215.0, 15], // January 1, 1976 00:00:00 UTC
|
||||
[2443144, 43216.0, 16], // January 1, 1977 00:00:00 UTC
|
||||
[2443509, 43217.0, 17], // January 1, 1978 00:00:00 UTC
|
||||
[2443874, 43218.0, 18], // January 1, 1979 00:00:00 UTC
|
||||
[2444239, 43219.0, 19], // January 1, 1980 00:00:00 UTC
|
||||
[2444786, 43220.0, 20], // July 1, 1981 00:00:00 UTC
|
||||
[2445151, 43221.0, 21], // July 1, 1982 00:00:00 UTC
|
||||
[2445516, 43222.0, 22], // July 1, 1983 00:00:00 UTC
|
||||
[2446247, 43223.0, 23], // July 1, 1985 00:00:00 UTC
|
||||
[2447161, 43224.0, 24], // January 1, 1988 00:00:00 UTC
|
||||
[2447892, 43225.0, 25], // January 1, 1990 00:00:00 UTC
|
||||
[2448257, 43226.0, 26], // January 1, 1991 00:00:00 UTC
|
||||
[2448804, 43227.0, 27], // July 1, 1992 00:00:00 UTC
|
||||
[2449169, 43228.0, 28], // July 1, 1993 00:00:00 UTC
|
||||
[2449534, 43229.0, 29], // July 1, 1994 00:00:00 UTC
|
||||
[2450083, 43230.0, 30], // January 1, 1996 00:00:00 UTC
|
||||
[2450630, 43231.0, 31], // July 1, 1997 00:00:00 UTC
|
||||
[2451179, 43232.0, 32], // January 1, 1999 00:00:00 UTC
|
||||
[2453736, 43233.0, 33], // January 1, 2006 00:00:00 UTC
|
||||
[2454832, 43234.0, 34], // January 1, 2009 00:00:00 UTC
|
||||
[2456109, 43235.0, 35], // July 1, 2012 00:00:00 UTC
|
||||
[2457204, 43236.0, 36], // July 1, 2015 00:00:00 UTC
|
||||
[2457754, 43237.0, 37], // January 1, 2017 00:00:00 UTC
|
||||
].map(([dayNumber, secondsOfDay, offset]) => ({
|
||||
julianDate: { dayNumber, secondsOfDay },
|
||||
offset,
|
||||
}));
|
||||
|
||||
function setComponents(wholeDays, secondsOfDay, julianDate) {
|
||||
const extraDays = (secondsOfDay / SECONDS_PER_DAY) | 0;
|
||||
wholeDays += extraDays;
|
||||
secondsOfDay -= SECONDS_PER_DAY * extraDays;
|
||||
|
||||
if (secondsOfDay < 0) {
|
||||
wholeDays--;
|
||||
secondsOfDay += SECONDS_PER_DAY;
|
||||
}
|
||||
|
||||
julianDate.dayNumber = wholeDays;
|
||||
julianDate.secondsOfDay = secondsOfDay;
|
||||
return julianDate;
|
||||
}
|
||||
|
||||
function compare(left, right) {
|
||||
const julianDayNumberDifference = left.dayNumber - right.dayNumber;
|
||||
if (julianDayNumberDifference !== 0) {
|
||||
return julianDayNumberDifference;
|
||||
}
|
||||
return left.secondsOfDay - right.secondsOfDay;
|
||||
}
|
||||
|
||||
// Cesium's binarySearch over the leap second table.
|
||||
function searchLeapSeconds(julianDate) {
|
||||
let low = 0;
|
||||
let high = LEAP_SECONDS.length - 1;
|
||||
while (low <= high) {
|
||||
const i = ~~((low + high) / 2);
|
||||
const comparison = compare(LEAP_SECONDS[i].julianDate, julianDate);
|
||||
if (comparison < 0) {
|
||||
low = i + 1;
|
||||
continue;
|
||||
}
|
||||
if (comparison > 0) {
|
||||
high = i - 1;
|
||||
continue;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
return ~(high + 1);
|
||||
}
|
||||
|
||||
function secondsDifference(left, right) {
|
||||
const dayDifference = (left.dayNumber - right.dayNumber) * SECONDS_PER_DAY;
|
||||
return dayDifference + (left.secondsOfDay - right.secondsOfDay);
|
||||
}
|
||||
|
||||
function convertUtcToTai(julianDate) {
|
||||
let index = searchLeapSeconds(julianDate);
|
||||
if (index < 0) {
|
||||
index = ~index;
|
||||
}
|
||||
if (index >= LEAP_SECONDS.length) {
|
||||
index = LEAP_SECONDS.length - 1;
|
||||
}
|
||||
let offset = LEAP_SECONDS[index].offset;
|
||||
if (index > 0) {
|
||||
const difference = secondsDifference(
|
||||
LEAP_SECONDS[index].julianDate,
|
||||
julianDate,
|
||||
);
|
||||
if (difference > offset) {
|
||||
index--;
|
||||
offset = LEAP_SECONDS[index].offset;
|
||||
}
|
||||
}
|
||||
addSeconds(julianDate, offset, julianDate);
|
||||
}
|
||||
|
||||
/** A TAI date from its whole Julian day number and seconds into that day. */
|
||||
export function fromTai(julianDayNumber, secondsOfDay) {
|
||||
const wholeDays = julianDayNumber | 0;
|
||||
secondsOfDay = secondsOfDay + (julianDayNumber - wholeDays) * SECONDS_PER_DAY;
|
||||
return setComponents(wholeDays, secondsOfDay, {
|
||||
dayNumber: 0,
|
||||
secondsOfDay: 0,
|
||||
});
|
||||
}
|
||||
|
||||
/** Cesium's JulianDate.fromDate: a valid JavaScript Date as a TAI date. */
|
||||
export function fromDate(date, result) {
|
||||
const year = date.getUTCFullYear();
|
||||
const month = date.getUTCMonth() + 1;
|
||||
const day = date.getUTCDate();
|
||||
let hour = date.getUTCHours();
|
||||
const minute = date.getUTCMinutes();
|
||||
const second = date.getUTCSeconds();
|
||||
const millisecond = date.getUTCMilliseconds();
|
||||
|
||||
// Algorithm from page 604 of the Explanatory Supplement to the
|
||||
// Astronomical Almanac (Seidelmann 1992).
|
||||
const a = ((month - 14) / 12) | 0;
|
||||
const b = year + 4800 + a;
|
||||
let dayNumber =
|
||||
(((1461 * b) / 4) | 0) +
|
||||
(((367 * (month - 2 - 12 * a)) / 12) | 0) -
|
||||
(((3 * (((b + 100) / 100) | 0)) / 4) | 0) +
|
||||
day -
|
||||
32075;
|
||||
|
||||
// JulianDates are noon-based
|
||||
hour = hour - 12;
|
||||
if (hour < 0) {
|
||||
hour += 24;
|
||||
}
|
||||
|
||||
const secondsOfDay =
|
||||
second + (hour * 3600.0 + minute * 60.0 + millisecond * 0.001);
|
||||
|
||||
if (secondsOfDay >= 43200.0) {
|
||||
dayNumber -= 1;
|
||||
}
|
||||
|
||||
result = setComponents(
|
||||
dayNumber,
|
||||
secondsOfDay,
|
||||
result ?? { dayNumber: 0, secondsOfDay: 0 },
|
||||
);
|
||||
convertUtcToTai(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/** The date `seconds` later (earlier when negative); `result` is required. */
|
||||
export function addSeconds(julianDate, seconds, result) {
|
||||
return setComponents(
|
||||
julianDate.dayNumber,
|
||||
julianDate.secondsOfDay + seconds,
|
||||
result,
|
||||
);
|
||||
}
|
||||
|
||||
/** The date as a fractional Julian day number. */
|
||||
export function totalDays(julianDate) {
|
||||
return julianDate.dayNumber + julianDate.secondsOfDay / SECONDS_PER_DAY;
|
||||
}
|
||||
|
||||
/** How many seconds TAI is ahead of UTC at the date. */
|
||||
export function computeTaiMinusUtc(julianDate) {
|
||||
let index = searchLeapSeconds(julianDate);
|
||||
if (index < 0) {
|
||||
index = ~index;
|
||||
--index;
|
||||
if (index < 0) {
|
||||
index = 0;
|
||||
}
|
||||
}
|
||||
return LEAP_SECONDS[index].offset;
|
||||
}
|
||||
@@ -0,0 +1,605 @@
|
||||
// Ported from CesiumJS 1.138 (Apache-2.0) — Simon1994PlanetaryPositions.js
|
||||
//
|
||||
// The Sun's and the Moon's positions in the Earth-centred inertial frame
|
||||
// (Simon et al. 1994), for the celestial ring on a page without the Cesium
|
||||
// SDK. The operation order matches Cesium so the outputs are bit-identical;
|
||||
// Cesium's debug range checks are left out (its inputs are its own orbit
|
||||
// constants). Dates are geo/julianDate.js values.
|
||||
|
||||
import * as Cartesian3 from './cartesian3.js';
|
||||
import * as Matrix3 from './matrix3.js';
|
||||
import * as CesiumMath from './math.js';
|
||||
import * as JulianDate from './julianDate.js';
|
||||
|
||||
const SECONDS_PER_DAY = 86400.0;
|
||||
const DAYS_PER_JULIAN_CENTURY = 36525.0;
|
||||
const RADIANS_PER_ARCSECOND = CesiumMath.RADIANS_PER_DEGREE / 3600.0;
|
||||
|
||||
/** Cesium's `new Matrix3(...)`: row-major arguments, column-major storage. */
|
||||
function rowMajor(c0r0, c1r0, c2r0, c0r1, c1r1, c2r1, c0r2, c1r2, c2r2) {
|
||||
return [c0r0, c0r1, c0r2, c1r0, c1r1, c1r2, c2r0, c2r1, c2r2];
|
||||
}
|
||||
|
||||
function computeTdbMinusTtSpice(daysSinceJ2000InTerrestrialTime) {
|
||||
/* STK Comments ------------------------------------------------------
|
||||
* This function uses constants designed to be consistent with
|
||||
* the SPICE Toolkit from JPL version N0051 (unitim.c)
|
||||
* M0 = 6.239996
|
||||
* M0Dot = 1.99096871e-7 rad/s = 0.01720197 rad/d
|
||||
* EARTH_ECC = 1.671e-2
|
||||
* TDB_AMPL = 1.657e-3 secs
|
||||
*--------------------------------------------------------------------*/
|
||||
|
||||
//* Values taken as specified in STK Comments except: 0.01720197 rad/day = 1.99096871e-7 rad/sec
|
||||
//* Here we use the more precise value taken from the SPICE value 1.99096871e-7 rad/sec converted to rad/day
|
||||
//* All other constants are consistent with the SPICE implementation of the TDB conversion
|
||||
//* except where we treat the independent time parameter to be in TT instead of TDB.
|
||||
//* This is an approximation made to facilitate performance due to the higher prevalance of
|
||||
//* the TT2TDB conversion over TDB2TT in order to avoid having to iterate when converting to TDB for the JPL ephemeris.
|
||||
//* Days are used instead of seconds to provide a slight improvement in numerical precision.
|
||||
|
||||
//* For more information see:
|
||||
//* http://www.cv.nrao.edu/~rfisher/Ephemerides/times.html#TDB
|
||||
//* ftp://ssd.jpl.nasa.gov/pub/eph/planets/ioms/ExplSupplChap8.pdf
|
||||
|
||||
const g = 6.239996 + 0.0172019696544 * daysSinceJ2000InTerrestrialTime;
|
||||
return 1.657e-3 * Math.sin(g + 1.671e-2 * Math.sin(g));
|
||||
}
|
||||
|
||||
const TdtMinusTai = 32.184;
|
||||
const J2000d = 2451545;
|
||||
function taiToTdb(date, result) {
|
||||
//Converts TAI to TT
|
||||
result = JulianDate.addSeconds(date, TdtMinusTai, result);
|
||||
|
||||
//Converts TT to TDB
|
||||
const days = JulianDate.totalDays(result) - J2000d;
|
||||
result = JulianDate.addSeconds(result, computeTdbMinusTtSpice(days), result);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
const epoch = JulianDate.fromTai(2451545, 0); //Actually TDB (not TAI)
|
||||
const MetersPerKilometer = 1000.0;
|
||||
const RadiansPerDegree = CesiumMath.RADIANS_PER_DEGREE;
|
||||
const RadiansPerArcSecond = RADIANS_PER_ARCSECOND;
|
||||
const MetersPerAstronomicalUnit = 1.4959787e11; // IAU 1976 value
|
||||
|
||||
const perifocalToEquatorial = Matrix3.create();
|
||||
function elementsToCartesian(
|
||||
semimajorAxis,
|
||||
eccentricity,
|
||||
inclination,
|
||||
longitudeOfPerigee,
|
||||
longitudeOfNode,
|
||||
meanLongitude,
|
||||
result,
|
||||
) {
|
||||
if (inclination < 0.0) {
|
||||
inclination = -inclination;
|
||||
longitudeOfNode += Math.PI;
|
||||
}
|
||||
|
||||
const radiusOfPeriapsis = semimajorAxis * (1.0 - eccentricity);
|
||||
const argumentOfPeriapsis = longitudeOfPerigee - longitudeOfNode;
|
||||
const rightAscensionOfAscendingNode = longitudeOfNode;
|
||||
const trueAnomaly = meanAnomalyToTrueAnomaly(
|
||||
meanLongitude - longitudeOfPerigee,
|
||||
eccentricity,
|
||||
);
|
||||
const type = chooseOrbit(eccentricity, 0.0);
|
||||
|
||||
perifocalToCartesianMatrix(
|
||||
argumentOfPeriapsis,
|
||||
inclination,
|
||||
rightAscensionOfAscendingNode,
|
||||
perifocalToEquatorial,
|
||||
);
|
||||
const semilatus = radiusOfPeriapsis * (1.0 + eccentricity);
|
||||
const costheta = Math.cos(trueAnomaly);
|
||||
const sintheta = Math.sin(trueAnomaly);
|
||||
|
||||
const denom = 1.0 + eccentricity * costheta;
|
||||
|
||||
const radius = semilatus / denom;
|
||||
if (result == null) {
|
||||
result = Cartesian3.create(radius * costheta, radius * sintheta, 0.0);
|
||||
} else {
|
||||
result.x = radius * costheta;
|
||||
result.y = radius * sintheta;
|
||||
result.z = 0.0;
|
||||
}
|
||||
|
||||
return Matrix3.multiplyByVector(perifocalToEquatorial, result, result);
|
||||
}
|
||||
|
||||
function chooseOrbit(eccentricity, tolerance) {
|
||||
if (eccentricity <= tolerance) {
|
||||
return 'Circular';
|
||||
} else if (eccentricity < 1.0 - tolerance) {
|
||||
return 'Elliptical';
|
||||
} else if (eccentricity <= 1.0 + tolerance) {
|
||||
return 'Parabolic';
|
||||
}
|
||||
return 'Hyperbolic';
|
||||
}
|
||||
|
||||
// Calculates the true anomaly given the mean anomaly and the eccentricity.
|
||||
function meanAnomalyToTrueAnomaly(meanAnomaly, eccentricity) {
|
||||
const eccentricAnomaly = meanAnomalyToEccentricAnomaly(
|
||||
meanAnomaly,
|
||||
eccentricity,
|
||||
);
|
||||
return eccentricAnomalyToTrueAnomaly(eccentricAnomaly, eccentricity);
|
||||
}
|
||||
|
||||
const maxIterationCount = 50;
|
||||
const keplerEqConvergence = 1.0e-8;
|
||||
// Calculates the eccentric anomaly given the mean anomaly and the eccentricity.
|
||||
function meanAnomalyToEccentricAnomaly(meanAnomaly, eccentricity) {
|
||||
const revs = Math.floor(meanAnomaly / CesiumMath.TWO_PI);
|
||||
|
||||
// Find angle in current revolution
|
||||
meanAnomaly -= revs * CesiumMath.TWO_PI;
|
||||
|
||||
// calculate starting value for iteration sequence
|
||||
let iterationValue =
|
||||
meanAnomaly +
|
||||
(eccentricity * Math.sin(meanAnomaly)) /
|
||||
(1.0 - Math.sin(meanAnomaly + eccentricity) + Math.sin(meanAnomaly));
|
||||
|
||||
// Perform Newton-Raphson iteration on Kepler's equation
|
||||
let eccentricAnomaly = Number.MAX_VALUE;
|
||||
|
||||
let count;
|
||||
for (
|
||||
count = 0;
|
||||
count < maxIterationCount &&
|
||||
Math.abs(eccentricAnomaly - iterationValue) > keplerEqConvergence;
|
||||
++count
|
||||
) {
|
||||
eccentricAnomaly = iterationValue;
|
||||
const NRfunction =
|
||||
eccentricAnomaly -
|
||||
eccentricity * Math.sin(eccentricAnomaly) -
|
||||
meanAnomaly;
|
||||
const dNRfunction = 1 - eccentricity * Math.cos(eccentricAnomaly);
|
||||
iterationValue = eccentricAnomaly - NRfunction / dNRfunction;
|
||||
}
|
||||
|
||||
eccentricAnomaly = iterationValue + revs * CesiumMath.TWO_PI;
|
||||
return eccentricAnomaly;
|
||||
}
|
||||
|
||||
// Calculates the true anomaly given the eccentric anomaly and the eccentricity.
|
||||
function eccentricAnomalyToTrueAnomaly(eccentricAnomaly, eccentricity) {
|
||||
// Calculate the number of previous revolutions
|
||||
const revs = Math.floor(eccentricAnomaly / CesiumMath.TWO_PI);
|
||||
|
||||
// Find angle in current revolution
|
||||
eccentricAnomaly -= revs * CesiumMath.TWO_PI;
|
||||
|
||||
// Calculate true anomaly from eccentric anomaly
|
||||
const trueAnomalyX = Math.cos(eccentricAnomaly) - eccentricity;
|
||||
const trueAnomalyY =
|
||||
Math.sin(eccentricAnomaly) * Math.sqrt(1 - eccentricity * eccentricity);
|
||||
|
||||
let trueAnomaly = Math.atan2(trueAnomalyY, trueAnomalyX);
|
||||
|
||||
// Ensure the correct quadrant
|
||||
trueAnomaly = CesiumMath.zeroToTwoPi(trueAnomaly);
|
||||
if (eccentricAnomaly < 0) {
|
||||
trueAnomaly -= CesiumMath.TWO_PI;
|
||||
}
|
||||
|
||||
// Add on previous revolutions
|
||||
trueAnomaly += revs * CesiumMath.TWO_PI;
|
||||
|
||||
return trueAnomaly;
|
||||
}
|
||||
|
||||
// Calculates the transformation matrix to convert from the perifocal (PQW) coordinate
|
||||
// system to inertial cartesian coordinates.
|
||||
function perifocalToCartesianMatrix(
|
||||
argumentOfPeriapsis,
|
||||
inclination,
|
||||
rightAscension,
|
||||
result,
|
||||
) {
|
||||
const cosap = Math.cos(argumentOfPeriapsis);
|
||||
const sinap = Math.sin(argumentOfPeriapsis);
|
||||
|
||||
const cosi = Math.cos(inclination);
|
||||
const sini = Math.sin(inclination);
|
||||
|
||||
const cosraan = Math.cos(rightAscension);
|
||||
const sinraan = Math.sin(rightAscension);
|
||||
if (result == null) {
|
||||
result = rowMajor(
|
||||
cosraan * cosap - sinraan * sinap * cosi,
|
||||
-cosraan * sinap - sinraan * cosap * cosi,
|
||||
sinraan * sini,
|
||||
|
||||
sinraan * cosap + cosraan * sinap * cosi,
|
||||
-sinraan * sinap + cosraan * cosap * cosi,
|
||||
-cosraan * sini,
|
||||
|
||||
sinap * sini,
|
||||
cosap * sini,
|
||||
cosi,
|
||||
);
|
||||
} else {
|
||||
result[0] = cosraan * cosap - sinraan * sinap * cosi;
|
||||
result[1] = sinraan * cosap + cosraan * sinap * cosi;
|
||||
result[2] = sinap * sini;
|
||||
result[3] = -cosraan * sinap - sinraan * cosap * cosi;
|
||||
result[4] = -sinraan * sinap + cosraan * cosap * cosi;
|
||||
result[5] = cosap * sini;
|
||||
result[6] = sinraan * sini;
|
||||
result[7] = -cosraan * sini;
|
||||
result[8] = cosi;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// From section 5.8
|
||||
const semiMajorAxis0 = 1.0000010178 * MetersPerAstronomicalUnit;
|
||||
const meanLongitude0 = 100.46645683 * RadiansPerDegree;
|
||||
const meanLongitude1 = 1295977422.83429 * RadiansPerArcSecond;
|
||||
|
||||
// From table 6
|
||||
const p1u = 16002;
|
||||
const p2u = 21863;
|
||||
const p3u = 32004;
|
||||
const p4u = 10931;
|
||||
const p5u = 14529;
|
||||
const p6u = 16368;
|
||||
const p7u = 15318;
|
||||
const p8u = 32794;
|
||||
|
||||
const Ca1 = 64 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Ca2 = -152 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Ca3 = 62 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Ca4 = -8 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Ca5 = 32 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Ca6 = -41 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Ca7 = 19 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Ca8 = -11 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
|
||||
const Sa1 = -150 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Sa2 = -46 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Sa3 = 68 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Sa4 = 54 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Sa5 = 14 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Sa6 = 24 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Sa7 = -28 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
const Sa8 = 22 * 1e-7 * MetersPerAstronomicalUnit;
|
||||
|
||||
const q1u = 10;
|
||||
const q2u = 16002;
|
||||
const q3u = 21863;
|
||||
const q4u = 10931;
|
||||
const q5u = 1473;
|
||||
const q6u = 32004;
|
||||
const q7u = 4387;
|
||||
const q8u = 73;
|
||||
|
||||
const Cl1 = -325 * 1e-7;
|
||||
const Cl2 = -322 * 1e-7;
|
||||
const Cl3 = -79 * 1e-7;
|
||||
const Cl4 = 232 * 1e-7;
|
||||
const Cl5 = -52 * 1e-7;
|
||||
const Cl6 = 97 * 1e-7;
|
||||
const Cl7 = 55 * 1e-7;
|
||||
const Cl8 = -41 * 1e-7;
|
||||
|
||||
const Sl1 = -105 * 1e-7;
|
||||
const Sl2 = -137 * 1e-7;
|
||||
const Sl3 = 258 * 1e-7;
|
||||
const Sl4 = 35 * 1e-7;
|
||||
const Sl5 = -116 * 1e-7;
|
||||
const Sl6 = -88 * 1e-7;
|
||||
const Sl7 = -112 * 1e-7;
|
||||
const Sl8 = -80 * 1e-7;
|
||||
|
||||
const scratchDate = JulianDate.fromTai(0, 0.0);
|
||||
// Gets a point describing the motion of the Earth-Moon barycenter according to the equations described in section 6.
|
||||
function computeSimonEarthMoonBarycenter(date, result) {
|
||||
// t is thousands of years from J2000 TDB
|
||||
taiToTdb(date, scratchDate);
|
||||
const x =
|
||||
scratchDate.dayNumber -
|
||||
epoch.dayNumber +
|
||||
(scratchDate.secondsOfDay - epoch.secondsOfDay) / SECONDS_PER_DAY;
|
||||
const t = x / (DAYS_PER_JULIAN_CENTURY * 10.0);
|
||||
|
||||
const u = 0.3595362 * t;
|
||||
const semimajorAxis =
|
||||
semiMajorAxis0 +
|
||||
Ca1 * Math.cos(p1u * u) +
|
||||
Sa1 * Math.sin(p1u * u) +
|
||||
Ca2 * Math.cos(p2u * u) +
|
||||
Sa2 * Math.sin(p2u * u) +
|
||||
Ca3 * Math.cos(p3u * u) +
|
||||
Sa3 * Math.sin(p3u * u) +
|
||||
Ca4 * Math.cos(p4u * u) +
|
||||
Sa4 * Math.sin(p4u * u) +
|
||||
Ca5 * Math.cos(p5u * u) +
|
||||
Sa5 * Math.sin(p5u * u) +
|
||||
Ca6 * Math.cos(p6u * u) +
|
||||
Sa6 * Math.sin(p6u * u) +
|
||||
Ca7 * Math.cos(p7u * u) +
|
||||
Sa7 * Math.sin(p7u * u) +
|
||||
Ca8 * Math.cos(p8u * u) +
|
||||
Sa8 * Math.sin(p8u * u);
|
||||
const meanLongitude =
|
||||
meanLongitude0 +
|
||||
meanLongitude1 * t +
|
||||
Cl1 * Math.cos(q1u * u) +
|
||||
Sl1 * Math.sin(q1u * u) +
|
||||
Cl2 * Math.cos(q2u * u) +
|
||||
Sl2 * Math.sin(q2u * u) +
|
||||
Cl3 * Math.cos(q3u * u) +
|
||||
Sl3 * Math.sin(q3u * u) +
|
||||
Cl4 * Math.cos(q4u * u) +
|
||||
Sl4 * Math.sin(q4u * u) +
|
||||
Cl5 * Math.cos(q5u * u) +
|
||||
Sl5 * Math.sin(q5u * u) +
|
||||
Cl6 * Math.cos(q6u * u) +
|
||||
Sl6 * Math.sin(q6u * u) +
|
||||
Cl7 * Math.cos(q7u * u) +
|
||||
Sl7 * Math.sin(q7u * u) +
|
||||
Cl8 * Math.cos(q8u * u) +
|
||||
Sl8 * Math.sin(q8u * u);
|
||||
|
||||
// All constants in this part are from section 5.8
|
||||
const eccentricity = 0.0167086342 - 0.0004203654 * t;
|
||||
const longitudeOfPerigee =
|
||||
102.93734808 * RadiansPerDegree + 11612.3529 * RadiansPerArcSecond * t;
|
||||
const inclination = 469.97289 * RadiansPerArcSecond * t;
|
||||
const longitudeOfNode =
|
||||
174.87317577 * RadiansPerDegree - 8679.27034 * RadiansPerArcSecond * t;
|
||||
|
||||
return elementsToCartesian(
|
||||
semimajorAxis,
|
||||
eccentricity,
|
||||
inclination,
|
||||
longitudeOfPerigee,
|
||||
longitudeOfNode,
|
||||
meanLongitude,
|
||||
result,
|
||||
);
|
||||
}
|
||||
|
||||
// Gets a point describing the position of the moon according to the equations described in section 4.
|
||||
function computeSimonMoon(date, result) {
|
||||
taiToTdb(date, scratchDate);
|
||||
const x =
|
||||
scratchDate.dayNumber -
|
||||
epoch.dayNumber +
|
||||
(scratchDate.secondsOfDay - epoch.secondsOfDay) / SECONDS_PER_DAY;
|
||||
const t = x / DAYS_PER_JULIAN_CENTURY;
|
||||
const t2 = t * t;
|
||||
const t3 = t2 * t;
|
||||
const t4 = t3 * t;
|
||||
|
||||
// Terms from section 3.4 (b.1)
|
||||
let semimajorAxis = 383397.7725 + 0.004 * t;
|
||||
let eccentricity = 0.055545526 - 0.000000016 * t;
|
||||
const inclinationConstant = 5.15668983 * RadiansPerDegree;
|
||||
let inclinationSecPart =
|
||||
-0.00008 * t + 0.02966 * t2 - 0.000042 * t3 - 0.00000013 * t4;
|
||||
const longitudeOfPerigeeConstant = 83.35324312 * RadiansPerDegree;
|
||||
let longitudeOfPerigeeSecPart =
|
||||
14643420.2669 * t - 38.2702 * t2 - 0.045047 * t3 + 0.00021301 * t4;
|
||||
const longitudeOfNodeConstant = 125.04455501 * RadiansPerDegree;
|
||||
let longitudeOfNodeSecPart =
|
||||
-6967919.3631 * t + 6.3602 * t2 + 0.007625 * t3 - 0.00003586 * t4;
|
||||
const meanLongitudeConstant = 218.31664563 * RadiansPerDegree;
|
||||
let meanLongitudeSecPart =
|
||||
1732559343.4847 * t - 6.391 * t2 + 0.006588 * t3 - 0.00003169 * t4;
|
||||
|
||||
// Delaunay arguments from section 3.5 b
|
||||
const D =
|
||||
297.85019547 * RadiansPerDegree +
|
||||
RadiansPerArcSecond *
|
||||
(1602961601.209 * t - 6.3706 * t2 + 0.006593 * t3 - 0.00003169 * t4);
|
||||
const F =
|
||||
93.27209062 * RadiansPerDegree +
|
||||
RadiansPerArcSecond *
|
||||
(1739527262.8478 * t - 12.7512 * t2 - 0.001037 * t3 + 0.00000417 * t4);
|
||||
const l =
|
||||
134.96340251 * RadiansPerDegree +
|
||||
RadiansPerArcSecond *
|
||||
(1717915923.2178 * t + 31.8792 * t2 + 0.051635 * t3 - 0.0002447 * t4);
|
||||
const lprime =
|
||||
357.52910918 * RadiansPerDegree +
|
||||
RadiansPerArcSecond *
|
||||
(129596581.0481 * t - 0.5532 * t2 + 0.000136 * t3 - 0.00001149 * t4);
|
||||
const psi =
|
||||
310.17137918 * RadiansPerDegree -
|
||||
RadiansPerArcSecond *
|
||||
(6967051.436 * t + 6.2068 * t2 + 0.007618 * t3 - 0.00003219 * t4);
|
||||
|
||||
// Add terms from Table 4
|
||||
const twoD = 2.0 * D;
|
||||
const fourD = 4.0 * D;
|
||||
const sixD = 6.0 * D;
|
||||
const twol = 2.0 * l;
|
||||
const threel = 3.0 * l;
|
||||
const fourl = 4.0 * l;
|
||||
const twoF = 2.0 * F;
|
||||
semimajorAxis +=
|
||||
3400.4 * Math.cos(twoD) -
|
||||
635.6 * Math.cos(twoD - l) -
|
||||
235.6 * Math.cos(l) +
|
||||
218.1 * Math.cos(twoD - lprime) +
|
||||
181.0 * Math.cos(twoD + l);
|
||||
eccentricity +=
|
||||
0.014216 * Math.cos(twoD - l) +
|
||||
0.008551 * Math.cos(twoD - twol) -
|
||||
0.001383 * Math.cos(l) +
|
||||
0.001356 * Math.cos(twoD + l) -
|
||||
0.001147 * Math.cos(fourD - threel) -
|
||||
0.000914 * Math.cos(fourD - twol) +
|
||||
0.000869 * Math.cos(twoD - lprime - l) -
|
||||
0.000627 * Math.cos(twoD) -
|
||||
0.000394 * Math.cos(fourD - fourl) +
|
||||
0.000282 * Math.cos(twoD - lprime - twol) -
|
||||
0.000279 * Math.cos(D - l) -
|
||||
0.000236 * Math.cos(twol) +
|
||||
0.000231 * Math.cos(fourD) +
|
||||
0.000229 * Math.cos(sixD - fourl) -
|
||||
0.000201 * Math.cos(twol - twoF);
|
||||
inclinationSecPart +=
|
||||
486.26 * Math.cos(twoD - twoF) -
|
||||
40.13 * Math.cos(twoD) +
|
||||
37.51 * Math.cos(twoF) +
|
||||
25.73 * Math.cos(twol - twoF) +
|
||||
19.97 * Math.cos(twoD - lprime - twoF);
|
||||
longitudeOfPerigeeSecPart +=
|
||||
-55609 * Math.sin(twoD - l) -
|
||||
34711 * Math.sin(twoD - twol) -
|
||||
9792 * Math.sin(l) +
|
||||
9385 * Math.sin(fourD - threel) +
|
||||
7505 * Math.sin(fourD - twol) +
|
||||
5318 * Math.sin(twoD + l) +
|
||||
3484 * Math.sin(fourD - fourl) -
|
||||
3417 * Math.sin(twoD - lprime - l) -
|
||||
2530 * Math.sin(sixD - fourl) -
|
||||
2376 * Math.sin(twoD) -
|
||||
2075 * Math.sin(twoD - threel) -
|
||||
1883 * Math.sin(twol) -
|
||||
1736 * Math.sin(sixD - 5.0 * l) +
|
||||
1626 * Math.sin(lprime) -
|
||||
1370 * Math.sin(sixD - threel);
|
||||
longitudeOfNodeSecPart +=
|
||||
-5392 * Math.sin(twoD - twoF) -
|
||||
540 * Math.sin(lprime) -
|
||||
441 * Math.sin(twoD) +
|
||||
423 * Math.sin(twoF) -
|
||||
288 * Math.sin(twol - twoF);
|
||||
meanLongitudeSecPart +=
|
||||
-3332.9 * Math.sin(twoD) +
|
||||
1197.4 * Math.sin(twoD - l) -
|
||||
662.5 * Math.sin(lprime) +
|
||||
396.3 * Math.sin(l) -
|
||||
218.0 * Math.sin(twoD - lprime);
|
||||
|
||||
// Add terms from Table 5
|
||||
const twoPsi = 2.0 * psi;
|
||||
const threePsi = 3.0 * psi;
|
||||
inclinationSecPart +=
|
||||
46.997 * Math.cos(psi) * t -
|
||||
0.614 * Math.cos(twoD - twoF + psi) * t +
|
||||
0.614 * Math.cos(twoD - twoF - psi) * t -
|
||||
0.0297 * Math.cos(twoPsi) * t2 -
|
||||
0.0335 * Math.cos(psi) * t2 +
|
||||
0.0012 * Math.cos(twoD - twoF + twoPsi) * t2 -
|
||||
0.00016 * Math.cos(psi) * t3 +
|
||||
0.00004 * Math.cos(threePsi) * t3 +
|
||||
0.00004 * Math.cos(twoPsi) * t3;
|
||||
const perigeeAndMean =
|
||||
2.116 * Math.sin(psi) * t -
|
||||
0.111 * Math.sin(twoD - twoF - psi) * t -
|
||||
0.0015 * Math.sin(psi) * t2;
|
||||
longitudeOfPerigeeSecPart += perigeeAndMean;
|
||||
meanLongitudeSecPart += perigeeAndMean;
|
||||
longitudeOfNodeSecPart +=
|
||||
-520.77 * Math.sin(psi) * t +
|
||||
13.66 * Math.sin(twoD - twoF + psi) * t +
|
||||
1.12 * Math.sin(twoD - psi) * t -
|
||||
1.06 * Math.sin(twoF - psi) * t +
|
||||
0.66 * Math.sin(twoPsi) * t2 +
|
||||
0.371 * Math.sin(psi) * t2 -
|
||||
0.035 * Math.sin(twoD - twoF + twoPsi) * t2 -
|
||||
0.015 * Math.sin(twoD - twoF + psi) * t2 +
|
||||
0.0014 * Math.sin(psi) * t3 -
|
||||
0.0011 * Math.sin(threePsi) * t3 -
|
||||
0.0009 * Math.sin(twoPsi) * t3;
|
||||
|
||||
// Add constants and convert units
|
||||
semimajorAxis *= MetersPerKilometer;
|
||||
const inclination =
|
||||
inclinationConstant + inclinationSecPart * RadiansPerArcSecond;
|
||||
const longitudeOfPerigee =
|
||||
longitudeOfPerigeeConstant +
|
||||
longitudeOfPerigeeSecPart * RadiansPerArcSecond;
|
||||
const meanLongitude =
|
||||
meanLongitudeConstant + meanLongitudeSecPart * RadiansPerArcSecond;
|
||||
const longitudeOfNode =
|
||||
longitudeOfNodeConstant + longitudeOfNodeSecPart * RadiansPerArcSecond;
|
||||
|
||||
return elementsToCartesian(
|
||||
semimajorAxis,
|
||||
eccentricity,
|
||||
inclination,
|
||||
longitudeOfPerigee,
|
||||
longitudeOfNode,
|
||||
meanLongitude,
|
||||
result,
|
||||
);
|
||||
}
|
||||
|
||||
// Gets a point describing the motion of the Earth. This point uses the Moon point and
|
||||
// the 1992 mu value (ratio between Moon and Earth masses) in Table 2 of the paper in order
|
||||
// to determine the position of the Earth relative to the Earth-Moon barycenter.
|
||||
const moonEarthMassRatio = 0.012300034; // From 1992 mu value in Table 2
|
||||
const factor = (moonEarthMassRatio / (moonEarthMassRatio + 1.0)) * -1;
|
||||
function computeSimonEarth(date, result) {
|
||||
result = computeSimonMoon(date, result);
|
||||
return Cartesian3.multiplyByScalar(result, factor, result);
|
||||
}
|
||||
|
||||
// Values for the <code>axesTransformation</code> needed for the rotation were found using the STK Components
|
||||
// GeographicTransformer on the position of the sun center of mass point and the earth J2000 frame.
|
||||
|
||||
const axesTransformation = rowMajor(
|
||||
1.0000000000000002,
|
||||
5.619723173785822e-16,
|
||||
4.690511510146299e-19,
|
||||
-5.154129427414611e-16,
|
||||
0.9174820620691819,
|
||||
-0.39777715593191376,
|
||||
-2.23970096136568e-16,
|
||||
0.39777715593191376,
|
||||
0.9174820620691819,
|
||||
);
|
||||
let translation = Cartesian3.create();
|
||||
|
||||
/**
|
||||
* Computes the position of the Sun in the Earth-centered inertial frame
|
||||
*
|
||||
* @param {JulianDate} [julianDate] The time at which to compute the Sun's position, if not provided the current system time is used.
|
||||
* @param {Cartesian3} [result] The object onto which to store the result.
|
||||
* @returns {Cartesian3} Calculated sun position
|
||||
*/
|
||||
export function computeSunPositionInEarthInertialFrame(julianDate, result) {
|
||||
if (result == null) result = Cartesian3.create();
|
||||
|
||||
//first forward transformation
|
||||
translation = computeSimonEarthMoonBarycenter(julianDate, translation);
|
||||
result = Cartesian3.negate(translation, result);
|
||||
|
||||
//second forward transformation
|
||||
computeSimonEarth(julianDate, translation);
|
||||
|
||||
Cartesian3.subtract(result, translation, result);
|
||||
Matrix3.multiplyByVector(axesTransformation, result, result);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Computes the position of the Moon in the Earth-centered inertial frame
|
||||
*
|
||||
* @param {JulianDate} [julianDate] The time at which to compute the Moon's position, if not provided the current system time is used.
|
||||
* @param {Cartesian3} [result] The object onto which to store the result.
|
||||
* @returns {Cartesian3} Calculated moon position
|
||||
*/
|
||||
export function computeMoonPositionInEarthInertialFrame(julianDate, result) {
|
||||
result = computeSimonMoon(julianDate, result);
|
||||
Matrix3.multiplyByVector(axesTransformation, result, result);
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
// Bit-for-bit comparison of the Sun and Moon positions, the TAI dates they
|
||||
// take and the TEME rotation with Cesium's, over dates from 1960 to 2100
|
||||
// (leap second edges included).
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import * as geo from './index.js';
|
||||
|
||||
const same = (a, b, label) =>
|
||||
assert.ok(Object.is(a, b), `${label}: ${a} !== ${b}`);
|
||||
const dates = [
|
||||
Date.UTC(1960, 0, 1),
|
||||
Date.UTC(1972, 0, 1),
|
||||
Date.UTC(1972, 0, 1) - 1,
|
||||
Date.UTC(2016, 11, 31, 23, 59, 59, 999),
|
||||
Date.UTC(2017, 0, 1),
|
||||
Date.UTC(2026, 10, 4, 12, 30, 15, 250),
|
||||
Date.UTC(2100, 5, 30, 11, 59, 59, 500),
|
||||
];
|
||||
for (let i = 0; i < 400; i++)
|
||||
dates.push(Date.UTC(1990, 0, 1) + Math.floor(i * 7919.123 * 3600 * 1000));
|
||||
|
||||
test('dates from JavaScript Dates match Cesium JulianDate.fromDate', () => {
|
||||
for (const ms of dates) {
|
||||
const ours = geo.julianDate.fromDate(new Date(ms));
|
||||
const theirs = Cesium.JulianDate.fromDate(new Date(ms));
|
||||
same(ours.dayNumber, theirs.dayNumber, `${ms} day`);
|
||||
same(ours.secondsOfDay, theirs.secondsOfDay, `${ms} seconds`);
|
||||
same(
|
||||
geo.julianDate.computeTaiMinusUtc(ours),
|
||||
Cesium.JulianDate.computeTaiMinusUtc(theirs),
|
||||
`${ms} TAI - UTC`,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('Sun and Moon inertial positions and the TEME rotation match Cesium bit for bit', () => {
|
||||
const Simon = Cesium.Simon1994PlanetaryPositions;
|
||||
for (const ms of dates) {
|
||||
const ours = geo.julianDate.fromDate(new Date(ms));
|
||||
const theirs = Cesium.JulianDate.fromDate(new Date(ms));
|
||||
for (const [name, mine, cesium] of [
|
||||
[
|
||||
'sun',
|
||||
geo.simon1994.computeSunPositionInEarthInertialFrame(ours),
|
||||
Simon.computeSunPositionInEarthInertialFrame(theirs),
|
||||
],
|
||||
[
|
||||
'moon',
|
||||
geo.simon1994.computeMoonPositionInEarthInertialFrame(ours),
|
||||
Simon.computeMoonPositionInEarthInertialFrame(theirs),
|
||||
],
|
||||
])
|
||||
for (const axis of ['x', 'y', 'z'])
|
||||
same(mine[axis], cesium[axis], `${ms} ${name}.${axis}`);
|
||||
const teme = geo.transforms.computeTemeToPseudoFixedMatrix(ours);
|
||||
const cesiumTeme = Cesium.Transforms.computeTemeToPseudoFixedMatrix(theirs);
|
||||
for (let k = 0; k < 9; k++)
|
||||
same(teme[k], cesiumTeme[k], `${ms} teme[${k}]`);
|
||||
}
|
||||
});
|
||||
+60
-1
@@ -9,7 +9,12 @@
|
||||
import { DEBUG } from './debug.js';
|
||||
import { Check } from './check.js';
|
||||
import { DeveloperError } from './developerError.js';
|
||||
import { EPSILON14, equalsEpsilon as scalarEqualsEpsilon } from './math.js';
|
||||
import {
|
||||
EPSILON14,
|
||||
TWO_PI,
|
||||
equalsEpsilon as scalarEqualsEpsilon,
|
||||
} from './math.js';
|
||||
import * as JulianDate from './julianDate.js';
|
||||
import {
|
||||
create as createCartesian3,
|
||||
cross,
|
||||
@@ -238,3 +243,57 @@ export function headingPitchRollToFixedFrame(
|
||||
result = fixedFrameTransform(origin, ellipsoid, result);
|
||||
return multiply(result, hprMatrix, result);
|
||||
}
|
||||
|
||||
const gmstConstant0 = 6 * 3600 + 41 * 60 + 50.54841;
|
||||
const gmstConstant1 = 8640184.812866;
|
||||
const gmstConstant2 = 0.093104;
|
||||
const gmstConstant3 = -6.2e-6;
|
||||
const rateCoef = 1.1772758384668e-19;
|
||||
const wgs84WRPrecessing = 7.2921158553e-5;
|
||||
const twoPiOverSecondsInDay = TWO_PI / 86400.0;
|
||||
let dateInUtc = { dayNumber: 0, secondsOfDay: 0 };
|
||||
|
||||
/**
|
||||
* The rotation from the True Equator Mean Equinox (TEME) axes to the
|
||||
* pseudo-fixed axes at a geo/julianDate.js date: Cesium's
|
||||
* computeTemeToPseudoFixedMatrix, which takes UTC for UT1.
|
||||
*/
|
||||
export function computeTemeToPseudoFixedMatrix(date, result) {
|
||||
dateInUtc = JulianDate.addSeconds(
|
||||
date,
|
||||
-JulianDate.computeTaiMinusUtc(date),
|
||||
dateInUtc,
|
||||
);
|
||||
const utcDayNumber = dateInUtc.dayNumber;
|
||||
const utcSecondsIntoDay = dateInUtc.secondsOfDay;
|
||||
|
||||
let t;
|
||||
const diffDays = utcDayNumber - 2451545;
|
||||
if (utcSecondsIntoDay >= 43200.0) {
|
||||
t = (diffDays + 0.5) / 36525.0;
|
||||
} else {
|
||||
t = (diffDays - 0.5) / 36525.0;
|
||||
}
|
||||
|
||||
const gmst0 =
|
||||
gmstConstant0 +
|
||||
t * (gmstConstant1 + t * (gmstConstant2 + t * gmstConstant3));
|
||||
const angle = (gmst0 * twoPiOverSecondsInDay) % TWO_PI;
|
||||
const ratio = wgs84WRPrecessing + rateCoef * (utcDayNumber - 2451545.5);
|
||||
const secondsSinceMidnight = (utcSecondsIntoDay + 86400.0 * 0.5) % 86400.0;
|
||||
const gha = angle + ratio * secondsSinceMidnight;
|
||||
const cosGha = Math.cos(gha);
|
||||
const sinGha = Math.sin(gha);
|
||||
|
||||
if (result == null) result = new Array(9);
|
||||
result[0] = cosGha;
|
||||
result[1] = -sinGha;
|
||||
result[2] = 0.0;
|
||||
result[3] = sinGha;
|
||||
result[4] = cosGha;
|
||||
result[5] = 0.0;
|
||||
result[6] = 0.0;
|
||||
result[7] = 0.0;
|
||||
result[8] = 1.0;
|
||||
return result;
|
||||
}
|
||||
Reference in new issue
Block a user