string_art 0.1.0-alpha.1

Convert images into thread patterns for creating string art. It generates detailed instructions in text format and provides graphical previews of the resulting patterns.
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

use std::ops::Deref;

use crate::{
    verboser::Verboser, AsLab, Image
};

pub unsafe trait Builder<S> {
    fn build_line_selector(
        &self,
        image: &Image<S>,
        palette: &[impl AsLab<S>],
        verboser: &mut impl Verboser,
    ) -> Result<LineSelector, Error>;
}

#[derive(Clone, Copy)]
pub struct LineItemSelector {
    color_idx: usize,
    count: usize,
    cap: usize,
}

impl LineItemSelector {
    pub fn new(color_idx: usize, count: usize, cap: usize) -> Self {
        LineItemSelector {
            color_idx,
            count,
            cap,
        }
    }

    pub fn color_idx(&self) -> usize {
        self.color_idx
    }

    pub fn cap(&self) -> usize {
        self.cap
    }
}

pub struct LineGroupSelector(Vec<LineItemSelector>);

impl FromIterator<LineItemSelector> for LineGroupSelector {
    fn from_iter<T: IntoIterator<Item = LineItemSelector>>(iter: T) -> Self {
        LineGroupSelector(iter.into_iter().collect())
    }
}

impl LineGroupSelector {
    fn select_next(&mut self) -> Option<usize> {
        let mut choice = None;
        let mut best_ratio = 1.0;
        for item in self.0.iter_mut() {
            let ratio = item.count as f32 / item.cap as f32;
            if ratio < best_ratio {
                best_ratio = ratio;
                choice = Some(item);
            }
        }

        choice.map(|item| {
            item.count += 1;
            item.color_idx
        })
    }    
}

impl Deref for LineGroupSelector{
    type Target = [LineItemSelector];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub struct LineSelector{
    lines: Vec<LineGroupSelector>,
    curr: usize,
}

impl LineSelector {
    pub (crate) fn select_next(&mut self) -> Option<usize> {        
        while let Some(last) = self.lines.get_mut(self.curr) {
            if let Some(res) = last.select_next() {
                return Some(res);
            } else {
                self.curr = if self.curr == 0{
                    self.lines.len()
                } else{
                    unsafe { self.curr.unchecked_sub(1) }
                }
            }
        }

        None
    }    
}

impl Deref for LineSelector {
    type Target = [LineGroupSelector];

    fn deref(&self) -> &Self::Target {
        &self.lines
    }
}

impl FromIterator<LineGroupSelector> for LineSelector {
    fn from_iter<T: IntoIterator<Item = LineGroupSelector>>(iter: T) -> Self {
        let lines: Vec<_> = iter.into_iter().collect();
        LineSelector{
            curr: lines.len().checked_sub(1).unwrap_or(lines.len()),
            lines, 
        
        }
    }
}

#[derive(Debug, thiserror::Error)]
#[error("Invalid group index")]
pub struct Error;