rasterkit 0.1.5

TIFF/GeoTIFF file structure analysis and manipulation tool
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
137
138
139
140
141
142
143
144
145

//! Byte order handling for TIFF files
//!
//! This module implements the Strategy pattern for handling different
//! byte orders (little-endian vs big-endian) when reading TIFF data.

use byteorder::{BigEndian, LittleEndian, ReadBytesExt};
use std::io::Result;

use crate::io::seekable::SeekableReader;
use crate::tiff::errors::{TiffError, TiffResult};

/// Represents the byte order of a TIFF file
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ByteOrder {
    /// Little-endian byte order (II)
    LittleEndian,
    /// Big-endian byte order (MM)
    BigEndian,
}

impl ByteOrder {
    /// Detects the byte order from the TIFF header
    pub fn detect(reader: &mut dyn SeekableReader) -> TiffResult<Self> {
        let byte_order = reader.read_u16::<LittleEndian>()?;
        match byte_order {
            0x4949 => Ok(ByteOrder::LittleEndian), // "II" (Intel)
            0x4D4D => Ok(ByteOrder::BigEndian),    // "MM" (Motorola)
            _ => Err(TiffError::InvalidByteOrder(byte_order)),
        }
    }

    /// Returns a string representation of this byte order
    pub fn name(&self) -> &'static str {
        match self {
            ByteOrder::LittleEndian => "Little Endian (II)",
            ByteOrder::BigEndian => "Big Endian (MM)",
        }
    }

    /// Creates the appropriate handler for this byte order
    pub fn create_handler(&self) -> Box<dyn ByteOrderHandler> {
        match self {
            ByteOrder::LittleEndian => Box::new(LittleEndianHandler),
            ByteOrder::BigEndian => Box::new(BigEndianHandler),
        }
    }
}

/// Trait for byte order handling strategies
pub trait ByteOrderHandler: Send + Sync {
    /// Read a u16 value
    fn read_u16(&self, reader: &mut dyn SeekableReader) -> Result<u16>;

    /// Read a u32 value
    fn read_u32(&self, reader: &mut dyn SeekableReader) -> Result<u32>;

    /// Read a u64 value
    fn read_u64(&self, reader: &mut dyn SeekableReader) -> Result<u64>;

    /// Read an f32 value
    fn read_f32(&self, reader: &mut dyn SeekableReader) -> Result<f32>;

    /// Read an f64 value
    fn read_f64(&self, reader: &mut dyn SeekableReader) -> Result<f64>;

    /// Read a rational value (two u32 values as numerator/denominator)
    fn read_rational(&self, reader: &mut dyn SeekableReader) -> Result<(u32, u32)>;

    /// Read a signed rational value (two i32 values as numerator/denominator)
    fn read_srational(&self, reader: &mut dyn SeekableReader) -> Result<(i32, i32)>;
}

/// Little-endian byte order handler
pub struct LittleEndianHandler;

impl ByteOrderHandler for LittleEndianHandler {
    fn read_u16(&self, reader: &mut dyn SeekableReader) -> Result<u16> {
        reader.read_u16::<LittleEndian>()
    }

    fn read_u32(&self, reader: &mut dyn SeekableReader) -> Result<u32> {
        reader.read_u32::<LittleEndian>()
    }

    fn read_u64(&self, reader: &mut dyn SeekableReader) -> Result<u64> {
        reader.read_u64::<LittleEndian>()
    }

    fn read_f32(&self, reader: &mut dyn SeekableReader) -> Result<f32> {
        reader.read_f32::<LittleEndian>()
    }

    fn read_f64(&self, reader: &mut dyn SeekableReader) -> Result<f64> {
        reader.read_f64::<LittleEndian>()
    }

    fn read_rational(&self, reader: &mut dyn SeekableReader) -> Result<(u32, u32)> {
        let numerator = reader.read_u32::<LittleEndian>()?;
        let denominator = reader.read_u32::<LittleEndian>()?;
        Ok((numerator, denominator))
    }

    fn read_srational(&self, reader: &mut dyn SeekableReader) -> Result<(i32, i32)> {
        let numerator = reader.read_i32::<LittleEndian>()?;
        let denominator = reader.read_i32::<LittleEndian>()?;
        Ok((numerator, denominator))
    }
}

/// Big-endian byte order handler
pub struct BigEndianHandler;

impl ByteOrderHandler for BigEndianHandler {
    fn read_u16(&self, reader: &mut dyn SeekableReader) -> Result<u16> {
        reader.read_u16::<BigEndian>()
    }

    fn read_u32(&self, reader: &mut dyn SeekableReader) -> Result<u32> {
        reader.read_u32::<BigEndian>()
    }

    fn read_u64(&self, reader: &mut dyn SeekableReader) -> Result<u64> {
        reader.read_u64::<BigEndian>()
    }

    fn read_f32(&self, reader: &mut dyn SeekableReader) -> Result<f32> {
        reader.read_f32::<BigEndian>()
    }

    fn read_f64(&self, reader: &mut dyn SeekableReader) -> Result<f64> {
        reader.read_f64::<BigEndian>()
    }

    fn read_rational(&self, reader: &mut dyn SeekableReader) -> Result<(u32, u32)> {
        let numerator = reader.read_u32::<BigEndian>()?;
        let denominator = reader.read_u32::<BigEndian>()?;
        Ok((numerator, denominator))
    }

    fn read_srational(&self, reader: &mut dyn SeekableReader) -> Result<(i32, i32)> {
        let numerator = reader.read_i32::<BigEndian>()?;
        let denominator = reader.read_i32::<BigEndian>()?;
        Ok((numerator, denominator))
    }
}