From 8ba6d56512c6759cc8a7ce429ca503f0964218f4 Mon Sep 17 00:00:00 2001 From: Don Garrett Date: Mon, 25 Aug 2025 21:30:22 -0500 Subject: [PATCH] Tweak code to be more idiomatic. --- src/args.rs | 12 +++++------- src/layers.rs | 12 +++++++++--- src/mushroom.rs | 4 ++-- src/render.rs | 32 ++++++++++++++++---------------- src/server.rs | 12 ++++++------ src/translate.rs | 20 ++++++++++---------- 6 files changed, 48 insertions(+), 44 deletions(-) diff --git a/src/args.rs b/src/args.rs index b05c014..4fb6314 100644 --- a/src/args.rs +++ b/src/args.rs @@ -8,8 +8,8 @@ pub struct Args { #[arg(long, default_value = "mesh.stl")] pub output: String, - /// Shape of the cap. - #[arg(long, default_value_t = false)] + /// Run web server. + #[arg(long, default_value_t = true)] pub run_server: bool, /// Height of total mushroom in millimeters. @@ -42,12 +42,10 @@ impl Args { // Default values are all based on height. let stalk_h: f32 = if self.stalk_h != 0 { self.stalk_h as f32 + } else if self.cap_h != 0 { + (self.height - self.cap_h) as f32 } else { - if self.cap_h != 0 { - (self.height - self.cap_h) as f32 - } else { - self.height as f32 * 0.66 - } + self.height as f32 * 0.66 }; let stalk_r: f32 = if self.stalk_d != 0 { self.stalk_d as f32 diff --git a/src/layers.rs b/src/layers.rs index 3725972..e7aaf1c 100644 --- a/src/layers.rs +++ b/src/layers.rs @@ -9,12 +9,18 @@ pub struct Layer { pub radius: f32, } +impl Default for Layer { + fn default() -> Self { + Self::new() + } +} + impl Layer { pub fn new() -> Self { - return Self { + Self { center: Vertex::new([1.0, 0.0, 0.0]), radius: 0.0, - }; + } } } @@ -31,6 +37,6 @@ impl Layers { for layer in &self.layers { max_radius = max_radius.max(layer.radius); } - return max_radius; + max_radius } } diff --git a/src/mushroom.rs b/src/mushroom.rs index e2a34a9..da52192 100644 --- a/src/mushroom.rs +++ b/src/mushroom.rs @@ -34,11 +34,11 @@ pub struct Mushroom { impl Mushroom { /// Total height of the mushroom. pub fn height(&self) -> f32 { - return self.stalk_h + self.cap_h; + self.stalk_h + self.cap_h } /// Maximum radius of the mushroom. pub fn radius(&self) -> f32 { - return self.stalk_r.max(self.cap_r) / 2.0; + self.stalk_r.max(self.cap_r) / 2.0 } } diff --git a/src/render.rs b/src/render.rs index b4f4045..586e17d 100644 --- a/src/render.rs +++ b/src/render.rs @@ -19,7 +19,7 @@ fn new_triangle(p1: &Vertex, p2: &Vertex, p3: &Vertex) -> stl_io::Triangle { stl_io::Triangle { normal: Normal::new([n_x, n_y, n_z]), - vertices: [p1.clone(), p2.clone(), p3.clone()], + vertices: [*p1, *p2, *p3], } } @@ -28,7 +28,7 @@ fn radian_steps(steps: u32) -> Vec { let counter = 0..steps; let stepsize = std::f64::consts::TAU / steps as f64; - return counter.map(|i| (i as f64 * stepsize) as f32).collect(); + counter.map(|i| (i as f64 * stepsize) as f32).collect() } /// Find a point on the cirle at a given angle (in radians). @@ -37,27 +37,27 @@ fn vertex_on_circle(center: &Vertex, radius: f32, angle: f32) -> Vertex { let y = center[1] + (radius * angle.sin()); let z = center[2]; - return Vertex::new([x, y, z]); + Vertex::new([x, y, z]) } fn vertexes_on_circle(layer: &Layer, steps: u32) -> Vec { - return radian_steps(steps) + radian_steps(steps) .iter() .map(|angle| vertex_on_circle(&layer.center, layer.radius, *angle)) - .collect(); + .collect() } -fn tube_base(center: &Vertex, edge: &Vec) -> Vec { +fn tube_base(center: &Vertex, edge: &[Vertex]) -> Vec { let mut result = Vec::with_capacity(edge.len()); for i in 0..edge.len() { - result.push(new_triangle(¢er, &edge[(i + 1) % edge.len()], &edge[i])); + result.push(new_triangle(center, &edge[(i + 1) % edge.len()], &edge[i])); } - return result; + result } -fn tube_sides(botoom_edge: &Vec, top_edge: &Vec) -> Vec { +fn tube_sides(botoom_edge: &[Vertex], top_edge: &[Vertex]) -> Vec { assert_eq!(botoom_edge.len(), top_edge.len()); let mut result = Vec::with_capacity(2 * botoom_edge.len()); @@ -69,15 +69,15 @@ fn tube_sides(botoom_edge: &Vec, top_edge: &Vec) -> Vec) -> Vec { +fn tube_top(center: &Vertex, edge: &[Vertex]) -> Vec { // The top is the same, except the normals are reversed. We can do that by reversing the order of the vertexes. - let mut edge = edge.clone(); + let mut edge = edge.to_owned(); edge.reverse(); - return tube_base(¢er, &edge); + tube_base(center, &edge) } pub fn render(layers: &Layers, resolution: f32) -> Vec { @@ -91,7 +91,7 @@ pub fn render(layers: &Layers, resolution: f32) -> Vec { let mut layer_vertexes: Vec> = Vec::new(); for layer in &layers.layers { - layer_vertexes.push(vertexes_on_circle(&layer, circle_steps)); + layer_vertexes.push(vertexes_on_circle(layer, circle_steps)); } let mut result: Vec = Vec::new(); @@ -100,9 +100,9 @@ pub fn render(layers: &Layers, resolution: f32) -> Vec { for i in 0..layer_vertexes.len() - 1 { result.append(&mut tube_sides(&layer_vertexes[i], &layer_vertexes[i + 1])); } - result.append(&mut tube_top(&layers.top, &layer_vertexes.last().unwrap())); + result.append(&mut tube_top(&layers.top, layer_vertexes.last().unwrap())); - return result; + result } #[cfg(test)] diff --git a/src/server.rs b/src/server.rs index 566e4b8..067fc63 100644 --- a/src/server.rs +++ b/src/server.rs @@ -37,7 +37,7 @@ fn generate_binary_stl(mushroom: mushroom::Mushroom) -> Vec { // Generate / return the byte array. let mut binary_stl = Vec::::new(); stl_io::write_stl(&mut binary_stl, mesh.iter()).unwrap(); - return binary_stl; + binary_stl } /// Responder class for BinarySTL or Error. @@ -56,13 +56,13 @@ enum AsyncBinaryStlResponder { async fn generate_helper(mushroom: mushroom::Mushroom) -> AsyncBinaryStlResponder { let result = rocket::tokio::task::spawn_blocking(move || { // Return the byte array. - return generate_binary_stl(mushroom); + generate_binary_stl(mushroom) }) .await; - return if result.is_ok() { + if let Ok(inner) = result { AsyncBinaryStlResponder::BinaryStl { - inner: result.unwrap(), + inner, header: ContentType::parse_flexible("model/x.stl-binary").unwrap(), filename: Header { name: "Content-Disposition".into(), @@ -71,7 +71,7 @@ async fn generate_helper(mushroom: mushroom::Mushroom) -> AsyncBinaryStlResponde } } else { AsyncBinaryStlResponder::Error("Internal JoinError") - }; + } } /// Handler for /generate GEt endpoint. @@ -91,5 +91,5 @@ async fn generate( cap_style: cap_style.unwrap_or(mushroom::CapStyle::Dome), }; - return generate_helper(mushroom).await; + generate_helper(mushroom).await } diff --git a/src/translate.rs b/src/translate.rs index a8c1589..e2690bb 100644 --- a/src/translate.rs +++ b/src/translate.rs @@ -6,9 +6,9 @@ use crate::mushroom::{CapStyle, Mushroom}; fn stalk_layers(mushroom: &Mushroom, base: &Vertex, _resolution: f32) -> Vec { let stalk_top = Vertex::new([base[0], base[1], base[2] + mushroom.stalk_h]); - return [ + [ layers::Layer { - center: base.clone(), + center: *base, radius: mushroom.stalk_r, }, layers::Layer { @@ -16,15 +16,15 @@ fn stalk_layers(mushroom: &Mushroom, base: &Vertex, _resolution: f32) -> Vec Vec { let top = Vertex::new([base[0], base[1], base[2] + mushroom.cap_h]); - return [ + [ layers::Layer { - center: base.clone(), + center: *base, radius: mushroom.cap_r, }, layers::Layer { @@ -32,7 +32,7 @@ fn cap_layers_cylinder(mushroom: &Mushroom, base: &Vertex) -> Vec radius: mushroom.cap_r, }, ] - .to_vec(); + .to_vec() } fn cap_layers_dome(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Vec { @@ -47,7 +47,7 @@ fn cap_layers_dome(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Vec Vec Vec { @@ -112,7 +112,7 @@ fn cap_layers_pointed(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Ve // TODO: // Investigate using spline to generate a pointed style cap. - return cap_layers_dome(mushroom, base, resolution); + cap_layers_dome(mushroom, base, resolution) } fn cap_layers(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Vec { @@ -144,5 +144,5 @@ pub fn mushroom(mushroom: &Mushroom, resolution: f32) -> layers::Layers { let mut layers: Vec = Vec::new(); layers.append(&mut stalk_layers); layers.append(&mut cap_layers); - return layers::Layers { base, top, layers }; + layers::Layers { base, top, layers } }