libczirw-sys 0.3.0

Wrapper around libCZIAPI
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

extern crate link_cplusplus;

pub mod error;
mod functions;
mod handle;
mod interop;
mod misc;
pub mod sys;

pub use functions::*;
pub use handle::*;
pub use interop::*;
pub use misc::{Dimension, PixelType, RawDataType};

#[cfg(test)]
mod tests {
    use crate::handle::{CziReader, InputStream};
    use crate::interop::{LibCZIBuildInformation, ReaderOpenInfo};
    use crate::misc::Dimension;
    use std::env;
    use std::path::PathBuf;

    #[test]
    fn test_read_shape() -> Result<(), Box<dyn std::error::Error>> {
        let path = env::home_dir()
            .unwrap()
            .join("code/rust/ndbioimage/tests/files/Experiment-2029.czi");
        assert!(path.exists());
        let czi = CziReader::create()?;
        let stream = InputStream::create_from_file_utf8(path.to_string_lossy().as_ref())?;
        let open_info = ReaderOpenInfo::new(&stream);
        czi.open(open_info)?;
        println!("pyramid statistics: {:?}", czi.get_pyramid_statistics()?);
        println!("file header info: {:?}", czi.get_file_header_info()?);
        let statistics_simple = czi.get_statistics_simple()?;
        println!("statistics simple: {:?}", czi.get_statistics_simple()?);
        let bounding_box = statistics_simple.get_bounding_box();
        let dim_bounds = statistics_simple.get_dim_bounds();
        let dimensions = Dimension::vec_from_bitflags(dim_bounds.get_dimensions_valid());
        let size = dim_bounds.get_size();
        for (i, d) in dimensions.iter().enumerate() {
            println!("{:?}: {}", d, size[i]);
        }
        println!("X: {}", bounding_box.get_w());
        println!("Y: {}", bounding_box.get_h());
        Ok(())
    }

    #[test]
    fn test_read_bytes() -> Result<(), Box<dyn std::error::Error>> {
        let path = env::home_dir()
            .unwrap()
            .join("code/rust/ndbioimage/tests/files/Experiment-2029.czi");
        assert!(path.exists());
        let czi = CziReader::create()?;
        let stream = InputStream::create_from_file_utf8(path.to_string_lossy().as_ref())?;
        let open_info = ReaderOpenInfo::new(&stream);
        czi.open(open_info)?;
        let sub_block = czi.read_sub_block(0)?;
        let bitmap = sub_block.create_bitmap()?.lock()?;
        let bitmap_info = bitmap.get_info()?;
        println!(
            "height: {}, width: {} pixel type: {:#?}",
            bitmap_info.get_height(),
            bitmap_info.get_width(),
            bitmap_info.get_pixel_type()?
        );
        let bytes = bitmap.lock_info.get_data_roi();
        println!("bytes: {:?}", bytes.as_slice()[..100].to_vec());
        Ok(())
    }

    #[test]
    fn test_libczi_xml() -> Result<(), Box<dyn std::error::Error>> {
        let path = env::home_dir()
            .unwrap()
            .join("code/rust/ndbioimage/tests/files/Experiment-2029.czi");
        assert!(path.exists());
        let czi = CziReader::create()?;
        let stream = InputStream::create_from_file_utf8(path.to_string_lossy().as_ref())?;
        let open_info = ReaderOpenInfo::new(&stream);
        czi.open(open_info)?;
        let metadata_segment = czi.get_metadata_segment()?;
        let xml = metadata_segment.get_metadata_as_xml()?;
        let s = String::try_from(&xml)?;
        println!("xml: {}", &s[..s.len().min(100)]);
        Ok(())
    }

    #[test]
    fn test_libczi_pyramid_statistics() -> Result<(), Box<dyn std::error::Error>> {
        let path = PathBuf::from("test-files/Experiment-2029.czi");
        assert!(path.exists());
        let czi = CziReader::create()?;
        let stream = InputStream::create_from_file_utf8(path.to_string_lossy().as_ref())?;
        let open_info = ReaderOpenInfo::new(&stream);
        czi.open(open_info)?;
        let s = czi.get_pyramid_statistics()?;
        println!("xml: {}", &s[..s.len().min(100)]);
        Ok(())
    }

    #[test]
    fn test_libczi_document_info() -> Result<(), Box<dyn std::error::Error>> {
        let path = PathBuf::from("test-files/Experiment-2029.czi");
        assert!(path.exists());
        let czi = CziReader::create()?;
        let stream = InputStream::create_from_file_utf8(path.to_string_lossy().as_ref())?;
        let open_info = ReaderOpenInfo::new(&stream);
        czi.open(open_info)?;
        let metadata_segment = czi.get_metadata_segment()?;
        let document_info = metadata_segment.get_czi_document_info()?;
        let general_document_info = document_info.get_general_document_info()?;
        println!(
            "xml: {}",
            &general_document_info[..general_document_info.len().min(100)]
        );
        Ok(())
    }

    #[test]
    fn test_lib_czi_build_information() -> Result<(), Box<dyn std::error::Error>> {
        let build_info = LibCZIBuildInformation::get()?;
        println!(
            "compiler information: {:?}",
            build_info.get_compiler_information()
        );
        println!("repository url: {:?}", build_info.get_repository_url());
        println!(
            "repository branch: {:?}",
            build_info.get_repository_branch()
        );
        println!("repository tag: {:?}", build_info.get_repository_tag());
        Ok(())
    }
}