use super::SizeForIndex;
use crate::common::DiscreteDomain;
use crate::image::imageops::{FilterType, resize};
use crate::image::{GrayImage, ImageBuffer, ImageFormat, ImageReader, Luma, Rgba, RgbaImage};
use crate::na::DMatrix;
use crate::raster2::area_average::AreaAverage;
use crate::raster2::raster_mask::RasterMask;
use crate::raster2::{FastApproxKernel, Point2I, Point2IIndexAccess, RasterKernel, inpaint};
use crate::{Mesh3, Point2, Point3, Result, Series1, Vector2};
use colorgrad::Gradient;
use imageproc::distance_transform::Norm::L1;
use imageproc::morphology::{dilate_mut, erode_mut};
use imageproc::region_labelling::Connectivity;
use rayon::prelude::*;
use std::fs::File;
use std::io::{BufReader, BufWriter, Cursor, Read, Write};
use std::path::Path;
pub type ScalarImage<T> = ImageBuffer<Luma<T>, Vec<T>>;
#[derive(Clone, Debug)]
pub struct ScalarRaster {
pub values: ScalarImage<u16>,
pub mask: RasterMask,
pub px_size: f64,
pub min_z: f64,
pub max_z: f64,
}
impl ScalarRaster {
pub fn width(&self) -> u32 {
self.values.width()
}
pub fn height(&self) -> u32 {
self.values.height()
}
pub fn f_at(&self, p: Point2I) -> f64 {
self.u_at(p).map(|u| self.u_to_f(u)).unwrap_or(f64::NAN)
}
pub fn u_at(&self, p: Point2I) -> Option<u16> {
if !self.mask.get_point(p) {
None
} else {
self.values.get_at(p)
}
}
pub fn set_f_at(&mut self, p: Point2I, val: f64) -> Result<()> {
let converted = if val.is_nan() {
None
} else {
Some(self.f_to_u(val))
};
self.set_u_at(p, converted)
}
pub fn set_u_at(&mut self, p: Point2I, val: Option<u16>) -> Result<()> {
let (v, valid) = if let Some(v) = val {
(v, true)
} else {
(0, false)
};
self.values.set_at(p, v)?;
self.mask.set_point_unchecked(p, valid);
Ok(())
}
fn f_to_u(&self, val: f64) -> u16 {
let f = (val.clamp(self.min_z, self.max_z) - self.min_z) / (self.max_z - self.min_z);
(f * u16::MAX as f64) as u16
}
fn u_to_f(&self, val: u16) -> f64 {
let f = val as f64 / u16::MAX as f64;
f * (self.max_z - self.min_z) + self.min_z
}
pub fn f_at_interp(&self, p: &Point2) -> f64 {
if p.x < 0.0
|| p.y < 0.0
|| p.x > self.width() as f64 - 1.0
|| p.y > self.height() as f64 - 1.0
{
return f64::NAN;
}
let x0 = p.x.floor() as i32;
let x1 = x0 + 1;
let y0 = p.y.floor() as i32;
let y1 = y0 + 1;
let a1 = p.x - p.x.floor();
let a0 = 1.0 - a1;
let b1 = p.y - p.y.floor();
let b0 = 1.0 - b1;
let q11 = self.f_at(Point2I::new(x0, y0)) * a0 * b0;
let q22 = if x1 < self.width() as i32 && y1 < self.height() as i32 {
self.f_at(Point2I::new(x1, y1)) * a1 * b1
} else {
0.0
};
let q12 = if y1 < self.height() as i32 {
self.f_at(Point2I::new(x0, y1)) * a0 * b1
} else {
0.0
};
let q21 = if x1 < self.width() as i32 {
self.f_at(Point2I::new(x1, y0)) * a1 * b0
} else {
0.0
};
q11 + q12 + q21 + q22
}
pub fn symmetric_trace(
&self,
point: &Point2,
dir: &Vector2,
radius: f64,
) -> (Series1, Vec<Point2>) {
let mut xs = Vec::new();
let mut ys = Vec::new();
let mut locations = Vec::new();
for i in 0..(radius * 2.0) as usize {
let length = i as f64 - radius;
let p = point + dir * length;
let v = self.f_at_interp(&p);
xs.push(length);
ys.push(v);
locations.push(p);
}
let dd = DiscreteDomain::try_from(xs).expect("invalid xs");
(Series1::new(dd, ys), locations)
}
pub fn serialized_bytes(&self, fmt: ImageFormat) -> Vec<u8> {
let mut value_bytes = Vec::new();
let mut mask_bytes = Vec::new();
self.values
.write_to(&mut Cursor::new(&mut value_bytes), fmt)
.unwrap();
self.mask
.buffer
.write_to(&mut Cursor::new(&mut mask_bytes), fmt)
.unwrap();
let mut bytes = Vec::new();
bytes.extend_from_slice(&self.px_size.to_le_bytes());
bytes.extend_from_slice(&self.min_z.to_le_bytes());
bytes.extend_from_slice(&self.max_z.to_le_bytes());
bytes.extend_from_slice(&(value_bytes.len() as u64).to_le_bytes());
bytes.extend(value_bytes);
bytes.extend_from_slice(&(mask_bytes.len() as u64).to_le_bytes());
bytes.extend(mask_bytes);
bytes
}
pub fn from_serialized_bytes(bytes: &[u8]) -> Result<Self> {
let mut reader = Cursor::new(bytes);
Self::from_reader(&mut reader)
}
fn from_reader(reader: &mut impl Read) -> Result<Self> {
let mut bytes_8 = [0u8; 8];
reader.read_exact(&mut bytes_8)?;
let px_size = f64::from_le_bytes(bytes_8);
reader.read_exact(&mut bytes_8)?;
let min_z = f64::from_le_bytes(bytes_8);
reader.read_exact(&mut bytes_8)?;
let max_z = f64::from_le_bytes(bytes_8);
reader.read_exact(&mut bytes_8)?;
let value_len = u64::from_le_bytes(bytes_8) as usize;
let mut value_bytes = vec![0u8; value_len];
reader.read_exact(&mut value_bytes)?;
reader.read_exact(&mut bytes_8)?;
let mask_len = u64::from_le_bytes(bytes_8) as usize;
let mut mask_bytes = vec![0u8; mask_len];
reader.read_exact(&mut mask_bytes)?;
let values = ImageReader::new(Cursor::new(value_bytes))
.with_guessed_format()?
.decode()?;
let mask_buffer = ImageReader::new(Cursor::new(mask_bytes))
.with_guessed_format()?
.decode()?;
if values.width() != mask_buffer.width() || values.height() != mask_buffer.height() {
return Err("Values and mask images must have the same dimensions".into());
}
let mask = RasterMask::new(mask_buffer.into_luma8());
Ok(Self {
values: values.into_luma16(),
mask,
px_size,
min_z,
max_z,
})
}
pub fn save_combined(&self, path: &Path, fmt: ImageFormat) -> Result<()> {
let file = File::create(path)?;
let mut writer = BufWriter::new(file);
writer.write_all(&self.serialized_bytes(fmt))?;
Ok(())
}
pub fn load_combined(path: &Path) -> Result<Self> {
let file = File::open(path)?;
let mut reader = BufReader::new(file);
Self::from_reader(&mut reader)
}
pub fn build_depth_mesh(&self) -> Result<Mesh3> {
let (pixels, faces) = self.mask.triangle_structure();
let points = pixels
.into_iter()
.map(|p| {
let z = self.f_at(p);
Point3::new(p.x as f64 * self.px_size, p.y as f64 * self.px_size, z)
})
.collect::<Vec<_>>();
Ok(Mesh3::new(points, faces, false))
}
pub fn render_with_cmap(
&self,
path: &Path,
gradient: &dyn Gradient,
min_max: Option<(f64, f64)>,
) -> Result<()> {
let (min_z, max_z) = min_max.unwrap_or((self.min_z, self.max_z));
let mut img = RgbaImage::new(self.width(), self.height());
for p in self.mask.iter_true() {
let value = self.f_at(p);
let f = (value - min_z) / (max_z - min_z);
let color = gradient.at(f as f32).to_rgba8();
img.put_pixel(p.x as u32, p.y as u32, Rgba(color));
}
img.save(path).map_err(|e| e.into())
}
pub fn to_rgba(&self, limits: Option<(f64, f64)>) -> RgbaImage {
let working = if let Some((min_z, max_z)) = limits {
self.with_new_z_limits(min_z, max_z)
} else {
self.clone()
};
let mut img = RgbaImage::new(working.width(), working.height());
for p in working.mask.iter_true() {
let value = (working.u_at(p).unwrap() / 256) as u8;
img.put_pixel(p.x as u32, p.y as u32, Rgba([value, value, value, 255]));
}
img
}
pub fn filled_like(other: &Self, value: u16) -> Self {
let values = ScalarImage::from_pixel(other.width(), other.height(), Luma([value]));
let mut mask = RasterMask::empty_like(&values);
mask.not_mut();
ScalarRaster {
values,
mask,
px_size: other.px_size,
min_z: other.min_z,
max_z: other.max_z,
}
}
pub fn empty_like(other: &Self) -> Self {
Self::empty(
other.width(),
other.height(),
other.px_size,
other.min_z,
other.max_z,
)
}
pub fn empty(width: u32, height: u32, px_size: f64, min_z: f64, max_z: f64) -> Self {
let values = ScalarImage::new(width, height);
let mask = RasterMask::new(GrayImage::new(width, height));
ScalarRaster {
values,
mask,
px_size,
min_z,
max_z,
}
}
pub fn try_new(
values: ScalarImage<u16>,
mask: RasterMask,
px_size: f64,
min_z: f64,
max_z: f64,
) -> Result<ScalarRaster> {
if values.width() != mask.width() || values.height() != mask.height() {
return Err("Values and mask images must have the same dimensions".into());
}
Ok(ScalarRaster {
values,
mask,
px_size,
min_z,
max_z,
})
}
pub fn from_matrix(matrix: &DMatrix<f64>, px_size: f64, min_z: f64, max_z: f64) -> Self {
let mut value = ScalarImage::new(matrix.ncols() as u32, matrix.nrows() as u32);
let mut mask = RasterMask::empty_like(&value);
let type_min = u16::MIN;
let type_max = u16::MAX;
let type_range = (type_max - type_min) as f64;
for i in 0..matrix.nrows() {
for j in 0..matrix.ncols() {
let v = matrix[(i, j)];
if !v.is_finite() {
continue;
}
let v = v.clamp(min_z, max_z);
let f = (v - min_z) / (max_z - min_z);
let r = (f * type_range) as u16 + type_min;
value.put_pixel(j as u32, i as u32, Luma([r]));
mask.set_point_unchecked(Point2I::new(j as i32, i as i32), true);
}
}
ScalarRaster {
values: value,
mask,
px_size,
min_z,
max_z,
}
}
pub fn copy_with_predicate(&self, predicate: impl Fn(f64) -> bool) -> Self {
let mut output = ScalarRaster::empty_like(self);
for p in self.mask.iter_true() {
let value = self.f_at(p);
if predicate(value) {
output.set_f_at(p, value).unwrap();
} else {
output.set_f_at(p, f64::NAN).unwrap();
}
}
output
}
pub fn to_matrix(&self) -> DMatrix<f64> {
let mut matrix =
DMatrix::from_element(self.height() as usize, self.width() as usize, f64::NAN);
for p in self.mask.iter_true() {
matrix
.set_at(
p,
self.u_to_f(self.values.get_pixel(p.x as u32, p.y as u32).0[0]),
)
.unwrap();
}
matrix
}
pub fn to_value_and_mask_matrices(&self) -> (DMatrix<f64>, DMatrix<f64>) {
let mut matrix = DMatrix::zeros(self.height() as usize, self.width() as usize);
let mut mask = DMatrix::zeros(matrix.nrows(), matrix.ncols());
for p in self.mask.iter_true() {
matrix
.set_at(
p,
self.u_to_f(self.values.get_pixel(p.x as u32, p.y as u32).0[0]),
)
.unwrap();
mask.set_at(p, 1.0).unwrap();
}
(matrix, mask)
}
pub fn inpaint(&mut self, mask: &RasterMask, inpaint_radius: usize) {
let filled = inpaint(&self.values, &mask.buffer, &self.mask, inpaint_radius);
self.values = filled;
self.mask = self
.mask
.clone()
.or(mask)
.expect("Mask and raster must have same dimensions");
}
pub fn delete_by_mask(&mut self, mask: &RasterMask) -> Result<()> {
for p in mask.iter_true() {
self.values.set_at(p, u16::MIN)?;
self.mask.set_point_unchecked(p, false);
}
Ok(())
}
fn clear_row(&mut self, y: usize) {
for x in 0..self.values.width() {
self.values.put_pixel(x, y as u32, Luma([0]));
self.mask
.set_point_unchecked(Point2I::new(x as i32, y as i32), false);
}
}
fn clear_col(&mut self, x: usize) {
for y in 0..self.values.height() {
self.values.put_pixel(x as u32, y, Luma([0]));
self.mask
.set_point_unchecked(Point2I::new(x as i32, y as i32), false);
}
}
pub fn clear_boundary(&mut self) {
self.clear_row(0);
self.clear_row(self.values.height() as usize - 1);
self.clear_col(0);
self.clear_col(self.values.width() as usize - 1);
}
pub fn with_new_z_limits(&self, min_z: f64, max_z: f64) -> Self {
let matrix = self.to_matrix();
ScalarRaster::from_matrix(&matrix, self.px_size, min_z, max_z)
}
pub fn negative_mut(&mut self) {
for p in self.iter_indices() {
if !self.mask.get_point(p) {
continue;
}
let v = self.f_at(p);
self.set_f_at(p, -v).unwrap();
}
}
pub fn negative(&self) -> Self {
let mut negated = self.clone();
negated.negative_mut();
negated
}
pub fn mean_stdev(&self) -> (f64, f64) {
let mut sum = 0.0;
let mut count = 0.0;
for p in self.mask.iter_true() {
sum += self.f_at(p);
count += 1.0;
}
if count == 0.0 {
return (f64::NAN, f64::NAN);
}
let mean = sum / count;
let mut variance_sum = 0.0;
for p in self.mask.iter_true() {
variance_sum += (self.f_at(p) - mean).powi(2);
}
let stdev = (variance_sum / count).sqrt();
(mean, stdev)
}
pub fn subtract(&self, reference: &Self) -> Result<Self> {
let mut corrected = self.clone();
for (x, y, v) in corrected.values.enumerate_pixels_mut() {
if !self.mask.get_point(Point2I::new(x as i32, y as i32)) {
*v = Luma([0]);
} else {
let ref_val = reference.u_to_f(reference.values.get_pixel(x, y)[0]);
let self_val = self.u_to_f(v[0]);
let f = self_val - ref_val;
if f.is_nan() {
*v = Luma([0]);
continue;
}
if f < self.min_z || f > self.max_z {
return Err(format!(
"Value {} out of bounds for raster with min_z {} and max_z {}",
f, self.min_z, self.max_z
)
.into());
}
*v = Luma([self.f_to_u(self_val - ref_val)]);
}
}
Ok(corrected)
}
pub fn create_scaled(&self, scale: f64) -> Self {
let width = (self.values.width() as f64 * scale) as u32;
let height = (self.values.height() as f64 * scale) as u32;
let values = resize(&self.values, width, height, FilterType::Nearest);
let buffer = resize(&self.mask.buffer, width, height, FilterType::Nearest);
let mask = RasterMask::new(buffer);
Self {
values,
mask,
px_size: self.px_size / scale,
min_z: self.min_z,
max_z: self.max_z,
}
}
pub fn create_shrunk(&self, shrink_factor: u32) -> Self {
let width = self.values.width() / shrink_factor;
let height = self.values.height() / shrink_factor;
let values = resize(&self.values, width, height, FilterType::Nearest);
let buffer = resize(&self.mask.buffer, width, height, FilterType::Nearest);
let mask = RasterMask::new(buffer);
Self {
values,
mask,
px_size: self.px_size * shrink_factor as f64,
min_z: self.min_z,
max_z: self.max_z,
}
}
pub fn convolve(&self, kernel: &RasterKernel, skip_unmasked: bool, keep_zlim: bool) -> Self {
kernel.convolve(self, skip_unmasked, keep_zlim)
}
pub fn convolve_fast(
&self,
kernel: &dyn FastApproxKernel,
skip_unmasked: bool,
keep_zlim: bool,
target_size: usize,
) -> Result<Self> {
let full_kernel = kernel.make(self.px_size)?;
let shrink_factor = ((full_kernel.size as f64) / target_size as f64).floor();
if shrink_factor + f64::EPSILON <= 1.0 {
return Ok(full_kernel.convolve(self, skip_unmasked, keep_zlim));
}
let shrunk_values = self.create_shrunk(shrink_factor as u32);
let shrunk_kernel = kernel.make(shrunk_values.px_size)?;
let shrunk_result = shrunk_kernel.convolve(&shrunk_values, skip_unmasked, keep_zlim);
let scaled_result = shrunk_result.create_scaled(shrink_factor);
let scale_x = scaled_result.width() as f32 / self.width() as f32;
let scale_y = scaled_result.height() as f32 / self.height() as f32;
let mut full_result = ScalarRaster::empty_like(self);
let mut need_calc = Vec::new();
for (x, y, v) in full_result.values.enumerate_pixels_mut() {
if skip_unmasked && !self.mask.get_point(Point2I::new(x as i32, y as i32)) {
continue;
}
let sx = (x as f32 * scale_x).floor() as u32;
let sy = (y as f32 * scale_y).floor() as u32;
let scaled_mask = scaled_result.mask.buffer.get_pixel(sx, sy)[0];
if scaled_mask == 0 {
continue;
}
if scaled_mask < 255 {
need_calc.push((x, y));
continue;
}
*v = Luma([scaled_result.values.get_pixel(
(x as f32 * scale_x).floor() as u32,
(y as f32 * scale_y).floor() as u32,
)[0]]);
full_result
.mask
.set_point_unchecked(Point2I::new(x as i32, y as i32), true);
}
let (target_matrix, target_mask) = self.to_value_and_mask_matrices();
let final_calcs = need_calc
.par_iter()
.map(|(x, y)| {
(
*x,
*y,
full_kernel.convolved_pixel_mat(
*x as usize,
*y as usize,
&target_matrix,
&target_mask,
),
)
})
.collect::<Vec<_>>();
for (x, y, v) in final_calcs {
full_result.set_f_at(Point2I::new(x as i32, y as i32), v)?;
}
Ok(full_result)
}
pub fn area_blurred(&self, radius_mm: f32) -> Self {
let optimal_scale = get_shrink_factor(radius_mm, self.px_size as f32, 16);
let blurred = if optimal_scale > 1 {
let small = self.create_shrunk(optimal_scale);
let small_blurred = small.area_blurred(radius_mm);
self.area_average_with_resized(radius_mm, &small_blurred)
} else {
self.area_average(radius_mm)
};
Self {
values: blurred,
mask: self.mask.clone(),
px_size: self.px_size,
min_z: self.min_z,
max_z: self.max_z,
}
}
pub fn area_filtered(&self, radius_mm: f32) -> Result<Self> {
let blurred = self.area_blurred(radius_mm);
self.subtract(&blurred)
}
fn area_average_px(&self, x: u32, y: u32, radius_px: u32) -> u16 {
let area = AreaAverage::from(&self.values, &self.mask.buffer, x, y, radius_px);
area.get_average()
}
fn area_average(&self, radius_mm: f32) -> ScalarImage<u16> {
let radius = (radius_mm / self.px_size as f32).ceil() as u32;
let mut blurred = ScalarImage::new(self.width(), self.height());
let xys = self
.mask
.buffer
.enumerate_pixels()
.filter(|(_, _, p)| (*p)[0] == 255)
.map(|(x, y, _)| (x, y))
.collect::<Vec<_>>();
let result = xys
.par_iter()
.map(|(x, y)| (x, y, self.area_average_px(*x, *y, radius)))
.collect::<Vec<_>>();
for (x, y, v) in result {
blurred.put_pixel(*x, *y, Luma([v]));
}
blurred
}
fn area_average_with_resized(&self, radius_mm: f32, resized: &Self) -> ScalarImage<u16> {
let mut blurred = ScalarImage::new(self.width(), self.height());
let mut transferred = GrayImage::new(self.mask.width(), self.mask.height());
let radius = (radius_mm / self.px_size as f32).ceil() as u32;
let scale_x = resized.mask.width() as f32 / self.mask.width() as f32;
let scale_y = resized.mask.height() as f32 / self.mask.height() as f32;
for (x, y, v) in blurred.enumerate_pixels_mut() {
let p = Point2I::new(x as i32, y as i32);
if !self.mask.get_point(p) {
continue;
}
let sx = (x as f32 * scale_x).floor() as u32;
let sy = (y as f32 * scale_y).floor() as u32;
if !resized.mask.get_point(Point2I::new(sx as i32, sy as i32)) {
continue;
}
*v = Luma([resized.values.get_pixel(sx, sy)[0]]);
transferred.put_pixel(x, y, Luma([255]));
}
let xys = self
.mask
.buffer
.enumerate_pixels()
.filter(|(x, y, p)| (*p)[0] != 0 && transferred.get_pixel(*x, *y)[0] == 0)
.map(|(x, y, _)| (x, y))
.collect::<Vec<_>>();
let result = xys
.par_iter()
.map(|(x, y)| (x, y, self.area_average_px(*x, *y, radius)))
.collect::<Vec<_>>();
for (x, y, v) in result {
blurred.put_pixel(*x, *y, Luma([v]));
}
blurred
}
pub fn erode_mut(&mut self, count: usize) -> Result<()> {
let mut eroded = self.mask.clone();
eroded.erode_alternating_norms_mut(count);
eroded.not_mut();
eroded.and_mut(&self.mask)?;
for p in eroded.iter_true() {
self.set_u_at(p, None)?;
}
Ok(())
}
pub fn erode_from_border_mut(&mut self, count: usize) -> Result<()> {
let mut eroded = self.mask.get_flood_fill_from_borders(Connectivity::Eight);
eroded.not_mut();
eroded.erode_alternating_norms_mut(count);
eroded.not_mut();
eroded.and_mut(&self.mask)?;
for p in eroded.iter_true() {
self.set_u_at(p, None)?;
}
Ok(())
}
}
fn get_shrink_factor(radius_mm: f32, mm_per_px: f32, target: u32) -> u32 {
let mut shrink_factor = 1;
let radius = (radius_mm / mm_per_px).ceil() as u32;
while radius / shrink_factor > target {
shrink_factor += 1;
}
shrink_factor
}
pub fn diff_img(img1: &GrayImage, img2: &GrayImage) -> GrayImage {
let mut diff = GrayImage::new(img1.width(), img1.height());
for (p1, p2, p3) in diff.enumerate_pixels_mut() {
let v1 = img1.get_pixel(p1, p2)[0];
let v2 = img2.get_pixel(p1, p2)[0];
if v1 >= v2 {
*p3 = Luma([v1 - v2]);
} else {
*p3 = Luma([0]);
}
}
diff
}
pub fn fill_cycle(mask: &GrayImage, count: usize) -> GrayImage {
let mut dilated = mask.clone();
for _ in 0..count {
dilate_mut(&mut dilated, L1, 1);
}
for _ in 0..count {
erode_mut(&mut dilated, L1, 1);
}
dilated
}
pub fn erode_cycle(mask: &GrayImage, count: usize) -> GrayImage {
let mut dilated = mask.clone();
for _ in 0..count {
erode_mut(&mut dilated, L1, 1);
}
for _ in 0..count {
dilate_mut(&mut dilated, L1, 1);
}
dilated
}
#[cfg(test)]
mod tests {
use super::*;
use crate::na::DMatrix;
use approx::assert_relative_eq;
#[test]
fn scalar_raster_round_trip() {
let expected = DMatrix::from_row_slice(
3,
4,
&[
-1.0, -2.0, -3.0, -4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0,
],
);
let raster = ScalarRaster::from_matrix(&expected, 1.0, -10.0, 20.0);
let matrix = raster.to_matrix();
for i in 0..expected.nrows() {
for j in 0..expected.ncols() {
assert_relative_eq!(expected[(i, j)], matrix[(i, j)], epsilon = 5e-4)
}
}
}
#[test]
fn round_trip_serialization() {
let m = 300;
let n = 200;
let mut values = DMatrix::from_fn(m, n, |i, j| {
if (i + j) % 2 == 0 {
(i * j) as f64
} else {
0.0
}
});
values /= values.sum();
let expected = ScalarRaster::from_matrix(&values, 1.0, -2.0, 2.0);
let bytes = expected.serialized_bytes(ImageFormat::Png);
let deserialized = ScalarRaster::from_serialized_bytes(&bytes).unwrap();
for i in 0..m {
for j in 0..n {
let p = Point2I::new(j as i32, i as i32);
let expected_value = expected.f_at(p);
let actual_value = deserialized.f_at(p);
if expected_value.is_nan() {
assert!(actual_value.is_nan());
continue;
}
assert_relative_eq!(expected_value, actual_value, epsilon = 1e-4);
}
}
}
}