// Port of proj4js 2.22.0's pseudocylindrical projections (sinu.js, eck6.js,
// moll.js, robin.js; MIT, Copyright (c) 2014 Mike Adair et al.) and Equal Earth
// (eqearth.js, Apache 2.0, Copyright 2018 Bernie Jenny); see NOTICE.
///|
/// Sinusoidal, and Eckert VI on a sphere (`m`, `n`, `c_x`, `c_y` of the
/// generalized form; Eckert VI is always spherical).
priv struct Sinu {
p : Base
sphere : Bool
en : FixedArray[Double]
m : Double
n : Double
c_x : Double
c_y : Double
}
///|
fn Sinu::new(p : Base, eck6 : Bool) -> Sinu {
let (m, n) = if eck6 {
(1.0, 2.570796326794896619231321691)
} else {
(0.0, 1.0)
}
let sphere = eck6 || p.sphere
let c_y = ((m + 1.0) / n).sqrt()
{
p: { ..p, es: if sphere { 0.0 } else { p.es }, },
sphere,
en: if sphere {
[]
} else {
pj_enfn(p.es)
},
m,
n,
c_x: c_y / (m + 1.0),
c_y,
}
}
///|
fn Sinu::forward(self : Sinu, lon : Double, lat : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let lon = adjust_lon(lon - p.long0)
let (x, y) = if self.sphere {
let mut lat = lat
if self.m == 0.0 {
if self.n != 1.0 {
lat = m.asin(self.n * m.sin(lat))
}
} else {
let k = self.n * m.sin(lat)
for _ in 0..<20 {
let v = (self.m * lat + m.sin(lat) - k) / (self.m + m.cos(lat))
lat -= v
if v.abs() < EPSLN {
break
}
}
}
(p.a * self.c_x * lon * (self.m + m.cos(lat)), p.a * self.c_y * lat)
} else {
let s = m.sin(lat)
let c = m.cos(lat)
(
p.a * lon * c / (1.0 - p.es * s * s).sqrt(),
p.a * pj_mlfn(lat, s, c, self.en),
)
}
// proj4js leaves out the false easting and northing here, which breaks
// their round trip; PROJ adds them.
(x + p.x0, y + p.y0)
}
///|
fn Sinu::inverse(self : Sinu, x : Double, y : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let x = x - p.x0
let y = y - p.y0
if self.sphere {
let lat = y / p.a / self.c_y
let lon = x / p.a / (self.c_x * (self.m + m.cos(lat)))
let lat = if self.m != 0.0 {
asinz(m, (self.m * lat + m.sin(lat)) / self.n)
} else if self.n != 1.0 {
asinz(m, m.sin(lat) / self.n)
} else {
lat
}
(adjust_lon(lon + p.long0), adjust_lat(lat))
} else {
let lat = pj_inv_mlfn(m, y / p.a, p.es, self.en)
let s = lat.abs()
if s < HALF_PI {
let s = m.sin(lat)
(
adjust_lon(
p.long0 + x * (1.0 - p.es * s * s).sqrt() / (p.a * m.cos(lat)),
),
lat,
)
} else if s - EPSLN < HALF_PI {
(p.long0, lat)
} else {
nan2
}
}
}
///|
/// Mollweide.
fn moll_forward(
m : Trig,
p : Base,
lon : Double,
lat : Double,
) -> (Double, Double) {
let mut delta_lon = adjust_lon(lon - p.long0)
let mut theta = lat
let con = PI * m.sin(lat)
// proj4js iterates without a bound; 50 steps reach EPSLN everywhere.
for _ in 0..<50 {
let delta_theta = -(theta + m.sin(theta) - con) / (1.0 + m.cos(theta))
theta += delta_theta
if delta_theta.abs() < EPSLN {
break
}
}
theta /= 2.0
if PI / 2.0 - lat.abs() < EPSLN {
delta_lon = 0.0
}
(
0.900316316158 * p.a * delta_lon * m.cos(theta) + p.x0,
1.4142135623731 * p.a * m.sin(theta) + p.y0,
)
}
///|
fn moll_inverse(m : Trig, p : Base, x : Double, y : Double) -> (Double, Double) {
let mut arg = (y - p.y0) / (1.4142135623731 * p.a)
if arg.abs() > 0.999999999999 {
arg = 0.999999999999
}
let theta = m.asin(arg)
let lon = adjust_lon(
p.long0 + (x - p.x0) / (0.900316316158 * p.a * m.cos(theta)),
)
let lon = @cmp.maximum(-PI, @cmp.minimum(PI, lon))
let arg = (2.0 * theta + m.sin(2.0 * theta)) / PI
(lon, m.asin(if arg.abs() > 1.0 { 1.0 } else { arg }))
}
///|
/// Robinson's table: x and y polynomials per 5° of latitude.
let robin_x : FixedArray[Double] = [
1.0000, 2.2199e-17, -7.15515e-05, 3.1103e-06, 0.9986, -0.000482243, -2.4897e-05,
-1.3309e-06, 0.9954, -0.00083103, -4.48605e-05, -9.86701e-07, 0.9900, -0.00135364,
-5.9661e-05, 3.6777e-06, 0.9822, -0.00167442, -4.49547e-06, -5.72411e-06, 0.9730,
-0.00214868, -9.03571e-05, 1.8736e-08, 0.9600, -0.00305085, -9.00761e-05, 1.64917e-06,
0.9427, -0.00382792, -6.53386e-05, -2.6154e-06, 0.9216, -0.00467746, -0.00010457,
4.81243e-06, 0.8962, -0.00536223, -3.23831e-05, -5.43432e-06, 0.8679, -0.00609363,
-0.000113898, 3.32484e-06, 0.8350, -0.00698325, -6.40253e-05, 9.34959e-07, 0.7986,
-0.00755338, -5.00009e-05, 9.35324e-07, 0.7597, -0.00798324, -3.5971e-05, -2.27626e-06,
0.7186, -0.00851367, -7.01149e-05, -8.6303e-06, 0.6732, -0.00986209, -0.000199569,
1.91974e-05, 0.6213, -0.010418, 8.83923e-05, 6.24051e-06, 0.5722, -0.00906601,
0.000182, 6.24051e-06, 0.5322, -0.00677797, 0.000275608, 6.24051e-06,
]
///|
let robin_y : FixedArray[Double] = [
-5.20417e-18, 0.0124, 1.21431e-18, -8.45284e-11, 0.0620, 0.0124, -1.26793e-09,
4.22642e-10, 0.1240, 0.0124, 5.07171e-09, -1.60604e-09, 0.1860, 0.0123999, -1.90189e-08,
6.00152e-09, 0.2480, 0.0124002, 7.10039e-08, -2.24e-08, 0.3100, 0.0123992, -2.64997e-07,
8.35986e-08, 0.3720, 0.0124029, 9.88983e-07, -3.11994e-07, 0.4340, 0.0123893, -3.69093e-06,
-4.35621e-07, 0.4958, 0.0123198, -1.02252e-05, -3.45523e-07, 0.5571, 0.0121916,
-1.54081e-05, -5.82288e-07, 0.6176, 0.0119938, -2.41424e-05, -5.25327e-07, 0.6769,
0.011713, -3.20223e-05, -5.16405e-07, 0.7346, 0.0113541, -3.97684e-05, -6.09052e-07,
0.7903, 0.0109107, -4.89042e-05, -1.04739e-06, 0.8435, 0.0103431, -6.4615e-05,
-1.40374e-09, 0.8936, 0.00969686, -6.4636e-05, -8.547e-06, 0.9394, 0.00840947,
-0.000192841, -4.2106e-06, 0.9761, 0.00616527, -0.000256, -4.2106e-06, 1.0000,
0.00328947, -0.000319159, -4.2106e-06,
]
///|
fn poly3(t : FixedArray[Double], i : Int32, x : Double) -> Double {
t[i * 4] + x * (t[i * 4 + 1] + x * (t[i * 4 + 2] + x * t[i * 4 + 3]))
}
///|
fn robin_forward(p : Base, lon : Double, lat : Double) -> (Double, Double) {
let lon = adjust_lon(lon - p.long0)
let dphi = lat.abs()
let i = @cmp.maximum(
0,
@cmp.minimum(17, @math.floor(dphi * R2D / 5.0).to_int()),
)
let dphi = R2D * (dphi - 5.0 / R2D * i.to_double())
let y = poly3(robin_y, i, dphi)
(
poly3(robin_x, i, dphi) * lon * p.a * 0.8487 + p.x0,
(if lat < 0.0 { -y } else { y }) * p.a * 1.3523 + p.y0,
)
}
///|
fn robin_inverse(p : Base, x : Double, y : Double) -> (Double, Double) {
let lx = (x - p.x0) / (p.a * 0.8487)
let ly = (y - p.y0).abs() / (p.a * 1.3523)
if ly >= 1.0 {
return (
adjust_lon(lx / robin_x[18 * 4] + p.long0),
if y < 0.0 {
-HALF_PI
} else {
HALF_PI
},
)
}
let mut i = @cmp.maximum(0, @cmp.minimum(17, @math.floor(ly * 18.0).to_int()))
for _ in 0..<40 {
if robin_y[i * 4] > ly {
i -= 1
} else if robin_y[(i + 1) * 4] <= ly {
i += 1
} else {
break
}
}
let y0 = robin_y[i * 4]
let mut t = 5.0 * (ly - y0) / (robin_y[(i + 1) * 4] - y0)
for _ in 0..<100 {
let der = robin_y[i * 4 + 1] +
t * (2.0 * robin_y[i * 4 + 2] + t * 3.0 * robin_y[i * 4 + 3])
let upd = (poly3(robin_y, i, t) - ly) / der
t -= upd
if upd.abs() < EPSLN {
break
}
}
let lat = (5.0 * i.to_double() + t) * D2R
(
adjust_lon(lx / poly3(robin_x, i, t) + p.long0),
if y < 0.0 {
-lat
} else {
lat
},
)
}
///|
/// Equal Earth.
priv struct Eqearth {
p : Base
apa : FixedArray[Double]
qp : Double
rqda : Double
}
///|
const EQEARTH_M : Double = 0.8660254037844386
///|
fn Eqearth::new(p : Base) -> Eqearth {
let m = p.m
if p.es != 0.0 {
let qp = qsfnz(m, p.e, 1.0)
{ p, apa: authset(p.es), qp, rqda: (0.5 * qp).sqrt(), }
} else {
{ p, apa: [], qp: 0.0, rqda: 1.0, }
}
}
///|
fn eqearth_y(t : Double) -> Double {
let t2 = t * t
let t6 = t2 * t2 * t2
t * (1.340264 + -0.081106 * t2 + t6 * (0.000893 + 0.003796 * t2))
}
///|
fn eqearth_dy(t : Double) -> Double {
let t2 = t * t
let t6 = t2 * t2 * t2
1.340264 + 3.0 * -0.081106 * t2 + t6 * (7.0 * 0.000893 + 9.0 * 0.003796 * t2)
}
///|
fn Eqearth::forward(
self : Eqearth,
lon : Double,
lat : Double,
) -> (Double, Double) {
let m = self.p.m
let p = self.p
let lam = adjust_lon(lon - p.long0)
let sinphi = if p.es != 0.0 {
qsfnz(m, p.e, m.sin(lat)) / self.qp
} else {
m.sin(lat)
}
let t = m.asin(EQEARTH_M * sinphi)
let x = lam * m.cos(t) / (EQEARTH_M * eqearth_dy(t)) * self.rqda
let y = eqearth_y(t) * self.rqda
(p.a * x + p.x0, p.a * y + p.y0)
}
///|
fn Eqearth::inverse(self : Eqearth, x : Double, y : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let x = (x - p.x0) / p.a / self.rqda
let y = (y - p.y0) / p.a / self.rqda
let mut t = y
for _ in 0..<12 {
let dlat = (eqearth_y(t) - y) / eqearth_dy(t)
t -= dlat
if dlat.abs() < 1.0e-9 {
break
}
}
let lon = EQEARTH_M * x * eqearth_dy(t) / m.cos(t)
let lat = m.asin(m.sin(t) / EQEARTH_M)
(
adjust_lon(lon + p.long0),
if p.es != 0.0 {
authlat(m, lat, self.apa)
} else {
lat
},
)
}