rust/integral-geometry/src/lib.rs
author Wuzzy <Wuzzy2@mail.ru>
Thu, 25 Apr 2019 23:01:05 +0200
changeset 14839 e239378a9400
parent 14726 75ff5c643004
child 15025 dc4a12a84c92
permissions -rw-r--r--
Prevent entering “/”, “\” and “:” in team and scheme names. The name of teams and schems is saved in the file name itself, so these characters would cause trouble as they are used in path names in Linux and Windows.
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
     1
use fpnum::{distance, fp, FPNum, FPPoint};
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
     2
use std::{
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
     3
    cmp::{max, min},
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
     4
    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Range, RangeInclusive, Sub, SubAssign},
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
     5
};
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
     6
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
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: 13937
diff changeset
     8
pub struct Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
     9
    pub x: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    10
    pub y: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    11
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    12
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    13
impl Point {
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    14
    pub const ZERO: Self = Self::new(0, 0);
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    15
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    16
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    17
    pub const fn new(x: i32, y: i32) -> Self {
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
    18
        Self { x, y }
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    19
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    20
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    21
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    22
    pub const fn diag(v: i32) -> Self {
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    23
        Self::new(v, v)
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    24
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    25
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    26
    #[inline]
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    27
    pub fn signum(self) -> Self {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    28
        Self::new(self.x.signum(), self.y.signum())
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    29
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    30
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    31
    #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    32
    pub fn abs(self) -> Self {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    33
        Self::new(self.x.abs(), self.y.abs())
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    34
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    35
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    36
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    37
    pub const fn dot(self, other: Point) -> i32 {
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    38
        self.x * other.x + self.y * other.y
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    39
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    40
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    41
    #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    42
    pub fn max_norm(self) -> i32 {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
    43
        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: 13937
diff changeset
    44
    }
14031
c47283feafac add circle filling to land2d
alfadur
parents: 13950
diff changeset
    45
c47283feafac add circle filling to land2d
alfadur
parents: 13950
diff changeset
    46
    #[inline]
14081
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14078
diff changeset
    47
    pub fn integral_norm(self) -> u32 {
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14078
diff changeset
    48
        distance(self.x, self.y).abs_round()
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14078
diff changeset
    49
    }
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14078
diff changeset
    50
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14078
diff changeset
    51
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    52
    pub const fn transform(self, matrix: &[i32; 4]) -> Self {
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
    53
        Point::new(
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
    54
            matrix[0] * self.x + matrix[1] * self.y,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
    55
            matrix[2] * self.x + matrix[3] * self.y,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
    56
        )
14031
c47283feafac add circle filling to land2d
alfadur
parents: 13950
diff changeset
    57
    }
14106
5c1ce63114a5 a bit of simplification
alfadur
parents: 14096
diff changeset
    58
5c1ce63114a5 a bit of simplification
alfadur
parents: 14096
diff changeset
    59
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    60
    pub const fn rotate90(self) -> Self {
14107
6a3bcb7c2981 swap coordinate system
alfadur
parents: 14106
diff changeset
    61
        Point::new(self.y, -self.x)
14106
5c1ce63114a5 a bit of simplification
alfadur
parents: 14096
diff changeset
    62
    }
14108
36b792842d5b a bit more simplification
alfadur
parents: 14107
diff changeset
    63
36b792842d5b a bit more simplification
alfadur
parents: 14107
diff changeset
    64
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    65
    pub const fn cross(self, other: Point) -> i32 {
14108
36b792842d5b a bit more simplification
alfadur
parents: 14107
diff changeset
    66
        self.dot(other.rotate90())
36b792842d5b a bit more simplification
alfadur
parents: 14107
diff changeset
    67
    }
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
    68
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
    69
    #[inline]
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
    70
    pub fn clamp(self, rect: &Rect) -> Point {
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
    71
        Point::new(rect.x_range().clamp(self.x), rect.y_range().clamp(self.y))
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    72
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    73
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    74
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    75
    pub const fn line_to(self, end: Point) -> Line {
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    76
        Line::new(self, end)
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    77
    }
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
    78
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    79
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    80
    pub const fn ray_with_dir(self, direction: Point) -> Ray {
14141
477faa7b8a48 fix ray construction
alfadur
parents: 14140
diff changeset
    81
        Ray::new(self, direction)
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    82
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    83
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    84
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    85
    pub const fn tangent_mul(self, x: i32) -> i32 {
14142
11202097584f fix tangents
alfadur
parents: 14141
diff changeset
    86
        x * self.y / self.x
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    87
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    88
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
    89
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
    90
    pub const fn cotangent_mul(self, y: i32) -> i32 {
14142
11202097584f fix tangents
alfadur
parents: 14141
diff changeset
    91
        y * self.x / self.y
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
    92
    }
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
    93
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
    94
    #[inline]
14144
165e43c3ed59 pull land into collision detector
alfadur
parents: 14142
diff changeset
    95
    pub fn to_fppoint(self) -> FPPoint {
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
    96
        FPPoint::new(self.x.into(), self.y.into())
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
    97
    }
14144
165e43c3ed59 pull land into collision detector
alfadur
parents: 14142
diff changeset
    98
165e43c3ed59 pull land into collision detector
alfadur
parents: 14142
diff changeset
    99
    #[inline]
165e43c3ed59 pull land into collision detector
alfadur
parents: 14142
diff changeset
   100
    pub fn from_fppoint(p: &FPPoint) -> Self {
165e43c3ed59 pull land into collision detector
alfadur
parents: 14142
diff changeset
   101
        Self::new(p.x().round(), p.y().round())
165e43c3ed59 pull land into collision detector
alfadur
parents: 14142
diff changeset
   102
    }
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   103
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   104
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   105
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   106
pub struct Size {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   107
    pub width: usize,
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   108
    pub height: usize,
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   109
}
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   110
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   111
impl Size {
14717
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   112
    pub const EMPTY: Self = Self::square(0);
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   113
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   114
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   115
    pub const fn new(width: usize, height: usize) -> Self {
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   116
        Self { width, height }
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   117
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   118
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   119
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   120
    pub const fn square(size: usize) -> Self {
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   121
        Self {
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   122
            width: size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   123
            height: size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   124
        }
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   125
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   126
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   127
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   128
    pub const fn area(&self) -> usize {
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   129
        self.width * self.height
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   130
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   131
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   132
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   133
    pub const fn linear_index(&self, x: usize, y: usize) -> usize {
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   134
        y * self.width + x
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   135
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   136
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   137
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   138
    pub fn is_power_of_two(&self) -> bool {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   139
        self.width.is_power_of_two() && self.height.is_power_of_two()
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   140
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   141
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   142
    #[inline]
14052
alfadur
parents: 14051 14032
diff changeset
   143
    pub fn next_power_of_two(&self) -> Self {
alfadur
parents: 14051 14032
diff changeset
   144
        Self {
alfadur
parents: 14051 14032
diff changeset
   145
            width: self.width.next_power_of_two(),
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   146
            height: self.height.next_power_of_two(),
14052
alfadur
parents: 14051 14032
diff changeset
   147
        }
alfadur
parents: 14051 14032
diff changeset
   148
    }
alfadur
parents: 14051 14032
diff changeset
   149
alfadur
parents: 14051 14032
diff changeset
   150
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   151
    pub const fn transpose(&self) -> Self {
14175
76a52e8149e3 add some texture transforms
alfadur
parents: 14155
diff changeset
   152
        Self::new(self.height, self.width)
76a52e8149e3 add some texture transforms
alfadur
parents: 14155
diff changeset
   153
    }
76a52e8149e3 add some texture transforms
alfadur
parents: 14155
diff changeset
   154
76a52e8149e3 add some texture transforms
alfadur
parents: 14155
diff changeset
   155
    #[inline]
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   156
    pub fn to_mask(&self) -> SizeMask {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   157
        SizeMask::new(*self)
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   158
    }
14059
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   159
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   160
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   161
    pub fn to_square(&self) -> Self {
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   162
        Self::square(max(self.width, self.height))
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   163
    }
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   164
14059
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   165
    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: 14054
diff changeset
   166
        GridIndex::new(*self)
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   167
    }
14717
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   168
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   169
    #[inline]
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   170
    pub fn contains(&self, other: Self) -> bool {
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   171
        self.width >= other.width && self.height >= other.height
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   172
    }
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   173
}
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   174
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14146
diff changeset
   175
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   176
pub struct SizeMask {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   177
    size: Size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   178
}
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   179
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   180
impl SizeMask {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   181
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   182
    pub fn new(size: Size) -> Self {
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   183
        debug_assert!(size.is_power_of_two());
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   184
        let size = Size {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   185
            width: !(size.width - 1),
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   186
            height: !(size.height - 1),
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   187
        };
14059
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   188
        Self { size }
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   189
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   190
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   191
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   192
    pub fn contains_x<T: Into<usize>>(&self, x: T) -> bool {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   193
        (self.size.width & x.into()) == 0
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   194
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   195
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   196
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   197
    pub fn contains_y<T: Into<usize>>(&self, y: T) -> bool {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   198
        (self.size.height & y.into()) == 0
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   199
    }
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   200
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   201
    #[inline]
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   202
    pub fn contains(&self, point: Point) -> bool {
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   203
        self.contains_x(point.x as usize) && self.contains_y(point.y as usize)
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   204
    }
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   205
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   206
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   207
pub struct GridIndex {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   208
    shift: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   209
}
14059
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   210
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   211
impl GridIndex {
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   212
    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: 14054
diff changeset
   213
        assert!(size.is_power_of_two());
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   214
        let shift = Point::new(
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   215
            size.width.trailing_zeros() as i32,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   216
            size.height.trailing_zeros() as i32,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   217
        );
14059
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   218
        Self { shift }
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   219
    }
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   220
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   221
    pub fn map(&self, position: Point) -> Point {
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   222
        Point::new(position.x >> self.shift.x, position.y >> self.shift.y)
14059
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   223
    }
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   224
}
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about
alfadur
parents: 14054
diff changeset
   225
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   226
macro_rules! bin_op_impl {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   227
    ($op: ty, $name: tt) => {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   228
        impl $op for Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   229
            type Output = Self;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   230
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   231
            #[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   232
            fn $name(self, rhs: Self) -> Self::Output {
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   233
                Self::new(self.x.$name(rhs.x), self.y.$name(rhs.y))
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   234
            }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   235
        }
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   236
    };
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   237
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   238
14088
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   239
macro_rules! scalar_bin_op_impl {
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   240
    ($($op: tt)::+, $name: tt) => {
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   241
        impl $($op)::+<i32> for Point {
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   242
            type Output = Self;
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   243
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   244
            #[inline]
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   245
            fn $name(self, rhs: i32) -> Self::Output {
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   246
                Self::new(self.x.$name(rhs), self.y.$name(rhs))
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   247
            }
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   248
        }
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   249
    };
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   250
}
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   251
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   252
macro_rules! bin_assign_op_impl {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   253
    ($op: ty, $name: tt) => {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   254
        impl $op for Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   255
            #[inline]
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   256
            fn $name(&mut self, rhs: Self) {
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   257
                self.x.$name(rhs.x);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   258
                self.y.$name(rhs.y);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   259
            }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   260
        }
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   261
    };
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   262
}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   263
14146
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   264
macro_rules! fp_scalar_bin_op_impl {
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   265
    ($($op: tt)::+, $name: tt) => {
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   266
        impl $($op)::+<FPNum> for Point {
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   267
            type Output = FPPoint;
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   268
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   269
            #[inline]
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   270
            fn $name(self, rhs: FPNum) -> Self::Output {
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   271
                FPPoint::new(rhs.$name(self.x), rhs.$name(self.y))
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   272
            }
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   273
        }
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   274
    };
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   275
}
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   276
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   277
macro_rules! left_fp_scalar_bin_op_impl {
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   278
    ($($op: tt)::+, $name: tt) => {
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   279
        impl $($op)::+<Point> for FPNum {
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   280
            type Output = FPPoint;
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   281
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   282
            #[inline]
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   283
            fn $name(self, rhs: Point) -> Self::Output {
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   284
                FPPoint::new(self.$name(rhs.x), self.$name(rhs.y))
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   285
            }
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   286
        }
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   287
    };
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   288
}
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   289
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   290
bin_op_impl!(Add, add);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   291
bin_op_impl!(Sub, sub);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   292
bin_op_impl!(Mul, mul);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   293
bin_op_impl!(Div, div);
14088
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   294
scalar_bin_op_impl!(Mul, mul);
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   295
scalar_bin_op_impl!(Div, div);
14146
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   296
fp_scalar_bin_op_impl!(Mul, mul);
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   297
fp_scalar_bin_op_impl!(Div, div);
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   298
left_fp_scalar_bin_op_impl!(Mul, mul);
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   299
left_fp_scalar_bin_op_impl!(Div, div);
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   300
bin_assign_op_impl!(AddAssign, add_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   301
bin_assign_op_impl!(SubAssign, sub_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   302
bin_assign_op_impl!(MulAssign, mul_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   303
bin_assign_op_impl!(DivAssign, div_assign);
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   304
14051
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   305
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   306
pub struct Rect {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   307
    top_left: Point,
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   308
    bottom_right: Point,
14051
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   309
}
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   310
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   311
impl Rect {
14717
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   312
    pub const EMPTY: Self = Self {
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   313
        top_left: Point::ZERO,
14725
19d30d96d7d6 fix atlas.insert
alfadur
parents: 14717
diff changeset
   314
        bottom_right: Point::diag(-1),
14717
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   315
    };
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   316
14051
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   317
    #[inline]
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   318
    pub fn new(top_left: Point, bottom_right: Point) -> Self {
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   319
        debug_assert!(top_left.x <= bottom_right.x + 1);
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   320
        debug_assert!(top_left.y <= bottom_right.y + 1);
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   321
        Self {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   322
            top_left,
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   323
            bottom_right,
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   324
        }
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   325
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   326
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   327
    pub fn from_box(left: i32, right: i32, top: i32, bottom: i32) -> Self {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   328
        Self::new(Point::new(left, top), Point::new(right, bottom))
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   329
    }
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   330
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   331
    pub fn from_size(top_left: Point, size: Size) -> Self {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   332
        Self::new(
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   333
            top_left,
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   334
            top_left + Point::new(size.width as i32 - 1, size.height as i32 - 1),
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   335
        )
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   336
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   337
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   338
    pub fn from_size_coords(x: i32, y: i32, width: usize, height: usize) -> Self {
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   339
        Self::from_size(Point::new(x, y), Size::new(width, height))
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   340
    }
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   341
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   342
    pub fn at_origin(size: Size) -> Self {
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   343
        Self::from_size(Point::ZERO, size)
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   344
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   345
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   346
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   347
    pub const fn width(&self) -> usize {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   348
        (self.right() - self.left() + 1) as usize
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   349
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   350
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   351
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   352
    pub const fn height(&self) -> usize {
14207
bb2f301d4fe0 2018ize everything
alfadur
parents: 14175
diff changeset
   353
        (self.bottom() - self.top() + 1) as usize
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   354
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   355
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   356
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   357
    pub const fn size(&self) -> Size {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   358
        Size::new(self.width(), self.height())
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   359
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   360
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   361
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   362
    pub const fn area(&self) -> usize {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   363
        self.size().area()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   364
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   365
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   366
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   367
    pub const fn left(&self) -> i32 {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   368
        self.top_left().x
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   369
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   370
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   371
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   372
    pub const fn top(&self) -> i32 {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   373
        self.top_left().y
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   374
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   375
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   376
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   377
    pub const fn right(&self) -> i32 {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   378
        self.bottom_right().x
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   379
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   380
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   381
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   382
    pub const fn bottom(&self) -> i32 {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   383
        self.bottom_right().y
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   384
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   385
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   386
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   387
    pub const fn top_left(&self) -> Point {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   388
        self.top_left
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   389
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   390
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   391
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   392
    pub const fn bottom_right(&self) -> Point {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   393
        self.bottom_right
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   394
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   395
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   396
    #[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   397
    pub fn center(&self) -> Point {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   398
        (self.top_left() + self.bottom_right()) / 2
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   399
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   400
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   401
    #[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   402
    pub fn with_margin(&self, margin: i32) -> Self {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   403
        let offset = Point::diag(margin);
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   404
        Self::new(self.top_left() + offset, self.bottom_right() - offset)
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   405
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   406
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   407
    #[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   408
    pub fn x_range(&self) -> RangeInclusive<i32> {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   409
        self.left()..=self.right()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   410
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   411
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   412
    #[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   413
    pub fn y_range(&self) -> RangeInclusive<i32> {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   414
        self.top()..=self.bottom()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   415
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   416
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   417
    #[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   418
    pub fn contains(&self, point: Point) -> bool {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   419
        self.x_range().contains(point.x) && self.y_range().contains(point.y)
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   420
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   421
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   422
    #[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   423
    pub fn contains_inside(&self, point: Point) -> bool {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   424
        point.x > self.left()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   425
            && point.x < self.right()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   426
            && point.y > self.top()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   427
            && point.y < self.bottom()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   428
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   429
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   430
    #[inline]
14717
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   431
    pub fn contains_rect(&self, other: &Self) -> bool {
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   432
        self.contains(other.top_left()) && self.contains(other.bottom_right())
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   433
    }
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   434
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   435
    #[inline]
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   436
    pub fn intersects(&self, other: &Rect) -> bool {
14726
75ff5c643004 actually atlas tests were also broken
alfadur
parents: 14725
diff changeset
   437
        self.left() <= other.right()
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   438
            && self.right() >= other.left()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   439
            && self.top() <= other.bottom()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   440
            && self.bottom() >= other.top()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   441
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   442
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   443
    #[inline]
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   444
    pub fn split_at(&self, point: Point) -> [Rect; 4] {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   445
        assert!(self.contains_inside(point));
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   446
        [
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   447
            Self::from_box(self.left(), point.x, self.top(), point.y),
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   448
            Self::from_box(point.x, self.right(), self.top(), point.y),
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   449
            Self::from_box(point.x, self.right(), point.y, self.bottom()),
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   450
            Self::from_box(self.left(), point.x, point.y, self.bottom()),
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   451
        ]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   452
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   453
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   454
    #[inline]
14717
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   455
    pub fn with_margins(&self, left: i32, right: i32, top: i32, bottom: i32) -> Self {
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   456
        Self::from_box(
14725
19d30d96d7d6 fix atlas.insert
alfadur
parents: 14717
diff changeset
   457
            self.left() - left,
14717
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   458
            self.right() + right,
14725
19d30d96d7d6 fix atlas.insert
alfadur
parents: 14717
diff changeset
   459
            self.top() - top,
14717
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   460
            self.bottom() + bottom,
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   461
        )
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   462
    }
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   463
16024046d458 rescue the atlas
alfadur
parents: 14627
diff changeset
   464
    #[inline]
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   465
    pub fn quotient(self, x: usize, y: usize) -> Point {
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   466
        self.top_left() + Point::new((x % self.width()) as i32, (y % self.height()) as i32)
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   467
    }
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   468
}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   469
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   470
trait RangeContains<T> {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   471
    fn contains(&self, value: T) -> bool;
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   472
}
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   473
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   474
impl<T: Ord> RangeContains<T> for Range<T> {
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   475
    fn contains(&self, value: T) -> bool {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   476
        value >= self.start && value < self.end
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   477
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   478
}
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   479
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   480
impl<T: Ord> RangeContains<T> for RangeInclusive<T> {
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   481
    fn contains(&self, value: T) -> bool {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   482
        value >= *self.start() && value <= *self.end()
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   483
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   484
}
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   485
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   486
trait RangeClamp<T> {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   487
    fn clamp(&self, value: T) -> T;
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   488
}
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   489
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   490
impl<T: Ord + Copy> RangeClamp<T> for RangeInclusive<T> {
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   491
    fn clamp(&self, value: T) -> T {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   492
        if value < *self.start() {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   493
            *self.start()
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   494
        } else if value > *self.end() {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   495
            *self.end()
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   496
        } else {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   497
            value
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   498
        }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   499
    }
14051
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   500
}
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   501
14094
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   502
pub struct Polygon {
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   503
    vertices: Vec<Point>,
14094
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   504
}
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   505
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   506
impl Polygon {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   507
    pub fn new(vertices: &[Point]) -> Self {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   508
        let mut v = Vec::with_capacity(vertices.len() + 1);
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   509
        v.extend_from_slice(vertices);
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   510
        if !v.is_empty() {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   511
            let start = v[0];
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   512
            v.push(start);
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   513
        }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   514
        Self { vertices: v }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   515
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   516
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   517
    pub fn edges_count(&self) -> usize {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   518
        self.vertices.len() - 1
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   519
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   520
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   521
    pub fn get_edge(&self, index: usize) -> Line {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   522
        Line::new(self.vertices[index], self.vertices[index + 1])
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   523
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   524
14124
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14112
diff changeset
   525
    pub fn split_edge(&mut self, edge_index: usize, vertex: Point) {
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14112
diff changeset
   526
        self.vertices.insert(edge_index + 1, vertex);
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14112
diff changeset
   527
    }
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14112
diff changeset
   528
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14112
diff changeset
   529
    pub fn iter<'a>(&'a self) -> impl Iterator<Item = &Point> + 'a {
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14112
diff changeset
   530
        (&self.vertices[..self.edges_count()]).iter()
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14112
diff changeset
   531
    }
6e0be42d0a8f polygonize OutlinePoints
alfadur
parents: 14112
diff changeset
   532
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   533
    pub fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &mut Point> + 'a {
14155
8f82d87d223f save edges_count
alfadur
parents: 14152
diff changeset
   534
        let edges_count = self.edges_count();
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   535
        let start = self.vertices.as_mut_ptr();
14155
8f82d87d223f save edges_count
alfadur
parents: 14152
diff changeset
   536
        let end = unsafe { start.add(edges_count) };
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   537
        PolygonPointsIteratorMut {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   538
            source: self,
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   539
            start,
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   540
            end,
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   541
        }
14094
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   542
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   543
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   544
    fn force_close(&mut self) {
14133
a65b60f36b96 fix polygons getting unclosed on mirroring
alfadur
parents: 14131
diff changeset
   545
        if !self.vertices.is_empty() {
14208
87f1054c2333 fix polygon closure
alfadur
parents: 14207
diff changeset
   546
            let edges_count = self.edges_count();
87f1054c2333 fix polygon closure
alfadur
parents: 14207
diff changeset
   547
            self.vertices[edges_count] = self.vertices[0];
14133
a65b60f36b96 fix polygons getting unclosed on mirroring
alfadur
parents: 14131
diff changeset
   548
        }
a65b60f36b96 fix polygons getting unclosed on mirroring
alfadur
parents: 14131
diff changeset
   549
    }
a65b60f36b96 fix polygons getting unclosed on mirroring
alfadur
parents: 14131
diff changeset
   550
14094
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   551
    pub fn iter_edges<'a>(&'a self) -> impl Iterator<Item = Line> + 'a {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   552
        (&self.vertices[0..self.edges_count()])
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   553
            .iter()
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   554
            .zip(&self.vertices[1..])
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   555
            .map(|(s, e)| Line::new(*s, *e))
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   556
    }
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   557
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   558
    pub fn bezierize(&mut self, segments_number: u32) {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   559
        fn calc_point(p1: Point, p2: Point, p3: Point) -> FPPoint {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   560
            let diff13 = (p1 - p3).to_fppoint();
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   561
            let diff13_norm = diff13.distance();
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   562
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   563
            if diff13_norm.is_zero() {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   564
                diff13
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   565
            } else {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   566
                let diff12_norm = (p1 - p2).to_fppoint().distance();
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   567
                let diff23_norm = (p2 - p3).to_fppoint().distance();
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   568
                let min_distance = min(diff13_norm, min(diff12_norm, diff23_norm));
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   569
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   570
                diff13 * min_distance / diff13_norm / 3
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   571
            }
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   572
        }
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   573
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   574
        if self.vertices.len() < 4 {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   575
            return;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   576
        }
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   577
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   578
        let delta = fp!(1 / segments_number);
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   579
        let mut bezierized_vertices = Vec::new();
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   580
        let mut pi = 0;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   581
        let mut i = 1;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   582
        let mut ni = 2;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   583
        let mut right_point = calc_point(self.vertices[pi], self.vertices[i], self.vertices[ni]);
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   584
        let mut left_point;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   585
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   586
        pi += 1;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   587
        while pi != 0 {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   588
            pi = i;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   589
            i = ni;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   590
            ni += 1;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   591
            if ni >= self.vertices.len() {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   592
                ni = 0;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   593
            }
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   594
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   595
            left_point = right_point;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   596
            right_point = calc_point(self.vertices[pi], self.vertices[i], self.vertices[ni]);
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   597
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   598
            bezierized_vertices.extend(BezierCurveSegments::new(
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   599
                Line::new(self.vertices[pi], self.vertices[i]),
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   600
                left_point,
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   601
                -right_point,
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   602
                delta,
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   603
            ));
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   604
        }
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   605
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   606
        self.vertices = bezierized_vertices;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   607
    }
14094
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   608
}
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   609
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   610
struct PolygonPointsIteratorMut<'a> {
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   611
    source: &'a mut Polygon,
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   612
    start: *mut Point,
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   613
    end: *mut Point,
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   614
}
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   615
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   616
impl<'a> Iterator for PolygonPointsIteratorMut<'a> {
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   617
    type Item = &'a mut Point;
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   618
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   619
    fn next(&mut self) -> Option<<Self as Iterator>::Item> {
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   620
        if self.start == self.end {
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   621
            None
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   622
        } else {
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   623
            unsafe {
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   624
                let result = &mut *self.start;
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   625
                self.start = self.start.add(1);
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   626
                Some(result)
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   627
            }
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   628
        }
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   629
    }
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   630
}
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   631
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   632
impl<'a> Drop for PolygonPointsIteratorMut<'a> {
14134
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   633
    fn drop(&mut self) {
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   634
        self.source.force_close();
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   635
    }
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   636
}
09f62bb046ef actually there is a way to preserve mutable polygon iterator
alfadur
parents: 14133
diff changeset
   637
14094
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   638
impl From<Vec<Point>> for Polygon {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   639
    fn from(mut v: Vec<Point>) -> Self {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   640
        if !v.is_empty() && v[0] != v[v.len() - 1] {
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   641
            let start = v[0];
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   642
            v.push(start)
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   643
        }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   644
        Self { vertices: v }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   645
    }
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   646
}
d0b0d61b7d5e add polygons
alfadur
parents: 14092
diff changeset
   647
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   648
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   649
pub struct Ray {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   650
    pub start: Point,
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   651
    pub direction: Point,
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   652
}
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   653
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   654
impl Ray {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   655
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   656
    pub const fn new(start: Point, direction: Point) -> Ray {
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   657
        Self { start, direction }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   658
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   659
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   660
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   661
    pub const fn tangent_mul(&self, x: i32) -> i32 {
14142
11202097584f fix tangents
alfadur
parents: 14141
diff changeset
   662
        self.direction.tangent_mul(x)
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   663
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   664
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   665
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   666
    pub const fn cotangent_mul(&self, y: i32) -> i32 {
14142
11202097584f fix tangents
alfadur
parents: 14141
diff changeset
   667
        self.direction.cotangent_mul(y)
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   668
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   669
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   670
    #[inline]
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   671
    pub fn orientation(&self, point: Point) -> i32 {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   672
        (point - self.start).cross(self.direction).signum()
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   673
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   674
}
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   675
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   676
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   677
pub struct Line {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   678
    pub start: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   679
    pub end: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   680
}
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   681
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   682
impl Line {
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   683
    pub const ZERO: Self = Self::new(Point::ZERO, Point::ZERO);
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   684
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   685
    #[inline]
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   686
    pub const fn new(start: Point, end: Point) -> Self {
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   687
        Self { start, end }
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   688
    }
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   689
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   690
    #[inline]
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   691
    pub fn center(&self) -> Point {
14088
f483f844da98 component-wise division is actually useful sometimes
alfadur
parents: 14081
diff changeset
   692
        (self.start + self.end) / 2
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   693
    }
14106
5c1ce63114a5 a bit of simplification
alfadur
parents: 14096
diff changeset
   694
5c1ce63114a5 a bit of simplification
alfadur
parents: 14096
diff changeset
   695
    #[inline]
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   696
    pub fn scaled_direction(&self) -> Point {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   697
        self.end - self.start
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   698
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   699
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   700
    #[inline]
14106
5c1ce63114a5 a bit of simplification
alfadur
parents: 14096
diff changeset
   701
    pub fn scaled_normal(&self) -> Point {
14131
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   702
        self.scaled_direction().rotate90()
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   703
    }
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   704
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   705
    #[inline]
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   706
    pub fn to_ray(&self) -> Ray {
c416d32764b7 organize landgen a bit more
alfadur
parents: 14126
diff changeset
   707
        Ray::new(self.start, self.scaled_direction())
14106
5c1ce63114a5 a bit of simplification
alfadur
parents: 14096
diff changeset
   708
    }
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   709
}
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   710
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   711
impl IntoIterator for Line {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   712
    type Item = Point;
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   713
    type IntoIter = LinePoints;
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   714
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   715
    fn into_iter(self) -> Self::IntoIter {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   716
        LinePoints::new(self)
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   717
    }
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   718
}
14051
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen
unc0rr
parents: 13950
diff changeset
   719
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   720
pub struct LinePoints {
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   721
    accumulator: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   722
    direction: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   723
    sign: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   724
    current: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   725
    total_steps: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   726
    step: i32,
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   727
}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   728
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   729
impl LinePoints {
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   730
    pub fn new(line: Line) -> Self {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   731
        let dir = line.end - line.start;
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   732
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   733
        Self {
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   734
            accumulator: Point::ZERO,
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   735
            direction: dir.abs(),
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   736
            sign: dir.signum(),
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14059
diff changeset
   737
            current: line.start,
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   738
            total_steps: dir.max_norm(),
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   739
            step: 0,
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   740
        }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   741
    }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   742
}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   743
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   744
impl Iterator for LinePoints {
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   745
    type Item = Point;
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   746
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   747
    fn next(&mut self) -> Option<Self::Item> {
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   748
        if self.step <= self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   749
            self.accumulator += self.direction;
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   750
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   751
            if self.accumulator.x > self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   752
                self.accumulator.x -= self.total_steps;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   753
                self.current.x += self.sign.x;
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   754
            }
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   755
            if self.accumulator.y > self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   756
                self.accumulator.y -= self.total_steps;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   757
                self.current.y += self.sign.y;
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   758
            }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   759
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   760
            self.step += 1;
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   761
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   762
            Some(self.current)
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   763
        } else {
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   764
            None
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   765
        }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   766
    }
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   767
}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   768
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   769
pub struct ArcPoints {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   770
    point: Point,
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   771
    step: i32,
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   772
}
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   773
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   774
impl ArcPoints {
14627
2e2b31cf0871 make stuff const
alfadur
parents: 14208
diff changeset
   775
    pub const fn new(radius: i32) -> Self {
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   776
        Self {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   777
            point: Point::new(0, radius),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   778
            step: 3 - 2 * radius,
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   779
        }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   780
    }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   781
}
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   782
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   783
impl Iterator for ArcPoints {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   784
    type Item = Point;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   785
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   786
    fn next(&mut self) -> Option<Self::Item> {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   787
        if self.point.x < self.point.y {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   788
            let result = self.point;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   789
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   790
            if self.step < 0 {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   791
                self.step += self.point.x * 4 + 6;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   792
            } else {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   793
                self.step += (self.point.x - self.point.y) * 4 + 10;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   794
                self.point.y -= 1;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   795
            }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   796
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   797
            self.point.x += 1;
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   798
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   799
            Some(result)
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   800
        } else if self.point.x == self.point.y {
13947
85645992bc8a Fix ArcPoints never finishing
unc0rr
parents: 13943
diff changeset
   801
            self.point.x += 1;
13950
48796bef9e69 Add --protocol option to engine
unc0rr
parents: 13947
diff changeset
   802
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   803
            Some(self.point)
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   804
        } else {
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   805
            None
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   806
        }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   807
    }
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   808
}
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   809
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   810
pub struct EquidistantPoints {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   811
    vector: Point,
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   812
    iteration: u8,
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   813
}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   814
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   815
impl EquidistantPoints {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   816
    pub fn new(vector: Point) -> Self {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   817
        Self {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   818
            vector,
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   819
            iteration: if vector.x == vector.y { 4 } else { 8 },
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   820
        }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   821
    }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   822
}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   823
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   824
impl Iterator for EquidistantPoints {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   825
    type Item = Point;
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   826
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   827
    fn next(&mut self) -> Option<Self::Item> {
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   828
        if self.iteration > 0 {
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   829
            self.vector.x = -self.vector.x;
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   830
            if self.iteration & 1 == 0 {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   831
                self.vector.y = -self.vector.y;
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   832
            }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   833
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   834
            if self.iteration == 4 {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   835
                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: 13941
diff changeset
   836
            }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   837
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   838
            self.iteration -= 1;
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   839
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   840
            Some(self.vector)
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   841
        } else {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   842
            None
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   843
        }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   844
    }
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   845
}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   846
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   847
pub struct BezierCurveSegments {
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   848
    segment: Line,
14146
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   849
    control_point1: FPPoint,
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   850
    control_point2: FPPoint,
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   851
    offset: FPNum,
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   852
    max_offset: FPNum,
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   853
    delta: FPNum,
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   854
    have_finished: bool,
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   855
}
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   856
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   857
impl BezierCurveSegments {
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   858
    pub fn new(segment: Line, p1: FPPoint, p2: FPPoint, delta: FPNum) -> Self {
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   859
        Self {
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   860
            segment,
14146
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   861
            control_point1: segment.start.to_fppoint() - p1,
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   862
            control_point2: segment.end.to_fppoint() - p2,
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   863
            offset: fp!(0),
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   864
            max_offset: fp!(4095 / 4096),
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   865
            delta,
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   866
            have_finished: false,
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   867
        }
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   868
    }
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   869
}
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   870
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   871
impl Iterator for BezierCurveSegments {
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   872
    type Item = Point;
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   873
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   874
    fn next(&mut self) -> Option<Self::Item> {
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   875
        if self.offset < self.max_offset {
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   876
            let offset_sq = self.offset * self.offset;
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   877
            let offset_cub = offset_sq * self.offset;
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   878
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   879
            let r1 = fp!(1) - self.offset * 3 + offset_sq * 3 - offset_cub;
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   880
            let r2 = self.offset * 3 - offset_sq * 6 + offset_cub * 3;
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   881
            let r3 = offset_sq * 3 - offset_cub * 3;
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   882
14146
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   883
            let p = r1 * self.segment.start
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   884
                + r2 * self.control_point1
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   885
                + r3 * self.control_point2
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   886
                + offset_cub * self.segment.end;
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   887
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   888
            self.offset += self.delta;
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   889
14146
4791c9a7d5e8 add more point operators
alfadur
parents: 14144
diff changeset
   890
            Some(Point::from_fppoint(&p))
14140
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   891
        } else if !self.have_finished {
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   892
            self.have_finished = true;
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   893
3078123e84ea Bezierize land outline
unc0rr
parents: 14139
diff changeset
   894
            Some(self.segment.end)
14139
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   895
        } else {
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   896
            None
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   897
        }
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   898
    }
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   899
}
37c99587825d Implement BeizerCurveSegments, no tests
unc0rr
parents: 14137
diff changeset
   900
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   901
#[cfg(test)]
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   902
mod tests {
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   903
    use super::*;
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   904
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   905
    fn get_points(coords: &[(i32, i32)]) -> Vec<Point> {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   906
        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: 13937
diff changeset
   907
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   908
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   909
    #[test]
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   910
    fn line_basic() {
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   911
        let line: Vec<Point> = Line::new(Point::new(0, 0), Point::new(3, 3))
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   912
            .into_iter()
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   913
            .collect();
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   914
        let v = get_points(&[(0, 0), (1, 1), (2, 2), (3, 3)]);
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   915
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   916
        assert_eq!(line, v);
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   917
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   918
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   919
    #[test]
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   920
    fn line_skewed() {
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   921
        let line: Vec<Point> = Line::new(Point::new(0, 0), Point::new(5, -7))
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   922
            .into_iter()
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   923
            .collect();
13941
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   924
        let v = get_points(&[
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   925
            (0, 0),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   926
            (1, -1),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   927
            (2, -2),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   928
            (2, -3),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   929
            (3, -4),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   930
            (4, -5),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   931
            (4, -6),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   932
            (5, -7),
3f69a70063a5 Implement ArcPoints iterator for circles
unc0rr
parents: 13938
diff changeset
   933
        ]);
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13937
diff changeset
   934
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   935
        assert_eq!(line, v);
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   936
    }
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   937
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   938
    #[test]
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   939
    fn equidistant_full() {
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   940
        let n: Vec<Point> = EquidistantPoints::new(Point::new(1, 3)).collect();
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   941
        let v = get_points(&[
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   942
            (-1, -3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   943
            (1, -3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   944
            (-1, 3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   945
            (1, 3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   946
            (-3, -1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   947
            (3, -1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   948
            (-3, 1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   949
            (3, 1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   950
        ]);
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   951
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   952
        assert_eq!(n, v);
13942
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles
unc0rr
parents: 13941
diff changeset
   953
    }
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   954
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   955
    #[test]
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   956
    fn equidistant_half() {
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   957
        let n: Vec<Point> = EquidistantPoints::new(Point::new(2, 2)).collect();
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   958
        let v = get_points(&[(-2, -2), (2, -2), (-2, 2), (2, 2)]);
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   959
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   960
        assert_eq!(n, v);
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   961
    }
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   962
14077
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   963
    #[test]
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   964
    fn line() {
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   965
        let l = Line::new(Point::new(1, 1), Point::new(5, 6));
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   966
5ade484f3351 Refactor tests, add fn center() for Line
unC0Rr
parents: 14076
diff changeset
   967
        assert_eq!(l.center(), Point::new(3, 3));
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13942
diff changeset
   968
    }
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14077
diff changeset
   969
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14077
diff changeset
   970
    #[test]
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14077
diff changeset
   971
    fn rect() {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   972
        let r = Rect::from_box(10, 100, 0, 70);
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14077
diff changeset
   973
14081
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14078
diff changeset
   974
        assert!(r.contains_inside(Point::new(99, 69)));
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14078
diff changeset
   975
        assert!(!r.contains_inside(Point::new(100, 70)));
5d42204ac35e Start convertion of FindPoint()
unC0Rr
parents: 14078
diff changeset
   976
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14077
diff changeset
   977
        assert_eq!(r.top_left(), Point::new(10, 0));
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   978
        assert_eq!(r.with_margin(12), Rect::from_box(22, 88, 12, 58));
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14077
diff changeset
   979
    }
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   980
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   981
    #[test]
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   982
    fn fit() {
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
   983
        let r = Rect::from_box(10, 100, 0, 70);
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   984
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   985
        assert_eq!(Point::new(0, -10).clamp(&r), Point::new(10, 0));
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14134
diff changeset
   986
        assert_eq!(Point::new(1000, 1000).clamp(&r), Point::new(100, 70));
14125
376a0551b00a - Add distance-divider option to land_dump
unc0rr
parents: 14124
diff changeset
   987
    }
13935
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator
unc0rr
parents:
diff changeset
   988
}