hedgewars-draft: rust/integral-geometry/src/lib.rs@7f5a591e1c43 (annotated)

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

author	alfadur
	Mon, 05 Nov 2018 22:43:58 +0300
changeset 14156	7f5a591e1c43
parent 14155	09f62bb046ef
child 14158	3119d665d3c6
permissions	-rw-r--r--