Fix clippy lints

Author: TrueDoctor

libraries/path-bool/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "path-bool"
 version = "0.1.0"
-rust-version = "1.79"
+rust-version = "1.81"
 authors = ["Graphite Authors <[email protected]>"]
 edition = "2021"
 keywords = ["bezier", "boolean", "path", "ops", "operations", "2d"]

libraries/path-bool/benches/path_segment_intersection.rs

@@ -3,8 +3,8 @@ use glam::DVec2;
 use path_bool::*;
 
 pub fn criterion_benchmark(crit: &mut Criterion) {
-	crit.bench_function("intersect 1", |bench| bench.iter(|| path_segment_intersection(&a(), &b(), true, &EPS)));
-	crit.bench_function("intersect 2", |bench| bench.iter(|| path_segment_intersection(&c(), &d(), true, &EPS)));
+	crit.bench_function("intersect 1", |bench| bench.iter(|| path_segment_intersection(black_box(&a()), black_box(&b()), true, &EPS)));
+	crit.bench_function("intersect 2", |bench| bench.iter(|| path_segment_intersection(black_box(&c()), black_box(&d()), true, &EPS)));
 }
 
 criterion_group!(benches, criterion_benchmark);

libraries/path-bool/src/intersection_path_segment.rs

@@ -143,9 +143,6 @@ pub fn path_segment_intersection(seg0: &PathSegment, seg1: &PathSegment, endpoin
 				continue; // TODO: what to do?
 			}
 
-			let diff1 = (seg0.start_param - seg0.end_param).abs();
-			let diff2 = (seg1.start_param - seg1.end_param).abs();
-			// dbg!(diff1.min(diff2));
 			let is_linear0 = bounding_box_max_extent(&seg0.bounding_box) <= eps.linear || (seg0.end_param - seg0.start_param).abs() < eps.param;
 			let is_linear1 = bounding_box_max_extent(&seg1.bounding_box) <= eps.linear || (seg1.end_param - seg1.start_param).abs() < eps.param;
 

libraries/path-bool/src/path_boolean.rs

