gmt_dos-clients_scope 3.1.1

GMT DOS Scope Client
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

use interface::UniqueIdentifier;
use serde::{Deserialize, Serialize};
use std::marker::PhantomData;

/// [ScopeData] is the unique identifier type
/// for the data that holds the scope [Payload]
pub(crate) struct ScopeData<U: UniqueIdentifier>(PhantomData<U>);
impl<U: UniqueIdentifier> UniqueIdentifier for ScopeData<U> {
    type DataType = Payload;
    const PORT: u16 = U::PORT;
}

/// Scope client/server payload
///
/// The data type that is sent from a server application to the scope client
#[non_exhaustive]
#[derive(Debug, Serialize, Deserialize)]
pub(crate) enum Payload {
    Signal {
        tag: String,
        tau: f64,
        value: f64,
    },
    Signals {
        tag: String,
        tau: f64,
        value: Vec<f64>,
    },
    Image {
        tag: String,
        tau: f64,
        size: [usize; 2],
        pixels: Vec<f64>,
        mask: Option<Vec<bool>>,
        minmax: Option<(f64, f64)>,
    },
}

#[cfg(feature = "server")]
impl Payload {
    /// Creates a new [Payload] for a signal
    pub fn signal<T, U>(
        data: interface::Data<U>,
        tau: f64,
        idx: Option<usize>,
        scale: Option<f64>,
    ) -> Option<Self>
    where
        T: Copy,
        U: UniqueIdentifier<DataType = Vec<T>>,
        f64: From<T>,
    {
        if let Some(idx) = idx {
            data.get(idx).map(|&v| Self::Signal {
                tag: <U as interface::Quote>::quote(),
                tau,
                value: scale.map_or_else(|| v.into(), |s| f64::from(v) * s),
            })
        } else {
            Some(Self::Signals {
                tag: <U as interface::Quote>::quote(),
                tau,
                value: data.iter().map(|v| f64::from(*v)).collect(),
            })
        }
    }
    /// Creates a new [Payload] for an image
    pub fn image<T, U>(
        data: interface::Data<U>,
        tau: f64,
        size: [usize; 2],
        minmax: Option<(f64, f64)>,
        scale: Option<f64>,
    ) -> Option<Self>
    where
        T: Copy,
        U: UniqueIdentifier<DataType = Vec<T>>,
        f64: From<T>,
    {
        Some(Self::Image {
            tag: <U as interface::Quote>::quote(),
            tau,
            size,
            pixels: Vec::from(data)
                .into_iter()
                .map(|x| scale.map_or_else(|| x.into(), |s| f64::from(x) * s))
                .collect(),
            mask: None,
            minmax,
        })
    }
    /// Creates a new [Payload] for the GMT wavefront
    pub fn gmt<T, U>(
        data: interface::Data<U>,
        tau: f64,
        size: [usize; 2],
        minmax: Option<(f64, f64)>,
        scale: Option<f64>,
    ) -> Option<Self>
    where
        T: Copy,
        U: UniqueIdentifier<DataType = (Vec<T>, Vec<bool>)>,
        f64: From<T>,
    {
        let (pixels, mask) = std::ops::Deref::deref(&data).clone();
        Some(Self::Image {
            tag: <U as interface::Quote>::quote(),
            tau,
            size,
            pixels: Vec::from(pixels)
                .into_iter()
                .map(|x| scale.map_or_else(|| x.into(), |s| f64::from(x) * s))
                .collect(),
            mask: Some(mask),
            minmax,
        })
    }
}

#[cfg(feature = "client")]
impl Payload {
    pub fn max(&self) -> f64 {
        match self {
            Payload::Image { pixels, .. } => {
                *(pixels.iter().max_by(|&a, &b| a.total_cmp(b)).unwrap())
            }
            _ => unimplemented!("max is implemented only for Payload::Image"),
        }
    }
    pub fn min(&self) -> f64 {
        match self {
            Payload::Image { pixels, .. } => {
                *(pixels.iter().min_by(|&a, &b| a.total_cmp(b)).unwrap())
            }
            _ => unimplemented!("min is implemented only for Payload::Image"),
        }
    }
}