gribberish 1.1.1

Parse grib 2 files with Rust
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

use bitvec::prelude::*;

use super::data_representation_template::DataRepresentationTemplate;
use super::tables::OriginalFieldValue;
use crate::error::GribberishError;
use crate::utils::read_f32_from_bytes;
use crate::{
    templates::template::{Template, TemplateType},
    utils::{iter::ScaleGribValueIterator, read_u16_from_bytes},
};

pub struct SimplePackingDataRepresentationTemplate {
    data: Vec<u8>,
}

impl Template for SimplePackingDataRepresentationTemplate {
    fn data(&self) -> &[u8] {
        self.data.as_slice()
    }

    fn template_number(&self) -> u16 {
        0
    }

    fn template_type(&self) -> TemplateType {
        TemplateType::DataRepresentation
    }

    fn template_name(&self) -> &str {
        "grid point data - simple packing"
    }
}

impl SimplePackingDataRepresentationTemplate {
    pub fn new(data: Vec<u8>) -> SimplePackingDataRepresentationTemplate {
        SimplePackingDataRepresentationTemplate { data }
    }

    pub fn reference_value(&self) -> f32 {
        read_f32_from_bytes(self.data.as_slice(), 11).unwrap_or(0.0)
    }

    pub fn binary_scale_factor(&self) -> i16 {
        as_signed!(
            read_u16_from_bytes(self.data.as_slice(), 15).unwrap_or(0),
            16,
            i16
        )
    }

    pub fn decimal_scale_factor(&self) -> i16 {
        as_signed!(
            read_u16_from_bytes(self.data.as_slice(), 17).unwrap_or(0),
            16,
            i16
        )
    }

    pub fn bit_count(&self) -> u8 {
        self.data[19]
    }

    pub fn original_field_value(&self) -> OriginalFieldValue {
        self.data[20].into()
    }
}

impl DataRepresentationTemplate<f64> for SimplePackingDataRepresentationTemplate {
    fn compression_type(&self) -> String {
        "Simple Grid Packing".into()
    }

    fn bit_count_per_datapoint(&self) -> usize {
        self.bit_count() as usize
    }

    fn unpack(&self, bits: &BitSlice<u8, Msb0>) -> Result<Vec<f64>, GribberishError> {
        let bits_per_val: usize = self.bit_count().into();
        if bits_per_val == 0 {
            return Ok(vec![]);
        }

        let values = (0..bits.len())
            .step_by(bits_per_val)
            .filter_map(|i| {
                let mut i_end_index = i + bits_per_val;
                if i_end_index > bits.len() {
                    i_end_index = bits.len();
                }

                let relevent_bits = &bits[i..i_end_index];
                if relevent_bits.is_empty() {
                    None
                } else {
                    Some(relevent_bits.load_be::<u32>())
                }
            })
            .scale_value_by(
                self.binary_scale_factor(),
                self.decimal_scale_factor(),
                self.reference_value(),
            )
            .collect();

        Ok(values)
    }
}