rsspice 0.1.0

Pure Rust port of the SPICE Toolkit for space geometry
Documentation 
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//
// GENERATED FILE
//

use super::*;
use f2rust_std::*;

const UBEL: i32 = 9;
const UBPL: i32 = 4;
const IPTOL: f64 = 0.00000000000005;
const LVLTOL: f64 = 0.00000000000005;
const NPT: i32 = 4;

//
// Supporting function T_ISLIMB
//
pub fn T_ISLIMB(
    LIMB: &[f64],
    A: f64,
    B: f64,
    C: f64,
    VIEWPT: &[f64],
    OK: &mut bool,
    ctx: &mut Context,
) -> f2rust_std::Result<bool> {
    let LIMB = DummyArray::new(LIMB, 1..=UBEL);
    let VIEWPT = DummyArray::new(VIEWPT, 1..=3);
    let mut T_ISLIMB: bool = false;
    let mut CENTER = StackArray::<f64, 3>::new(1..=3);
    let mut DIFF = StackArray::<f64, 3>::new(1..=3);
    let mut ELPT = StackArray2D::<f64, 12>::new(1..=3, 1..=NPT);
    let mut LEVEL: f64 = 0.0;
    let mut NORMAL = StackArray::<f64, 3>::new(1..=3);
    let mut SCALE: f64 = 0.0;
    let mut SCLA: f64 = 0.0;
    let mut SCLB: f64 = 0.0;
    let mut SCLC: f64 = 0.0;
    let mut SEP: f64 = 0.0;
    let mut SMAJOR = StackArray::<f64, 3>::new(1..=3);
    let mut SMINOR = StackArray::<f64, 3>::new(1..=3);
    let mut VP = StackArray::<f64, 3>::new(1..=3);

    //
    // Test whether an ellipse is the limb of an ellipsoid as seen
    // from a specified viewing location.
    //

    //
    // SPICELIB functions
    //

    //
    // Local parameters
    //

    //
    // Local variables
    //

    //
    // Scale ellipse and viewing point.
    //
    SCALE = intrinsics::DMAX1(&[
        f64::abs(A),
        f64::abs(B),
        f64::abs(C),
        spicelib::VNORM(VIEWPT.as_slice()),
    ]);

    SCLA = (A / SCALE);
    SCLB = (B / SCALE);
    SCLC = (C / SCALE);

    spicelib::VSCL((1.0 / SCALE), VIEWPT.as_slice(), VP.as_slice_mut());

    spicelib::EL2CGV(
        LIMB.as_slice(),
        CENTER.as_slice_mut(),
        SMAJOR.as_slice_mut(),
        SMINOR.as_slice_mut(),
    );
    testutil::CHCKXC(false, b" ", OK, ctx)?;

    spicelib::VSCLIP((1.0 / SCALE), CENTER.as_slice_mut());
    spicelib::VSCLIP((1.0 / SCALE), SMAJOR.as_slice_mut());
    spicelib::VSCLIP((1.0 / SCALE), SMINOR.as_slice_mut());

    //
    // Construct the endpoints of the major and minor axes.
    //
    spicelib::VADD(
        CENTER.as_slice(),
        SMAJOR.as_slice(),
        ELPT.subarray_mut([1, 1]),
    );
    spicelib::VSUB(
        CENTER.as_slice(),
        SMAJOR.as_slice(),
        ELPT.subarray_mut([1, 2]),
    );
    spicelib::VADD(
        CENTER.as_slice(),
        SMINOR.as_slice(),
        ELPT.subarray_mut([1, 3]),
    );
    spicelib::VSUB(
        CENTER.as_slice(),
        SMINOR.as_slice(),
        ELPT.subarray_mut([1, 4]),
    );

    //
    // Check the `level' of each point.
    //
    for I in 1..=NPT {
        LEVEL = (((f64::powi(ELPT[[1, I]], 2) / f64::powi(SCLA, 2))
            + (f64::powi(ELPT[[2, I]], 2) / f64::powi(SCLB, 2)))
            + (f64::powi(ELPT[[3, I]], 2) / f64::powi(SCLC, 2)));

        testutil::CHCKSD(b"LEVEL", LEVEL, b"~", 1.0, LVLTOL, OK, ctx)?;

        if !*OK {
            //
            // The putative limb point is not on the ellipsoid.
            //
            T_ISLIMB = false;
        }
    }

    //
    // For each endpoint, find the surface normal and its
    // angular separation from the difference vector between it and
    // the viewing point.
    //
    for I in 1..=NPT {
        spicelib::VSUB(VP.as_slice(), ELPT.subarray([1, I]), DIFF.as_slice_mut());

        spicelib::SURFNM(A, B, C, ELPT.subarray([1, I]), NORMAL.as_slice_mut(), ctx)?;
        testutil::CHCKXC(false, b" ", OK, ctx)?;

        SEP = spicelib::VSEP(NORMAL.as_slice(), DIFF.as_slice(), ctx);

        testutil::CHCKSD(b"SEP", SEP, b"~", spicelib::HALFPI(ctx), IPTOL, OK, ctx)?;

        if !*OK {
            return Ok(T_ISLIMB);
        }
    }

    T_ISLIMB = true;

    Ok(T_ISLIMB)
}