hedgewars: rust/integral-geometry/src/lib.rs@09f62bb046ef (annotated)

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

author	alfadur
	Mon, 05 Nov 2018 21:21:53 +0300
changeset 14134	09f62bb046ef
parent 14133	a65b60f36b96
child 14135	7f5a591e1c43
permissions	-rw-r--r--