pixelar 0.1.0

Show everyone the art hidden inside your code.
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

use crate::prelude::Position;

pub struct GrowingSquare {
    n: isize,
    start_row: isize,
    start_column: isize,
    latest_square: Vec<(isize, isize)>,
}

impl GrowingSquare {
    pub fn new(row: isize, column: isize) -> Self {
        Self {
            n: 0,
            start_row: row,
            start_column: column,
            latest_square: vec![],
        }
    }
}

impl Iterator for GrowingSquare {
    type Item = Vec<Position>;

    fn next(&mut self) -> Option<Self::Item> {
        let new_square: Vec<(isize, isize)> = get_square(self.start_row, self.start_column, self.n);
        let result = new_square
            .iter()
            .filter(|x| !self.latest_square.contains(x))
            .filter_map(|x| Position::from_signed(x.0, x.1))
            .collect();

        self.n += 1;
        self.latest_square = new_square;
        Some(result)
    }
}

#[derive(Debug, Default)]
struct OddSeries {
    n: usize,
}

impl Iterator for OddSeries {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        let res = Some((2 * self.n) + 1);
        self.n += 1;
        res
    }
}

fn get_square(x0: isize, y0: isize, offset: isize) -> Vec<(isize, isize)> {
    let mut res = vec![];
    for x in (x0 - offset)..=(x0 + offset) {
        for y in (y0 - offset)..=(y0 + offset) {
            res.push((x, y))
        }
    }

    res
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_odd_series() {
        let os = OddSeries::default();
        assert_eq!(vec![1, 3, 5], os.take(3).collect::<Vec<usize>>())
    }

    #[test]
    fn test_square_grow_1() {
        for x in -1..=1 {
            for y in -1..=1 {
                println!("({}, {})", x, y)
            }
        }
    }

    #[test]
    fn test_square_grow_2() {
        let sg = GrowingSquare::new(0, 0);

        for t in sg.take(1) {
            println!("{:?}", t)
        }
    }
}