953 lines
29 KiB
Rust
953 lines
29 KiB
Rust
#[cfg(feature = "python")]
|
|
mod py;
|
|
|
|
use anyhow::Result;
|
|
use chrono::Utc;
|
|
use ndarray::{s, ArcArray2, AsArray, Ix2};
|
|
use num::{traits::ToBytes, Complex, FromPrimitive, Rational32};
|
|
use rayon::prelude::*;
|
|
use std::collections::HashSet;
|
|
use std::fs::{File, OpenOptions};
|
|
use std::hash::{DefaultHasher, Hash, Hasher};
|
|
use std::io::{Read, Seek, SeekFrom, Write};
|
|
use std::time::Duration;
|
|
use std::{cmp::Ordering, collections::HashMap};
|
|
use std::{
|
|
thread,
|
|
thread::{sleep, JoinHandle},
|
|
};
|
|
use zstd::{stream::Encoder, DEFAULT_COMPRESSION_LEVEL};
|
|
|
|
const TAG_SIZE: usize = 20;
|
|
const OFFSET_SIZE: usize = 8;
|
|
const OFFSET: u64 = 16;
|
|
const COMPRESSION: u16 = 50000;
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct IFD {
|
|
tags: HashSet<Tag>,
|
|
}
|
|
|
|
impl IFD {
|
|
pub fn new() -> Self {
|
|
IFD {
|
|
tags: HashSet::new(),
|
|
}
|
|
}
|
|
|
|
fn write(&mut self, ijtifffile: &mut IJTiffFile, where_to_write_offset: u64) -> Result<u64> {
|
|
let mut tags = self.tags.drain().collect::<Vec<_>>();
|
|
tags.sort();
|
|
ijtifffile.file.seek(SeekFrom::End(0))?;
|
|
if ijtifffile.file.stream_position()? % 2 == 1 {
|
|
ijtifffile.file.write(&[0])?;
|
|
}
|
|
let offset = ijtifffile.file.stream_position()?;
|
|
ijtifffile.file.write(&(tags.len() as u64).to_le_bytes())?;
|
|
|
|
for tag in tags.iter_mut() {
|
|
tag.write_tag(ijtifffile)?;
|
|
}
|
|
let where_to_write_next_ifd_offset = ijtifffile.file.stream_position()?;
|
|
ijtifffile.file.write(&vec![0u8; OFFSET_SIZE])?;
|
|
for tag in tags.iter() {
|
|
tag.write_data(ijtifffile)?;
|
|
}
|
|
ijtifffile
|
|
.file
|
|
.seek(SeekFrom::Start(where_to_write_offset))?;
|
|
ijtifffile.file.write(&offset.to_le_bytes())?;
|
|
Ok(where_to_write_next_ifd_offset)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Eq)]
|
|
pub struct Tag {
|
|
code: u16,
|
|
bytes: Vec<u8>,
|
|
ttype: u16,
|
|
offset: u64,
|
|
}
|
|
|
|
impl PartialOrd<Self> for Tag {
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
Some(self.cmp(other))
|
|
}
|
|
}
|
|
|
|
impl Ord for Tag {
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
|
self.code.cmp(&other.code)
|
|
}
|
|
}
|
|
|
|
impl PartialEq for Tag {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.code == other.code
|
|
}
|
|
}
|
|
|
|
impl Hash for Tag {
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
self.code.hash(state);
|
|
}
|
|
}
|
|
|
|
impl Tag {
|
|
pub fn new(code: u16, bytes: Vec<u8>, ttype: u16) -> Self {
|
|
Tag {
|
|
code,
|
|
bytes,
|
|
ttype,
|
|
offset: 0,
|
|
}
|
|
}
|
|
|
|
pub fn byte(code: u16, value: &Vec<u8>) -> Self {
|
|
Tag::new(code, value.to_owned(), 1)
|
|
}
|
|
|
|
pub fn ascii(code: u16, value: &str) -> Self {
|
|
let mut bytes = value.as_bytes().to_vec();
|
|
bytes.push(0);
|
|
Tag::new(code, bytes, 2)
|
|
}
|
|
|
|
pub fn short(code: u16, value: &Vec<u16>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
3,
|
|
)
|
|
}
|
|
|
|
pub fn long(code: u16, value: &Vec<u32>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
4,
|
|
)
|
|
}
|
|
|
|
pub fn rational(code: u16, value: &Vec<Rational32>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| {
|
|
u32::try_from(*x.denom())
|
|
.unwrap()
|
|
.to_le_bytes()
|
|
.into_iter()
|
|
.chain(u32::try_from(*x.numer()).unwrap().to_le_bytes())
|
|
.collect::<Vec<_>>()
|
|
})
|
|
.flatten()
|
|
.collect(),
|
|
5,
|
|
)
|
|
}
|
|
|
|
pub fn sbyte(code: u16, value: &Vec<i8>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value.iter().map(|x| x.to_le_bytes()).flatten().collect(),
|
|
6,
|
|
)
|
|
}
|
|
|
|
pub fn sshort(code: u16, value: &Vec<i16>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
8,
|
|
)
|
|
}
|
|
|
|
pub fn slong(code: u16, value: &Vec<i32>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
9,
|
|
)
|
|
}
|
|
|
|
pub fn srational(code: u16, value: &Vec<Rational32>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| {
|
|
i32::try_from(*x.denom())
|
|
.unwrap()
|
|
.to_le_bytes()
|
|
.into_iter()
|
|
.chain(i32::try_from(*x.numer()).unwrap().to_le_bytes())
|
|
.collect::<Vec<_>>()
|
|
})
|
|
.flatten()
|
|
.collect(),
|
|
10,
|
|
)
|
|
}
|
|
|
|
pub fn float(code: u16, value: &Vec<f32>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
11,
|
|
)
|
|
}
|
|
|
|
pub fn double(code: u16, value: &Vec<f64>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
12,
|
|
)
|
|
}
|
|
|
|
pub fn ifd(code: u16, value: &Vec<u32>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
13,
|
|
)
|
|
}
|
|
|
|
pub fn unicode(code: u16, value: &str) -> Self {
|
|
let mut bytes: Vec<u8> = value
|
|
.encode_utf16()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect();
|
|
bytes.push(0);
|
|
Tag::new(code, bytes, 14)
|
|
}
|
|
|
|
pub fn complex(code: u16, value: &Vec<Complex<f32>>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| {
|
|
x.re.to_le_bytes()
|
|
.into_iter()
|
|
.chain(x.im.to_le_bytes())
|
|
.collect::<Vec<_>>()
|
|
})
|
|
.flatten()
|
|
.collect(),
|
|
15,
|
|
)
|
|
}
|
|
|
|
pub fn long8(code: u16, value: &Vec<u64>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
16,
|
|
)
|
|
}
|
|
|
|
pub fn slong8(code: u16, value: &Vec<i64>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
17,
|
|
)
|
|
}
|
|
|
|
pub fn ifd8(code: u16, value: &Vec<u64>) -> Self {
|
|
Tag::new(
|
|
code,
|
|
value
|
|
.into_iter()
|
|
.map(|x| x.to_le_bytes())
|
|
.flatten()
|
|
.collect(),
|
|
18,
|
|
)
|
|
}
|
|
|
|
pub fn short_long_or_long8(code: u16, value: &Vec<u64>) -> Self {
|
|
let m = *value.iter().max().unwrap();
|
|
if m < 65536 {
|
|
Tag::short(code, &value.into_iter().map(|x| *x as u16).collect())
|
|
} else if m < 4294967296 {
|
|
Tag::long(code, &value.into_iter().map(|x| *x as u32).collect())
|
|
} else {
|
|
Tag::long8(code, value)
|
|
}
|
|
}
|
|
|
|
pub fn count(&self) -> u64 {
|
|
let c = match self.ttype {
|
|
1 => self.bytes.len(), // BYTE
|
|
2 => self.bytes.len(), // ASCII
|
|
3 => self.bytes.len() / 2, // SHORT
|
|
4 => self.bytes.len() / 4, // LONG
|
|
5 => self.bytes.len() / 8, // RATIONAL
|
|
6 => self.bytes.len(), // SBYTE
|
|
7 => self.bytes.len(), // UNDEFINED
|
|
8 => self.bytes.len() / 2, // SSHORT
|
|
9 => self.bytes.len() / 4, // SLONG
|
|
10 => self.bytes.len() / 8, // SRATIONAL
|
|
11 => self.bytes.len() / 4, // FLOAT
|
|
12 => self.bytes.len() / 8, // DOUBLE
|
|
13 => self.bytes.len() / 4, // IFD
|
|
14 => self.bytes.len() / 2, // UNICODE
|
|
15 => self.bytes.len() / 8, // COMPLEX
|
|
16 => self.bytes.len() / 8, // LONG8
|
|
17 => self.bytes.len() / 8, // SLONG8
|
|
18 => self.bytes.len() / 8, // IFD8
|
|
_ => self.bytes.len(),
|
|
};
|
|
c as u64
|
|
}
|
|
|
|
fn write_tag(&mut self, ijtifffile: &mut IJTiffFile) -> Result<()> {
|
|
self.offset = ijtifffile.file.stream_position()?;
|
|
ijtifffile.file.write(&self.code.to_le_bytes())?;
|
|
ijtifffile.file.write(&self.ttype.to_le_bytes())?;
|
|
ijtifffile.file.write(&self.count().to_le_bytes())?;
|
|
if self.bytes.len() <= OFFSET_SIZE {
|
|
ijtifffile.file.write(&self.bytes)?;
|
|
for _ in self.bytes.len()..OFFSET_SIZE {
|
|
ijtifffile.file.write(&[0])?;
|
|
}
|
|
} else {
|
|
ijtifffile.file.write(&vec![0u8; OFFSET_SIZE])?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn write_data(&self, ijtifffile: &mut IJTiffFile) -> Result<()> {
|
|
if self.bytes.len() > OFFSET_SIZE {
|
|
ijtifffile.file.seek(SeekFrom::End(0))?;
|
|
let offset = ijtifffile.write(&self.bytes)?;
|
|
ijtifffile.file.seek(SeekFrom::Start(
|
|
self.offset + (TAG_SIZE - OFFSET_SIZE) as u64,
|
|
))?;
|
|
ijtifffile.file.write(&offset.to_le_bytes())?;
|
|
if ijtifffile.file.stream_position()? % 2 == 1 {
|
|
ijtifffile.file.write(&[0u8])?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct CompressedFrame {
|
|
bytes: Vec<Vec<u8>>,
|
|
image_width: u32,
|
|
image_length: u32,
|
|
tile_width: usize,
|
|
tile_length: usize,
|
|
bits_per_sample: u16,
|
|
sample_format: u16,
|
|
}
|
|
|
|
impl CompressedFrame {
|
|
fn new<T>(frame: ArcArray2<T>, compression_level: i32) -> CompressedFrame
|
|
where
|
|
T: Bytes + Send + Sync,
|
|
{
|
|
let shape = frame.shape();
|
|
let tile_size = 2usize
|
|
.pow(((shape[0] as f64 * shape[1] as f64 / 2f64).log2() / 2f64).round() as u32)
|
|
.max(16)
|
|
.min(1024);
|
|
|
|
let tile_width = tile_size;
|
|
let tile_length = tile_size;
|
|
let n = shape[0] / tile_width;
|
|
let m = shape[1] / tile_length;
|
|
let mut slices = Vec::new();
|
|
for i in 0..n {
|
|
for j in 0..m {
|
|
slices.push((
|
|
i * tile_width,
|
|
(i + 1) * tile_width,
|
|
j * tile_length,
|
|
(j + 1) * tile_length,
|
|
));
|
|
}
|
|
if shape[1] % tile_length != 0 {
|
|
slices.push((
|
|
i * tile_width,
|
|
(i + 1) * tile_width,
|
|
m * tile_length,
|
|
shape[1],
|
|
));
|
|
}
|
|
}
|
|
if shape[0] % tile_width != 0 {
|
|
for j in 0..m {
|
|
slices.push((
|
|
n * tile_width,
|
|
shape[0],
|
|
j * tile_length,
|
|
(j + 1) * tile_length,
|
|
));
|
|
}
|
|
if shape[1] % tile_length != 0 {
|
|
slices.push((n * tile_width, shape[0], m * tile_length, shape[1]));
|
|
}
|
|
}
|
|
|
|
let mut a = Vec::new();
|
|
for i in 0..24 {
|
|
a.push(i);
|
|
}
|
|
let bytes: Vec<_> = if slices.len() > 4 {
|
|
slices
|
|
.into_par_iter()
|
|
.map(|slice| {
|
|
CompressedFrame::compress_tile(
|
|
frame.clone(),
|
|
slice,
|
|
tile_size,
|
|
tile_size,
|
|
compression_level,
|
|
)
|
|
.unwrap()
|
|
})
|
|
.collect()
|
|
} else {
|
|
slices
|
|
.into_iter()
|
|
.map(|slice| {
|
|
CompressedFrame::compress_tile(
|
|
frame.clone(),
|
|
slice,
|
|
tile_size,
|
|
tile_size,
|
|
compression_level,
|
|
)
|
|
.unwrap()
|
|
})
|
|
.collect()
|
|
};
|
|
|
|
CompressedFrame {
|
|
bytes,
|
|
image_width: shape[0] as u32,
|
|
image_length: shape[1] as u32,
|
|
tile_width,
|
|
tile_length,
|
|
bits_per_sample: T::BITS_PER_SAMPLE,
|
|
sample_format: T::SAMPLE_FORMAT,
|
|
}
|
|
}
|
|
|
|
fn compress_tile<T>(
|
|
frame: ArcArray2<T>,
|
|
slice: (usize, usize, usize, usize),
|
|
tile_width: usize,
|
|
tile_length: usize,
|
|
compression_level: i32,
|
|
) -> Result<Vec<u8>>
|
|
where
|
|
T: Bytes,
|
|
{
|
|
let mut dest = Vec::new();
|
|
let mut encoder = Encoder::new(&mut dest, compression_level)?;
|
|
let bytes_per_sample = (T::BITS_PER_SAMPLE / 8) as usize;
|
|
encoder.include_contentsize(true)?;
|
|
encoder.set_pledged_src_size(Some((bytes_per_sample * tile_width * tile_length) as u64))?;
|
|
let shape = (slice.1 - slice.0, slice.3 - slice.2);
|
|
for i in 0..shape.0 {
|
|
encoder.write(
|
|
&frame
|
|
.slice(s![slice.0..slice.1, slice.2..slice.3])
|
|
.slice(s![i, ..])
|
|
.map(|x| x.bytes())
|
|
.into_iter()
|
|
.flatten()
|
|
.collect::<Vec<_>>(),
|
|
)?;
|
|
encoder.write(&vec![0u8; bytes_per_sample * (tile_width - shape.1)])?;
|
|
}
|
|
encoder.write(&vec![
|
|
0u8;
|
|
bytes_per_sample * tile_width * (tile_length - shape.0)
|
|
])?;
|
|
encoder.finish()?;
|
|
Ok(dest)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct Frame {
|
|
offsets: Vec<u64>,
|
|
bytecounts: Vec<u64>,
|
|
image_width: u32,
|
|
image_length: u32,
|
|
bits_per_sample: u16,
|
|
sample_format: u16,
|
|
tile_width: u16,
|
|
tile_length: u16,
|
|
}
|
|
|
|
impl Frame {
|
|
fn new(
|
|
offsets: Vec<u64>,
|
|
bytecounts: Vec<u64>,
|
|
image_width: u32,
|
|
image_length: u32,
|
|
bits_per_sample: u16,
|
|
sample_format: u16,
|
|
tile_width: u16,
|
|
tile_length: u16,
|
|
) -> Self {
|
|
Frame {
|
|
offsets,
|
|
bytecounts,
|
|
image_width,
|
|
image_length,
|
|
bits_per_sample,
|
|
sample_format,
|
|
tile_width,
|
|
tile_length,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait Bytes {
|
|
const BITS_PER_SAMPLE: u16;
|
|
const SAMPLE_FORMAT: u16;
|
|
|
|
fn bytes(&self) -> Vec<u8>;
|
|
}
|
|
|
|
macro_rules! bytes_impl {
|
|
($T:ty, $bits_per_sample:expr, $sample_format:expr) => {
|
|
impl Bytes for $T {
|
|
const BITS_PER_SAMPLE: u16 = $bits_per_sample;
|
|
const SAMPLE_FORMAT: u16 = $sample_format;
|
|
|
|
#[inline]
|
|
fn bytes(&self) -> Vec<u8> {
|
|
self.to_le_bytes().to_vec()
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
bytes_impl!(u8, 8, 1);
|
|
bytes_impl!(u16, 16, 1);
|
|
bytes_impl!(u32, 32, 1);
|
|
bytes_impl!(u64, 64, 1);
|
|
bytes_impl!(u128, 128, 1);
|
|
#[cfg(target_pointer_width = "64")]
|
|
bytes_impl!(usize, 64, 1);
|
|
#[cfg(target_pointer_width = "32")]
|
|
bytes_impl!(usize, 32, 1);
|
|
bytes_impl!(i8, 8, 2);
|
|
bytes_impl!(i16, 16, 2);
|
|
bytes_impl!(i32, 32, 2);
|
|
bytes_impl!(i64, 64, 2);
|
|
bytes_impl!(i128, 128, 2);
|
|
#[cfg(target_pointer_width = "64")]
|
|
bytes_impl!(isize, 64, 2);
|
|
#[cfg(target_pointer_width = "32")]
|
|
bytes_impl!(isize, 32, 2);
|
|
bytes_impl!(f32, 32, 3);
|
|
bytes_impl!(f64, 64, 3);
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum Colors {
|
|
None,
|
|
Colors(Vec<Vec<u8>>),
|
|
Colormap(Vec<Vec<u8>>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct IJTiffFile {
|
|
file: File,
|
|
frames: HashMap<(usize, usize, usize), Frame>,
|
|
hashes: HashMap<u64, u64>,
|
|
threads: HashMap<(usize, usize, usize), JoinHandle<CompressedFrame>>,
|
|
pub compression_level: i32,
|
|
pub colors: Colors,
|
|
pub comment: Option<String>,
|
|
pub px_size: Option<f64>,
|
|
pub delta_z: Option<f64>,
|
|
pub time_interval: Option<f64>,
|
|
pub extra_tags: HashMap<Option<(usize, usize, usize)>, Vec<Tag>>,
|
|
}
|
|
|
|
impl Drop for IJTiffFile {
|
|
fn drop(&mut self) {
|
|
if let Err(e) = self.close() {
|
|
println!("Error closing IJTiffFile: {:?}", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl IJTiffFile {
|
|
/// create new tifffile from path string
|
|
pub fn new(path: &str) -> Result<Self> {
|
|
let mut file = OpenOptions::new()
|
|
.create(true)
|
|
.truncate(true)
|
|
.write(true)
|
|
.read(true)
|
|
.open(path)?;
|
|
file.write(b"II")?;
|
|
file.write(&43u16.to_le_bytes())?;
|
|
file.write(&8u16.to_le_bytes())?;
|
|
file.write(&0u16.to_le_bytes())?;
|
|
file.write(&OFFSET.to_le_bytes())?;
|
|
Ok(IJTiffFile {
|
|
file,
|
|
frames: HashMap::new(),
|
|
hashes: HashMap::new(),
|
|
threads: HashMap::new(),
|
|
compression_level: DEFAULT_COMPRESSION_LEVEL,
|
|
colors: Colors::None,
|
|
comment: None,
|
|
px_size: None,
|
|
delta_z: None,
|
|
time_interval: None,
|
|
extra_tags: HashMap::new(),
|
|
})
|
|
}
|
|
|
|
/// to be saved in description tag (270)
|
|
pub fn description(&self, c_size: usize, z_size: usize, t_size: usize) -> String {
|
|
let mut desc: String = String::from("ImageJ=1.11a");
|
|
if let Colors::None = self.colors {
|
|
desc += &format!("\nimages={}", c_size);
|
|
desc += &format!("\nslices={}", z_size);
|
|
desc += &format!("\nframes={}", t_size);
|
|
} else {
|
|
desc += &format!("\nimages={}", c_size * z_size * t_size);
|
|
desc += &format!("\nchannels={}", c_size);
|
|
desc += &format!("\nslices={}", z_size);
|
|
desc += &format!("\nframes={}", t_size);
|
|
};
|
|
if c_size == 1 {
|
|
desc += "\nmode=grayscale";
|
|
} else {
|
|
desc += "\nmode=composite";
|
|
}
|
|
desc += "\nhyperstack=true\nloop=false\nunit=micron";
|
|
if let Some(delta_z) = self.delta_z {
|
|
desc += &format!("\nspacing={}", delta_z);
|
|
}
|
|
if let Some(timeinterval) = self.time_interval {
|
|
desc += &format!("\ninterval={}", timeinterval);
|
|
}
|
|
if let Some(comment) = &self.comment {
|
|
desc += &format!("\ncomment={}", comment);
|
|
}
|
|
desc
|
|
}
|
|
|
|
fn get_czt(
|
|
&self,
|
|
frame_number: usize,
|
|
channel: u8,
|
|
c_size: usize,
|
|
z_size: usize,
|
|
) -> (usize, usize, usize) {
|
|
if let Colors::None = self.colors {
|
|
(
|
|
channel as usize,
|
|
frame_number % z_size,
|
|
frame_number / z_size,
|
|
)
|
|
} else {
|
|
(
|
|
frame_number % c_size,
|
|
frame_number / c_size % z_size,
|
|
frame_number / c_size / z_size,
|
|
)
|
|
}
|
|
}
|
|
|
|
fn spp_and_n_frames(&self, c_size: usize, z_size: usize, t_size: usize) -> (u8, usize) {
|
|
if let Colors::None = &self.colors {
|
|
(c_size as u8, z_size * t_size)
|
|
} else {
|
|
(1, c_size * z_size * t_size)
|
|
}
|
|
}
|
|
|
|
fn hash<T: Hash>(value: &T) -> u64 {
|
|
let mut hasher = DefaultHasher::new();
|
|
value.hash(&mut hasher);
|
|
hasher.finish()
|
|
}
|
|
|
|
fn hash_check(&mut self, bytes: &Vec<u8>, offset: u64) -> Result<bool> {
|
|
let current_offset = self.file.stream_position()?;
|
|
self.file.seek(SeekFrom::Start(offset))?;
|
|
let mut buffer = vec![0u8; bytes.len()];
|
|
self.file.read_exact(&mut buffer)?;
|
|
let same = bytes == &buffer;
|
|
self.file.seek(SeekFrom::Start(current_offset))?;
|
|
Ok(same)
|
|
}
|
|
|
|
fn write(&mut self, bytes: &Vec<u8>) -> Result<u64> {
|
|
let hash = IJTiffFile::hash(&bytes);
|
|
if self.hashes.contains_key(&hash)
|
|
&& self.hash_check(&bytes, *self.hashes.get(&hash).unwrap())?
|
|
{
|
|
Ok(*self.hashes.get(&hash).unwrap())
|
|
} else {
|
|
if self.file.stream_position()? % 2 == 1 {
|
|
self.file.write(&[0])?;
|
|
}
|
|
let offset = self.file.stream_position()?;
|
|
self.hashes.insert(hash, offset);
|
|
self.file.write(&bytes)?;
|
|
Ok(offset)
|
|
}
|
|
}
|
|
|
|
pub fn save<'a, A, T>(&mut self, frame: A, c: usize, z: usize, t: usize) -> Result<()>
|
|
where
|
|
A: AsArray<'a, T, Ix2>,
|
|
T: Bytes + Clone + Send + Sync + 'static,
|
|
{
|
|
loop {
|
|
self.collect_threads(false)?;
|
|
if self.threads.len() < 48 {
|
|
break;
|
|
}
|
|
sleep(Duration::from_millis(100));
|
|
}
|
|
let compression_level = self.compression_level;
|
|
let frame = frame.into().to_shared();
|
|
self.threads.insert(
|
|
(c, z, t),
|
|
thread::spawn(move || CompressedFrame::new(frame, compression_level)),
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
fn collect_threads(&mut self, block: bool) -> Result<()> {
|
|
for (c, z, t) in self.threads.keys().cloned().collect::<Vec<_>>() {
|
|
if block || self.threads[&(c, z, t)].is_finished() {
|
|
if let Some(thread) = self.threads.remove(&(c, z, t)) {
|
|
self.write_frame(thread.join().unwrap(), c, z, t)?;
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn write_frame(&mut self, frame: CompressedFrame, c: usize, z: usize, t: usize) -> Result<()> {
|
|
let mut offsets = Vec::new();
|
|
let mut bytecounts = Vec::new();
|
|
for tile in frame.bytes {
|
|
bytecounts.push(tile.len() as u64);
|
|
offsets.push(self.write(&tile)?);
|
|
}
|
|
let frame = Frame::new(
|
|
offsets,
|
|
bytecounts,
|
|
frame.image_width,
|
|
frame.image_length,
|
|
frame.bits_per_sample,
|
|
frame.sample_format,
|
|
frame.tile_width as u16,
|
|
frame.tile_length as u16,
|
|
);
|
|
self.frames.insert((c, z, t), frame);
|
|
Ok(())
|
|
}
|
|
|
|
fn get_colormap(&self, colormap: &Vec<Vec<u8>>, bits_per_sample: u16) -> Vec<u16> {
|
|
let mut r = Vec::new();
|
|
let mut g = Vec::new();
|
|
let mut b = Vec::new();
|
|
let n = 2usize.pow(bits_per_sample as u32 - 8);
|
|
for color in colormap {
|
|
r.extend(vec![(color[0] as u16) * 257; n]);
|
|
g.extend(vec![(color[1] as u16) * 257; n]);
|
|
b.extend(vec![(color[2] as u16) * 257; n]);
|
|
}
|
|
r.extend(g);
|
|
r.extend(b);
|
|
r
|
|
}
|
|
|
|
fn get_color(&self, colors: &Vec<u8>, bits_per_sample: u16) -> Vec<u16> {
|
|
let mut c = Vec::new();
|
|
let n = 2usize.pow(bits_per_sample as u32 - 8);
|
|
for color in colors {
|
|
for i in 0..256 {
|
|
c.extend(vec![i * (*color as u16) / 255 * 257; n])
|
|
}
|
|
}
|
|
c
|
|
}
|
|
|
|
fn close(&mut self) -> Result<()> {
|
|
self.collect_threads(true)?;
|
|
let mut c_size = 1;
|
|
let mut z_size = 1;
|
|
let mut t_size = 1;
|
|
for (c, z, t) in self.frames.keys() {
|
|
c_size = c_size.max(c + 1);
|
|
z_size = z_size.max(z + 1);
|
|
t_size = t_size.max(t + 1);
|
|
}
|
|
|
|
let mut where_to_write_next_ifd_offset = OFFSET - OFFSET_SIZE as u64;
|
|
let mut warn = Vec::new();
|
|
let (samples_per_pixel, n_frames) = self.spp_and_n_frames(c_size, t_size, z_size);
|
|
for frame_number in 0..n_frames {
|
|
if let Some(frame) = self
|
|
.frames
|
|
.get(&self.get_czt(frame_number, 0, c_size, z_size))
|
|
{
|
|
let mut offsets = Vec::new();
|
|
let mut bytecounts = Vec::new();
|
|
let mut frame_count = 0;
|
|
for channel in 0..samples_per_pixel {
|
|
if let Some(frame_n) =
|
|
self.frames
|
|
.get(&self.get_czt(frame_number, channel, c_size, z_size))
|
|
{
|
|
offsets.extend(frame_n.offsets.iter());
|
|
bytecounts.extend(frame_n.bytecounts.iter());
|
|
frame_count += 1;
|
|
} else {
|
|
warn.push((frame_number, channel));
|
|
}
|
|
}
|
|
let mut ifd = IFD::new();
|
|
ifd.tags.insert(Tag::long(256, &vec![frame.image_width]));
|
|
ifd.tags.insert(Tag::long(257, &vec![frame.image_length]));
|
|
ifd.tags
|
|
.insert(Tag::short(258, &vec![frame.bits_per_sample; frame_count]));
|
|
ifd.tags.insert(Tag::short(259, &vec![COMPRESSION]));
|
|
ifd.tags
|
|
.insert(Tag::ascii(270, &self.description(c_size, z_size, t_size)));
|
|
ifd.tags.insert(Tag::short(277, &vec![frame_count as u16]));
|
|
ifd.tags.insert(Tag::ascii(305, "tiffwrite_rs"));
|
|
ifd.tags.insert(Tag::short(322, &vec![frame.tile_width]));
|
|
ifd.tags.insert(Tag::short(323, &vec![frame.tile_length]));
|
|
ifd.tags.insert(Tag::short_long_or_long8(324, &offsets));
|
|
ifd.tags.insert(Tag::short_long_or_long8(325, &bytecounts));
|
|
if frame.sample_format > 1 {
|
|
ifd.tags.insert(Tag::short(339, &vec![frame.sample_format]));
|
|
}
|
|
if let Some(px_size) = self.px_size {
|
|
let r = vec![Rational32::from_f64(px_size).unwrap()];
|
|
ifd.tags.insert(Tag::rational(282, &r));
|
|
ifd.tags.insert(Tag::rational(283, &r));
|
|
ifd.tags.insert(Tag::short(296, &vec![1]));
|
|
}
|
|
if let Colors::Colormap(_) = &self.colors {
|
|
ifd.tags.insert(Tag::short(262, &vec![3]));
|
|
} else if let Colors::None = self.colors {
|
|
ifd.tags.insert(Tag::short(262, &vec![1]));
|
|
}
|
|
if frame_number == 0 {
|
|
if let Colors::Colormap(colormap) = &self.colors {
|
|
ifd.tags.insert(Tag::short(
|
|
320,
|
|
&self.get_colormap(colormap, frame.bits_per_sample),
|
|
));
|
|
}
|
|
}
|
|
if frame_number < c_size {
|
|
if let Colors::Colors(colors) = &self.colors {
|
|
ifd.tags.insert(Tag::short(
|
|
320,
|
|
&self.get_color(&colors[frame_number], frame.bits_per_sample),
|
|
));
|
|
ifd.tags.insert(Tag::short(262, &vec![3]));
|
|
}
|
|
}
|
|
if let Colors::None = &self.colors {
|
|
if c_size > 1 {
|
|
ifd.tags.insert(Tag::short(284, &vec![2]));
|
|
}
|
|
}
|
|
for channel in 0..samples_per_pixel {
|
|
let czt = self.get_czt(frame_number, channel, c_size, z_size);
|
|
if let Some(extra_tags) = self.extra_tags.get(&Some(czt)) {
|
|
for tag in extra_tags {
|
|
ifd.tags.insert(tag.to_owned());
|
|
}
|
|
}
|
|
}
|
|
if let Some(extra_tags) = self.extra_tags.get(&None) {
|
|
for tag in extra_tags {
|
|
ifd.tags.insert(tag.to_owned());
|
|
}
|
|
}
|
|
if frame_number == 0 {
|
|
ifd.tags.insert(Tag::ascii(
|
|
306,
|
|
&format!("{}", Utc::now().format("%Y:%m:%d %H:%M:%S")),
|
|
));
|
|
}
|
|
where_to_write_next_ifd_offset = ifd.write(self, where_to_write_next_ifd_offset)?;
|
|
} else {
|
|
warn.push((frame_number, 0));
|
|
}
|
|
if warn.len() > 0 {
|
|
println!("The following frames were not added to the tif file:");
|
|
for (frame_number, channel) in &warn {
|
|
let (c, z, t) = self.get_czt(*frame_number, *channel, c_size, z_size);
|
|
println!("c: {c}, z: {z}, t: {t}")
|
|
}
|
|
println!(
|
|
"Either you forgot them, \
|
|
or an error occurred and the tif file was closed prematurely."
|
|
)
|
|
}
|
|
}
|
|
self.file
|
|
.seek(SeekFrom::Start(where_to_write_next_ifd_offset))?;
|
|
self.file.write(&0u64.to_le_bytes())?;
|
|
Ok(())
|
|
}
|
|
}
|