kanoko 0.2.0

Generate a random pattern inspired by the traditional Japanese kanoko pattern
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

use std::f64::consts::{PI, SQRT_2};

use itertools::iproduct;

use crate::{
    geometry::{Angle, Coordinate},
    point_set::PointSet,
};

#[derive(Debug, Clone, Copy)]
pub struct Index {
    pub x: u16,
    pub y: u16,
}

#[derive(Debug, Clone, Copy)]
pub struct Lattice {
    pub grid_size: Index,
    pub a: f64,
    pub b: f64,
    pub theta: Angle,
}

impl Lattice {
    pub fn new(grid_size: Index, a: f64, b: f64, theta: Angle) -> Self {
        Self {
            grid_size,
            a,
            b,
            theta,
        }
    }

    pub fn new_square(grid_size: Index, a: f64) -> Self {
        Self {
            grid_size,
            a,
            b: a,
            theta: Angle::Radian(PI / 2.0),
        }
    }

    pub fn new_rectangle(grid_size: Index, a: f64, b: f64) -> Self {
        Self {
            grid_size,
            a,
            b,
            theta: Angle::Radian(PI / 2.0),
        }
    }

    pub fn new_centered_rectangle(grid_size: Index, a: f64, b: f64) -> Self {
        Self {
            grid_size,
            a,
            b,
            theta: Angle::Radian((a / b).atan()),
        }
    }

    pub fn new_centered_square(grid_size: Index, a: f64) -> Self {
        Self {
            grid_size,
            a,
            b: a / SQRT_2,
            theta: Angle::Radian(PI / 4.0),
        }
    }

    pub fn new_hexagonal(grid_size: Index, a: f64) -> Self {
        Self {
            grid_size,
            a,
            b: a,
            theta: Angle::Radian(PI / 3.0),
        }
    }
}

impl PointSet for Lattice {
    type Index = Index;

    fn index_iter(&self) -> Box<dyn Iterator<Item = Self::Index>> {
        let iter = iproduct!(0..self.grid_size.x, 0..self.grid_size.y).map(|(x, y)| Index { x, y });

        Box::new(iter)
    }

    fn index_to_coordinate(&self, index: &Self::Index) -> Coordinate {
        let x =
            index.x as f64 * self.a + (index.y % 2) as f64 * self.b * self.theta.to_radian().cos();
        let y = index.y as f64 * self.b * self.theta.to_radian().sin();

        Coordinate { x, y }
    }

    fn bounding_box(&self) -> Coordinate {
        let max_x = (self.grid_size.x - 1) as f64 * self.a
            + ((self.grid_size.y - 1) % 2) as f64 * self.b * self.theta.to_radian().cos();
        let max_y = (self.grid_size.y - 1) as f64 * self.b * self.theta.to_radian().sin();

        Coordinate { x: max_x, y: max_y }
    }
}