1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
/*!
# **rust-spice**
WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust.
## Using **rust-spice**
Simply add the following to your `Cargo.toml` file:
```.ignore
[dependencies]
rust-spice = "*" // replace * by the latest version of the crate
```
Rust layered Spice functions of **rust-spice** are grouped in the root module `spice::` and all
wrapper functions in `spice::c::`.
You can find a guide for the Rust interface [here][crate::core].
## **rust-spice** basics
```.ignore
use spice;
// ugly: using binded C Spice.
unsafe {
let kernel = CString::new("/path/to/metakernel.mk").unwrap().into_raw();
spice::c::furnsh_c(kernel);
spice::c::unload_c(kernel);
}
// pretty: using the nice Rust interface.
let mut kernel = spice::Kernel::new("/path/to/metakernels.mk")?;
kernel.unload()?;
```
## In action
With this code, you can get the evolution of the distance in the system.
```.ignore
use itertools::multizip;
use spice;
// Define the system.
let mut system = spice::SystemBuilder::default()
.kernel("/path/to/metakernels.mk")?
.frame("J2000")
.observer("HERA")
.target("DIMORPHOS")
.start_date("2027-MAR-23 16:00:00")
.duration(129.0 * spice::DAY)
.aberration_correction("NONE")
.build()?;
// Define the time step.
let time_step = 1.0 * spice::DAY;
// Get all the times string-formatted.
let times = system.times_formatted(time_step);
// Get all the positions at the times.
let positions = system.positions(time_step);
// Get the distances from the positions.
let distances = spice::distance(positions);
// Display
for (time, distance) in multizip((times.iter(), distances.iter())) {
println!("{} -> {:.2} km", time, distance);
}
// Always unload the kernels.
system.unload()?;
```
You can also read other [examples](https://github.com/GregoireHENRY/rust-spice/tree/main/examples).
## Rust layer in development
The Rust layer is nicer to use: no unsafe and easy types. But it takes a long time to write because
it is not automated, I have to do it by hand. I started from my needs, basically getting positions
from start to end date of target in referential. I will implemented a nice Rust layer more and more
when I will need to use other functions. You can submit issues if you want a layer to some
functionalities, and we will implement it immediately. Pull requests are also welcomed to help!
The Rust layer for the most Used C Spice API for accessing kernel data is located in [`core`].
The type [`System`] provides some tools, built on top of spice.
*/
extern crate cspice_sys;
extern crate itertools;
extern crate nalgebra as na;
extern crate serial_test;
extern crate tool;
/// Complete NASA/NAIF C Spice binded functions, very unsafe, from [`cspice_sys`] wrapper.
/// The Rust layer to ease the use of the wrapper.
/// Tools developped on top of Spice for even easier usage of the library.
pub use crate*;
pub use crate*;