rust/integral-geometry/src/lib.rs
author unc0rr
Sun, 04 Nov 2018 00:20:27 +0100
changeset 14146 376a0551b00a
parent 14145 6e0be42d0a8f
child 14147 32383b888309
permissions -rw-r--r--
- Add distance-divider option to land_dump - Fix multiplication overflow errors (iy went widly out of bounds)
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
14102
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
     1
extern crate fpnum;
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
     2
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
     3
use fpnum::distance;
14146
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
     4
use std::cmp::max;
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
     5
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, RangeInclusive, Sub, SubAssign};
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
     6
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
     7
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
     8
pub struct Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
     9
    pub x: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    10
    pub y: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    11
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    12
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    13
impl Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    14
    #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    15
    pub fn new(x: i32, y: i32) -> Self {
13962
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
    16
        Self { x, y }
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    17
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    18
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    19
    #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    20
    pub fn zero() -> Self {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    21
        Self::new(0, 0)
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    22
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    23
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    24
    #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    25
    pub fn signum(self) -> Self {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    26
        Self::new(self.x.signum(), self.y.signum())
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    27
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    28
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    29
    #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    30
    pub fn abs(self) -> Self {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    31
        Self::new(self.x.abs(), self.y.abs())
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    32
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    33
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    34
    #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    35
    pub fn dot(self, other: Point) -> i32 {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    36
        self.x * other.x + self.y * other.y
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    37
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    38
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    39
    #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    40
    pub fn max_norm(self) -> i32 {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    41
        std::cmp::max(self.x.abs(), self.y.abs())
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    42
    }
14052
c47283feafac add circle filling to land2d
alfadur
parents: 13971
diff changeset
    43
c47283feafac add circle filling to land2d
alfadur
parents: 13971
diff changeset
    44
    #[inline]
14102
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
    45
    pub fn integral_norm(self) -> u32 {
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
    46
        distance(self.x, self.y).abs_round()
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
    47
    }
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
    48
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
    49
    #[inline]
14052
c47283feafac add circle filling to land2d
alfadur
parents: 13971
diff changeset
    50
    pub fn transform(self, matrix: &[i32; 4]) -> Self {
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
    51
        Point::new(
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
    52
            matrix[0] * self.x + matrix[1] * self.y,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
    53
            matrix[2] * self.x + matrix[3] * self.y,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
    54
        )
14052
c47283feafac add circle filling to land2d
alfadur
parents: 13971
diff changeset
    55
    }
14127
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
    56
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
    57
    #[inline]
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
    58
    pub fn rotate90(self) -> Self {
14128
6a3bcb7c2981 swap coordinate system
alfadur
parents: 14127
diff changeset
    59
        Point::new(self.y, -self.x)
14127
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
    60
    }
14129
36b792842d5b a bit more simplification
alfadur
parents: 14128
diff changeset
    61
36b792842d5b a bit more simplification
alfadur
parents: 14128
diff changeset
    62
    #[inline]
36b792842d5b a bit more simplification
alfadur
parents: 14128
diff changeset
    63
    pub fn cross(self, other: Point) -> i32 {
36b792842d5b a bit more simplification
alfadur
parents: 14128
diff changeset
    64
        self.dot(other.rotate90())
36b792842d5b a bit more simplification
alfadur
parents: 14128
diff changeset
    65
    }
14146
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    66
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    67
    #[inline]
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    68
    pub fn fit(&self, rect: &Rect) -> Point {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    69
        let x = if self.x > rect.right() {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    70
            rect.right()
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    71
        } else if self.x < rect.left() {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    72
            rect.left()
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    73
        } else {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    74
            self.x
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    75
        };
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    76
        let y = if self.y > rect.bottom() {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    77
            rect.bottom()
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    78
        } else if self.y < rect.top() {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    79
            rect.top()
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    80
        } else {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    81
            self.y
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    82
        };
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    83
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    84
        Point::new(x, y)
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
    85
    }
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    86
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
    87
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    88
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    89
pub struct Size {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    90
    pub width: usize,
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    91
    pub height: usize,
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    92
}
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    93
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    94
impl Size {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    95
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    96
    pub fn new(width: usize, height: usize) -> Self {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    97
        Size { width, height }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    98
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
    99
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   100
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   101
    pub fn square(size: usize) -> Self {
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   102
        Size {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   103
            width: size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   104
            height: size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   105
        }
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   106
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   107
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   108
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   109
    pub fn area(&self) -> usize {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   110
        self.width * self.height
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   111
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   112
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   113
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   114
    pub fn linear_index(&self, x: usize, y: usize) -> usize {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   115
        y * self.width + x
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   116
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   117
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   118
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   119
    pub fn is_power_of_two(&self) -> bool {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   120
        self.width.is_power_of_two() && self.height.is_power_of_two()
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   121
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   122
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   123
    #[inline]
14073
alfadur
parents: 14072 14053
diff changeset
   124
    pub fn next_power_of_two(&self) -> Self {
alfadur
parents: 14072 14053
diff changeset
   125
        Self {
alfadur
parents: 14072 14053
diff changeset
   126
            width: self.width.next_power_of_two(),
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   127
            height: self.height.next_power_of_two(),
14073
alfadur
parents: 14072 14053
diff changeset
   128
        }
alfadur
parents: 14072 14053
diff changeset
   129
    }
alfadur
parents: 14072 14053
diff changeset
   130
alfadur
parents: 14072 14053
diff changeset
   131
    #[inline]
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   132
    pub fn to_mask(&self) -> SizeMask {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   133
        SizeMask::new(*self)
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   134
    }
14080
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   135
14146
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   136
    #[inline]
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   137
    pub fn to_square(&self) -> Size {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   138
        Size::square(max(self.width, self.height))
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   139
    }
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   140
14080
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   141
    pub fn to_grid_index(&self) -> GridIndex {
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   142
        GridIndex::new(*self)
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   143
    }
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   144
}
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   145
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   146
pub struct SizeMask {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   147
    size: Size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   148
}
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   149
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   150
impl SizeMask {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   151
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   152
    pub fn new(size: Size) -> Self {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   153
        assert!(size.is_power_of_two());
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   154
        let size = Size {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   155
            width: !(size.width - 1),
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   156
            height: !(size.height - 1),
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   157
        };
14080
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   158
        Self { size }
14053
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   159
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   160
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   161
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   162
    pub fn contains_x<T: Into<usize>>(&self, x: T) -> bool {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   163
        (self.size.width & x.into()) == 0
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   164
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   165
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   166
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   167
    pub fn contains_y<T: Into<usize>>(&self, y: T) -> bool {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   168
        (self.size.height & y.into()) == 0
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   169
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   170
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   171
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   172
    pub fn contains(&self, point: Point) -> bool {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   173
        self.contains_x(point.x as usize) && self.contains_y(point.y as usize)
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14052
diff changeset
   174
    }
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   175
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   176
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   177
pub struct GridIndex {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   178
    shift: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   179
}
14080
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   180
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   181
impl GridIndex {
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   182
    pub fn new(size: Size) -> Self {
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   183
        assert!(size.is_power_of_two());
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   184
        let shift = Point::new(
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   185
            size.width.trailing_zeros() as i32,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   186
            size.height.trailing_zeros() as i32,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   187
        );
14080
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   188
        Self { shift }
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   189
    }
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   190
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   191
    pub fn map(&self, position: Point) -> Point {
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   192
        Point::new(position.x >> self.shift.x, position.y >> self.shift.y)
14080
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   193
    }
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   194
}
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14075
diff changeset
   195
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   196
macro_rules! bin_op_impl {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   197
    ($op: ty, $name: tt) => {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   198
        impl $op for Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   199
            type Output = Self;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   200
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   201
            #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   202
            fn $name(self, rhs: Self) -> Self::Output {
13962
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   203
                Self::new(self.x.$name(rhs.x), self.y.$name(rhs.y))
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   204
            }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   205
        }
13962
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   206
    };
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   207
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   208
14109
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   209
macro_rules! scalar_bin_op_impl {
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   210
    ($($op: tt)::+, $name: tt) => {
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   211
        impl $($op)::+<i32> for Point {
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   212
            type Output = Self;
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   213
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   214
            #[inline]
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   215
            fn $name(self, rhs: i32) -> Self::Output {
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   216
                Self::new(self.x.$name(rhs), self.y.$name(rhs))
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   217
            }
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   218
        }
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   219
    };
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   220
}
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   221
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   222
macro_rules! bin_assign_op_impl {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   223
    ($op: ty, $name: tt) => {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   224
        impl $op for Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   225
            #[inline]
13962
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   226
            fn $name(&mut self, rhs: Self) {
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   227
                self.x.$name(rhs.x);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   228
                self.y.$name(rhs.y);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   229
            }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   230
        }
13962
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   231
    };
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   232
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   233
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   234
bin_op_impl!(Add, add);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   235
bin_op_impl!(Sub, sub);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   236
bin_op_impl!(Mul, mul);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   237
bin_op_impl!(Div, div);
14109
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   238
scalar_bin_op_impl!(Mul, mul);
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   239
scalar_bin_op_impl!(Div, div);
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   240
bin_assign_op_impl!(AddAssign, add_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   241
bin_assign_op_impl!(SubAssign, sub_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   242
bin_assign_op_impl!(MulAssign, mul_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   243
bin_assign_op_impl!(DivAssign, div_assign);
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   244
14072
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   245
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   246
pub struct Rect {
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   247
    pub x: i32,
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   248
    pub y: i32,
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   249
    pub width: u32,
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   250
    pub height: u32,
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   251
}
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   252
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   253
impl Rect {
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   254
    #[inline]
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   255
    pub fn new(x: i32, y: i32, width: u32, height: u32) -> Self {
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   256
        Self {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   257
            x,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   258
            y,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   259
            width,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   260
            height,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   261
        }
14072
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   262
    }
14075
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   263
14099
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   264
    pub fn from_box(left: i32, right: i32, top: i32, bottom: i32) -> Self {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   265
        assert!(left <= right);
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   266
        assert!(top <= bottom);
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   267
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   268
        Rect::new(left, top, (right - left) as u32, (bottom - top) as u32)
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   269
    }
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   270
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   271
    pub fn from_size(top_left: Point, size: Size) -> Self {
14102
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   272
        Rect::new(
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   273
            top_left.x,
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   274
            top_left.y,
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   275
            size.width as u32,
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   276
            size.height as u32,
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   277
        )
14099
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   278
    }
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   279
14117
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   280
    pub fn at_origin(size: Size) -> Self {
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   281
        Rect::from_size(Point::zero(), size)
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   282
    }
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   283
14075
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   284
    #[inline]
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   285
    pub fn size(&self) -> Size {
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   286
        Size::new(self.width as usize, self.height as usize)
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   287
    }
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   288
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   289
    #[inline]
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   290
    pub fn area(&self) -> usize {
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   291
        self.size().area()
3185fb34f3b5 update theme editor to use new land generator implementation
alfadur
parents: 14073
diff changeset
   292
    }
14099
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   293
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   294
    #[inline]
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   295
    pub fn left(&self) -> i32 {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   296
        self.x
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   297
    }
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   298
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   299
    #[inline]
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   300
    pub fn top(&self) -> i32 {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   301
        self.y
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   302
    }
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   303
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   304
    #[inline]
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   305
    pub fn right(&self) -> i32 {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   306
        self.x + self.width as i32
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   307
    }
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   308
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   309
    #[inline]
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   310
    pub fn bottom(&self) -> i32 {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   311
        self.y + self.height as i32
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   312
    }
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   313
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   314
    #[inline]
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   315
    pub fn top_left(&self) -> Point {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   316
        Point::new(self.x, self.y)
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   317
    }
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   318
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   319
    #[inline]
14117
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   320
    pub fn bottom_right(&self) -> Point {
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   321
        Point::new(self.right(), self.bottom())
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   322
    }
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   323
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   324
    #[inline]
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   325
    pub fn center(&self) -> Point {
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   326
        (self.top_left() + self.bottom_right()) / 2
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   327
    }
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   328
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   329
    #[inline]
14099
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   330
    pub fn with_margin(&self, margin: i32) -> Self {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   331
        Rect::from_box(
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   332
            self.left() + margin,
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   333
            self.right() - margin,
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   334
            self.top() + margin,
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   335
            self.bottom() - margin,
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   336
        )
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   337
    }
14102
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   338
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   339
    #[inline]
14113
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   340
    pub fn x_range(&self) -> RangeInclusive<i32> {
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   341
        self.x..=self.x + self.width as i32
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   342
    }
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   343
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   344
    #[inline]
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   345
    pub fn y_range(&self) -> RangeInclusive<i32> {
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   346
        self.y..=self.y + self.height as i32
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   347
    }
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   348
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   349
    /* requires #[feature(range_contains)]
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   350
    #[inline]
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   351
    pub fn contains(&self, point: Point) -> bool {
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   352
        x_range().contains(point.x) && y_range.contains(point.y)
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   353
    }*/
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   354
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   355
    #[inline]
14102
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   356
    pub fn contains_inside(&self, point: Point) -> bool {
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   357
        point.x > self.left()
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   358
            && point.x < self.right()
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   359
            && point.y > self.top()
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   360
            && point.y < self.bottom()
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   361
    }
14113
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   362
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   363
    #[inline]
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   364
    pub fn intersects(&self, other: &Rect) -> bool {
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   365
        self.left() <= self.right()
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   366
            && self.right() >= other.left()
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   367
            && self.top() <= other.bottom()
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   368
            && self.bottom() >= other.top()
32a34bf70f65 add more rectangle methods
alfadur
parents: 14109
diff changeset
   369
    }
14117
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   370
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   371
    #[inline]
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   372
    pub fn split_at(&self, point: Point) -> [Rect; 4] {
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   373
        assert!(self.contains_inside(point));
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   374
        [
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   375
            Rect::from_box(self.left(), point.x, self.top(), point.y),
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   376
            Rect::from_box(point.x, self.right(), self.top(), point.y),
14133
f04bc39f0c05 reorder split rectangles
alfadur
parents: 14129
diff changeset
   377
            Rect::from_box(point.x, self.right(), point.y, self.bottom()),
14146
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   378
            Rect::from_box(self.left(), point.x, point.y, self.bottom()),
14117
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   379
        ]
133f648c5fbd add some more rectangle convenience methods
alfadur
parents: 14115
diff changeset
   380
    }
14072
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   381
}
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   382
14115
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   383
pub struct Polygon {
14146
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   384
    vertices: Vec<Point>,
14115
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   385
}
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   386
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   387
impl Polygon {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   388
    pub fn new(vertices: &[Point]) -> Self {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   389
        let mut v = Vec::with_capacity(vertices.len() + 1);
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   390
        v.extend_from_slice(vertices);
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   391
        if !v.is_empty() {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   392
            let start = v[0];
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   393
            v.push(start);
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   394
        }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   395
        Self { vertices: v }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   396
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   397
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   398
    pub fn edges_count(&self) -> usize {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   399
        self.vertices.len() - 1
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   400
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   401
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   402
    pub fn get_edge(&self, index: usize) -> Line {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   403
        Line::new(self.vertices[index], self.vertices[index + 1])
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   404
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   405
14145
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   406
    pub fn split_edge(&mut self, edge_index: usize, vertex: Point) {
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   407
        self.vertices.insert(edge_index + 1, vertex);
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   408
    }
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   409
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   410
    pub fn iter<'a>(&'a self) -> impl Iterator<Item = &Point> + 'a {
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   411
        (&self.vertices[..self.edges_count()]).iter()
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   412
    }
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   413
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   414
    pub fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &mut Point> + 'a {
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   415
        let edges_count = self.edges_count();
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14133
diff changeset
   416
        (&mut self.vertices[..edges_count]).iter_mut()
14115
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   417
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   418
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   419
    pub fn iter_edges<'a>(&'a self) -> impl Iterator<Item = Line> + 'a {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   420
        (&self.vertices[0..self.edges_count()])
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   421
            .iter()
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   422
            .zip(&self.vertices[1..])
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   423
            .map(|(s, e)| Line::new(*s, *e))
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   424
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   425
}
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   426
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   427
impl From<Vec<Point>> for Polygon {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   428
    fn from(mut v: Vec<Point>) -> Self {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   429
        if !v.is_empty() && v[0] != v[v.len() - 1] {
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   430
            let start = v[0];
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   431
            v.push(start)
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   432
        }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   433
        Self { vertices: v }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   434
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   435
}
d0b0d61b7d5e add polygons
alfadur
parents: 14113
diff changeset
   436
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   437
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   438
pub struct Line {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   439
    pub start: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   440
    pub end: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   441
}
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   442
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   443
impl Line {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   444
    #[inline]
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   445
    pub fn new(start: Point, end: Point) -> Self {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   446
        Self { start, end }
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   447
    }
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   448
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   449
    #[inline]
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   450
    pub fn zero() -> Self {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   451
        Self::new(Point::zero(), Point::zero())
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   452
    }
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   453
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   454
    #[inline]
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   455
    pub fn center(&self) -> Point {
14109
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14102
diff changeset
   456
        (self.start + self.end) / 2
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   457
    }
14127
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
   458
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
   459
    #[inline]
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
   460
    pub fn scaled_normal(&self) -> Point {
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
   461
        (self.end - self.start).rotate90()
5c1ce63114a5 a bit of simplification
alfadur
parents: 14117
diff changeset
   462
    }
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   463
}
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   464
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   465
impl IntoIterator for Line {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   466
    type Item = Point;
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   467
    type IntoIter = LinePoints;
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   468
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   469
    fn into_iter(self) -> Self::IntoIter {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   470
        LinePoints::new(self)
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   471
    }
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   472
}
14072
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13971
diff changeset
   473
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   474
pub struct LinePoints {
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   475
    accumulator: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   476
    direction: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   477
    sign: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   478
    current: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   479
    total_steps: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   480
    step: i32,
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   481
}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   482
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   483
impl LinePoints {
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   484
    pub fn new(line: Line) -> Self {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   485
        let dir = line.end - line.start;
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   486
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   487
        Self {
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   488
            accumulator: Point::zero(),
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   489
            direction: dir.abs(),
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   490
            sign: dir.signum(),
14097
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14080
diff changeset
   491
            current: line.start,
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   492
            total_steps: dir.max_norm(),
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   493
            step: 0,
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   494
        }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   495
    }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   496
}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   497
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   498
impl Iterator for LinePoints {
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   499
    type Item = Point;
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   500
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   501
    fn next(&mut self) -> Option<Self::Item> {
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   502
        if self.step <= self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   503
            self.accumulator += self.direction;
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   504
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   505
            if self.accumulator.x > self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   506
                self.accumulator.x -= self.total_steps;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   507
                self.current.x += self.sign.x;
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   508
            }
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   509
            if self.accumulator.y > self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   510
                self.accumulator.y -= self.total_steps;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   511
                self.current.y += self.sign.y;
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   512
            }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   513
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   514
            self.step += 1;
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   515
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   516
            Some(self.current)
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   517
        } else {
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   518
            None
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   519
        }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   520
    }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   521
}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   522
13962
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   523
pub struct ArcPoints {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   524
    point: Point,
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   525
    step: i32,
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   526
}
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   527
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   528
impl ArcPoints {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   529
    pub fn new(radius: i32) -> Self {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   530
        Self {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   531
            point: Point::new(0, radius),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   532
            step: 3 - 2 * radius,
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   533
        }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   534
    }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   535
}
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   536
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   537
impl Iterator for ArcPoints {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   538
    type Item = Point;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   539
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   540
    fn next(&mut self) -> Option<Self::Item> {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   541
        if self.point.x < self.point.y {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   542
            let result = self.point;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   543
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   544
            if self.step < 0 {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   545
                self.step += self.point.x * 4 + 6;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   546
            } else {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   547
                self.step += (self.point.x - self.point.y) * 4 + 10;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   548
                self.point.y -= 1;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   549
            }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   550
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   551
            self.point.x += 1;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   552
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   553
            Some(result)
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   554
        } else if self.point.x == self.point.y {
13968
85645992bc8a Fix ArcPoints never finishing
unc0rr
parents: 13964
diff changeset
   555
            self.point.x += 1;
13971
48796bef9e69 Add --protocol option to engine
unc0rr
parents: 13968
diff changeset
   556
13962
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   557
            Some(self.point)
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   558
        } else {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   559
            None
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   560
        }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   561
    }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   562
}
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   563
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   564
pub struct EquidistantPoints {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   565
    vector: Point,
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   566
    iteration: u8,
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   567
}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   568
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   569
impl EquidistantPoints {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   570
    pub fn new(vector: Point) -> Self {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   571
        Self {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   572
            vector,
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   573
            iteration: if vector.x == vector.y { 4 } else { 8 },
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   574
        }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   575
    }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   576
}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   577
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   578
impl Iterator for EquidistantPoints {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   579
    type Item = Point;
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   580
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   581
    fn next(&mut self) -> Option<Self::Item> {
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   582
        if self.iteration > 0 {
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   583
            self.vector.x = -self.vector.x;
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   584
            if self.iteration & 1 == 0 {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   585
                self.vector.y = -self.vector.y;
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   586
            }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   587
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   588
            if self.iteration == 4 {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   589
                std::mem::swap(&mut self.vector.x, &mut self.vector.y);
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   590
            }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   591
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   592
            self.iteration -= 1;
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   593
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   594
            Some(self.vector)
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   595
        } else {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   596
            None
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   597
        }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   598
    }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   599
}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   600
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   601
#[cfg(test)]
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   602
mod tests {
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   603
    use super::*;
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   604
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   605
    fn get_points(coords: &[(i32, i32)]) -> Vec<Point> {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   606
        coords.iter().map(|(x, y)| Point::new(*x, *y)).collect()
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   607
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   608
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   609
    #[test]
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   610
    fn line_basic() {
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   611
        let line: Vec<Point> = Line::new(Point::new(0, 0), Point::new(3, 3))
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   612
            .into_iter()
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   613
            .collect();
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   614
        let v = get_points(&[(0, 0), (1, 1), (2, 2), (3, 3)]);
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   615
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   616
        assert_eq!(line, v);
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   617
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   618
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   619
    #[test]
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   620
    fn line_skewed() {
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   621
        let line: Vec<Point> = Line::new(Point::new(0, 0), Point::new(5, -7))
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   622
            .into_iter()
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   623
            .collect();
13962
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   624
        let v = get_points(&[
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   625
            (0, 0),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   626
            (1, -1),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   627
            (2, -2),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   628
            (2, -3),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   629
            (3, -4),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   630
            (4, -5),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   631
            (4, -6),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   632
            (5, -7),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13959
diff changeset
   633
        ]);
13959
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13958
diff changeset
   634
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   635
        assert_eq!(line, v);
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   636
    }
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   637
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   638
    #[test]
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   639
    fn equidistant_full() {
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   640
        let n: Vec<Point> = EquidistantPoints::new(Point::new(1, 3)).collect();
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   641
        let v = get_points(&[
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   642
            (-1, -3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   643
            (1, -3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   644
            (-1, 3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   645
            (1, 3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   646
            (-3, -1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   647
            (3, -1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   648
            (-3, 1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   649
            (3, 1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   650
        ]);
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   651
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   652
        assert_eq!(n, v);
13963
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13962
diff changeset
   653
    }
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   654
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   655
    #[test]
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   656
    fn equidistant_half() {
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   657
        let n: Vec<Point> = EquidistantPoints::new(Point::new(2, 2)).collect();
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   658
        let v = get_points(&[(-2, -2), (2, -2), (-2, 2), (2, 2)]);
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   659
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   660
        assert_eq!(n, v);
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   661
    }
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   662
14098
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   663
    #[test]
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   664
    fn line() {
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   665
        let l = Line::new(Point::new(1, 1), Point::new(5, 6));
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   666
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14097
diff changeset
   667
        assert_eq!(l.center(), Point::new(3, 3));
13964
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13963
diff changeset
   668
    }
14099
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   669
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   670
    #[test]
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   671
    fn rect() {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   672
        let r = Rect::from_box(10, 100, 0, 70);
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   673
14102
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   674
        assert!(r.contains_inside(Point::new(99, 69)));
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   675
        assert!(!r.contains_inside(Point::new(100, 70)));
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14099
diff changeset
   676
14099
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   677
        assert_eq!(r.top_left(), Point::new(10, 0));
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   678
        assert_eq!(r.with_margin(12), Rect::from_box(22, 88, 12, 58));
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14098
diff changeset
   679
    }
14146
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   680
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   681
    #[test]
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   682
    fn fit() {
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   683
        let r = Rect::from_box(10, 100, 0, 70);
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   684
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   685
        assert_eq!(Point::new(0, -10).fit(&r), Point::new(10, 0));
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   686
        assert_eq!(Point::new(1000, 1000).fit(&r), Point::new(100, 70));
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14145
diff changeset
   687
    }
13956
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   688
}