qart 1.0.1

encodes images into qr codes
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

// type aliases to distinguish between arrays of bits and arrays of bytes, and conversion + qol methods

pub type ByteArr = Vec<u8>;
pub trait ByteArrMethods {
    fn bit_at(&self, index: usize) -> u8;
    fn to_bits(&self) -> Vec<u8>;
}
impl ByteArrMethods for ByteArr {
    fn bit_at(&self, index: usize) -> u8 {
        (self[index / 8] >> (7 - (index & 7))) & 1
    }
    fn to_bits(&self) -> Vec<u8> {
        self.iter()
            .fold(Vec::with_capacity(self.len() * 8), |mut v, byte| {
                let mut mask = 0b10000000;
                for _ in 0..8 {
                    let bit = ((byte & mask) != 0) as u8;
                    v.push(bit);
                    mask >>= 1;
                }
                v
            })
    }
}

pub type BitArr = Vec<Bit>;
pub trait BitArrMethods {
    fn extend_bits(&mut self, bits: &[u8], role: Role);
    fn extend_bytes(&mut self, bytes: &[u8], role: Role);
    fn to_byte_arr(&self) -> ByteArr;
}
impl BitArrMethods for BitArr {
    fn extend_bits(&mut self, bits: &[u8], role: Role) {
        let iter = bits.iter().map(|b| Bit { val: *b == 1, role });
        self.extend(iter);
    }
    fn extend_bytes(&mut self, bytes: &[u8], role: Role) {
        bytes.iter().for_each(|byte| {
            let mut mask = 0b10000000;
            for _ in 0..8 {
                let bit = ((byte & mask) != 0) as u8;
                self.push(Bit {
                    val: bit == 1,
                    role,
                });
                mask >>= 1;
            }
        })
    }
    fn to_byte_arr(&self) -> ByteArr {
        (0..(self.len() / 8)).fold(Vec::with_capacity(self.len() / 8), |mut v, i| {
            let i = i * 8;
            let mut s: u8 = 0;
            let mut mask = 0b10000000;
            for j in 0..8 {
                let val = self[i + j].val as u8;
                s += val * mask;
                mask >>= 1;
            }
            v.push(s);
            v
        })
    }
}

#[derive(Clone)]
pub struct Bit {
    // true = 1 = black
    pub val: bool,
    pub role: Role,
}

// TODO: change this back to a can_edit bool
#[derive(Clone, Copy)]
pub enum Role {
    Data,
    EC,
    Num,
}

impl Bit {
    pub fn can_edit(&self) -> bool {
        match self.role {
            Role::Data => false,
            _ => true,
        }
    }
    pub fn is_num(&self) -> bool {
        match self.role {
            Role::Num => true,
            _ => false,
        }
    }
}