dipr 0.1.0

Converts the National Weather Service's (NWS) Digital Instantaneous Precipitation Rate (DIPR) radar product from its native data format into more common vector GIS formats
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

use std::ops::RangeInclusive;

use chrono::{DateTime, Utc};
use uom::si::{f32::Length, length::meter};

use crate::{
    DiprError, ParseResult,
    radials::{Radial, radial},
    utils::*,
};

pub(crate) struct ProductSymbology {
    pub(crate) range_to_first_bin: Length,
    pub(crate) bin_size: Length,
    pub(crate) scan_number: u8,
    pub(crate) capture_time: DateTime<Utc>,
    pub(crate) radials: Vec<Radial>,
}

impl ProductSymbology {
    const NAME: &'static str = "product symbology";
    const SCAN_NUMBER_RANGE: RangeInclusive<i32> = 1..=80;
    const RADIAL_COMPONENT_TYPE_VALUE: i32 = 1;
    const BIN_SIZE_RANGE: RangeInclusive<f32> = (0.)..=1000.;
    // It seems like the specified range may be incorrect for actual DIPR files
    // const RANGE_TO_FIRST_BIN_RANGE: RangeInclusive<f32> = (1000.)..=460000.;
    const NUM_RADIALS_RANGE: RangeInclusive<i32> = 0..=800;
}

pub(crate) fn product_symbology(input: &[u8]) -> ParseResult<ProductSymbology> {
    // header (Figure 3-6, Sheet 7)
    let (_, tail) = take_bytes(input, 16)?;

    // another header (Figure 3-15c)
    let (_, tail) = take_bytes(tail, 8)?;

    // Product Description Data Structure header (Figure E-1)
    let (_, tail) = take_string(tail)?; // name
    let (_, tail) = take_string(tail)?; // description
    let (_, tail) = take_bytes(tail, 12)?;
    let (_, tail) = take_string(tail)?; // radar name
    let (_, tail) = take_bytes(tail, 12)?;
    let (capture_time, tail) = take_u32(tail)?; // volume scan start time
    let (_, tail) = take_bytes(tail, 8)?;
    let (scan_number, tail) = take_i32(tail)?;
    check_range_inclusive(
        ProductSymbology::SCAN_NUMBER_RANGE,
        scan_number,
        "scan number",
        ProductSymbology::NAME,
    )?;
    let (_, tail) = take_bytes(tail, 24)?;
    let (number_of_components, tail) = take_i32(tail)?;
    if number_of_components != 1 {
        return Err(DiprError::Unsupported(format!(
            "found number of components in product symbology not equal to 1 (got {}); DIPR files containing multiple components are not supported",
            number_of_components
        )));
    }
    let (_, tail) = take_bytes(tail, (number_of_components * 8) as u16)?;

    // Radial Component Data Structure (Figure E-3)
    let (radial_component_type, tail) = take_i32(tail)?;
    check_value(
        ProductSymbology::RADIAL_COMPONENT_TYPE_VALUE,
        radial_component_type,
        "radial component type",
        ProductSymbology::NAME,
    )?;
    let (_, tail) = take_string(tail)?; // description
    let (bin_size, tail) = take_float(tail)?;
    check_range_inclusive(
        ProductSymbology::BIN_SIZE_RANGE,
        bin_size,
        "bin size",
        ProductSymbology::NAME,
    )?;
    let (range_to_first_bin, tail) = take_float(tail)?;
    let (_, tail) = take_bytes(tail, 8)?;
    let (num_radials, mut tail) = take_i32(tail)?;
    check_range_inclusive(
        ProductSymbology::NUM_RADIALS_RANGE,
        num_radials,
        "num radials",
        ProductSymbology::NAME,
    )?;

    // parse the radials themselves
    let mut radials: Vec<Radial> = Vec::with_capacity(num_radials as usize);
    for _ in 0..num_radials {
        let tmp = radial(tail)?;
        radials.push(tmp.0);
        tail = tmp.1;
    }

    let range_to_first_bin = Length::new::<meter>(range_to_first_bin);
    let bin_size = Length::new::<meter>(bin_size);
    let scan_number = scan_number as u8;
    let capture_time = match DateTime::from_timestamp(capture_time as i64, 0) {
        Some(t) => t,
        None => return Err(DiprError::InvalidCaptureTime(capture_time)),
    };

    Ok((
        ProductSymbology {
            range_to_first_bin,
            bin_size,
            scan_number,
            capture_time,
            radials,
        },
        tail,
    ))
}