// Port of proj4js 2.22.0's conic projections (lib/projections/lcc.js, aea.js,
// eqdc.js, bonne.js, poly.js), MIT License, Copyright (c) 2014 Mike Adair et al.; see NOTICE.
///|
/// Lambert conformal conic, on one standard parallel or two.
priv struct Lcc {
p : Base
e : Double
ns : Double
f0 : Double
rh : Double
}
///|
fn Lcc::new(p : Base, d : Definition) -> Lcc {
let m = p.m
let lat1 = d.lat1
let lat2 = or(d.lat2, lat1)
let temp = p.b / p.a
let e = (1.0 - temp * temp).sqrt()
let sin1 = m.sin(lat1)
let ms1 = msfnz(e, sin1, m.cos(lat1))
let ts1 = tsfnz(m, e, lat1, sin1)
let sin2 = m.sin(lat2)
let ms2 = msfnz(e, sin2, m.cos(lat2))
let ts2 = tsfnz(m, e, lat2, sin2)
let ts0 = tsfnz(m, e, p.lat0, m.sin(p.lat0))
let mut ns = if (lat1 - lat2).abs() > EPSLN {
m.ln(ms1 / ms2) / m.ln(ts1 / ts2)
} else {
sin1
}
if ns.is_nan() {
ns = sin1
}
let f0 = ms1 / (ns * m.pow(ts1, ns))
let rh = if (p.lat0.abs() - HALF_PI).abs() < EPSLN {
0.0
} else {
p.a * f0 * m.pow(ts0, ns)
}
{ p, e, ns, f0, rh, }
}
///|
fn Lcc::forward(self : Lcc, lon : Double, lat : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let lat = if (2.0 * lat.abs() - PI).abs() <= EPSLN {
sign(lat) * (HALF_PI - 2.0 * EPSLN)
} else {
lat
}
let rh1 = if (lat.abs() - HALF_PI).abs() > EPSLN {
p.a * self.f0 * m.pow(tsfnz(m, self.e, lat, m.sin(lat)), self.ns)
} else if lat * self.ns <= 0.0 {
return nan2
} else {
0.0
}
let theta = self.ns * adjust_lon(lon - p.long0)
(
p.k0 * (rh1 * m.sin(theta)) + p.x0,
p.k0 * (self.rh - rh1 * m.cos(theta)) + p.y0,
)
}
///|
fn Lcc::inverse(self : Lcc, x : Double, y : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let x = (x - p.x0) / p.k0
let y = self.rh - (y - p.y0) / p.k0
let (rh1, con) = if self.ns > 0.0 {
((x * x + y * y).sqrt(), 1.0)
} else {
(-(x * x + y * y).sqrt(), -1.0)
}
let theta = if rh1 != 0.0 { m.atan2(con * x, con * y) } else { 0.0 }
let lat = if rh1 != 0.0 || self.ns > 0.0 {
phi2z(m, self.e, m.pow(rh1 / (p.a * self.f0), 1.0 / self.ns))
} else {
-HALF_PI
}
(adjust_lon(theta / self.ns + p.long0), lat)
}
///|
/// Albers conic equal area.
priv struct Aea {
p : Base
e3 : Double
ns0 : Double
c : Double
rh : Double
}
///|
fn Aea::new(p : Base, d : Definition) -> Aea {
let m = p.m
let lat1 = d.lat1
let lat2 = if d.lat2.is_nan() { lat1 } else { d.lat2 }
let temp = p.b / p.a
let es = 1.0 - temp * temp
let e3 = es.sqrt()
let sin1 = m.sin(lat1)
let ms1 = msfnz(e3, sin1, m.cos(lat1))
let qs1 = qsfnz(m, e3, sin1)
let sin2 = m.sin(lat2)
let ms2 = msfnz(e3, sin2, m.cos(lat2))
let qs2 = qsfnz(m, e3, sin2)
let qs0 = qsfnz(m, e3, m.sin(p.lat0))
let ns0 = if (lat1 - lat2).abs() > EPSLN {
(ms1 * ms1 - ms2 * ms2) / (qs2 - qs1)
} else {
sin1
}
let c = ms1 * ms1 + ns0 * qs1
{ p, e3, ns0, c, rh: p.a * (c - ns0 * qs0).sqrt() / ns0, }
}
///|
fn Aea::forward(self : Aea, lon : Double, lat : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let qs = qsfnz(m, self.e3, m.sin(lat))
let rh1 = p.a * (self.c - self.ns0 * qs).sqrt() / self.ns0
let theta = self.ns0 * adjust_lon(lon - p.long0)
(rh1 * m.sin(theta) + p.x0, self.rh - rh1 * m.cos(theta) + p.y0)
}
///|
fn Aea::inverse(self : Aea, x : Double, y : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let x = x - p.x0
let y = self.rh - y + p.y0
let (rh1, con) = if self.ns0 >= 0.0 {
((x * x + y * y).sqrt(), 1.0)
} else {
(-(x * x + y * y).sqrt(), -1.0)
}
let theta = if rh1 != 0.0 { m.atan2(con * x, con * y) } else { 0.0 }
let con = rh1 * self.ns0 / p.a
let lat = if p.sphere {
m.asin((self.c - con * con) / (2.0 * self.ns0))
} else {
aea_phi1z(m, self.e3, (self.c - con * con) / self.ns0)
}
(adjust_lon(theta / self.ns0 + p.long0), lat)
}
///|
fn aea_phi1z(m : Trig, e : Double, qs : Double) -> Double {
let mut phi = asinz(m, 0.5 * qs)
if e < EPSLN {
return phi
}
let eccnts = e * e
for _ in 1..<=25 {
let sinphi = m.sin(phi)
let cosphi = m.cos(phi)
let con = e * sinphi
let com = 1.0 - con * con
let dphi = 0.5 *
com *
com /
cosphi *
(
qs / (1.0 - eccnts) -
sinphi / com +
0.5 / e * m.ln((1.0 - con) / (1.0 + con))
)
phi += dphi
if dphi.abs() <= 1.0e-7 {
return phi
}
}
@double.not_a_number
}
///|
/// Equidistant conic.
priv struct Eqdc {
p : Base
en : (Double, Double, Double, Double)
ns : Double
g : Double
rh : Double
}
///|
fn Eqdc::new(p : Base, d : Definition) -> Eqdc {
let m = p.m
let lat1 = d.lat1
let lat2 = or(d.lat2, lat1)
let temp = p.b / p.a
let es = 1.0 - temp * temp
let e = es.sqrt()
let en = mlfn_coefficients(es)
let ms1 = msfnz(e, m.sin(lat1), m.cos(lat1))
let ml1 = mlfn(m, en, lat1)
let ns = if (lat1 - lat2).abs() < EPSLN {
m.sin(lat1)
} else {
let ms2 = msfnz(e, m.sin(lat2), m.cos(lat2))
(ms1 - ms2) / (mlfn(m, en, lat2) - ml1)
}
let g = ml1 + ms1 / ns
{ p, en, ns, g, rh: p.a * (g - mlfn(m, en, p.lat0)), }
}
///|
fn Eqdc::forward(self : Eqdc, lon : Double, lat : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let rh1 = p.a *
(self.g - (if p.sphere { lat } else { mlfn(m, self.en, lat) }))
let theta = self.ns * adjust_lon(lon - p.long0)
(p.x0 + rh1 * m.sin(theta), p.y0 + self.rh - rh1 * m.cos(theta))
}
///|
fn Eqdc::inverse(self : Eqdc, x : Double, y : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let x = x - p.x0
let y = self.rh - y + p.y0
let (rh1, con) = if self.ns >= 0.0 {
((x * x + y * y).sqrt(), 1.0)
} else {
(-(x * x + y * y).sqrt(), -1.0)
}
let theta = if rh1 != 0.0 { m.atan2(con * x, con * y) } else { 0.0 }
let lon = adjust_lon(p.long0 + theta / self.ns)
if p.sphere {
(lon, adjust_lat(self.g - rh1 / p.a))
} else {
(lon, imlfn(m, self.g - rh1 / p.a, self.en))
}
}
///|
/// Bonne (pseudoconic, equal area).
priv struct Bonne {
p : Base
phi1 : Double
en : FixedArray[Double]
m1 : Double
am1 : Double
cphi1 : Double
}
///|
fn Bonne::new(p : Base, d : Definition) -> Bonne? {
let m = p.m
let phi1 = d.lat1
guard phi1.abs() >= EPSLN else { return None }
if p.es != 0.0 {
let en = pj_enfn(p.es)
let s = m.sin(phi1)
let c = m.cos(phi1)
let m1 = pj_mlfn(phi1, s, c, en)
let am1 = c / ((1.0 - p.es * s * s).sqrt() * s)
Some({ p, phi1, en, m1, am1, cphi1: 0.0, })
} else {
let cphi1 = if phi1.abs() + EPSLN >= HALF_PI {
0.0
} else {
1.0 / m.tan(phi1)
}
Some({ p, phi1, en: [], m1: 0.0, am1: 0.0, cphi1, })
}
}
///|
fn Bonne::forward(self : Bonne, lon : Double, lat : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let lam = adjust_lon(lon - p.long0)
let (x, y) = if p.es != 0.0 {
let s = m.sin(lat)
let c = m.cos(lat)
let rh = self.am1 + self.m1 - pj_mlfn(lat, s, c, self.en)
let e = c * lam / (rh * (1.0 - p.es * s * s).sqrt())
(rh * m.sin(e), self.am1 - rh * m.cos(e))
} else {
let rh = self.cphi1 + self.phi1 - lat
if rh.abs() > EPSLN {
let e = lam * m.cos(lat) / rh
(rh * m.sin(e), self.cphi1 - rh * m.cos(e))
} else {
(0.0, 0.0)
}
}
(p.a * x + p.x0, p.a * y + p.y0)
}
///|
fn Bonne::inverse(self : Bonne, x : Double, y : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let x = (x - p.x0) / p.a
let y = (y - p.y0) / p.a
if p.es != 0.0 {
let y = self.am1 - y
let rh = hypot(x, y)
let phi = pj_inv_mlfn(m, self.am1 + self.m1 - rh, p.es, self.en)
let lam = if phi.abs() < HALF_PI {
let s = m.sin(phi)
rh * m.atan2(x, y) * (1.0 - p.es * s * s).sqrt() / m.cos(phi)
} else if (phi.abs() - HALF_PI).abs() <= EPSLN {
0.0
} else {
return nan2
}
(adjust_lon(lam + p.long0), adjust_lat(phi))
} else {
let y = self.cphi1 - y
let rh = hypot(x, y)
let phi = self.cphi1 + self.phi1 - rh
guard phi.abs() <= HALF_PI else { return nan2 }
let lam = if (phi.abs() - HALF_PI).abs() <= EPSLN {
0.0
} else {
rh * m.atan2(x, y) / m.cos(phi)
}
(adjust_lon(lam + p.long0), adjust_lat(phi))
}
}
///|
/// American polyconic.
priv struct Poly {
p : Base
e : Double
es : Double
en : (Double, Double, Double, Double)
ml0 : Double
}
///|
fn Poly::new(p : Base) -> Poly {
let m = p.m
let temp = p.b / p.a
let es = 1.0 - temp * temp
let en = mlfn_coefficients(es)
{ p, e: es.sqrt(), es, en, ml0: p.a * mlfn(m, en, p.lat0), }
}
///|
fn Poly::forward(self : Poly, lon : Double, lat : Double) -> (Double, Double) {
let m = self.p.m
let p = self.p
let dlon = adjust_lon(lon - p.long0)
let el = dlon * m.sin(lat)
let (x, y) = if lat.abs() <= EPSLN {
(p.a * dlon, if p.sphere { -p.a * p.lat0 } else { -self.ml0 })
} else if p.sphere {
(
p.a * m.sin(el) / m.tan(lat),
p.a * (adjust_lat(lat - p.lat0) + (1.0 - m.cos(el)) / m.tan(lat)),
)
} else {
let nl = g_n(p.a, self.e, m.sin(lat)) / m.tan(lat)
(
nl * m.sin(el),
p.a * mlfn(m, self.en, lat) - self.ml0 + nl * (1.0 - m.cos(el)),
)
}
(x + p.x0, y + p.y0)
}
///|
fn Poly::inverse(self : Poly, 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
let mut lat = @double.not_a_number
if p.sphere {
if (y + p.a * p.lat0).abs() <= EPSLN {
return (adjust_lon(x / p.a + p.long0), 0.0)
}
let al = p.lat0 + y / p.a
let bl = x * x / p.a / p.a + al * al
let mut phi = al
for _ in 0..<20 {
let tanphi = m.tan(phi)
let dphi = -1.0 *
(al * (phi * tanphi + 1.0) - phi - 0.5 * (phi * phi + bl) * tanphi) /
((phi - al) / tanphi - 1.0)
phi += dphi
if dphi.abs() <= EPSLN {
lat = phi
break
}
}
(adjust_lon(p.long0 + m.asin(x * m.tan(phi) / p.a) / m.sin(lat)), lat)
} else {
if (y + self.ml0).abs() <= EPSLN {
return (adjust_lon(p.long0 + x / p.a), 0.0)
}
let (e0, e1, e2, e3) = self.en
let al = (self.ml0 + y) / p.a
let bl = x * x / p.a / p.a + al * al
let mut phi = al
for _ in 0..<20 {
let con = self.e * m.sin(phi)
let cl = (1.0 - con * con).sqrt() * m.tan(phi)
let ma = p.a * mlfn(m, self.en, phi) / p.a
let mlnp = 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)
let dphi = (al * (cl * ma + 1.0) - ma - 0.5 * cl * (ma * ma + bl)) /
(
self.es *
m.sin(2.0 * phi) *
(ma * ma + bl - 2.0 * al * ma) /
(4.0 * cl) +
(al - ma) * (cl * mlnp - 2.0 / m.sin(2.0 * phi)) -
mlnp
)
phi -= dphi
if dphi.abs() <= EPSLN {
lat = phi
break
}
}
let s = m.sin(lat)
let cl = (1.0 - self.es * s * s).sqrt() * m.tan(lat)
(adjust_lon(p.long0 + m.asin(x * cl / p.a) / m.sin(lat)), lat)
}
}