From 142b8c02e6c5c99de2f1ef6abce2648590565b7f Mon Sep 17 00:00:00 2001 From: Arne Keller Date: Fri, 29 Mar 2019 17:35:03 +0100 Subject: [PATCH] Format using tabs --- rustfmt.toml | 1 + src/main.rs | 748 +++++++++++++++++++++++++-------------------------- 2 files changed, 375 insertions(+), 374 deletions(-) create mode 100644 rustfmt.toml diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 0000000..218e203 --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1 @@ +hard_tabs = true diff --git a/src/main.rs b/src/main.rs index 4770790..71f15bb 100644 --- a/src/main.rs +++ b/src/main.rs @@ -11,416 +11,416 @@ mod input; #[derive(Debug, Clone)] struct World { - /// Dreiecksgrundstücke - tris: Vec<(usize, Triangle)>, - /// Gesamtabstand - width: f32, + /// Dreiecksgrundstücke + tris: Vec<(usize, Triangle)>, + /// Gesamtabstand + width: f32, } impl cmp::PartialEq for World { - fn eq(&self, _other: &Self) -> bool { - unimplemented!() - } + fn eq(&self, _other: &Self) -> bool { + unimplemented!() + } } impl cmp::Eq for World {} impl cmp::Ord for World { - fn cmp(&self, other: &Self) -> cmp::Ordering { - self.width.partial_cmp(&other.width).unwrap().reverse() - } + fn cmp(&self, other: &Self) -> cmp::Ordering { + self.width.partial_cmp(&other.width).unwrap().reverse() + } } impl cmp::PartialOrd for World { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } } fn main() { - let tris = input::read_input(); - let count_tris = tris.len(); - let tris = transformations(&tris); + let tris = input::read_input(); + let count_tris = tris.len(); + let tris = transformations(&tris); - let save_prefix = "tri_"; - let mut save_counter = 0; - let mut normalized_tris = Vec::with_capacity(tris.len() * 2); - let mut left_tris = Vec::with_capacity(tris.len()); - for (mut idx, t) in tris.into_iter().enumerate() { - idx /= 6; - let prev_angle = angle_of(t, t.1); - let mut added = false; - let rotated = rotate(t, 0.5 * PI - prev_angle); - if rotated.1.y >= -0.001 - && rotated.2.y >= -0.001 - && (rotated.1.y < 0.1 || rotated.2.y < 0.1) - { - normalized_tris.push((idx, rotated)); - if rotated.1.x > -0.001 && rotated.2.x > -0.001 { - left_tris.push((idx, rotated)); - } - added = true; - } - let rotated = rotate(rotated, PI); - if !added - && rotated.1.y >= -0.001 - && rotated.2.y >= -0.001 - && (rotated.1.y < 0.1 || rotated.2.y < 0.1) - { - normalized_tris.push((idx, rotated)); - if rotated.1.x > -0.001 && rotated.2.x > -0.001 { - left_tris.push((idx, rotated)); - } - added = true; - } - let rotated = rotate(t, -0.5 * PI + prev_angle); - if !added - && rotated.1.y >= -0.001 - && rotated.2.y >= -0.001 - && (rotated.1.y < 0.1 || rotated.2.y < 0.1) - { - normalized_tris.push((idx, rotated)); - if rotated.1.x > -0.001 && rotated.2.x > -0.001 { - left_tris.push((idx, rotated)); - } - added = true; - } - let rotated = rotate(rotated, PI); - if !added - && rotated.1.y >= -0.001 - && rotated.2.y >= -0.001 - && (rotated.1.y < 0.1 || rotated.2.y < 0.1) - { - normalized_tris.push((idx, rotated)); - if rotated.1.x > -0.001 && rotated.2.x > -0.001 { - left_tris.push((idx, rotated)); - } - } - let prev_angle = angle_of(t, t.2); - added = false; - let rotated = rotate(t, 0.5 * PI - prev_angle); - if rotated.1.y >= -0.001 - && rotated.2.y >= -0.001 - && (rotated.1.y < 0.1 || rotated.2.y < 0.1) - { - normalized_tris.push((idx, rotated)); - if rotated.1.x > -0.001 && rotated.2.x > -0.001 { - left_tris.push((idx, rotated)); - } - added = true; - } - let rotated = rotate(rotated, PI); - if !added - && rotated.1.y >= -0.001 - && rotated.2.y >= -0.001 - && (rotated.1.y < 0.1 || rotated.2.y < 0.1) - { - normalized_tris.push((idx, rotated)); - if rotated.1.x > -0.001 && rotated.2.x > -0.001 { - left_tris.push((idx, rotated)); - } - added = true; - } - let rotated = rotate(t, -0.5 * PI + prev_angle); - if !added - && rotated.1.y >= -0.001 - && rotated.2.y >= -0.001 - && (rotated.1.y < 0.1 || rotated.2.y < 0.1) - { - normalized_tris.push((idx, rotated)); - if rotated.1.x > -0.001 && rotated.2.x > -0.001 { - left_tris.push((idx, rotated)); - } - added = true; - } - let rotated = rotate(rotated, PI); - if !added - && rotated.1.y >= -0.001 - && rotated.2.y >= -0.001 - && (rotated.1.y < 0.1 || rotated.2.y < 0.1) - { - normalized_tris.push((idx, rotated)); - if rotated.1.x > -0.001 && rotated.2.x > -0.001 { - left_tris.push((idx, rotated)); - } - } - } - for (_idx, t) in &normalized_tris { - display::save_tri(&format!("{}{}.svg", save_prefix, save_counter), *t); - save_counter += 1; - } - let save_prefix = "start_"; - save_counter = 0; - let mut worlds = BinaryHeap::new(); - //let left_tris = vec![left_tris[1], left_tris[11], left_tris[17], left_tris[22], left_tris[28]]; - for t in &left_tris { - let mut world = World { - tris: vec![*t], - width: 0.0, - }; - world.normalize(); - display::save_world(&format!("{}{}.svg", save_prefix, save_counter), &world); - save_counter += 1; - worlds.push(world); - } + let save_prefix = "tri_"; + let mut save_counter = 0; + let mut normalized_tris = Vec::with_capacity(tris.len() * 2); + let mut left_tris = Vec::with_capacity(tris.len()); + for (mut idx, t) in tris.into_iter().enumerate() { + idx /= 6; + let prev_angle = angle_of(t, t.1); + let mut added = false; + let rotated = rotate(t, 0.5 * PI - prev_angle); + if rotated.1.y >= -0.001 + && rotated.2.y >= -0.001 + && (rotated.1.y < 0.1 || rotated.2.y < 0.1) + { + normalized_tris.push((idx, rotated)); + if rotated.1.x > -0.001 && rotated.2.x > -0.001 { + left_tris.push((idx, rotated)); + } + added = true; + } + let rotated = rotate(rotated, PI); + if !added + && rotated.1.y >= -0.001 + && rotated.2.y >= -0.001 + && (rotated.1.y < 0.1 || rotated.2.y < 0.1) + { + normalized_tris.push((idx, rotated)); + if rotated.1.x > -0.001 && rotated.2.x > -0.001 { + left_tris.push((idx, rotated)); + } + added = true; + } + let rotated = rotate(t, -0.5 * PI + prev_angle); + if !added + && rotated.1.y >= -0.001 + && rotated.2.y >= -0.001 + && (rotated.1.y < 0.1 || rotated.2.y < 0.1) + { + normalized_tris.push((idx, rotated)); + if rotated.1.x > -0.001 && rotated.2.x > -0.001 { + left_tris.push((idx, rotated)); + } + added = true; + } + let rotated = rotate(rotated, PI); + if !added + && rotated.1.y >= -0.001 + && rotated.2.y >= -0.001 + && (rotated.1.y < 0.1 || rotated.2.y < 0.1) + { + normalized_tris.push((idx, rotated)); + if rotated.1.x > -0.001 && rotated.2.x > -0.001 { + left_tris.push((idx, rotated)); + } + } + let prev_angle = angle_of(t, t.2); + added = false; + let rotated = rotate(t, 0.5 * PI - prev_angle); + if rotated.1.y >= -0.001 + && rotated.2.y >= -0.001 + && (rotated.1.y < 0.1 || rotated.2.y < 0.1) + { + normalized_tris.push((idx, rotated)); + if rotated.1.x > -0.001 && rotated.2.x > -0.001 { + left_tris.push((idx, rotated)); + } + added = true; + } + let rotated = rotate(rotated, PI); + if !added + && rotated.1.y >= -0.001 + && rotated.2.y >= -0.001 + && (rotated.1.y < 0.1 || rotated.2.y < 0.1) + { + normalized_tris.push((idx, rotated)); + if rotated.1.x > -0.001 && rotated.2.x > -0.001 { + left_tris.push((idx, rotated)); + } + added = true; + } + let rotated = rotate(t, -0.5 * PI + prev_angle); + if !added + && rotated.1.y >= -0.001 + && rotated.2.y >= -0.001 + && (rotated.1.y < 0.1 || rotated.2.y < 0.1) + { + normalized_tris.push((idx, rotated)); + if rotated.1.x > -0.001 && rotated.2.x > -0.001 { + left_tris.push((idx, rotated)); + } + added = true; + } + let rotated = rotate(rotated, PI); + if !added + && rotated.1.y >= -0.001 + && rotated.2.y >= -0.001 + && (rotated.1.y < 0.1 || rotated.2.y < 0.1) + { + normalized_tris.push((idx, rotated)); + if rotated.1.x > -0.001 && rotated.2.x > -0.001 { + left_tris.push((idx, rotated)); + } + } + } + for (_idx, t) in &normalized_tris { + display::save_tri(&format!("{}{}.svg", save_prefix, save_counter), *t); + save_counter += 1; + } + let save_prefix = "start_"; + save_counter = 0; + let mut worlds = BinaryHeap::new(); + //let left_tris = vec![left_tris[1], left_tris[11], left_tris[17], left_tris[22], left_tris[28]]; + for t in &left_tris { + let mut world = World { + tris: vec![*t], + width: 0.0, + }; + world.normalize(); + display::save_world(&format!("{}{}.svg", save_prefix, save_counter), &world); + save_counter += 1; + worlds.push(world); + } - let mut best = World { - tris: vec![], - width: f32::MAX, - }; - let save_prefix = "world_"; - save_counter = 0; - let mut counter = 0; - let mut bins = Vec::new(); - bins.push(worlds); - let mut progress = true; - while progress { - progress = false; - for bin_idx in 0..bins.len() { - counter += 1; - if counter % 10000 == 0 { - println!("{}/∞", counter); - } - if bins[bin_idx].is_empty() { - continue; - } - let w = bins[bin_idx].pop().unwrap(); - //println!("working"); - if w.width >= best.width { - continue; - } - //println!("s: {:?}", w); + let mut best = World { + tris: vec![], + width: f32::MAX, + }; + let save_prefix = "world_"; + save_counter = 0; + let mut counter = 0; + let mut bins = Vec::new(); + bins.push(worlds); + let mut progress = true; + while progress { + progress = false; + for bin_idx in 0..bins.len() { + counter += 1; + if counter % 10000 == 0 { + println!("{}/∞", counter); + } + if bins[bin_idx].is_empty() { + continue; + } + let w = bins[bin_idx].pop().unwrap(); + //println!("working"); + if w.width >= best.width { + continue; + } + //println!("s: {:?}", w); - /* - if save_counter < 1000000 { - display::save_world(&format!("{}a_{}.svg", save_prefix, save_counter), &w); - } - */ - let save_iterations = false; + /* + if save_counter < 1000000 { + display::save_world(&format!("{}a_{}.svg", save_prefix, save_counter), &w); + } + */ + let save_iterations = false; - let mut new = vec![]; - for (next_idx, next_tri) in left_tris - .iter() - .filter(|(idx1, _tri)| w.tris.iter().all(|(idx2, _tri)| idx1 != idx2)) - { - //println!("trying {:?}", next_idx); - let (last_idx, last_tri) = *w.tris.last().unwrap(); + let mut new = vec![]; + for (next_idx, next_tri) in left_tris + .iter() + .filter(|(idx1, _tri)| w.tris.iter().all(|(idx2, _tri)| idx1 != idx2)) + { + //println!("trying {:?}", next_idx); + let (last_idx, last_tri) = *w.tris.last().unwrap(); - let vertex1 = last_tri.1; - let vertex2 = last_tri.2; + let vertex1 = last_tri.1; + let vertex2 = last_tri.2; - let free_angle = if vertex1.y > 0.001 && vertex2.y < 0.001 { - PI - (vertex1.y / (vertex2.x - vertex1.x).abs()).atan() - } else if vertex2.y > 0.001 && vertex1.y < 0.001 { - PI - (vertex2.y / (vertex2.x - vertex1.x).abs()).atan() - } else { - let angle1 = - 0.5 * PI - vertex1.x.signum() * (vertex1.x.abs() / vertex1.y).atan(); - let angle2 = - 0.5 * PI - vertex2.x.signum() * (vertex2.x.abs() / vertex2.y).atan(); - min(angle1, angle2) - }; + let free_angle = if vertex1.y > 0.001 && vertex2.y < 0.001 { + PI - (vertex1.y / (vertex2.x - vertex1.x).abs()).atan() + } else if vertex2.y > 0.001 && vertex1.y < 0.001 { + PI - (vertex2.y / (vertex2.x - vertex1.x).abs()).atan() + } else { + let angle1 = + 0.5 * PI - vertex1.x.signum() * (vertex1.x.abs() / vertex1.y).atan(); + let angle2 = + 0.5 * PI - vertex2.x.signum() * (vertex2.x.abs() / vertex2.y).atan(); + min(angle1, angle2) + }; - let vertex1 = next_tri.1; - let vertex2 = next_tri.2; + let vertex1 = next_tri.1; + let vertex2 = next_tri.2; - let next_angle = if vertex1.y > 0.001 && vertex2.y > 0.001 { - let angle1 = - 0.5 * PI + vertex1.x.signum() * (vertex1.x.abs() / vertex1.y).atan(); - let angle2 = - 0.5 * PI + vertex2.x.signum() * (vertex2.x.abs() / vertex2.y).atan(); - min(angle1, angle2) - } else if vertex1.y < 0.001 { - 0.5 * PI + vertex2.x.signum() * (vertex2.x.abs() / vertex2.y).atan() - } else { - 0.5 * PI + vertex1.x.signum() * (vertex1.x.abs() / vertex1.y).atan() - }; - //println!("{:?} -> {:?}: {:?} {:?}", last_idx, next_idx, free_angle.to_degrees(), next_angle.to_degrees()); - let target = (next_angle - PI + free_angle).to_degrees(); - let step = 40.0; - let as_f32 = |x| x as f32 * step; - let range = if target >= 0.0 { - (0..=((target - 0.0001) / step) as usize) - .map(as_f32) - .chain(Some(target)) - } else { - (0..=((next_angle - 0.0001) / step) as usize) - .map(as_f32) - .chain(None) - }; + let next_angle = if vertex1.y > 0.001 && vertex2.y > 0.001 { + let angle1 = + 0.5 * PI + vertex1.x.signum() * (vertex1.x.abs() / vertex1.y).atan(); + let angle2 = + 0.5 * PI + vertex2.x.signum() * (vertex2.x.abs() / vertex2.y).atan(); + min(angle1, angle2) + } else if vertex1.y < 0.001 { + 0.5 * PI + vertex2.x.signum() * (vertex2.x.abs() / vertex2.y).atan() + } else { + 0.5 * PI + vertex1.x.signum() * (vertex1.x.abs() / vertex1.y).atan() + }; + //println!("{:?} -> {:?}: {:?} {:?}", last_idx, next_idx, free_angle.to_degrees(), next_angle.to_degrees()); + let target = (next_angle - PI + free_angle).to_degrees(); + let step = 40.0; + let as_f32 = |x| x as f32 * step; + let range = if target >= 0.0 { + (0..=((target - 0.0001) / step) as usize) + .map(as_f32) + .chain(Some(target)) + } else { + (0..=((next_angle - 0.0001) / step) as usize) + .map(as_f32) + .chain(None) + }; - for angle in range { - //println!("angle {:?}", angle); - let radians = angle.to_radians(); - let next_angle = next_angle - radians; - let mut tri = rotate(*next_tri, radians); + for angle in range { + //println!("angle {:?}", angle); + let radians = angle.to_radians(); + let next_angle = next_angle - radians; + let mut tri = rotate(*next_tri, radians); - // "binary search"-like optimization here - for &delta in &[ - /*80.0, 30.0, 10.0, 5.0,*/ 1.0, 0.6, 0.32, 0.18, 0.1, 0.06, 0.03, - 0.01, 0.003, - ] { - let initial_state = last_tri.intersects(&tri); - let dx = if initial_state { delta } else { -delta }; - while last_tri.intersects(&tri) == initial_state { - tri.0.x += dx; - tri.1.x += dx; - tri.2.x += dx; - } - } - let mut w = w.clone(); - w.tris.push((*next_idx, tri)); - w.normalize(); - w.calc_width(); - if save_iterations { - display::save_world(&format!("{}b_{}.svg", save_prefix, save_counter), &w); - } - if w.tris.len() == count_tris { - if w.width < best.width { - println!("[{}] new best: {}", save_counter, w.width); - //println!("{:?}", w.tris); - display::save_world( - &format!("{}best_{}.svg", save_prefix, save_counter), - &w, - ); - best = w; - } - } else if w.width < best.width { - w.width -= (2.0 * PI - free_angle - next_angle) * 0.01; - //if (angle > 50 && angle < 55) || (angle > 88 && angle < 92) { - //println!("{:?} -> {:?}", angle, w.width); - //} - new.push(w); - } - save_counter += 1; - } - } - progress = true; - if bin_idx + 1 == bins.len() { - let mut new_bin = BinaryHeap::new(); - new_bin.extend(new); - bins.push(new_bin); - } else { - bins[bin_idx + 1].extend(new); - } - } - } - println!("best width = {:?}", best.width); - display::save_world("world_best.svg", &best); + // "binary search"-like optimization here + for &delta in &[ + /*80.0, 30.0, 10.0, 5.0,*/ 1.0, 0.6, 0.32, 0.18, 0.1, 0.06, 0.03, + 0.01, 0.003, + ] { + let initial_state = last_tri.intersects(&tri); + let dx = if initial_state { delta } else { -delta }; + while last_tri.intersects(&tri) == initial_state { + tri.0.x += dx; + tri.1.x += dx; + tri.2.x += dx; + } + } + let mut w = w.clone(); + w.tris.push((*next_idx, tri)); + w.normalize(); + w.calc_width(); + if save_iterations { + display::save_world(&format!("{}b_{}.svg", save_prefix, save_counter), &w); + } + if w.tris.len() == count_tris { + if w.width < best.width { + println!("[{}] new best: {}", save_counter, w.width); + //println!("{:?}", w.tris); + display::save_world( + &format!("{}best_{}.svg", save_prefix, save_counter), + &w, + ); + best = w; + } + } else if w.width < best.width { + w.width -= (2.0 * PI - free_angle - next_angle) * 0.01; + //if (angle > 50 && angle < 55) || (angle > 88 && angle < 92) { + //println!("{:?} -> {:?}", angle, w.width); + //} + new.push(w); + } + save_counter += 1; + } + } + progress = true; + if bin_idx + 1 == bins.len() { + let mut new_bin = BinaryHeap::new(); + new_bin.extend(new); + bins.push(new_bin); + } else { + bins[bin_idx + 1].extend(new); + } + } + } + println!("best width = {:?}", best.width); + display::save_world("world_best.svg", &best); } impl World { - fn normalize(&mut self) { - let mut maxx = 0.0; - for (_, tri) in &self.tris { - if tri.0.x > maxx && tri.0.y < 0.01 && tri.0.y > -0.01 { - maxx = tri.0.x; - } - if tri.1.x > maxx && tri.1.y < 0.01 && tri.1.y > -0.01 { - maxx = tri.1.x; - } - if tri.2.x > maxx && tri.2.y < 0.01 && tri.2.y > -0.01 { - maxx = tri.2.x; - } - } - if maxx != 0.0 { - self.move_left(maxx); - } - } - fn move_left(&mut self, amount: f32) { - for (_, tri) in &mut self.tris { - tri.0.x -= amount; - tri.1.x -= amount; - tri.2.x -= amount; - } - } - fn calc_width(&mut self) { - let mut minx = f32::MIN; - if (self.tris[0].1).0.y > -0.001 && (self.tris[0].1).0.y < 0.001 { - minx = max((self.tris[0].1).0.x, minx); - } - if (self.tris[0].1).1.y > -0.001 && (self.tris[0].1).1.y < 0.001 { - minx = max((self.tris[0].1).1.x, minx); - } - if (self.tris[0].1).2.y > -0.001 && (self.tris[0].1).2.y < 0.001 { - minx = max((self.tris[0].1).2.x, minx); - } - let mut maxx = f32::MAX; - if (self.tris[self.tris.len() - 1].1).0.y > -0.001 - && (self.tris[self.tris.len() - 1].1).0.y < 0.001 - { - maxx = min((self.tris[self.tris.len() - 1].1).0.x, maxx); - } - if (self.tris[self.tris.len() - 1].1).1.y > -0.001 - && (self.tris[self.tris.len() - 1].1).1.y < 0.001 - { - maxx = min((self.tris[self.tris.len() - 1].1).1.x, maxx); - } - if (self.tris[self.tris.len() - 1].1).2.y > -0.001 - && (self.tris[self.tris.len() - 1].1).2.y < 0.001 - { - maxx = min((self.tris[self.tris.len() - 1].1).2.x, maxx); - } - self.width = maxx - minx; - } + fn normalize(&mut self) { + let mut maxx = 0.0; + for (_, tri) in &self.tris { + if tri.0.x > maxx && tri.0.y < 0.01 && tri.0.y > -0.01 { + maxx = tri.0.x; + } + if tri.1.x > maxx && tri.1.y < 0.01 && tri.1.y > -0.01 { + maxx = tri.1.x; + } + if tri.2.x > maxx && tri.2.y < 0.01 && tri.2.y > -0.01 { + maxx = tri.2.x; + } + } + if maxx != 0.0 { + self.move_left(maxx); + } + } + fn move_left(&mut self, amount: f32) { + for (_, tri) in &mut self.tris { + tri.0.x -= amount; + tri.1.x -= amount; + tri.2.x -= amount; + } + } + fn calc_width(&mut self) { + let mut minx = f32::MIN; + if (self.tris[0].1).0.y > -0.001 && (self.tris[0].1).0.y < 0.001 { + minx = max((self.tris[0].1).0.x, minx); + } + if (self.tris[0].1).1.y > -0.001 && (self.tris[0].1).1.y < 0.001 { + minx = max((self.tris[0].1).1.x, minx); + } + if (self.tris[0].1).2.y > -0.001 && (self.tris[0].1).2.y < 0.001 { + minx = max((self.tris[0].1).2.x, minx); + } + let mut maxx = f32::MAX; + if (self.tris[self.tris.len() - 1].1).0.y > -0.001 + && (self.tris[self.tris.len() - 1].1).0.y < 0.001 + { + maxx = min((self.tris[self.tris.len() - 1].1).0.x, maxx); + } + if (self.tris[self.tris.len() - 1].1).1.y > -0.001 + && (self.tris[self.tris.len() - 1].1).1.y < 0.001 + { + maxx = min((self.tris[self.tris.len() - 1].1).1.x, maxx); + } + if (self.tris[self.tris.len() - 1].1).2.y > -0.001 + && (self.tris[self.tris.len() - 1].1).2.y < 0.001 + { + maxx = min((self.tris[self.tris.len() - 1].1).2.x, maxx); + } + self.width = maxx - minx; + } } fn rotate(mut tri: Triangle, angle: f32) -> Triangle { - let x1 = tri.1.x; - let y1 = tri.1.y; - tri.1.x = x1 * angle.cos() - y1 * angle.sin(); - tri.1.y = x1 * angle.sin() + y1 * angle.cos(); - let x2 = tri.2.x; - let y2 = tri.2.y; - tri.2.x = x2 * angle.cos() - y2 * angle.sin(); - tri.2.y = x2 * angle.sin() + y2 * angle.cos(); - tri + let x1 = tri.1.x; + let y1 = tri.1.y; + tri.1.x = x1 * angle.cos() - y1 * angle.sin(); + tri.1.y = x1 * angle.sin() + y1 * angle.cos(); + let x2 = tri.2.x; + let y2 = tri.2.y; + tri.2.x = x2 * angle.cos() - y2 * angle.sin(); + tri.2.y = x2 * angle.sin() + y2 * angle.cos(); + tri } fn angle_of(_tri: Triangle, point: Coordinate) -> f32 { - let d = (point.x.powi(2) + point.y.powi(2)).sqrt(); - (point.y / d).acos() + let d = (point.x.powi(2) + point.y.powi(2)).sqrt(); + (point.y / d).acos() } fn transformations(tris: &[Triangle]) -> Vec> { - let mut new = Vec::with_capacity(tris.len() * 6); - for t in tris { - let n = Triangle( - (0.0, 0.0).into(), - (t.1.x - t.0.x, t.1.y - t.0.y).into(), - (t.2.x - t.0.x, t.2.y - t.0.y).into(), - ); - new.push(n); - let n = [[-n.0.x, n.0.y], [-n.1.x, n.1.y], [-n.2.x, n.2.y]].into(); - new.push(n); - let n = Triangle( - (0.0, 0.0).into(), - (t.2.x - t.1.x, t.2.y - t.1.y).into(), - (t.0.x - t.1.x, t.0.y - t.1.y).into(), - ); - new.push(n); - let n = [[-n.0.x, n.0.y], [-n.1.x, n.1.y], [-n.2.x, n.2.y]].into(); - new.push(n); - let n = Triangle( - (0.0, 0.0).into(), - (t.0.x - t.2.x, t.0.y - t.2.y).into(), - (t.1.x - t.2.x, t.1.y - t.2.y).into(), - ); - new.push(n); - let n = [[-n.0.x, n.0.y], [-n.1.x, n.1.y], [-n.2.x, n.2.y]].into(); - new.push(n); - } - new + let mut new = Vec::with_capacity(tris.len() * 6); + for t in tris { + let n = Triangle( + (0.0, 0.0).into(), + (t.1.x - t.0.x, t.1.y - t.0.y).into(), + (t.2.x - t.0.x, t.2.y - t.0.y).into(), + ); + new.push(n); + let n = [[-n.0.x, n.0.y], [-n.1.x, n.1.y], [-n.2.x, n.2.y]].into(); + new.push(n); + let n = Triangle( + (0.0, 0.0).into(), + (t.2.x - t.1.x, t.2.y - t.1.y).into(), + (t.0.x - t.1.x, t.0.y - t.1.y).into(), + ); + new.push(n); + let n = [[-n.0.x, n.0.y], [-n.1.x, n.1.y], [-n.2.x, n.2.y]].into(); + new.push(n); + let n = Triangle( + (0.0, 0.0).into(), + (t.0.x - t.2.x, t.0.y - t.2.y).into(), + (t.1.x - t.2.x, t.1.y - t.2.y).into(), + ); + new.push(n); + let n = [[-n.0.x, n.0.y], [-n.1.x, n.1.y], [-n.2.x, n.2.y]].into(); + new.push(n); + } + new } fn min(a: f32, b: f32) -> f32 { - if a < b { - a - } else { - b - } + if a < b { + a + } else { + b + } } fn max(a: f32, b: f32) -> f32 { - if a > b { - a - } else { - b - } + if a > b { + a + } else { + b + } }