Skip to main content

async_tiff/
tiff.rs

1use crate::ifd::ImageFileDirectory;
2use crate::reader::Endianness;
3
4/// A TIFF file.
5#[derive(Debug, Clone)]
6pub struct TIFF {
7    endianness: Endianness,
8    ifds: Vec<ImageFileDirectory>,
9}
10
11impl TIFF {
12    /// Create a new TIFF from existing IFDs.
13    pub fn new(ifds: Vec<ImageFileDirectory>, endianness: Endianness) -> Self {
14        Self { ifds, endianness }
15    }
16
17    /// Access the underlying Image File Directories.
18    pub fn ifds(&self) -> &[ImageFileDirectory] {
19        &self.ifds
20    }
21
22    /// Get the endianness of the TIFF file.
23    pub fn endianness(&self) -> Endianness {
24        self.endianness
25    }
26}
27
28#[cfg(test)]
29mod test {
30    use std::io::BufReader;
31    use std::sync::Arc;
32
33    use object_store::local::LocalFileSystem;
34    use tiff::decoder::{DecodingResult, Limits};
35
36    use super::*;
37    use crate::metadata::cache::ReadaheadMetadataCache;
38    use crate::metadata::TiffMetadataReader;
39    use crate::reader::{AsyncFileReader, ObjectReader};
40    use crate::TypedArray;
41
42    #[ignore = "local file"]
43    #[tokio::test]
44    async fn tmp() {
45        let folder = "/Users/kyle/github/developmentseed/async-tiff/";
46        let path = object_store::path::Path::parse("m_4007307_sw_18_060_20220803.tif").unwrap();
47        let store = Arc::new(LocalFileSystem::new_with_prefix(folder).unwrap());
48        let reader = Arc::new(ObjectReader::new(store, path)) as Arc<dyn AsyncFileReader>;
49        let cached_reader = ReadaheadMetadataCache::new(reader.clone());
50        let mut metadata_reader = TiffMetadataReader::try_open(&cached_reader).await.unwrap();
51        let ifds = metadata_reader.read_all_ifds(&cached_reader).await.unwrap();
52        let tiff = TIFF::new(ifds, metadata_reader.endianness());
53
54        let ifd = &tiff.ifds[1];
55        let tile = ifd.fetch_tile(0, 0, reader.as_ref()).await.unwrap();
56        let array = tile.decode(&Default::default()).unwrap();
57        let contents = match array.data() {
58            TypedArray::UInt8(data) => data,
59            _ => panic!("unexpected data type"),
60        };
61        std::fs::write("img.buf", contents).unwrap();
62    }
63
64    #[ignore = "local file"]
65    #[test]
66    fn tmp_tiff_example() {
67        let path = "/Users/kyle/github/developmentseed/async-tiff/m_4007307_sw_18_060_20220803.tif";
68        let reader = std::fs::File::open(path).unwrap();
69        let mut decoder = tiff::decoder::Decoder::new(BufReader::new(reader))
70            .unwrap()
71            .with_limits(Limits::unlimited());
72        let result = decoder.read_image().unwrap();
73        match result {
74            DecodingResult::U8(content) => std::fs::write("img_from_tiff.buf", content).unwrap(),
75            _ => todo!(),
76        }
77    }
78}