@@ -1,4 +1,3 @@
-use glam::DVec2;
 use slotmap::{new_key_type, SlotMap};
 
 new_key_type! {
@@ -19,12 +18,12 @@ use crate::intersection_path_segment::{path_segment_intersection, segments_equal
 use crate::path::Path;
 use crate::path_cubic_segment_self_intersection::path_cubic_segment_self_intersection;
 use crate::path_segment::{get_end_point, get_start_point, path_segment_bounding_box, reverse_path_segment, sample_path_segment_at, split_segment_at, PathSegment};
+#[cfg(feature = "logging")]
 use crate::path_to_path_data;
 use crate::quad_tree::QuadTree;
 use crate::vector::{vectors_equal, Vector};
 use std::cmp::Ordering;
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::f64::consts::TAU;
 
 #[derive(Debug, Clone, Copy)]
 pub enum PathBooleanOperation {
@@ -65,6 +64,7 @@ pub struct MajorGraphEdge {
 
 #[derive(Debug, Clone, Default)]
 pub struct MajorGraphVertex {
+	#[cfg_attr(not(feature = "logging"), expect(dead_code))]
 	pub point: Vector,
 	outgoing_edges: Vec<MajorEdgeKey>,
 }
@@ -85,25 +85,6 @@ struct MinorGraphEdge {
 }
 
 impl MinorGraphEdge {
-	#[cfg(feature = "logging")]
-	fn format_path(&self) -> String {
-		use std::fmt::Write;
-		let mut output = String::new();
-		let segments = self.segments.clone();
-		for segment in segments.into_iter() {
-			let _ = match segment {
-				PathSegment::Line(mut start, mut end) | PathSegment::Cubic(mut start, _, _, mut end) => {
-					if self.direction_flag.backwards() {
-						(end, start) = (start, end);
-					}
-					write!(&mut output, "{:.1},{:.1}-{:.1},{:.1}  ", start.x, start.y, end.x, end.y)
-				}
-				x => write!(&mut output, "{:?}", x),
-			};
-		}
-		output
-	}
-
 	fn start_segment(&self) -> PathSegment {
 		let segment = self.segments[0];
 		match self.direction_flag {
@@ -199,7 +180,7 @@ fn major_graph_to_dot(graph: &MajorGraph) -> String {
 	for (vertex_key, vertex) in &graph.vertices {
 		dot.push_str(&format!("  {:?} [label=\"{:.1},{:.1}\"]\n", (vertex_key.0.as_ffi() & 0xFF), vertex.point.x, vertex.point.y));
 	}
-	for (edge_key, edge) in &graph.edges {
+	for (_, edge) in &graph.edges {
 		dot.push_str(&format!(
 			"  {:?} -> {:?}: {:0b}\n",
 			(edge.incident_vertices[0].0.as_ffi() & 0xFF),
@@ -393,9 +374,6 @@ impl Direction {
 	pub fn forward(self) -> bool {
 		self == Self::Forward
 	}
-	pub fn backwards(self) -> bool {
-		self == Self::Backwards
-	}
 }
 
 // TODO:(@TrueDoctor) Optimize this by rounding each vertex up and down and then inserting them in a hashmap. This should remove the need for bbox calculations and the quad tree
@@ -667,7 +645,7 @@ fn get_incidence_angle(edge: &MinorGraphEdge) -> f64 {
 }
 
 fn sort_outgoing_edges_by_angle(graph: &mut MinorGraph) {
-	for vertex in graph.vertices.values_mut() {
+	for (vertex_key, vertex) in graph.vertices.iter_mut() {
 		if vertex.outgoing_edges.len() > 2 {
 			vertex.outgoing_edges.sort_by(|&a, &b| {
 				// TODO(@TrueDoctor): Make more robust. The js version seems to sort the data slightly differently when the angles are reallly close. In that case put the edge wich was discovered later first.
@@ -680,14 +658,14 @@ fn sort_outgoing_edges_by_angle(graph: &mut MinorGraph) {
 				}
 				new
 			});
-			let edges: Vec<_> = vertex
-				.outgoing_edges
-				.iter()
-				.map(|key| (*key, &graph.edges[*key]))
-				.map(|(key, edge)| ((key.0.as_ffi() & 0xFF), (edge.start_segment()).start_angle()))
-				.collect();
-			#[cfg(feature = "logging")]
-			dbg!(edges);
+			if cfg!(feature = "logging") {
+				eprintln!("Outgoing edges for {:?}:", vertex_key);
+				for &edge_key in &vertex.outgoing_edges {
+					let edge = &graph.edges[edge_key];
+					let angle = edge.start_segment().start_angle();
+					eprintln!("{:?}: {}°", edge_key.0, angle.to_degrees())
+				}
+			}
 		}
 	}
 }
@@ -926,9 +904,6 @@ fn compute_dual(minor_graph: &MinorGraph) -> Result<DualGraph, BooleanError> {
 		}
 		#[cfg(feature = "logging")]
 		eprintln!("component_vertices: {}", component_vertices.len());
-		for edge in &dual_edges {
-			// eprintln!("{:?}", edge.incident_vertex);
-		}
 
 		let windings: Option<Vec<_>> = component_vertices
 			.iter()
@@ -971,21 +946,13 @@ fn compute_dual(minor_graph: &MinorGraph) -> Result<DualGraph, BooleanError> {
 			// return Err(BooleanError::MultipleOuterFaces);
 			#[cfg(feature = "logging")]
 			eprintln!("Found multiple outer faces: {areas:?}, falling back to area calculation");
-			let (key, area) = *areas.iter().max_by_key(|(_, area)| ((area.abs() * 1000.) as u64)).unwrap();
-			if area < 0. {
-				reverse_winding = true;
-			}
+			let (key, _) = *areas.iter().max_by_key(|(_, area)| ((area.abs() * 1000.) as u64)).unwrap();
 			*key
 		} else {
 			*windings.iter().find(|(&_, winding)| (winding < &0) ^ reverse_winding).expect("No outer face of a component found.").0
 		};
 		#[cfg(feature = "logging")]
 		dbg!(outer_face_key);
-		if reverse_winding {
-			for &edge in component_edges.iter() {
-				// dual_edges[edge].direction_flag = !dual_edges[edge].direction_flag;
-			}
-		}
 
 		components.push(DualGraphComponent {
 			vertices: component_vertices,

node-graph/gstd/src/vector.rs

@@ -10,8 +10,6 @@ use graphene_core::{Color, GraphicElement, GraphicGroup};
 
 use glam::{DAffine2, DVec2};
 use path_bool::PathBooleanOperation;
-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen::prelude::*;
 
 pub struct BooleanOperationNode<BooleanOp> {
 	operation: BooleanOp,
@@ -211,6 +209,7 @@ fn to_path_segments(path: &mut Vec<path_bool::PathSegment>, subpath: &bezier_rs:
 		path.push(segment);
 	}
 }
+
 fn from_path(path_data: &[Path]) -> VectorData {
 	const EPSILON: f64 = 1e-5;
 
@@ -302,50 +301,27 @@ pub fn convert_usvg_path(path: &usvg::Path) -> Vec<Subpath<PointId>> {
 	subpaths
 }
 
-// #[cfg(target_arch = "wasm32")]
-// #[wasm_bindgen(module = "/../../frontend/src/utility-functions/computational-geometry.ts")]
-// extern "C" {
-// 	#[wasm_bindgen(js_name = booleanUnion)]
-// 	fn boolean_union(path1: String, path2: String) -> String;
-// 	#[wasm_bindgen(js_name = booleanSubtract)]
-// 	fn boolean_subtract(path1: String, path2: String) -> String;
-// 	#[wasm_bindgen(js_name = booleanIntersect)]
-// 	fn boolean_intersect(path1: String, path2: String) -> String;
-// }
-// #[cfg(not(target_arch = "wasm32"))]
-
 type Path = Vec<path_bool::PathSegment>;
 fn boolean_union(a: Path, b: Path) -> Vec<Path> {
 	path_bool(a, b, PathBooleanOperation::Union)
 }
 
 fn path_bool(a: Path, b: Path, op: PathBooleanOperation) -> Vec<Path> {
 	use path_bool::FillRule;
-	let a_path = path_bool::path_to_path_data(&a, 0.001);
-	let b_path = path_bool::path_to_path_data(&b, 0.001);
-	// log::debug!("{:?}\n{:?}", a, b);
-	// let a = path_bool::path_from_path_data(&a_path);
-	// let b = path_bool::path_from_path_data(&b_path);
-	// log::debug!("{:?}\n{:?}", a, b);
-	// log::error!("Boolean error  encontered while processing {a_path}\n {op:?}\n {b_path}");
-	let results = match path_bool::path_boolean(&a, FillRule::NonZero, &b, FillRule::NonZero, op) {
+	match path_bool::path_boolean(&a, FillRule::NonZero, &b, FillRule::NonZero, op) {
 		Ok(results) => results,
 		Err(e) => {
-			// log::error!("Boolean error {e:?} encontered while processing {a}\n {op:?}\n {b}");
+			let a_path = path_bool::path_to_path_data(&a, 0.001);
+			let b_path = path_bool::path_to_path_data(&b, 0.001);
+			log::error!("Boolean error {e:?} encontered while processing {a_path}\n {op:?}\n {b_path}");
 			Vec::new()
 		}
-	};
-	results
-	// let string = results.iter().map(|result| path_bool::path_to_path_data(result, 0.001)).fold(String::new(), |o, n| o + &n);
-	// // log::debug!("result: {}", string);
-	// string
+	}
 }
 
-// #[cfg(not(target_arch = "wasm32"))]
 fn boolean_subtract(a: Path, b: Path) -> Vec<Path> {
 	path_bool(a, b, PathBooleanOperation::Difference)
 }
-// #[cfg(not(target_arch = "wasm32"))]
 fn boolean_intersect(a: Path, b: Path) -> Vec<Path> {
 	path_bool(a, b, PathBooleanOperation::Intersection)
 }