Skip to main content

fpm_rs/measurements/
read.rs

1use std::{ops::Deref, sync::Arc};
2
3use crate::Result;
4
5use super::{FrameMetadata, LazyMeasurementStack, MeasurementStack};
6
7/// Read-only measurement access used by reconstruction algorithms.
8///
9/// Implementations retain responsibility for storage, caching, preprocessing,
10/// and mutation. The opaque frame view may borrow directly from the
11/// implementation or own a shared cache handle.
12pub trait MeasurementRead: Sync {
13    /// Returns the number of acquisition frames.
14    fn frame_count(&self) -> usize;
15
16    /// Returns low-resolution image shape as `(height, width)`.
17    fn image_shape(&self) -> (usize, usize);
18
19    /// Returns `height * width`, the row-major element count of one frame.
20    fn frame_len(&self) -> usize;
21
22    /// Borrows or shares a row-major intensity frame by zero-based acquisition index.
23    fn frame(&self, index: usize) -> Result<impl Deref<Target = [f64]> + '_>;
24
25    /// Returns a frame's non-negative reconstruction weight.
26    fn frame_weight(&self, index: usize) -> Result<f64>;
27
28    /// Borrows an optional row-major binary validity mask for one frame.
29    fn frame_mask(&self, index: usize) -> Result<Option<&[u8]>>;
30
31    /// Borrows metadata in acquisition-frame order.
32    fn frame_metadata(&self) -> &[FrameMetadata];
33
34    /// Checks shapes, counts, finite intensities, metadata, weights, and masks.
35    fn validate(&self) -> Result<()>;
36}
37
38impl<T: MeasurementRead + ?Sized> MeasurementRead for &T {
39    fn frame_count(&self) -> usize {
40        T::frame_count(self)
41    }
42
43    fn image_shape(&self) -> (usize, usize) {
44        T::image_shape(self)
45    }
46
47    fn frame_len(&self) -> usize {
48        T::frame_len(self)
49    }
50
51    fn frame(&self, index: usize) -> Result<impl Deref<Target = [f64]> + '_> {
52        T::frame(self, index)
53    }
54
55    fn frame_weight(&self, index: usize) -> Result<f64> {
56        T::frame_weight(self, index)
57    }
58
59    fn frame_mask(&self, index: usize) -> Result<Option<&[u8]>> {
60        T::frame_mask(self, index)
61    }
62
63    fn frame_metadata(&self) -> &[FrameMetadata] {
64        T::frame_metadata(self)
65    }
66
67    fn validate(&self) -> Result<()> {
68        T::validate(self)
69    }
70}
71
72impl MeasurementRead for MeasurementStack {
73    fn frame_count(&self) -> usize {
74        MeasurementStack::frame_count(self)
75    }
76
77    fn image_shape(&self) -> (usize, usize) {
78        MeasurementStack::image_shape(self)
79    }
80
81    fn frame_len(&self) -> usize {
82        MeasurementStack::frame_len(self)
83    }
84
85    fn frame(&self, index: usize) -> Result<impl Deref<Target = [f64]> + '_> {
86        MeasurementStack::frame(self, index)
87    }
88
89    fn frame_weight(&self, index: usize) -> Result<f64> {
90        MeasurementStack::frame_weight(self, index)
91    }
92
93    fn frame_mask(&self, index: usize) -> Result<Option<&[u8]>> {
94        MeasurementStack::frame_mask(self, index)
95    }
96
97    fn frame_metadata(&self) -> &[FrameMetadata] {
98        MeasurementStack::frame_metadata(self)
99    }
100
101    fn validate(&self) -> Result<()> {
102        MeasurementStack::validate(self)
103    }
104}
105
106struct SharedFrame(Arc<Vec<f64>>);
107
108impl Deref for SharedFrame {
109    type Target = [f64];
110
111    fn deref(&self) -> &Self::Target {
112        self.0.as_slice()
113    }
114}
115
116impl MeasurementRead for LazyMeasurementStack {
117    fn frame_count(&self) -> usize {
118        LazyMeasurementStack::frame_count(self)
119    }
120
121    fn image_shape(&self) -> (usize, usize) {
122        LazyMeasurementStack::image_shape(self)
123    }
124
125    fn frame_len(&self) -> usize {
126        LazyMeasurementStack::frame_len(self)
127    }
128
129    fn frame(&self, index: usize) -> Result<impl Deref<Target = [f64]> + '_> {
130        LazyMeasurementStack::frame(self, index).map(SharedFrame)
131    }
132
133    fn frame_weight(&self, index: usize) -> Result<f64> {
134        LazyMeasurementStack::frame_weight(self, index)
135    }
136
137    fn frame_mask(&self, index: usize) -> Result<Option<&[u8]>> {
138        LazyMeasurementStack::frame_mask(self, index)
139    }
140
141    fn frame_metadata(&self) -> &[FrameMetadata] {
142        LazyMeasurementStack::frame_metadata(self)
143    }
144
145    fn validate(&self) -> Result<()> {
146        LazyMeasurementStack::validate(self)
147    }
148}