319 lines
11 KiB
Rust
319 lines
11 KiB
Rust
use crate::axes::Axis;
|
|
use crate::colors::Color;
|
|
use crate::error::Error;
|
|
use crate::metadata::Metadata;
|
|
use crate::readers::{DynReader, PixelType, Reader};
|
|
use crate::stats::MinMax;
|
|
use crate::utils::progress::get_bar;
|
|
use crate::view::{Number, View};
|
|
use indicatif::ProgressBar;
|
|
use itertools::iproduct;
|
|
use ndarray::{Array0, Array1, Array2, ArrayD, Dimension};
|
|
use rayon::prelude::*;
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::{Arc, Condvar, Mutex};
|
|
use tiffwrite::{Bytes, Colors, Compression, IJTiffFile};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct TiffOptions {
|
|
bar: Option<ProgressBar>,
|
|
compression: Compression,
|
|
colors: Option<Vec<Vec<u8>>>,
|
|
overwrite: bool,
|
|
}
|
|
|
|
impl Default for TiffOptions {
|
|
fn default() -> Self {
|
|
Self {
|
|
bar: None,
|
|
compression: Compression::Zstd(10),
|
|
colors: None,
|
|
overwrite: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TiffOptions {
|
|
pub fn new(
|
|
bar: Option<ProgressBar>,
|
|
compression: Option<Compression>,
|
|
colors: Vec<String>,
|
|
overwrite: bool,
|
|
) -> Result<Self, Error> {
|
|
let mut options = Self {
|
|
bar,
|
|
compression: compression.unwrap_or(Compression::Zstd(10)),
|
|
colors: None,
|
|
overwrite,
|
|
};
|
|
if !colors.is_empty() {
|
|
options.set_colors(&colors)?;
|
|
}
|
|
Ok(options)
|
|
}
|
|
|
|
/// show a progress bar while saving tiff
|
|
pub fn enable_bar(&mut self, message: Option<String>) {
|
|
self.bar = Some(get_bar(Some(0), message));
|
|
}
|
|
|
|
/// do not show a progress bar while saving tiff
|
|
pub fn disable_bar(&mut self) {
|
|
self.bar = None;
|
|
}
|
|
|
|
/// save tiff with zstd compression (default)
|
|
pub fn set_zstd_compression(&mut self) {
|
|
self.compression = Compression::Zstd(10)
|
|
}
|
|
|
|
/// save tiff with zstd compression, choose a level between 7..=22
|
|
pub fn set_zstd_compression_level(&mut self, level: i32) {
|
|
self.compression = Compression::Zstd(level)
|
|
}
|
|
|
|
/// save tiff with deflate compression
|
|
pub fn set_deflate_compression(&mut self) {
|
|
self.compression = Compression::Deflate
|
|
}
|
|
|
|
pub fn set_colors(&mut self, colors: &[String]) -> Result<(), Error> {
|
|
let colors = colors
|
|
.iter()
|
|
.map(|c| c.parse::<Color>())
|
|
.collect::<Result<Vec<_>, Error>>()?;
|
|
self.colors = Some(colors.into_iter().map(|c| c.to_rgb()).collect());
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_overwrite(&mut self, overwrite: bool) {
|
|
self.overwrite = overwrite;
|
|
}
|
|
}
|
|
|
|
impl Drop for TiffOptions {
|
|
fn drop(&mut self) {
|
|
if let Some(bar) = self.bar.take() {
|
|
bar.finish()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<D> View<D>
|
|
where
|
|
D: Dimension,
|
|
{
|
|
/// save as tiff with a certain type
|
|
pub fn save_as_tiff_with_type<T, P>(&self, path: P, options: &TiffOptions) -> Result<(), Error>
|
|
where
|
|
P: AsRef<Path>,
|
|
T: Bytes + Number + Send + Sync,
|
|
ArrayD<T>: MinMax<Output = ArrayD<T>>,
|
|
Array1<T>: MinMax<Output = Array0<T>>,
|
|
Array2<T>: MinMax<Output = Array1<T>>,
|
|
{
|
|
let path = path.as_ref().to_path_buf();
|
|
if path.exists() {
|
|
if options.overwrite {
|
|
std::fs::remove_file(&path)?;
|
|
} else {
|
|
return Err(Error::FileAlreadyExists(path.display().to_string()));
|
|
}
|
|
}
|
|
let shape = self.shape();
|
|
let mut tiff = IJTiffFile::new(path)?;
|
|
tiff.set_compression(options.compression);
|
|
let metadata = self.metadata()?;
|
|
tiff.px_size = metadata.pixel_size()?.map(|i| i / 1e3);
|
|
tiff.time_interval = metadata.time_interval()?.map(|i| i / 1e3);
|
|
tiff.delta_z = metadata.delta_z()?.map(|i| i / 1e3);
|
|
tiff.comment = Some(metadata.summary()?);
|
|
if let Some(mut colors) = options.colors.clone() {
|
|
while colors.len() < shape.c {
|
|
colors.push(vec![255, 255, 255]);
|
|
}
|
|
tiff.colors = Colors::Colors(colors);
|
|
}
|
|
let tiff = Arc::new(Mutex::new(tiff));
|
|
if let Some(bar) = options.bar.as_ref() {
|
|
bar.inc_length((shape.c * shape.z * shape.t) as u64);
|
|
}
|
|
iproduct!(0..shape.c, 0..shape.z, 0..shape.t)
|
|
.collect::<Vec<_>>()
|
|
.into_iter()
|
|
.try_for_each(|(c, z, t)| {
|
|
if let Ok(mut tiff) = tiff.lock() {
|
|
tiff.save(&self.get_frame::<T, _>(c, z, t)?, c, z, t)?;
|
|
if let Some(bar) = options.bar.as_ref() {
|
|
bar.inc(1);
|
|
}
|
|
Ok(())
|
|
} else {
|
|
Err(Error::TiffLock)
|
|
}
|
|
})?;
|
|
Ok(())
|
|
}
|
|
|
|
/// save as tiff with whatever pixel type the view has
|
|
pub fn save_as_tiff<P>(&self, path: P, options: &TiffOptions) -> Result<(), Error>
|
|
where
|
|
P: AsRef<Path>,
|
|
{
|
|
match self.pixel_type() {
|
|
PixelType::I8 => self.save_as_tiff_with_type::<i8, P>(path, options)?,
|
|
PixelType::U8 => self.save_as_tiff_with_type::<u8, P>(path, options)?,
|
|
PixelType::I16 => self.save_as_tiff_with_type::<i16, P>(path, options)?,
|
|
PixelType::U16 => self.save_as_tiff_with_type::<u16, P>(path, options)?,
|
|
PixelType::I32 => self.save_as_tiff_with_type::<i32, P>(path, options)?,
|
|
PixelType::U32 => self.save_as_tiff_with_type::<u32, P>(path, options)?,
|
|
PixelType::F32 => self.save_as_tiff_with_type::<f32, P>(path, options)?,
|
|
PixelType::F64 => self.save_as_tiff_with_type::<f64, P>(path, options)?,
|
|
PixelType::I64 => self.save_as_tiff_with_type::<i64, P>(path, options)?,
|
|
PixelType::U64 => self.save_as_tiff_with_type::<u64, P>(path, options)?,
|
|
PixelType::I128 => self.save_as_tiff_with_type::<i64, P>(path, options)?,
|
|
PixelType::U128 => self.save_as_tiff_with_type::<u64, P>(path, options)?,
|
|
PixelType::F128 => self.save_as_tiff_with_type::<f64, P>(path, options)?,
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub fn batch_to_tiff(
|
|
files_in: &[PathBuf],
|
|
files_out: &[PathBuf],
|
|
operations: Option<Vec<(String, String)>>,
|
|
colors: Option<Vec<String>>,
|
|
overwrite: bool,
|
|
bar: bool,
|
|
message: Option<String>,
|
|
) -> Result<(), Error> {
|
|
let bar = if bar {
|
|
Some(get_bar(
|
|
Some(0),
|
|
Some(message.unwrap_or("writing tiff files".to_string())),
|
|
))
|
|
} else {
|
|
None
|
|
};
|
|
let options = TiffOptions::new(bar, None, colors.unwrap_or_default().clone(), overwrite)?;
|
|
let semaphore = Arc::new((Mutex::new(0usize), Condvar::new()));
|
|
files_in
|
|
.iter()
|
|
.zip(files_out)
|
|
.collect::<Vec<_>>()
|
|
.into_par_iter()
|
|
.map(|(file_in, file_out)| {
|
|
let (lock, cvar) = &*semaphore;
|
|
{
|
|
let mut count = lock.lock().unwrap();
|
|
while *count >= 10 {
|
|
count = cvar.wait(count).unwrap();
|
|
}
|
|
*count += 1;
|
|
}
|
|
let mut view = View::<_, DynReader>::from_path(file_in)?.into_dyn();
|
|
if let Some(operations) = operations.as_ref() {
|
|
for (ax, op) in operations {
|
|
view = view.operate(ax.parse::<Axis>()?, op.parse()?)?;
|
|
}
|
|
}
|
|
view.save_as_tiff(file_out, &options)?;
|
|
{
|
|
let mut count = lock.lock().unwrap();
|
|
*count -= 1;
|
|
cvar.notify_one();
|
|
}
|
|
Ok(())
|
|
})
|
|
.collect::<Result<Vec<()>, Error>>()?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::error::Error;
|
|
use crate::readers::DynReader;
|
|
use crate::tiffwrite::{TiffOptions, batch_to_tiff, get_bar};
|
|
use crate::view::View;
|
|
use std::fs::create_dir_all;
|
|
use std::path::PathBuf;
|
|
|
|
#[cfg(any(
|
|
feature = "czi",
|
|
feature = "tiffseq",
|
|
feature = "tiff",
|
|
feature = "bioformats_java"
|
|
))]
|
|
#[test]
|
|
fn tiff() -> Result<(), Error> {
|
|
let file = if cfg!(any(feature = "czi", feature = "bioformats_java")) {
|
|
"czi/1xp53-01-AP1.czi"
|
|
} else if cfg!(feature = "tiff") {
|
|
"tiff/20251014_20-Pos_000_000_loc_results_Cy3.tif"
|
|
} else if cfg!(feature = "tiffseq") {
|
|
"tiffseq/20-Pos_005_005"
|
|
} else {
|
|
unreachable!(
|
|
"need to enable one of these features: czi, bioformats_java, tiff, tiffseq"
|
|
);
|
|
};
|
|
let path = std::env::current_dir()?
|
|
.join("tests")
|
|
.join("files")
|
|
.join(file);
|
|
let view: View<_, DynReader> = View::from_path(&path)?;
|
|
println!("{}", view.summary()?);
|
|
let bar = Some(get_bar(Some(0), Some("writing tiff file".to_string())));
|
|
let options = TiffOptions::new(bar, None, Vec::new(), true)?;
|
|
view.save_as_tiff(
|
|
std::env::home_dir().unwrap().join("tmp/movie.tif"),
|
|
&options,
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(any(feature = "tiffseq", feature = "tiff", feature = "bioformats_java"))]
|
|
#[test]
|
|
fn tiff_parallel() -> Result<(), Error> {
|
|
let files = [
|
|
#[cfg(any(feature = "tiffseq", feature = "bioformats_java"))]
|
|
"tiffseq/YTL1841B2-2-1_1hr_DMSO_galinduction_1",
|
|
#[cfg(any(feature = "tiff", feature = "bioformats_java"))]
|
|
"tiff/20251014_20-Pos_000_000_max.tif",
|
|
#[cfg(any(feature = "czi", feature = "bioformats_java"))]
|
|
"czi/1xp53-01-AP1.czi",
|
|
#[cfg(any(feature = "czi", feature = "bioformats_java"))]
|
|
"czi/beads_2023_05_04__19_00_22.czi",
|
|
#[cfg(any(feature = "czi", feature = "bioformats_java"))]
|
|
"czi/YTL1849A131_2023_05_04__13_36_36.czi",
|
|
#[cfg(any(feature = "czi", feature = "bioformats_java"))]
|
|
"czi/p53_2x_3-pos_20s_SR-8Y-01_AP-Scene-3-P2.czi",
|
|
];
|
|
let files_in = files
|
|
.iter()
|
|
.map(|file| {
|
|
Ok(std::env::current_dir()?
|
|
.join("tests")
|
|
.join("files")
|
|
.join(file))
|
|
})
|
|
.collect::<Result<Vec<_>, Error>>()?;
|
|
let files_out = files
|
|
.iter()
|
|
.map(|file| {
|
|
std::env::home_dir()
|
|
.unwrap()
|
|
.join("tmp")
|
|
.join(PathBuf::from(file).with_extension("tif"))
|
|
})
|
|
.collect::<Vec<_>>();
|
|
for file in &files_out {
|
|
create_dir_all(file.parent().unwrap())?;
|
|
}
|
|
batch_to_tiff(&files_in, &files_out, None, None, true, true, None)?;
|
|
Ok(())
|
|
}
|
|
}
|