use openreadout_core::{Error, Result};
use serde_json::Value;
use super::FORMAT_ID;
pub const PIXEL_END: u16 = 0xFFFF;
pub const MAX_EVENTS: u64 = 400_000_000;
#[derive(Debug, Clone, PartialEq)]
pub struct VeloxSpectrum {
pub id: String,
pub detector: Option<String>,
pub bins: u64,
pub offset_ev: Option<f64>,
pub dispersion_ev: Option<f64>,
pub metadata: Option<Value>,
}
impl VeloxSpectrum {
pub fn energy_kev(&self, k: u64) -> Option<f64> {
Some((self.offset_ev? + k as f64 * self.dispersion_ev?) / 1000.0)
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct VeloxStream {
pub id: String,
pub bins: u32,
pub raster: Option<(u32, u32)>,
pub frames: u64,
pub values: u64,
}
#[derive(Debug, Clone, Default)]
pub struct EventTable {
pub offsets: Vec<u64>,
pub pixels: Vec<u32>,
pub per_stream: Vec<u64>,
}
pub fn decode_stream(
values: &[u8],
bins: u32,
pixels: u64,
frames: u64,
events: &mut Vec<(u16, u32)>,
) -> Result<u64> {
let mut marker = 0u64;
let mut n = 0u64;
let want = pixels.saturating_mul(frames.max(1));
for c in values.as_chunks::<2>().0 {
let v = u16::from_le_bytes([c[0], c[1]]);
if v == PIXEL_END {
marker += 1;
continue;
}
if u32::from(v) >= bins {
return Err(Error::corrupt(
FORMAT_ID,
format!("event stream holds channel {v}, beyond its {bins} channels"),
));
}
if marker >= want {
return Err(Error::corrupt(
FORMAT_ID,
format!("event stream has events after its last pixel ({want} pixel markers)"),
));
}
if events.len() as u64 >= MAX_EVENTS {
return Err(Error::unsupported(
FORMAT_ID,
format!("a spectrum image with more than {MAX_EVENTS} X-ray events"),
"Read the detector spectra (`trace`) or the Velox images instead; very long acquisitions are not assembled in memory.",
));
}
let px = u32::try_from(marker % pixels.max(1)).unwrap_or(u32::MAX);
events.push((v, px));
n += 1;
}
if marker != want {
return Err(Error::corrupt(
FORMAT_ID,
format!(
"event stream ends {marker} pixels, {want} expected ({frames} frame(s) of {pixels} pixels)"
),
));
}
Ok(n)
}
pub fn event_table(events: &[(u16, u32)], bins: u32, per_stream: Vec<u64>) -> EventTable {
let mut offsets = vec![0u64; bins as usize + 1];
for (c, _) in events {
offsets[*c as usize + 1] += 1;
}
for i in 1..offsets.len() {
offsets[i] += offsets[i - 1];
}
let mut next = offsets.clone();
let mut pixels = vec![0u32; events.len()];
for (c, p) in events {
let slot = &mut next[*c as usize];
pixels[*slot as usize] = *p;
*slot += 1;
}
EventTable {
offsets,
pixels,
per_stream,
}
}
pub fn stream_histogram(values: &[u8], bins: u32) -> Vec<u64> {
let mut h = vec![0u64; bins as usize];
for c in values.as_chunks::<2>().0 {
let v = u16::from_le_bytes([c[0], c[1]]);
if v != PIXEL_END
&& let Some(slot) = h.get_mut(v as usize)
{
*slot += 1;
}
}
h
}
#[cfg(test)]
mod tests {
use super::*;
fn stream(v: &[u16]) -> Vec<u8> {
v.iter().flat_map(|x| x.to_le_bytes()).collect()
}
#[test]
fn events_belong_to_the_pixel_their_marker_ends() {
let s = stream(&[3, PIXEL_END, 1, 2, PIXEL_END, PIXEL_END, 3, PIXEL_END]);
let mut ev = Vec::new();
assert_eq!(decode_stream(&s, 4, 2, 2, &mut ev).unwrap(), 4);
assert_eq!(ev, [(3, 0), (1, 1), (2, 1), (3, 1)]);
let t = event_table(&ev, 4, vec![4]);
assert_eq!(t.offsets, [0, 0, 1, 2, 4]);
assert_eq!(&t.pixels[2..4], &[0, 1]);
assert_eq!(stream_histogram(&s, 4), [0, 1, 1, 2]);
assert!(decode_stream(&s, 4, 2, 3, &mut Vec::new()).is_err());
assert!(decode_stream(&stream(&[9, PIXEL_END]), 4, 1, 1, &mut Vec::new()).is_err());
}
}