rust/land2d/src/lib.rs
author alfadur
Thu, 01 Nov 2018 02:55:22 +0300
changeset 14073 9c817b2eedae
parent 14071 4b40bdd214df
parent 14053 2869c2ccb1b8
child 14097 e5904ead4864
permissions -rw-r--r--
merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
13957
78c798d655ad Make use of LinePoints in Land2D::draw_line
unc0rr
parents: 13955
diff changeset
     1
extern crate integral_geometry;
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
     2
extern crate vec2d;
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
     3
13967
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13966
diff changeset
     4
use std::cmp;
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
     5
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
     6
use integral_geometry::{
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
     7
    ArcPoints, EquidistantPoints, LinePoints,
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
     8
    Point, Size, SizeMask
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
     9
};
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
    10
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    11
pub struct Land2D<T> {
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    12
    pixels: vec2d::Vec2D<T>,
14073
alfadur
parents: 14071 14053
diff changeset
    13
    play_size: Size,
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    14
    mask: SizeMask
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    15
}
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    16
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    17
impl<T: Copy + PartialEq> Land2D<T> {
14073
alfadur
parents: 14071 14053
diff changeset
    18
    pub fn new(play_size: Size, fill_value: T) -> Self {
alfadur
parents: 14071 14053
diff changeset
    19
        let real_size = play_size.next_power_of_two();
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    20
        Self {
14073
alfadur
parents: 14071 14053
diff changeset
    21
            play_size,
alfadur
parents: 14071 14053
diff changeset
    22
            pixels: vec2d::Vec2D::new(real_size, fill_value),
alfadur
parents: 14071 14053
diff changeset
    23
            mask: real_size.to_mask()
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    24
        }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    25
    }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    26
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    27
    #[inline]
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    28
    pub fn width(&self) -> usize {
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    29
        self.pixels.width()
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    30
    }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    31
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    32
    #[inline]
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    33
    pub fn height(&self) -> usize {
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    34
        self.pixels.height()
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    35
    }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    36
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    37
    #[inline]
14073
alfadur
parents: 14071 14053
diff changeset
    38
    pub fn size(&self) -> Size {
alfadur
parents: 14071 14053
diff changeset
    39
        self.pixels.size()
alfadur
parents: 14071 14053
diff changeset
    40
    }
alfadur
parents: 14071 14053
diff changeset
    41
alfadur
parents: 14071 14053
diff changeset
    42
    #[inline]
14071
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
    43
    pub fn play_width(&self) -> usize {
14073
alfadur
parents: 14071 14053
diff changeset
    44
        self.play_size.width
14071
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
    45
    }
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
    46
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
    47
    #[inline]
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
    48
    pub fn play_height(&self) -> usize {
14073
alfadur
parents: 14071 14053
diff changeset
    49
        self.play_size.height
alfadur
parents: 14071 14053
diff changeset
    50
    }
alfadur
parents: 14071 14053
diff changeset
    51
alfadur
parents: 14071 14053
diff changeset
    52
    #[inline]
alfadur
parents: 14071 14053
diff changeset
    53
    pub fn play_size(&self) -> Size {
alfadur
parents: 14071 14053
diff changeset
    54
        self.play_size
14071
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
    55
    }
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
    56
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
    57
    #[inline]
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    58
    pub fn is_valid_x(&self, x: i32) -> bool {
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    59
        self.mask.contains_x(x as usize)
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    60
    }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    61
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    62
    #[inline]
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    63
    pub fn is_valid_y(&self, y: i32) -> bool {
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    64
        self.mask.contains_y(y as usize)
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    65
    }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    66
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    67
    #[inline]
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
    68
    pub fn is_valid_coordinate(&self, x: i32, y: i32) -> bool {
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    69
        self.is_valid_x(x) && self.is_valid_y(y)
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    70
    }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    71
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    72
    #[inline]
14051
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13972
diff changeset
    73
    pub fn rows(&self) -> impl Iterator<Item = &[T]> {
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13972
diff changeset
    74
        self.pixels.rows()
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13972
diff changeset
    75
    }
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13972
diff changeset
    76
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13972
diff changeset
    77
    #[inline]
13961
1c30793b1cea put back land2d.map accidentally replaced by testing code
alfadur
parents: 13959
diff changeset
    78
    pub fn map<U: Default, F: FnOnce(&mut T) -> U>(&mut self, y: i32, x: i32, f: F) -> U {
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    79
        if self.is_valid_coordinate(x, y) {
13955
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
    80
            unsafe {
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
    81
                // hey, I just checked that coordinates are valid!
13961
1c30793b1cea put back land2d.map accidentally replaced by testing code
alfadur
parents: 13959
diff changeset
    82
                f(self.pixels.get_unchecked_mut(y as usize, x as usize))
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
    83
            }
13955
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
    84
        } else {
13961
1c30793b1cea put back land2d.map accidentally replaced by testing code
alfadur
parents: 13959
diff changeset
    85
            U::default()
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    86
        }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    87
    }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    88
13965
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13964
diff changeset
    89
    #[inline]
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13964
diff changeset
    90
    pub fn map_point<U: Default, F: FnOnce(&mut T) -> U>(&mut self, point: Point, f: F) -> U {
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13964
diff changeset
    91
        self.map(point.y, point.x, f)
13955
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
    92
    }
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
    93
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
    94
    pub fn fill_from_iter<I>(&mut self, i: I, value: T) -> usize
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
    95
    where
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
    96
        I: std::iter::Iterator<Item = Point>,
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
    97
    {
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
    98
        i.map(|p| {
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
    99
            self.map(p.y, p.x, |v| {
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   100
                *v = value;
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   101
                1
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   102
            })
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   103
        }).count()
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   104
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   105
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   106
    pub fn draw_line(&mut self, from: Point, to: Point, value: T) -> usize {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   107
        self.fill_from_iter(LinePoints::new(from, to), value)
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   108
    }
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   109
13969
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   110
    pub fn fill(&mut self, start_point: Point, border_value: T, fill_value: T) {
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   111
        debug_assert!(self.is_valid_coordinate(start_point.x - 1, start_point.y));
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   112
        debug_assert!(self.is_valid_coordinate(start_point.x, start_point.y));
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   113
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   114
        let mut stack: Vec<(usize, usize, usize, isize)> = Vec::new();
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   115
        fn push<T: Copy + PartialEq>(
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   116
            land: &Land2D<T>,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   117
            stack: &mut Vec<(usize, usize, usize, isize)>,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   118
            xl: usize,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   119
            xr: usize,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   120
            y: usize,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   121
            dir: isize,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   122
        ) {
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   123
            let yd = y as isize + dir;
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   124
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   125
            if land.is_valid_coordinate(0, yd as i32) {
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   126
                stack.push((xl, xr, yd as usize, dir));
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   127
            }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   128
        };
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   129
13969
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   130
        let start_x_l = (start_point.x - 1) as usize;
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   131
        let start_x_r = start_point.x as usize;
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   132
        push(
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   133
            self,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   134
            &mut stack,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   135
            start_x_l,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   136
            start_x_r,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   137
            start_point.y as usize,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   138
            -1,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   139
        );
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   140
        push(
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   141
            self,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   142
            &mut stack,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   143
            start_x_l,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   144
            start_x_r,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   145
            start_point.y as usize,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   146
            1,
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   147
        );
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   148
13972
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   149
        while let Some(a) = stack.pop() {
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   150
            let (mut xl, mut xr, y, mut dir) = a;
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   151
13972
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   152
            while xl > 0 && self
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   153
                .pixels
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   154
                .get(y, xl)
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   155
                .map_or(false, |v| *v != border_value && *v != fill_value)
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   156
            {
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   157
                xl -= 1;
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   158
            }
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   159
13972
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   160
            while xr < self.width() - 1 && self
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   161
                .pixels
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   162
                .get(y, xr)
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   163
                .map_or(false, |v| *v != border_value && *v != fill_value)
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   164
            {
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   165
                xr += 1;
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   166
            }
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   167
13972
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   168
            while xl < xr {
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   169
                while xl <= xr
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   170
                    && (self.pixels[y][xl] == border_value || self.pixels[y][xl] == fill_value)
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   171
                {
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   172
                    xl += 1;
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   173
                }
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   174
13972
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   175
                let mut x = xl;
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   176
13972
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   177
                while xl <= xr
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   178
                    && (self.pixels[y][xl] != border_value && self.pixels[y][xl] != fill_value)
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   179
                {
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   180
                    self.pixels[y][xl] = fill_value;
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   181
13972
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   182
                    xl += 1;
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   183
                }
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   184
13972
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   185
                if x < xl {
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   186
                    push(self, &mut stack, x, xl - 1, y, dir);
03e41712eef8 Fix silly loop
unc0rr
parents: 13970
diff changeset
   187
                    push(self, &mut stack, x, xl - 1, y, -dir);
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   188
                }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   189
            }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   190
        }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   191
    }
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   192
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   193
    #[inline]
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   194
    fn fill_circle_line<F: Fn(&mut T) -> usize>(
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   195
        &mut self,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   196
        y: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   197
        x_from: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   198
        x_to: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   199
        f: &F,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   200
    ) -> usize {
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   201
        let mut result = 0;
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   202
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   203
        if self.is_valid_y(y) {
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   204
            for i in cmp::min(x_from, 0) as usize..cmp::max(x_to as usize, self.width() - 1) {
13955
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
   205
                unsafe {
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
   206
                    // coordinates are valid at this point
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   207
                    result += f(self.pixels.get_unchecked_mut(y as usize, i));
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   208
                }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   209
            }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   210
        }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   211
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   212
        result
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   213
    }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   214
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   215
    #[inline]
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   216
    fn fill_circle_lines<F: Fn(&mut T) -> usize>(
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   217
        &mut self,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   218
        x: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   219
        y: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   220
        dx: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   221
        dy: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   222
        f: &F,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   223
    ) -> usize {
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   224
        self.fill_circle_line(y + dy, x - dx, x + dx, f)
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   225
            + self.fill_circle_line(y - dy, x - dx, x + dx, f)
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   226
            + self.fill_circle_line(y + dx, x - dy, x + dy, f)
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   227
            + self.fill_circle_line(y - dx, x - dy, x + dy, f)
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   228
    }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   229
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   230
    pub fn change_round<F: Fn(&mut T) -> usize>(
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   231
        &mut self,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   232
        x: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   233
        y: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   234
        radius: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   235
        f: F,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   236
    ) -> usize {
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   237
        ArcPoints::new(radius)
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   238
            .map(&mut |p: Point| self.fill_circle_lines(x, y, p.x, p.y, &f))
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   239
            .sum()
13955
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
   240
    }
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   241
14052
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   242
    fn fill_row(&mut self, center: Point, offset: Point, value: T) -> usize {
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   243
        let row_index = center.y + offset.y;
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   244
        if self.is_valid_y(row_index) {
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   245
            let from_x = cmp::max(0, center.x - offset.x) as usize;
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   246
            let to_x = cmp::min(self.width() - 1, (center.x + offset.x) as usize);
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   247
            self.pixels[row_index as usize][from_x..=to_x]
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   248
                .iter_mut().for_each(|v| *v = value);
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   249
            to_x - from_x + 1
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   250
        } else {
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   251
            0
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   252
        }
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   253
    }
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   254
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   255
    pub fn fill_circle(&mut self, center: Point, radius: i32, value: T) -> usize {
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   256
        let transforms =
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   257
            [[0, 1, 1, 0], [0, 1, -1, 0],
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   258
             [1, 0, 0, 1], [1, 0, 0, -1]];
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   259
        ArcPoints::new(radius).map(|vector| {
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   260
            transforms.iter().map(|m|
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   261
                self.fill_row(center, vector.transform(m), value)
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   262
            ).sum::<usize>()
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   263
        }).sum()
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   264
    }
c47283feafac add circle filling to land2d
alfadur
parents: 14051
diff changeset
   265
13965
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13964
diff changeset
   266
    pub fn draw_thick_line(&mut self, from: Point, to: Point, radius: i32, value: T) -> usize {
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13964
diff changeset
   267
        let mut result = 0;
13952
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13945
diff changeset
   268
13970
a1895019bb94 change draw_thick_line iteration order to benchmark winner
alfadur
parents: 13969
diff changeset
   269
        for vector in ArcPoints::new(radius) {
a1895019bb94 change draw_thick_line iteration order to benchmark winner
alfadur
parents: 13969
diff changeset
   270
            for delta in EquidistantPoints::new(vector) {
a1895019bb94 change draw_thick_line iteration order to benchmark winner
alfadur
parents: 13969
diff changeset
   271
                for point in LinePoints::new(from, to) {
13967
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13966
diff changeset
   272
                    self.map_point(point + delta, |p| {
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13966
diff changeset
   273
                        if *p != value {
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13966
diff changeset
   274
                            *p = value;
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13966
diff changeset
   275
                            result += 1;
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13966
diff changeset
   276
                        }
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13966
diff changeset
   277
                    })
13965
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13964
diff changeset
   278
                }
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   279
            }
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   280
        }
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13961
diff changeset
   281
13965
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13964
diff changeset
   282
        result
13955
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13952
diff changeset
   283
    }
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   284
}
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   285
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   286
#[cfg(test)]
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   287
mod tests {
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   288
    use super::*;
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   289
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   290
    #[test]
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   291
    fn basics() {
14073
alfadur
parents: 14071 14053
diff changeset
   292
        let l: Land2D<u8> = Land2D::new(Size::new(30, 50), 0);
14071
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
   293
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
   294
        assert_eq!(l.play_width(), 30);
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
   295
        assert_eq!(l.play_height(), 50);
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
   296
        assert_eq!(l.width(), 32);
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13972
diff changeset
   297
        assert_eq!(l.height(), 64);
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   298
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   299
        assert!(l.is_valid_coordinate(0, 0));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   300
        assert!(!l.is_valid_coordinate(-1, -1));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   301
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   302
        assert!(l.is_valid_coordinate(31, 63));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   303
        assert!(!l.is_valid_coordinate(32, 63));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   304
        assert!(!l.is_valid_coordinate(31, 64));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   305
    }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   306
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   307
    #[test]
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   308
    fn fill() {
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   309
        let mut l: Land2D<u8> = Land2D::new(Size::square(128), 0);
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   310
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   311
        l.draw_line(Point::new(0, 0), Point::new(32, 96), 1);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   312
        l.draw_line(Point::new(32, 96), Point::new(64, 32), 1);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   313
        l.draw_line(Point::new(64, 32), Point::new(96, 80), 1);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   314
        l.draw_line(Point::new(96, 80), Point::new(128, 0), 1);
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   315
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   316
        l.draw_line(Point::new(0, 128), Point::new(64, 96), 1);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13957
diff changeset
   317
        l.draw_line(Point::new(128, 128), Point::new(64, 96), 1);
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   318
13969
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   319
        l.fill(Point::new(32, 32), 1, 2);
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   320
        l.fill(Point::new(16, 96), 1, 3);
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13967
diff changeset
   321
        l.fill(Point::new(60, 100), 1, 4);
13945
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   322
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   323
        assert_eq!(l.pixels[0][0], 1);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   324
        assert_eq!(l.pixels[96][64], 1);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   325
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   326
        assert_eq!(l.pixels[40][32], 2);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   327
        assert_eq!(l.pixels[40][96], 2);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   328
        assert_eq!(l.pixels[5][0], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   329
        assert_eq!(l.pixels[120][0], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   330
        assert_eq!(l.pixels[5][127], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   331
        assert_eq!(l.pixels[120][127], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   332
        assert_eq!(l.pixels[35][64], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   333
        assert_eq!(l.pixels[120][20], 4);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   334
        assert_eq!(l.pixels[120][100], 4);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   335
        assert_eq!(l.pixels[100][64], 4);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13938
diff changeset
   336
    }
13938
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   337
}