A subset of geographiclib implemented in Rust.
Currently this implements the direct and the inverse geodesic calculations.
If instead you are looking for Rust bindings to Karney's C++ implementation, see https://crates.io/geographiclib.
```rust // Determine the point 10000 km NE of JFK - the "direct" geodesic calculation. use geographiclib_rs::{Geodesic, DirectGeodesic};
let g = Geodesic::wgs84(); let jfklat = 40.64; let jfklon = -73.78; let northeast_azimuth = 45.0;
let (lat, lon, az) = g.direct(jfklat, jfklon, northeast_azimuth, 10e6);
use approx::assertrelativeeq; assertrelativeeq!(lat, 32.621100463725796); assertrelativeeq!(lon, 49.05248709295982); assertrelativeeq!(az, 140.4059858768007); ```
```rust // Determine the distance between two points - the "inverse" geodesic calculation. use geographiclib_rs::{Geodesic, InverseGeodesic};
let g = Geodesic::wgs84(); let p1 = (34.095925, -118.2884237); let p2 = (59.4323439, 24.7341649); let s12: f64 = g.inverse(p1.0, p1.1, p2.0, p2.1);
use approx::assertrelativeeq; assertrelativeeq!(s12, 9094718.72751138); ```
```rust // Determine the perimeter and area of a polygon. use geographiclib_rs::{Geodesic, PolygonArea, Winding};
let g = Geodesic::wgs84(); let mut pa = PolygonArea::new(&g, Winding::CounterClockwise); pa.addpoint(0.0, 0.0); pa.addpoint(0.0, 1.0); pa.addpoint(1.0, 1.0); pa.addpoint(1.0, 0.0);
let (perimeterm, areamsquared, numpoints) = pa.compute(false);
use approx::assertrelativeeq; assertrelativeeq!(perimeterm, 443770.91724830196); assertrelativeeq!(areamsquared, 12308778361.469452); asserteq!(num_points, 4); ```
```rust // Determine the distance between rovers Pathfinder and Curiosity on Mars use geographiclib_rs::{Geodesic, InverseGeodesic};
let mars = Geodesic::new(3396190.0, 1.0 / 169.8944472); let pathfinder = (19.26, 326.75); let curiosity = (-4.765700445, 137.39820983); let distance_m: f64 = mars.inverse(curiosity.0, curiosity.1, pathfinder.0, pathfinder.1);
asserteq!(distancem.round(), 9639113.0); ```
accurate: Enabled by default. Use the accurate crate to provide high accuracy polygon areas and perimeters in PolygonArea. Can be disabled for better performance or when PolygonArea is not being used.To compare the direct and inverse geodesic calculation against the geographiclib c bindings, run:
shell
cargo bench
Which produces output like:
```text
Running target/release/deps/geodesic_benchmark-af6ba4f7be913514
direct (c wrapper) time: [34.852 us 34.937 us 35.023 us]
change: [+1.1137% +1.7246% +2.2864%] (p = 0.00 < 0.05)
Performance has regressed.
Found 9 outliers among 100 measurements (9.00%)
3 (3.00%) low mild
6 (6.00%) high mild
direct (rust impl) time: [48.862 us 48.959 us 49.059 us]
change: [+0.0149% +0.8003% +1.5464%] (p = 0.04 < 0.05)
Change within noise threshold.
Found 9 outliers among 100 measurements (9.00%)
1 (1.00%) low mild
4 (4.00%) high mild
4 (4.00%) high severe
inverse (c wrapper) time: [70.875 us 71.138 us 71.464 us]
change: [+0.6259% +1.1321% +1.6653%] (p = 0.00 < 0.05)
Change within noise threshold.
Found 8 outliers among 100 measurements (8.00%)
1 (1.00%) high mild
7 (7.00%) high severe
inverse (rust impl) time: [103.66 us 104.07 us 104.58 us]
change: [-1.0415% -0.0086% +1.0291%] (p = 0.99 > 0.05)
No change in performance detected.
Found 7 outliers among 100 measurements (7.00%)
1 (1.00%) low mild
6 (6.00%) high severe
```
Showing that, at least in this benchmark, the Rust implementation is 40-50% slower than the c bindings.