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

use std::ops::Deref;
use num_traits::AsPrimitive;
use palette::{color_difference::EuclideanDistance, FromColor, Srgb};
use crate::{geometry::Segment, grid::Grid, AsLab, Float, Image, Lab};


#[derive(Clone)]
pub struct ColorConfig<L> {
    pub name: String,
    pub color: (u8, u8, u8),
    pub nail: usize,
    pub link: L,
}

impl<L, S: Float> AsLab<S> for ColorConfig<L> where u8: AsPrimitive<S>{
    fn as_lab(&self) -> Lab<S> {
        self.color.as_lab()
    }
}

impl<L> ColorConfig<L> {
    pub fn new(name: String, color: (u8, u8, u8), nail: usize, link: L) -> Self {
        Self {
            name,
            color,
            nail,
            link,
        }
    }
}

#[derive(Clone)]
pub struct LabColorMapSettings<S, L> {
    lab: Lab<S>,
    inner: ColorConfig<L>,
}

impl<S: Float, L> From<ColorConfig<L>> for LabColorMapSettings<S, L>
where
    u8: AsPrimitive<S>,
{
    fn from(settings: ColorConfig<L>) -> Self {
        Self {
            lab: Lab::from_color(Srgb::new(
                settings.color.0.as_() / S::TWO_FIVE_FIVE,
                settings.color.1.as_() / S::TWO_FIVE_FIVE,
                settings.color.2.as_() / S::TWO_FIVE_FIVE,
            )),
            inner: settings,
        }
    }
}

impl<S, L> Deref for LabColorMapSettings<S, L> {
    type Target = ColorConfig<L>;

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

pub struct ColorMap<S, L> {
    settings: ColorConfig<L>,
    weights: Vec<S>,
    pub(crate) curr_nail: usize,
    pub(crate) curr_link: L,
}


impl<S: Float, L> AsLab<S> for ColorMap<S, L> where u8: AsPrimitive<S>{
    fn as_lab(&self) -> Lab<S> {
        self.settings.as_lab()
    }
}

impl<S, L> Deref for ColorMap<S, L> {
    type Target = ColorConfig<L>;

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

impl<S: Float, L: Copy> ColorMap<S, L> {
    pub fn new(image: &Image<S>, settings: LabColorMapSettings<S, L>) -> Self {
        Self {
            weights: image
                .pixels()
                .iter()
                .map(|pixel_color| S::SQRT140050 - pixel_color.distance(settings.lab))
                .collect(),
            curr_nail: settings.nail,
            curr_link: settings.link,
            settings: settings.inner,
        }
    }

    pub (crate) fn calculate_weight(&self, segment: &Segment<S>, grid: &Grid) -> S {
        let mut weight = S::ZERO;
        let mut count = S::ZERO;
        for idx in grid.get_pixel_indexes_in_segment(segment) {
            let delta = unsafe { *self.weights.get_unchecked(idx) };
            weight += delta;
            count += S::ONE;
        }
        if count > S::ZERO {
            weight / count as S
        } else {
            -S::INFINITY
        }
    }

    pub fn weights(&mut self) -> &mut [S] {
        &mut self.weights
    }   
}