// Follows proj4js 2.22.0's lib/common/ helpers and lib/constants/values.js,
// MIT License, Copyright (c) 2014, Mike Adair, Richard Greenwood, Didier
// Richard, Stephen Irons, Olivier Terral, Calvin Metcalf. See NOTICE.
///|
const PI : Double = 3.141592653589793
///|
/// Degrees to radians as proj4js converts them.
const D2R : Double = 0.01745329251994329577
///|
const R2D : Double = 57.29577951308232088
///|
/// Slightly more than π, as proj4js's `adjust_lon` tests against.
const SPI : Double = 3.14159265359
///|
fn adjust_lon(x : Double) -> Double {
if x.abs() <= SPI {
x
} else {
x - (if x < 0.0 { -1.0 } else { 1.0 }) * 2.0 * PI
}
}
///|
fn sinh(m : Trig, x : Double) -> Double {
let r = m.exp(x)
(r - 1.0 / r) / 2.0
}
///|
fn cosh(m : Trig, x : Double) -> Double {
let r = m.exp(x)
(r + 1.0 / r) / 2.0
}
///|
fn hypot(x : Double, y : Double) -> Double {
let x = x.abs()
let y = y.abs()
let a = @cmp.maximum(x, y)
let b = @cmp.minimum(x, y) / (if a != 0.0 { a } else { 1.0 })
a * (1.0 + b * b).sqrt()
}
///|
fn log1py(m : Trig, x : Double) -> Double {
let y = 1.0 + x
let z = y - 1.0
if z == 0.0 {
x
} else {
x * m.ln(y) / z
}
}
///|
fn asinhy(m : Trig, x : Double) -> Double {
let y = x.abs()
let y = log1py(m, y * (1.0 + y / (hypot(1.0, y) + 1.0)))
if x < 0.0 {
-y
} else {
y
}
}
///|
/// Gaussian to geodetic latitude and back (`gatg`), by Clenshaw summation.
fn gatg(m : Trig, pp : FixedArray[Double], b : Double) -> Double {
let cos_2b = 2.0 * m.cos(2.0 * b)
let mut i = pp.length() - 1
let mut h1 = pp[i]
let mut h2 = 0.0
let mut h = 0.0
while i > 0 {
i -= 1
h = -h2 + cos_2b * h1 + pp[i]
h2 = h1
h1 = h
}
b + h * m.sin(2.0 * b)
}
///|
fn clens(m : Trig, pp : FixedArray[Double], arg_r : Double) -> Double {
let r = 2.0 * m.cos(arg_r)
let mut i = pp.length() - 1
let mut hr1 = pp[i]
let mut hr2 = 0.0
let mut hr = 0.0
while i > 0 {
i -= 1
hr = -hr2 + r * hr1 + pp[i]
hr2 = hr1
hr1 = hr
}
m.sin(arg_r) * hr
}
///|
fn clens_cmplx(
m : Trig,
pp : FixedArray[Double],
arg_r : Double,
arg_i : Double,
) -> (Double, Double) {
let sin_arg_r = m.sin(arg_r)
let cos_arg_r = m.cos(arg_r)
let sinh_arg_i = sinh(m, arg_i)
let cosh_arg_i = cosh(m, arg_i)
let r = 2.0 * cos_arg_r * cosh_arg_i
let i = -2.0 * sin_arg_r * sinh_arg_i
let mut j = pp.length() - 1
let mut hr = pp[j]
let mut hi1 = 0.0
let mut hr1 = 0.0
let mut hi = 0.0
while j > 0 {
j -= 1
let hr2 = hr1
let hi2 = hi1
hr1 = hr
hi1 = hi
hr = -hr2 + r * hr1 - i * hi1 + pp[j]
hi = -hi2 + i * hr1 + r * hi1
}
let r = sin_arg_r * cosh_arg_i
let i = cos_arg_r * sinh_arg_i
(r * hr - i * hi, r * hi + i * hr)
}
///|
/// What a projection gives for a point beyond its reach.
let nan2 : (Double, Double) = (@double.not_a_number, @double.not_a_number)
///|
const HALF_PI : Double = 1.5707963267948966
///|
const FORTPI : Double = 0.7853981633974483
///|
const EPSLN : Double = 1.0e-10
///|
fn sign(x : Double) -> Double {
if x < 0.0 {
-1.0
} else {
1.0
}
}
///|
fn adjust_lat(x : Double) -> Double {
if x.abs() < HALF_PI {
x
} else {
x - sign(x) * PI
}
}
///|
/// JavaScript's `x || d` for a parameter: `d` when `x` is missing (NaN) or 0.
fn or(x : Double, d : Double) -> Double {
if x.is_nan() || x == 0.0 {
d
} else {
x
}
}
///|
fn asinz(m : Trig, x : Double) -> Double {
m.asin(if x.abs() > 1.0 { sign(x) } else { x })
}
///|
fn msfnz(e : Double, sinphi : Double, cosphi : Double) -> Double {
let con = e * sinphi
cosphi / (1.0 - con * con).sqrt()
}
///|
fn tsfnz(m : Trig, e : Double, phi : Double, sinphi : Double) -> Double {
let con = e * sinphi
let con = m.pow((1.0 - con) / (1.0 + con), 0.5 * e)
m.tan(0.5 * (HALF_PI - phi)) / con
}
///|
/// The latitude of isometric `ts`; NaN if the iteration does not settle
/// (proj4js's -9999).
fn phi2z(m : Trig, e : Double, ts : Double) -> Double {
let eccnth = 0.5 * e
let mut phi = HALF_PI - 2.0 * m.atan(ts)
for _ in 0..<=15 {
let con = e * m.sin(phi)
let dphi = HALF_PI -
2.0 * m.atan(ts * m.pow((1.0 - con) / (1.0 + con), eccnth)) -
phi
phi += dphi
if dphi.abs() <= 0.0000000001 {
return phi
}
}
@double.not_a_number
}
///|
fn qsfnz(m : Trig, e : Double, sinphi : Double) -> Double {
if e > 1.0e-7 {
let con = e * sinphi
(1.0 - e * e) *
(sinphi / (1.0 - con * con) - 0.5 / e * m.ln((1.0 - con) / (1.0 + con)))
} else {
2.0 * sinphi
}
}
///|
fn iqsfnz(m : Trig, e : Double, q : Double) -> Double {
let temp = 1.0 - (1.0 - e * e) / (2.0 * e) * m.ln((1.0 - e) / (1.0 + e))
if (q.abs() - temp).abs() < 1.0e-6 {
return if q < 0.0 { -HALF_PI } else { HALF_PI }
}
let mut phi = m.asin(0.5 * q)
for _ in 0..<30 {
let sin_phi = m.sin(phi)
let cos_phi = m.cos(phi)
let con = e * sin_phi
let dphi = m.pow(1.0 - con * con, 2.0) /
(2.0 * cos_phi) *
(
q / (1.0 - e * e) -
sin_phi / (1.0 - con * con) +
0.5 / e * m.ln((1.0 - con) / (1.0 + con))
)
phi += dphi
if dphi.abs() <= 0.0000000001 {
return phi
}
}
@double.not_a_number
}
///|
/// The meridian distance series' coefficients e0-e3 (`e0fn`-`e3fn`).
fn mlfn_coefficients(es : Double) -> (Double, Double, Double, Double) {
(
1.0 - 0.25 * es * (1.0 + es / 16.0 * (3.0 + 1.25 * es)),
0.375 * es * (1.0 + 0.25 * es * (1.0 + 0.46875 * es)),
0.05859375 * es * es * (1.0 + 0.75 * es),
es * es * es * (35.0 / 3072.0),
)
}
///|
fn mlfn(m : Trig, e : (Double, Double, Double, Double), phi : Double) -> Double {
let (e0, e1, e2, e3) = e
e0 * phi -
e1 * m.sin(2.0 * phi) +
e2 * m.sin(4.0 * phi) -
e3 * m.sin(6.0 * phi)
}
///|
fn imlfn(m : Trig, ml : Double, e : (Double, Double, Double, Double)) -> Double {
let (e0, e1, e2, e3) = e
let mut phi = ml / e0
for _ in 0..<15 {
let dphi = (
ml -
(
e0 * phi -
e1 * m.sin(2.0 * phi) +
e2 * m.sin(4.0 * phi) -
e3 * m.sin(6.0 * phi)
)
) /
(
e0 -
2.0 * e1 * m.cos(2.0 * phi) +
4.0 * e2 * m.cos(4.0 * phi) -
6.0 * e3 * m.cos(6.0 * phi)
)
phi += dphi
if dphi.abs() <= 0.0000000001 {
return phi
}
}
@double.not_a_number
}
///|
fn g_n(a : Double, e : Double, sinphi : Double) -> Double {
let temp = e * sinphi
a / (1.0 - temp * temp).sqrt()
}
///|
fn srat(m : Trig, esinp : Double, exp : Double) -> Double {
m.pow((1.0 - esinp) / (1.0 + esinp), exp)
}
///|
fn pj_enfn(es : Double) -> FixedArray[Double] {
let en = FixedArray::make(5, 0.0)
en[0] = 1.0 -
es * (0.25 + es * (0.046875 + es * (0.01953125 + es * 0.01068115234375)))
en[1] = es *
(0.75 - es * (0.046875 + es * (0.01953125 + es * 0.01068115234375)))
let t = es * es
en[2] = t *
(0.46875 - es * (0.01302083333333333333 + es * 0.00712076822916666666))
let t = t * es
en[3] = t * (0.36458333333333333333 - es * 0.00569661458333333333)
en[4] = t * es * 0.3076171875
en
}
///|
fn pj_mlfn(
phi : Double,
sphi : Double,
cphi : Double,
en : FixedArray[Double],
) -> Double {
let cphi = cphi * sphi
let sphi = sphi * sphi
en[0] * phi - cphi * (en[1] + sphi * (en[2] + sphi * (en[3] + sphi * en[4])))
}
///|
fn pj_inv_mlfn(
m : Trig,
arg : Double,
es : Double,
en : FixedArray[Double],
) -> Double {
let k = 1.0 / (1.0 - es)
let mut phi = arg
for _ in 0..<20 {
let s = m.sin(phi)
let t = 1.0 - es * s * s
let t = (pj_mlfn(phi, s, m.cos(phi), en) - arg) * (t * t.sqrt()) * k
phi -= t
if t.abs() < EPSLN {
return phi
}
}
phi
}
///|
/// The authalic latitude series' coefficients (`authset`).
fn authset(es : Double) -> FixedArray[Double] {
let apa = FixedArray::make(3, 0.0)
apa[0] = es * 0.33333333333333333333
let t = es * es
apa[0] += t * 0.17222222222222222222
apa[1] = t * 0.06388888888888888888
let t = t * es
apa[0] += t * 0.10257936507936507936
apa[1] += t * 0.06640211640211640211
apa[2] = t * 0.01641501294219154443
apa
}
///|
fn authlat(m : Trig, beta : Double, apa : FixedArray[Double]) -> Double {
let t = beta + beta
beta + apa[0] * m.sin(t) + apa[1] * m.sin(t + t) + apa[2] * m.sin(t + t + t)
}
///|
/// The elementary functions the projections use (`@trig.Trig`): a wasm build
/// passes the host's `Math`, as proj4js computes.
pub using @trig {type Trig}