async-tiff 0.3.0

Asynchronous TIFF reader.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::ifd::ImageFileDirectory;
use crate::reader::Endianness;

/// A TIFF file.
#[derive(Debug, Clone)]
pub struct TIFF {
    endianness: Endianness,
    ifds: Vec<ImageFileDirectory>,
}

impl TIFF {
    /// Create a new TIFF from existing IFDs.
    pub fn new(ifds: Vec<ImageFileDirectory>, endianness: Endianness) -> Self {
        Self { ifds, endianness }
    }

    /// Access the underlying Image File Directories.
    pub fn ifds(&self) -> &[ImageFileDirectory] {
        &self.ifds
    }

    /// Get the endianness of the TIFF file.
    pub fn endianness(&self) -> Endianness {
        self.endianness
    }
}

#[cfg(test)]
mod test {
    use std::io::BufReader;
    use std::sync::Arc;

    use object_store::local::LocalFileSystem;
    use tiff::decoder::{DecodingResult, Limits};

    use super::*;
    use crate::metadata::cache::ReadaheadMetadataCache;
    use crate::metadata::TiffMetadataReader;
    use crate::reader::{AsyncFileReader, ObjectReader};
    use crate::TypedArray;

    #[ignore = "local file"]
    #[tokio::test]
    async fn tmp() {
        let folder = "/Users/kyle/github/developmentseed/async-tiff/";
        let path = object_store::path::Path::parse("m_4007307_sw_18_060_20220803.tif").unwrap();
        let store = Arc::new(LocalFileSystem::new_with_prefix(folder).unwrap());
        let reader = Arc::new(ObjectReader::new(store, path)) as Arc<dyn AsyncFileReader>;
        let cached_reader = ReadaheadMetadataCache::new(reader.clone());
        let mut metadata_reader = TiffMetadataReader::try_open(&cached_reader).await.unwrap();
        let ifds = metadata_reader.read_all_ifds(&cached_reader).await.unwrap();
        let tiff = TIFF::new(ifds, metadata_reader.endianness());

        let ifd = &tiff.ifds[1];
        let tile = ifd.fetch_tile(0, 0, reader.as_ref()).await.unwrap();
        let array = tile.decode(&Default::default()).unwrap();
        let contents = match array.data() {
            TypedArray::UInt8(data) => data,
            _ => panic!("unexpected data type"),
        };
        std::fs::write("img.buf", contents).unwrap();
    }

    #[ignore = "local file"]
    #[test]
    fn tmp_tiff_example() {
        let path = "/Users/kyle/github/developmentseed/async-tiff/m_4007307_sw_18_060_20220803.tif";
        let reader = std::fs::File::open(path).unwrap();
        let mut decoder = tiff::decoder::Decoder::new(BufReader::new(reader))
            .unwrap()
            .with_limits(Limits::unlimited());
        let result = decoder.read_image().unwrap();
        match result {
            DecodingResult::U8(content) => std::fs::write("img_from_tiff.buf", content).unwrap(),
            _ => todo!(),
        }
    }
}