use std::io::Read;
use std::path::Path;
use arcsec_core::types::{ImageBuffer, WcsSolution};
use arcsec_core::wcs::TanWcs;
use crate::{asdf_io, fits_io, raster_io, xisf_io};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ImageFormat {
Fits,
Xisf,
Asdf,
Jpeg,
Png,
Tiff,
}
impl ImageFormat {
pub const fn name(self) -> &'static str {
match self {
Self::Fits => "FITS",
Self::Xisf => "XISF",
Self::Asdf => "ASDF",
Self::Jpeg => "JPEG",
Self::Png => "PNG",
Self::Tiff => "TIFF",
}
}
pub const fn is_raster(self) -> bool {
matches!(self, Self::Jpeg | Self::Png | Self::Tiff)
}
}
pub fn detect_format(path: &Path) -> Result<ImageFormat, String> {
let mut head = [0u8; 16];
let n = match std::fs::File::open(path).and_then(|mut f| f.read(&mut head)) {
Ok(n) => n,
Err(e) => {
if path.to_string_lossy().contains('[') {
return Ok(ImageFormat::Fits);
}
return Err(format!("{}: {e}", path.display()));
}
};
let head = &head[..n];
if head.starts_with(b"XISF0100") {
Ok(ImageFormat::Xisf)
} else if head.starts_with(b"#ASDF ") {
Ok(ImageFormat::Asdf)
} else if head.starts_with(b"\xff\xd8\xff") {
Ok(ImageFormat::Jpeg)
} else if head.starts_with(b"\x89PNG\r\n\x1a\n") {
Ok(ImageFormat::Png)
} else if [b"II*\0", b"MM\0*", b"II+\0", b"MM\0+"]
.iter()
.any(|m| head.starts_with(*m))
{
Ok(ImageFormat::Tiff)
} else if head.starts_with(b"SIMPLE =")
|| head.starts_with(b"\x1f\x8b") || head.starts_with(b"BZh") || head.starts_with(b"\x1f\x9d")
{
Ok(ImageFormat::Fits)
} else {
Err(format!(
"{}: not a FITS, XISF, ASDF, JPEG, PNG or TIFF image (no recognised magic bytes)",
path.display()
))
}
}
#[cfg(not(fuzzing))]
pub const MAX_IMAGE_PIXELS: usize = 1 << 30;
#[cfg(fuzzing)]
pub const MAX_IMAGE_PIXELS: usize = 1 << 22;
pub fn checked_pixel_count(width: usize, height: usize, channels: usize) -> Result<usize, String> {
width
.checked_mul(height)
.and_then(|n| n.checked_mul(channels))
.filter(|&n| n <= MAX_IMAGE_PIXELS)
.ok_or_else(|| {
format!(
"image dimensions {width}×{height}×{channels} exceed the {MAX_IMAGE_PIXELS}-pixel \
limit"
)
})
}
pub fn try_alloc_pixels(npix: usize) -> Result<Vec<f32>, String> {
let mut data = Vec::new();
data.try_reserve_exact(npix)
.map_err(|_| format!("not enough memory for {npix} pixels"))?;
data.resize(npix, 0.0);
Ok(data)
}
std::thread_local! {
static IN_READER: core::cell::Cell<bool> = const { core::cell::Cell::new(false) };
static PANIC_SITE: core::cell::RefCell<String> = const { core::cell::RefCell::new(String::new()) };
}
fn guarded<T>(path: &Path, read: impl FnOnce() -> Result<T, String>) -> Result<T, String> {
#[cfg(fuzzing)]
if true {
let _ = path;
return read();
}
static HOOK: std::sync::Once = std::sync::Once::new();
HOOK.call_once(|| {
let previous = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
if IN_READER.with(core::cell::Cell::get) {
let site = info
.location()
.map(|l| format!(" at {}:{}", l.file(), l.line()))
.unwrap_or_default();
PANIC_SITE.with(|s| *s.borrow_mut() = site);
} else {
previous(info);
}
}));
});
let outer = IN_READER.with(|g| g.replace(true));
let result = std::panic::catch_unwind(core::panic::AssertUnwindSafe(read));
IN_READER.with(|g| g.set(outer));
result.unwrap_or_else(|panic| {
Err(format!(
"{}: the reader failed on this file, which is probably corrupt ({}{})",
path.display(),
panic_message(panic.as_ref()),
PANIC_SITE.with(core::cell::RefCell::take)
))
})
}
pub fn panic_message(payload: &(dyn core::any::Any + Send)) -> &str {
payload
.downcast_ref::<&str>()
.copied()
.or_else(|| payload.downcast_ref::<String>().map(String::as_str))
.unwrap_or("panic")
}
pub fn read_image(path: &Path) -> Result<ImageBuffer, String> {
let format = detect_format(path)?;
let img = guarded(path, || match format {
ImageFormat::Fits => fits_io::read_fits_image(path),
ImageFormat::Xisf => xisf_io::read_xisf_image(path),
ImageFormat::Asdf => asdf_io::read_asdf_image(path),
f @ (ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::Tiff) => {
raster_io::read_raster_image(path, f)
}
})?;
if img.data.len() != img.width * img.height {
return Err(format!(
"{}: the reader returned {} samples for a {}×{} image",
path.display(),
img.data.len(),
img.width,
img.height
));
}
Ok(img)
}
pub fn read_ra_dec(path: &Path) -> Option<(f64, f64)> {
let format = detect_format(path).ok()?;
guarded(path, || {
Ok(match format {
ImageFormat::Fits => fits_io::read_fits_ra_dec(path),
ImageFormat::Xisf => xisf_io::read_xisf_ra_dec(path),
ImageFormat::Asdf => asdf_io::read_asdf_ra_dec(path),
ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::Tiff => None,
})
})
.inspect_err(|e| log::warn!("{e}"))
.ok()
.flatten()
}
pub fn read_pixel_scale(path: &Path) -> Option<f64> {
let format = detect_format(path).ok()?;
guarded(path, || {
Ok(match format {
ImageFormat::Fits => fits_io::read_fits_pixel_scale(path),
ImageFormat::Xisf => xisf_io::read_xisf_pixel_scale(path),
ImageFormat::Asdf => asdf_io::read_asdf_pixel_scale(path),
ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::Tiff => None,
})
})
.inspect_err(|e| log::warn!("{e}"))
.ok()
.flatten()
}
pub fn read_dimensions(path: &Path) -> Option<(u32, u32)> {
let format = detect_format(path).ok()?;
guarded(path, || {
Ok(match format {
ImageFormat::Fits => fits_io::read_fits_dimensions(path),
ImageFormat::Xisf => xisf_io::read_xisf_dimensions(path),
ImageFormat::Asdf => asdf_io::read_asdf_dimensions(path),
f @ (ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::Tiff) => {
raster_io::read_raster_dimensions(path, f)
}
})
})
.inspect_err(|e| log::warn!("{e}"))
.ok()
.flatten()
}
pub fn read_header_wcs(path: &Path) -> Option<TanWcs> {
let format = detect_format(path).ok()?;
guarded(path, || {
Ok(match format {
ImageFormat::Fits => fits_io::read_fits_header_wcs(path),
ImageFormat::Xisf => xisf_io::read_xisf_header_wcs(path),
ImageFormat::Asdf | ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::Tiff => None,
})
})
.inspect_err(|e| log::warn!("{e}"))
.ok()
.flatten()
}
pub fn read_channels(path: &Path) -> usize {
let Ok(format) = detect_format(path) else {
return 1;
};
guarded(path, || {
Ok(match format {
ImageFormat::Fits => fits_io::read_fits_channels(path),
ImageFormat::Xisf => xisf_io::read_xisf_channels(path),
ImageFormat::Asdf => 1,
f @ (ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::Tiff) => {
raster_io::read_raster_channels(path, f)
}
})
})
.inspect_err(|e| log::warn!("{e}"))
.unwrap_or(1)
}
pub fn update_wcs(path: &Path, wcs: &WcsSolution) -> Result<(), String> {
match detect_format(path)? {
ImageFormat::Fits => guarded(path, || fits_io::update_fits_wcs(path, wcs)),
other => Err(format!(
"--update writes the solution into the image header, which is only \
supported for FITS (this file is {}). The .wcs and .ini files were \
still written.",
other.name()
)),
}
}
pub fn pixel_scale_from(
focallen_mm: Option<f64>,
xpixsz_um: Option<f64>,
xbinning: Option<f64>,
) -> Option<f64> {
let usable = |v: &f64| v.is_finite() && *v > 0.0;
let fl = focallen_mm.filter(usable)?;
let ps = xpixsz_um.filter(usable)?;
let bin = xbinning.filter(usable).unwrap_or(1.0);
Some(ps * bin / fl * 206.265).filter(|s| PLAUSIBLE_PIXEL_SCALE.contains(s))
}
const PLAUSIBLE_PIXEL_SCALE: core::ops::RangeInclusive<f64> = 1e-3..=1e4;
pub fn tan_wcs_from(mut key: impl FnMut(&str) -> Option<f64>) -> Option<TanWcs> {
let cd1_1 = key("CD1_1").filter(|v| *v != 0.0)?;
let wcs = TanWcs {
ra0: key("CRVAL1")?.to_radians(),
dec0: key("CRVAL2")?.to_radians(),
crpix1: key("CRPIX1")?,
crpix2: key("CRPIX2")?,
cd: [
[cd1_1, key("CD1_2").unwrap_or(0.0)],
[key("CD2_1").unwrap_or(0.0), key("CD2_2").unwrap_or(0.0)],
],
sip: None,
};
let finite = [wcs.ra0, wcs.dec0, wcs.crpix1, wcs.crpix2]
.into_iter()
.chain(wcs.cd.into_iter().flatten())
.all(f64::is_finite);
finite.then_some(wcs)
}
pub fn ra_dec_from(
ra: Option<f64>,
dec: Option<f64>,
crval1: Option<f64>,
crval2: Option<f64>,
) -> Option<(f64, f64)> {
let finite = |v: &f64| v.is_finite();
let (ra, dec) = (ra.filter(finite), dec.filter(finite));
let (crval1, crval2) = (crval1.filter(finite), crval2.filter(finite));
Some((ra.or(crval1)?, dec.or(crval2)?))
}
#[cfg(test)]
mod tests {
use super::*;
fn write(name: &str, bytes: &[u8]) -> std::path::PathBuf {
let p = std::env::temp_dir().join(name);
std::fs::write(&p, bytes).unwrap();
p
}
#[test]
fn detects_by_content_not_extension() {
let f = write("arcsec_fmt_a.dat", b"SIMPLE = T");
assert_eq!(detect_format(&f), Ok(ImageFormat::Fits));
let x = write("arcsec_fmt_b.fits", b"XISF0100\x00\x00\x00\x00");
assert_eq!(
detect_format(&x),
Ok(ImageFormat::Xisf),
"extension must not win"
);
let a = write("arcsec_fmt_c.fits", b"#ASDF 1.0.0\n#ASDF_STANDARD 1.6.0\n");
assert_eq!(detect_format(&a), Ok(ImageFormat::Asdf));
let j = write("arcsec_fmt_g.fits", b"\xff\xd8\xff\xe0\0\x10JFIF\0");
assert_eq!(detect_format(&j), Ok(ImageFormat::Jpeg));
let p = write("arcsec_fmt_h.jpg", b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR");
assert_eq!(detect_format(&p), Ok(ImageFormat::Png));
let mut tiffs = Vec::new();
for (i, magic) in [b"II*\0", b"MM\0*", b"II+\0", b"MM\0+"].iter().enumerate() {
let t = write(&format!("arcsec_fmt_t{i}.png"), *magic);
assert_eq!(detect_format(&t), Ok(ImageFormat::Tiff), "{magic:?}");
tiffs.push(t);
}
for p in [f, x, a, j, p].into_iter().chain(tiffs) {
std::fs::remove_file(p).ok();
}
}
#[test]
fn unknown_and_missing_files_are_rejected() {
let u = write("arcsec_fmt_d.bin", b"not any known magic");
assert!(
detect_format(&u).is_err(),
"junk must not be taken for FITS"
);
std::fs::remove_file(&u).ok();
assert!(
detect_format(Path::new("/nonexistent/arcsec/none.fits")).is_err(),
"a missing file must not be taken for FITS"
);
}
#[test]
fn compressed_fits_and_extended_syntax_still_reach_cfitsio() {
let g = write("arcsec_fmt_e.fits", b"\x1f\x8b\x08\x00rest-is-deflate");
assert_eq!(detect_format(&g), Ok(ImageFormat::Fits), "gzip");
std::fs::remove_file(&g).ok();
let b = write("arcsec_fmt_f.fits", b"BZh91AY&SY");
assert_eq!(detect_format(&b), Ok(ImageFormat::Fits), "bzip2");
std::fs::remove_file(&b).ok();
assert_eq!(
detect_format(Path::new("/nonexistent/arcsec/none.fits[1]")),
Ok(ImageFormat::Fits)
);
}
#[test]
fn pixel_scale_formula() {
let ps = pixel_scale_from(Some(250.0), Some(3.76), Some(1.0)).unwrap();
assert!((ps - 3.1022).abs() < 1e-3, "got {ps}");
let ps2 = pixel_scale_from(Some(250.0), Some(3.76), Some(2.0)).unwrap();
assert!((ps2 - 2.0 * ps).abs() < 1e-9);
assert!(pixel_scale_from(None, Some(3.76), None).is_none());
assert!(pixel_scale_from(Some(250.0), None, None).is_none());
assert!(pixel_scale_from(Some(0.0), Some(3.76), None).is_none());
assert!(pixel_scale_from(Some(250.0), Some(-1.0), None).is_none());
assert!(pixel_scale_from(Some(1e300), Some(3.76), None).is_none());
assert!(pixel_scale_from(Some(1e-300), Some(3.76), None).is_none());
assert!(pixel_scale_from(Some(f64::INFINITY), Some(3.76), None).is_none());
assert!(pixel_scale_from(Some(250.0), Some(f64::NAN), None).is_none());
assert_eq!(
pixel_scale_from(Some(250.0), Some(3.76), Some(f64::INFINITY)),
pixel_scale_from(Some(250.0), Some(3.76), None)
);
assert!(pixel_scale_from(Some(250.0), Some(3.76), None).is_some());
}
#[test]
fn a_header_wcs_needs_a_cd_matrix() {
let full = |k: &str| match k {
"CRVAL1" => Some(150.0),
"CRVAL2" => Some(40.0),
"CRPIX1" => Some(100.5),
"CRPIX2" => Some(80.5),
"CD1_1" => Some(-2e-4),
"CD2_2" => Some(2e-4),
_ => None,
};
let w = tan_wcs_from(full).unwrap();
assert_eq!(w.cd, [[-2e-4, 0.0], [0.0, 2e-4]]);
let (ra, dec) = w.pixel_to_sky(100.5, 80.5);
assert!((ra.to_degrees() - 150.0).abs() < 1e-9 && (dec.to_degrees() - 40.0).abs() < 1e-9);
assert!(tan_wcs_from(|k| if k == "CD1_1" { None } else { full(k) }).is_none());
assert!(tan_wcs_from(|k| if k == "CD1_1" { Some(0.0) } else { full(k) }).is_none());
assert!(tan_wcs_from(|k| if k == "CRPIX2" { None } else { full(k) }).is_none());
}
#[test]
fn ra_dec_prefers_the_telescope_over_crval() {
assert_eq!(
ra_dec_from(Some(10.0), Some(20.0), Some(99.0), Some(99.0)),
Some((10.0, 20.0))
);
assert_eq!(
ra_dec_from(None, None, Some(30.0), Some(40.0)),
Some((30.0, 40.0))
);
assert_eq!(ra_dec_from(Some(10.0), None, None, None), None);
assert_eq!(ra_dec_from(Some(f64::NAN), Some(20.0), None, None), None);
assert_eq!(
ra_dec_from(Some(f64::INFINITY), Some(20.0), Some(30.0), Some(40.0)),
Some((30.0, 20.0))
);
}
#[test]
fn a_panicking_reader_is_an_error_naming_where() {
let p = Path::new("x.fits");
let err = guarded::<()>(p, || panic!("boom {}", 42)).unwrap_err();
assert!(
err.starts_with("x.fits: ") && err.contains("boom 42"),
"{err}"
);
assert!(err.contains("image_io.rs"), "location missing: {err}");
assert_eq!(guarded(p, || guarded(p, || Ok(7))), Ok(7));
assert!(!IN_READER.with(core::cell::Cell::get));
}
#[test]
fn pixel_counts_are_checked_before_allocating() {
assert_eq!(checked_pixel_count(4, 3, 2), Ok(24));
assert!(checked_pixel_count(usize::MAX, 2, 1).is_err());
assert!(checked_pixel_count(1 << 20, 1 << 20, 1).is_err());
assert!(checked_pixel_count(MAX_IMAGE_PIXELS, 1, 1).is_ok());
assert!(checked_pixel_count(MAX_IMAGE_PIXELS, 1, 2).is_err());
assert_eq!(try_alloc_pixels(5).unwrap(), vec![0.0; 5]);
}
}