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

//
// GENERATED FILE
//

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

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

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

    //
    // Test whether an ellipse is the intersection of a specified
    // plane and ellipsoid.
    //

    //
    // SPICELIB functions
    //

    //
    // Local parameters
    //

    //
    // Local variables
    //

    //
    // Scale ellipse and plane.
    //
    SCALE = intrinsics::DMAX1(&[f64::abs(A), f64::abs(B), f64::abs(C)]);

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

    spicelib::EL2CGV(
        ELLIPS.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 {
            T_ISPXED = false;
            return Ok(T_ISPXED);
        }
    }

    //
    // Check each point to see if it's in the plane.
    //
    spicelib::PL2NVC(PLANE.as_slice(), NORMAL.as_slice_mut(), &mut CONST);
    testutil::CHCKXC(false, b" ", OK, ctx)?;

    CONST = (CONST / SCALE);

    for I in 1..=4 {
        PC = spicelib::VDOT(ELPT.subarray([1, I]), NORMAL.as_slice());

        testutil::CHCKSD(b"PC", PC, b"~/", CONST, PLNTOL, OK, ctx)?;

        if !*OK {
            T_ISPXED = false;
            return Ok(T_ISPXED);
        }
    }

    T_ISPXED = true;

    Ok(T_ISPXED)
}