splinosaurus 0.2.2

flexible spline and surface library
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
121
122
123
124
125
126
127
128
129
130
131

use alloc::vec::Vec;
use core::ops::{Index, IndexMut};

#[derive(Debug, Clone)]
pub struct Grid<T> {
    len: usize,
    values: Vec<T>,
}

impl<T> Grid<T> {
    pub(crate) fn with_capacity(len: usize, height: usize) -> Self {
        Self {
            len,
            values: Vec::with_capacity(len * height),
        }
    }

    pub fn new(len: usize, values: Vec<T>) -> Self {
        assert_eq!(
            0,
            values.len() % len,
            "points length must be a multiple of u_len"
        );

        Self { len, values }
    }

    pub(crate) fn push(&mut self, value: T) {
        self.values.push(value)
    }

    pub(crate) fn at(&self, index: usize) -> &T {
        &self.values[index]
    }

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

    pub fn height(&self) -> usize {
        self.values.len() / self.len
    }

    pub fn row_mut(&mut self, row: usize) -> &mut [T] {
        &mut self.values[(row * self.len)..(row * self.len) + self.len]
    }

    pub fn vec_index(&self, (col, row): (usize, usize)) -> usize {
        (row * self.len) + col
    }
}

impl<T> From<Grid<T>> for Vec<T> {
    fn from(value: Grid<T>) -> Self {
        value.values
    }
}

impl<T> Index<(usize, usize)> for Grid<T> {
    type Output = T;

    fn index(&self, (col, row): (usize, usize)) -> &Self::Output {
        assert!(
            col < self.len() && row < self.height(),
            "uv index out of bounds ({col},{row}) out of ({},{})",
            self.len(),
            self.height()
        );

        &self.values[self.vec_index((col, row))]
    }
}

impl<T> IndexMut<(usize, usize)> for Grid<T> {
    fn index_mut(&mut self, (col, row): (usize, usize)) -> &mut Self::Output {
        assert!(
            col < self.len() && row < self.height(),
            "uv index out of bounds ({col},{row}) out of ({},{})",
            self.len(),
            self.height()
        );

        let index = self.vec_index((col, row));
        &mut self.values[index]
    }
}

impl<T> AsRef<[T]> for Grid<T> {
    fn as_ref(&self) -> &[T] {
        &self.values
    }
}

impl<T> AsMut<[T]> for Grid<T> {
    fn as_mut(&mut self) -> &mut [T] {
        &mut self.values
    }
}

#[cfg(test)]
mod tests {
    use crate::grid::Grid;
    use alloc::vec;

    #[test]
    fn it_accesses_col_row() {
        let mut original = Grid::new(2, vec![1, 2, 3, 4]);

        assert_eq!(1, original[(0, 0)]);
        assert_eq!(2, original[(1, 0)]);
        assert_eq!(3, original[(0, 1)]);
        assert_eq!(4, original[(1, 1)]);

        assert_eq!(&[1, 2], original.row_mut(0));
        assert_eq!(&[3, 4], original.row_mut(1));
    }

    #[test]
    fn it_does_sub_grids() {
        let original = Grid::new(3, vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);

        let mut d = Grid::with_capacity(2, 2);
        for y in 0..2 {
            for x in 0..2 {
                d.push(original[(x, y)]);
            }
        }

        assert_eq!(vec![1, 2, 4, 5], d.values);
    }
}