author | unc0rr |
Wed, 07 Nov 2018 19:43:17 +0100 | |
changeset 14159 | 0aeea29ef890 |
parent 14142 | 11202097584f |
child 14207 | bb2f301d4fe0 |
permissions | -rw-r--r-- |
14069 | 1 |
use itertools::Itertools; |
14081 | 2 |
use std::cmp::min; |
14069 | 3 |
|
14137
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
4 |
use integral_geometry::{Line, Ray, Point, Polygon, Rect, Size}; |
14069 | 5 |
use land2d::Land2D; |
6 |
||
7 |
use outline_template::OutlineTemplate; |
|
8 |
||
9 |
pub struct OutlinePoints { |
|
14124 | 10 |
pub islands: Vec<Polygon>, |
14069 | 11 |
pub fill_points: Vec<Point>, |
12 |
pub size: Size, |
|
14137
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
13 |
pub play_box: Rect, |
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
14 |
intersections_box: Rect, |
14069 | 15 |
} |
16 |
||
17 |
impl OutlinePoints { |
|
18 |
pub fn from_outline_template<I: Iterator<Item = u32>>( |
|
19 |
outline_template: &OutlineTemplate, |
|
14137
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
20 |
play_box: Rect, |
14078 | 21 |
size: Size, |
14069 | 22 |
random_numbers: &mut I, |
23 |
) -> Self { |
|
24 |
Self { |
|
14078 | 25 |
play_box, |
26 |
size, |
|
14069 | 27 |
islands: outline_template |
28 |
.islands |
|
29 |
.iter() |
|
30 |
.map(|i| { |
|
31 |
i.iter() |
|
32 |
.zip(random_numbers.tuples()) |
|
33 |
.map(|(rect, (rnd_a, rnd_b))| { |
|
14137
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
34 |
play_box.top_left() + rect.quotient(rnd_a as usize, rnd_b as usize) |
14122
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
35 |
}) |
14125 | 36 |
.collect::<Vec<_>>() |
37 |
.into() |
|
14122
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
38 |
}) |
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
39 |
.collect(), |
14069 | 40 |
fill_points: outline_template.fill_points.clone(), |
14137
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
41 |
intersections_box: Rect::at_origin(size) |
14125 | 42 |
.with_margin(size.to_square().width as i32 * -2), |
14069 | 43 |
} |
44 |
} |
|
45 |
||
46 |
pub fn total_len(&self) -> usize { |
|
14124 | 47 |
self.islands.iter().map(|i| i.edges_count()).sum::<usize>() + self.fill_points.len() |
14069 | 48 |
} |
49 |
||
14100 | 50 |
pub fn iter(&self) -> impl Iterator<Item = &Point> { |
51 |
self.islands |
|
52 |
.iter() |
|
14124 | 53 |
.flat_map(|p| p.iter()) |
14100 | 54 |
.chain(self.fill_points.iter()) |
55 |
} |
|
56 |
||
14134
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
57 |
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Point> { |
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
58 |
self.islands |
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
59 |
.iter_mut() |
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
60 |
.flat_map(|i| i.iter_mut()) |
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
61 |
.chain(self.fill_points.iter_mut()) |
14069 | 62 |
} |
63 |
||
64 |
fn divide_edge<I: Iterator<Item = u32>>( |
|
65 |
&self, |
|
14076
e5904ead4864
Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents:
14069
diff
changeset
|
66 |
segment: Line, |
14100 | 67 |
distance_divisor: u32, |
14069 | 68 |
random_numbers: &mut I, |
69 |
) -> Option<Point> { |
|
14100 | 70 |
#[inline] |
14131 | 71 |
fn intersects(ray: &Ray, edge: &Line) -> bool { |
72 |
ray.orientation(edge.start) != ray.orientation(edge.end) |
|
14100 | 73 |
} |
74 |
||
75 |
#[inline] |
|
14135
7f5a591e1c43
separate rectangle types based on right/bottom edge inclusivity
alfadur
parents:
14134
diff
changeset
|
76 |
fn solve_intersection( |
14137
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
77 |
intersections_box: &Rect, |
14135
7f5a591e1c43
separate rectangle types based on right/bottom edge inclusivity
alfadur
parents:
14134
diff
changeset
|
78 |
ray: &Ray, |
7f5a591e1c43
separate rectangle types based on right/bottom edge inclusivity
alfadur
parents:
14134
diff
changeset
|
79 |
edge: &Line |
7f5a591e1c43
separate rectangle types based on right/bottom edge inclusivity
alfadur
parents:
14134
diff
changeset
|
80 |
) -> Option<(i32, u32)> |
14131 | 81 |
{ |
82 |
let edge_dir = edge.scaled_direction(); |
|
83 |
let aqpb = ray.direction.cross(edge_dir) as i64; |
|
14100 | 84 |
|
85 |
if aqpb != 0 { |
|
14131 | 86 |
let mut iy = |
87 |
((((edge.start.x - ray.start.x) as i64 * ray.direction.y as i64 |
|
88 |
+ ray.start.y as i64 * ray.direction.x as i64) |
|
89 |
* edge_dir.y as i64 |
|
90 |
- edge.start.y as i64 * edge_dir.x as i64 * ray.direction.y as i64) |
|
14100 | 91 |
/ aqpb) as i32; |
14125 | 92 |
|
93 |
// is there better way to do it? |
|
94 |
if iy < intersections_box.top() { |
|
95 |
iy = intersections_box.top(); |
|
96 |
} else if iy > intersections_box.bottom() { |
|
97 |
iy = intersections_box.bottom(); |
|
98 |
} |
|
99 |
||
14131 | 100 |
let ix = if ray.direction.y.abs() > edge_dir.y.abs() { |
14142 | 101 |
ray.start.x + ray.direction.cotangent_mul(iy - ray.start.y) |
14100 | 102 |
} else { |
14142 | 103 |
edge.start.x + edge_dir.cotangent_mul(iy - edge.start.y) |
14100 | 104 |
}; |
105 |
||
14132 | 106 |
let intersection_point = Point::new(ix, iy).clamp(intersections_box); |
14131 | 107 |
let diff_point = ray.start - intersection_point; |
108 |
let t = ray.direction.dot(diff_point); |
|
14132 | 109 |
|
14122
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
110 |
if diff_point.max_norm() >= std::i16::MAX as i32 { |
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
111 |
Some((t, std::i32::MAX as u32)) |
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
112 |
} else { |
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
113 |
let d = diff_point.integral_norm(); |
14100 | 114 |
|
14122
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
115 |
Some((t, d)) |
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
116 |
} |
14100 | 117 |
} else { |
118 |
None |
|
119 |
} |
|
120 |
} |
|
121 |
||
14081 | 122 |
let min_distance = 40; |
123 |
// new point should fall inside this box |
|
124 |
let map_box = self.play_box.with_margin(min_distance); |
|
125 |
||
14131 | 126 |
let normal = segment.scaled_normal(); |
127 |
let normal_len = normal.integral_norm(); |
|
14081 | 128 |
let mid_point = segment.center(); |
129 |
||
14131 | 130 |
if (normal_len < min_distance as u32 * 3) || !map_box.contains_inside(mid_point) { |
14081 | 131 |
return None; |
132 |
} |
|
133 |
||
14131 | 134 |
let normal_ray = Ray::new(mid_point, normal); |
14081 | 135 |
let mut dist_left = (self.size.width + self.size.height) as u32; |
136 |
let mut dist_right = dist_left; |
|
137 |
||
138 |
// find distances to map borders |
|
14131 | 139 |
if normal.x != 0 { |
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
140 |
// where the normal line intersects the left map border |
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
141 |
let left_intersection = Point::new( |
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
142 |
map_box.left(), |
14142 | 143 |
mid_point.y + normal.tangent_mul(map_box.left() - mid_point.x), |
14122
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
144 |
); |
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
145 |
dist_left = (mid_point - left_intersection).integral_norm(); |
14081 | 146 |
|
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
147 |
// same for the right border |
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
148 |
let right_intersection = Point::new( |
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
149 |
map_box.right(), |
14142 | 150 |
mid_point.y + normal.tangent_mul(map_box.right() - mid_point.x) , |
14122
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
151 |
); |
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
152 |
dist_right = (mid_point - right_intersection).integral_norm(); |
14081 | 153 |
|
14131 | 154 |
if normal.x > 0 { |
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
155 |
std::mem::swap(&mut dist_left, &mut dist_right); |
14081 | 156 |
} |
157 |
} |
|
158 |
||
14131 | 159 |
if normal.y != 0 { |
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
160 |
// where the normal line intersects the top map border |
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
161 |
let top_intersection = Point::new( |
14142 | 162 |
mid_point.x + normal.cotangent_mul(map_box.top() - mid_point.y), |
14122
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
163 |
map_box.top(), |
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
164 |
); |
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
165 |
let dl = (mid_point - top_intersection).integral_norm(); |
14081 | 166 |
|
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
167 |
// same for the bottom border |
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
168 |
let bottom_intersection = Point::new( |
14142 | 169 |
mid_point.x + normal.cotangent_mul(map_box.bottom() - mid_point.y), |
14122
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
170 |
map_box.bottom(), |
c27461e6a9eb
Implement non-overflowing calculations for high values
unc0rr
parents:
14121
diff
changeset
|
171 |
); |
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
172 |
let dr = (mid_point - bottom_intersection).integral_norm(); |
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
173 |
|
14131 | 174 |
if normal.y < 0 { |
14081 | 175 |
dist_left = min(dist_left, dl); |
176 |
dist_right = min(dist_right, dr); |
|
177 |
} else { |
|
178 |
dist_left = min(dist_left, dr); |
|
14110
21642eb0ff29
import some clarity into border distance computation
alfadur
parents:
14109
diff
changeset
|
179 |
dist_right = min(dist_right, dl); |
14081 | 180 |
} |
181 |
} |
|
182 |
||
183 |
// now go through all other segments |
|
14100 | 184 |
for s in self.segments_iter() { |
185 |
if s != segment { |
|
14131 | 186 |
if intersects(&normal_ray, &s) { |
187 |
if let Some((t, d)) = |
|
188 |
solve_intersection(&self.intersections_box, &normal_ray, &s) |
|
189 |
{ |
|
14100 | 190 |
if t > 0 { |
14113
be4419243735
fix normal offset for split points and make directions more consistent
alfadur
parents:
14111
diff
changeset
|
191 |
dist_right = min(dist_right, d); |
14100 | 192 |
} else { |
14113
be4419243735
fix normal offset for split points and make directions more consistent
alfadur
parents:
14111
diff
changeset
|
193 |
dist_left = min(dist_left, d); |
14100 | 194 |
} |
195 |
} |
|
196 |
} |
|
197 |
} |
|
198 |
} |
|
14081 | 199 |
|
14100 | 200 |
// go through all points, including fill points |
14126 | 201 |
for pi in self.iter().cloned() { |
202 |
if pi != segment.start && pi != segment.end { |
|
14141 | 203 |
if intersects(&pi.ray_with_dir(normal), &segment) { |
14100 | 204 |
// ray from segment.start |
14125 | 205 |
if let Some((t, d)) = solve_intersection( |
14131 | 206 |
&self.intersections_box, &normal_ray, &segment.start.line_to(pi), |
14125 | 207 |
) { |
14100 | 208 |
if t > 0 { |
14113
be4419243735
fix normal offset for split points and make directions more consistent
alfadur
parents:
14111
diff
changeset
|
209 |
dist_right = min(dist_right, d); |
14100 | 210 |
} else { |
14113
be4419243735
fix normal offset for split points and make directions more consistent
alfadur
parents:
14111
diff
changeset
|
211 |
dist_left = min(dist_left, d); |
14100 | 212 |
} |
213 |
} |
|
214 |
||
215 |
// ray from segment.end |
|
14125 | 216 |
if let Some((t, d)) = solve_intersection( |
14131 | 217 |
&self.intersections_box, &normal_ray, &segment.end.line_to(pi) |
14125 | 218 |
) { |
14100 | 219 |
if t > 0 { |
14113
be4419243735
fix normal offset for split points and make directions more consistent
alfadur
parents:
14111
diff
changeset
|
220 |
dist_right = min(dist_right, d); |
14100 | 221 |
} else { |
14113
be4419243735
fix normal offset for split points and make directions more consistent
alfadur
parents:
14111
diff
changeset
|
222 |
dist_left = min(dist_left, d); |
14100 | 223 |
} |
224 |
} |
|
225 |
} |
|
226 |
} |
|
227 |
} |
|
228 |
||
14131 | 229 |
let max_dist = normal_len * 100 / distance_divisor; |
14100 | 230 |
dist_left = min(dist_left, max_dist); |
231 |
dist_right = min(dist_right, max_dist); |
|
232 |
||
233 |
if dist_right + dist_left < min_distance as u32 * 2 + 10 { |
|
234 |
// limits are too narrow, just divide |
|
235 |
Some(mid_point) |
|
236 |
} else { |
|
14113
be4419243735
fix normal offset for split points and make directions more consistent
alfadur
parents:
14111
diff
changeset
|
237 |
// select distance within [-dist_right; dist_left], keeping min_distance in mind |
be4419243735
fix normal offset for split points and make directions more consistent
alfadur
parents:
14111
diff
changeset
|
238 |
let d = -(dist_right as i32) |
14100 | 239 |
+ min_distance |
240 |
+ random_numbers.next().unwrap() as i32 |
|
241 |
% (dist_right as i32 + dist_left as i32 - min_distance * 2); |
|
242 |
||
14131 | 243 |
Some(mid_point + normal * d / normal_len as i32) |
14100 | 244 |
} |
14069 | 245 |
} |
246 |
||
14100 | 247 |
fn divide_edges<I: Iterator<Item = u32>>( |
248 |
&mut self, |
|
249 |
distance_divisor: u32, |
|
250 |
random_numbers: &mut I, |
|
251 |
) { |
|
14069 | 252 |
for is in 0..self.islands.len() { |
253 |
let mut i = 0; |
|
14124 | 254 |
while i < self.islands[is].edges_count() { |
255 |
let segment = self.islands[is].get_edge(i); |
|
14125 | 256 |
if let Some(new_point) = self.divide_edge(segment, distance_divisor, random_numbers) |
257 |
{ |
|
14124 | 258 |
self.islands[is].split_edge(i, new_point); |
14069 | 259 |
i += 2; |
260 |
} else { |
|
261 |
i += 1; |
|
262 |
} |
|
263 |
} |
|
264 |
} |
|
265 |
} |
|
266 |
||
14140 | 267 |
pub fn bezierize(&mut self, segments_number: u32) { |
268 |
for island in &mut self.islands { |
|
269 |
island.bezierize(segments_number); |
|
270 |
} |
|
271 |
} |
|
14069 | 272 |
|
14100 | 273 |
pub fn distort<I: Iterator<Item = u32>>( |
274 |
&mut self, |
|
275 |
distance_divisor: u32, |
|
276 |
random_numbers: &mut I, |
|
277 |
) { |
|
14069 | 278 |
loop { |
279 |
let old_len = self.total_len(); |
|
14100 | 280 |
self.divide_edges(distance_divisor, random_numbers); |
14069 | 281 |
|
14093 | 282 |
if self.total_len() == old_len { |
14069 | 283 |
break; |
284 |
} |
|
285 |
} |
|
286 |
} |
|
287 |
||
288 |
pub fn draw<T: Copy + PartialEq>(&self, land: &mut Land2D<T>, value: T) { |
|
14076
e5904ead4864
Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents:
14069
diff
changeset
|
289 |
for segment in self.segments_iter() { |
e5904ead4864
Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents:
14069
diff
changeset
|
290 |
land.draw_line(segment, value); |
e5904ead4864
Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents:
14069
diff
changeset
|
291 |
} |
e5904ead4864
Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents:
14069
diff
changeset
|
292 |
} |
e5904ead4864
Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents:
14069
diff
changeset
|
293 |
|
14124 | 294 |
fn segments_iter<'a>(&'a self) -> impl Iterator<Item = Line> + 'a { |
295 |
self.islands.iter().flat_map(|p| p.iter_edges()) |
|
14069 | 296 |
} |
14095 | 297 |
|
298 |
pub fn mirror(&mut self) { |
|
14100 | 299 |
let r = self.size.width as i32 - 1; |
14134
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
300 |
|
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
301 |
self.iter_mut().for_each(|p| p.x = r - p.x); |
14095 | 302 |
} |
303 |
||
304 |
pub fn flip(&mut self) { |
|
14100 | 305 |
let t = self.size.height as i32 - 1; |
14134
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
306 |
|
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
307 |
self.iter_mut().for_each(|p| p.y = t - p.y); |
14095 | 308 |
} |
14069 | 309 |
} |
14076
e5904ead4864
Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents:
14069
diff
changeset
|
310 |
|
14078 | 311 |
#[test()] |
312 |
fn points_test() { |
|
14135
7f5a591e1c43
separate rectangle types based on right/bottom edge inclusivity
alfadur
parents:
14134
diff
changeset
|
313 |
let size = Size::square(100); |
14078 | 314 |
let mut points = OutlinePoints { |
315 |
islands: vec![ |
|
14124 | 316 |
Polygon::new(&[Point::new(0, 0), Point::new(20, 0), Point::new(30, 30)]), |
317 |
Polygon::new(&[Point::new(10, 15), Point::new(15, 20), Point::new(20, 15)]), |
|
14078 | 318 |
], |
319 |
fill_points: vec![Point::new(1, 1)], |
|
14137
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
320 |
play_box: Rect::at_origin(size).with_margin(10), |
14078 | 321 |
size: Size::square(100), |
14137
3119d665d3c6
collapse rectangle types back together with consistent usage of size
alfadur
parents:
14135
diff
changeset
|
322 |
intersections_box: Rect::at_origin(size), |
14078 | 323 |
}; |
324 |
||
325 |
let segments: Vec<Line> = points.segments_iter().collect(); |
|
326 |
assert_eq!( |
|
327 |
segments.first(), |
|
328 |
Some(&Line::new(Point::new(0, 0), Point::new(20, 0))) |
|
329 |
); |
|
330 |
assert_eq!( |
|
331 |
segments.last(), |
|
332 |
Some(&Line::new(Point::new(20, 15), Point::new(10, 15))) |
|
333 |
); |
|
334 |
||
14134
09f62bb046ef
actually there is a way to preserve mutable polygon iterator
alfadur
parents:
14133
diff
changeset
|
335 |
points.iter_mut().for_each(|p| p.x = 2); |
14125 | 336 |
|
14078 | 337 |
assert_eq!(points.fill_points[0].x, 2); |
14124 | 338 |
assert_eq!(points.islands[0].get_edge(0).start.x, 2); |
14078 | 339 |
} |