Lasso select for segment editing

Author: 4adex

Cargo.lock

@@ -45,6 +45,7 @@ thiserror = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 bezier-rs = { workspace = true }
+kurbo = { workspace = true }
 futures = { workspace = true }
 glam = { workspace = true, features = ["serde", "debug-glam-assert"] }
 derivative = { workspace = true }

editor/Cargo.toml

@@ -1,6 +1,6 @@
 use super::graph_modification_utils::merge_layers;
 use super::snapping::{SnapCache, SnapCandidatePoint, SnapData, SnapManager, SnappedPoint};
-use super::utility_functions::{adjust_handle_colinearity, calculate_segment_angle, restore_g1_continuity, restore_previous_handle_position};
+use super::utility_functions::{adjust_handle_colinearity, calculate_bezier_bbox, calculate_segment_angle, restore_g1_continuity, restore_previous_handle_position};
 use crate::consts::HANDLE_LENGTH_FACTOR;
 use crate::messages::portfolio::document::overlays::utility_functions::selected_segments;
 use crate::messages::portfolio::document::utility_types::document_metadata::{DocumentMetadata, LayerNodeIdentifier};
@@ -124,6 +124,10 @@ impl SelectedLayerState {
 		self.selected_points.clear();
 	}
 
+	pub fn clear_segments(&mut self) {
+		self.selected_segments.clear();
+	}
+
 	pub fn selected_points_count(&self) -> usize {
 		let count = self.selected_points.iter().fold(0, |acc, point| {
 			let is_ignored = (point.as_handle().is_some() && self.ignore_handles) || (point.as_anchor().is_some() && self.ignore_anchors);
@@ -164,6 +168,7 @@ pub struct ManipulatorPointInfo {
 
 pub type OpposingHandleLengths = HashMap<LayerNodeIdentifier, HashMap<HandleId, f64>>;
 
+#[derive(Clone)]
 pub struct ClosestSegment {
 	layer: LayerNodeIdentifier,
 	segment: SegmentId,
@@ -1822,7 +1827,8 @@ impl ShapeState {
 
 		for (&layer, state) in &mut self.selected_shape_state {
 			if selection_change == SelectionChange::Clear {
-				state.clear_points()
+				state.clear_points();
+				state.clear_segments();
 			}
 
 			let vector_data = network_interface.compute_modified_vector(layer);
@@ -1852,6 +1858,28 @@ impl ShapeState {
 			for (id, bezier, _, _) in vector_data.segment_bezier_iter() {
 				if select_segments {
 					// Checking for selection of segments if they lie inside the bounding box or lasso polygon
+					let segment_bbox = calculate_bezier_bbox(bezier);
+					let bottom_left = transform.transform_point2(segment_bbox[0]);
+					let top_right = transform.transform_point2(segment_bbox[1]);
+
+					let select = match selection_shape {
+						SelectionShape::Box(quad) => quad[0].min(quad[1]).cmple(bottom_left).all() && quad[0].max(quad[1]).cmpge(top_right).all(),
+						SelectionShape::Lasso(_) => {
+							//First check if the segement bbox intersects with lasso polygon (atleast one of the points of bbox should lie in lasso polygon)
+							let polygon = polygon_subpath.as_ref().expect("If `selection_shape` is a polygon then subpath is constructed beforehand.");
+
+							// Sample 10 points on the bezier and check if all lie inside the polygon or not
+							let points = bezier.compute_lookup_table(Some(10), None);
+							points.map(|p| transform.transform_point2(p)).all(|p| polygon.contains_point(p))
+						}
+					};
+
+					if select {
+						match selection_change {
+							SelectionChange::Shrink => state.deselect_segment(id),
+							_ => state.select_segment(id),
+						}
+					}
 				}
 
 				// Checking for selection of handles

editor/src/messages/tool/common_functionality/shape_editor.rs

@@ -2,11 +2,12 @@ use crate::messages::portfolio::document::utility_types::document_metadata::Laye
 use crate::messages::prelude::*;
 use crate::messages::tool::common_functionality::graph_modification_utils::get_text;
 use crate::messages::tool::tool_messages::path_tool::PathOverlayMode;
-use bezier_rs::Bezier;
+use bezier_rs::{Bezier, BezierHandles};
 use glam::DVec2;
 use graphene_core::renderer::Quad;
 use graphene_core::text::{FontCache, load_face};
 use graphene_std::vector::{HandleId, ManipulatorPointId, PointId, SegmentId, VectorData, VectorModificationType};
+use kurbo::{CubicBez, Line, ParamCurveExtrema, Point, QuadBez};
 
 /// Determines if a path should be extended. Goal in viewport space. Returns the path and if it is extending from the start, if applicable.
 pub fn should_extend(
@@ -198,6 +199,21 @@ pub fn is_visible_point(
 	}
 }
 
-pub fn calculate_bezier_bbox(_bezier: Bezier) {
-	// Get the bbox of bezier
+/// Function to find the bounding box of bezier (uses method from kurbo)
+pub fn calculate_bezier_bbox(bezier: Bezier) -> [DVec2; 2] {
+	let start = Point::new(bezier.start.x, bezier.start.y);
+	let end = Point::new(bezier.end.x, bezier.end.y);
+	let bbox = match bezier.handles {
+		BezierHandles::Cubic { handle_start, handle_end } => {
+			let p1 = Point::new(handle_start.x, handle_start.y);
+			let p2 = Point::new(handle_end.x, handle_end.y);
+			CubicBez::new(start, p1, p2, end).bounding_box()
+		}
+		BezierHandles::Quadratic { handle } => {
+			let p1 = Point::new(handle.x, handle.y);
+			QuadBez::new(start, p1, end).bounding_box()
+		}
+		BezierHandles::Linear => Line::new(start, end).bounding_box(),
+	};
+	[DVec2::new(bbox.x0, bbox.y0), DVec2::new(bbox.x1, bbox.y1)]
 }

editor/src/messages/tool/common_functionality/utility_functions.rs

@@ -435,6 +435,7 @@ struct PathToolData {
 	angle: f64,
 	opposite_handle_position: Option<DVec2>,
 	last_clicked_point_was_selected: bool,
+	last_clicked_segment_was_selected: bool,
 	snapping_axis: Option<Axis>,
 	alt_clicked_on_anchor: bool,
 	alt_dragging_from_anchor: bool,
@@ -632,6 +633,7 @@ impl PathToolData {
 				let layer = segment.layer();
 				let segment_id = segment.segment();
 				let already_selected = shape_editor.selected_shape_state.get(&layer).map_or(false, |state| state.is_selected_segment(segment_id));
+				self.last_clicked_segment_was_selected = already_selected;
 
 				if !(already_selected && extend_selection) {
 					// let vector_data = document.network_interface.compute_modified_vector(segment.layer());
@@ -676,6 +678,7 @@ impl PathToolData {
 		// We didn't find a segment, so consider selecting the nearest shape instead
 		else if let Some(layer) = document.click(input) {
 			shape_editor.deselect_all_points();
+			shape_editor.deselect_all_segments();
 			if extend_selection {
 				responses.add(NodeGraphMessage::SelectedNodesAdd { nodes: vec![layer.to_node()] });
 			} else {
@@ -698,77 +701,6 @@ impl PathToolData {
 		}
 	}
 
-	#[allow(clippy::too_many_arguments)]
-	fn mouse_down_segment_mode(
-		&mut self,
-		shape_editor: &mut ShapeState,
-		document: &DocumentMessageHandler,
-		input: &InputPreprocessorMessageHandler,
-		responses: &mut VecDeque<Message>,
-		extend_selection: bool,
-		_lasso_select: bool,
-		_handle_drag_from_anchor: bool,
-		_drag_zero_handle: bool,
-		_path_overlay_mode: PathOverlayMode,
-	) -> PathToolFsmState {
-		self.drag_start_pos = input.mouse.position;
-
-		// Check if a segment is already selected; if not, select the first segment within the threshold
-		if let Some(segment) = shape_editor.upper_closest_segment(&document.network_interface, input.mouse.position, SELECTION_THRESHOLD) {
-			//Got the segment add the segment in selected segments
-			let layer = segment.layer();
-			let segment_id = segment.segment();
-			let already_selected = shape_editor.selected_shape_state.get(&layer).map_or(false, |state| state.is_selected_segment(segment_id));
-
-			if !(already_selected && extend_selection) {
-				// let vector_data = document.network_interface.compute_modified_vector(segment.layer());
-
-				let new_selected = if already_selected { !extend_selection } else { true };
-				if new_selected {
-					let retain_existing_selection = extend_selection || already_selected;
-					if !retain_existing_selection {
-						shape_editor.deselect_all_segments();
-					}
-
-					// Add to selected segments
-					if let Some(selected_shape_state) = shape_editor.selected_shape_state.get_mut(&layer) {
-						selected_shape_state.select_segment(segment_id);
-					}
-				} else {
-					if let Some(selected_shape_state) = shape_editor.selected_shape_state.get_mut(&layer) {
-						selected_shape_state.deselect_segment(segment_id);
-					}
-				}
-			}
-			responses.add(OverlaysMessage::Draw);
-			PathToolFsmState::Dragging(self.dragging_state)
-		}
-		// We didn't find a segment, so consider selecting the nearest shape instead
-		else if let Some(layer) = document.click(input) {
-			shape_editor.deselect_all_points();
-			if extend_selection {
-				responses.add(NodeGraphMessage::SelectedNodesAdd { nodes: vec![layer.to_node()] });
-			} else {
-				responses.add(NodeGraphMessage::SelectedNodesSet { nodes: vec![layer.to_node()] });
-			}
-			self.drag_start_pos = input.mouse.position;
-			self.previous_mouse_position = document.metadata().document_to_viewport.inverse().transform_point2(input.mouse.position);
-
-			responses.add(DocumentMessage::StartTransaction);
-
-			PathToolFsmState::Dragging(self.dragging_state)
-		}
-		// Start drawing
-		else {
-			self.drag_start_pos = input.mouse.position;
-			self.previous_mouse_position = document.metadata().document_to_viewport.inverse().transform_point2(input.mouse.position);
-
-			let selection_shape = if _lasso_select { SelectionShapeType::Lasso } else { SelectionShapeType::Box };
-			responses.add(OverlaysMessage::Draw);
-			PathToolFsmState::Drawing { selection_shape }
-		}
-	}
-
 	fn start_dragging_point(&mut self, selected_points: SelectedPointsInfo, input: &InputPreprocessorMessageHandler, document: &DocumentMessageHandler, shape_editor: &mut ShapeState) {
 		let mut manipulators = HashMap::with_hasher(NoHashBuilder);
 		let mut unselected = Vec::new();
@@ -1742,6 +1674,7 @@ impl Fsm for PathToolFsmState {
 			(PathToolFsmState::Dragging { .. }, PathToolMessage::Escape | PathToolMessage::RightClick) => {
 				if tool_data.handle_drag_toggle && tool_data.drag_start_pos.distance(input.mouse.position) > DRAG_THRESHOLD {
 					shape_editor.deselect_all_points();
+					shape_editor.deselect_all_segments();
 					shape_editor.select_points_by_manipulator_id(&tool_data.saved_points_before_handle_drag);
 
 					tool_data.saved_points_before_handle_drag.clear();
@@ -1815,7 +1748,7 @@ impl Fsm for PathToolFsmState {
 			(_, PathToolMessage::DragStop { extend_selection, .. }) => {
 				let extend_selection = input.keyboard.get(extend_selection as usize);
 				let drag_occurred = tool_data.drag_start_pos.distance(input.mouse.position) > DRAG_THRESHOLD;
-				// TODO: Here we want only visible points to be considered
+
 				let nearest_point = shape_editor.find_nearest_visible_point_indices(
 					&document.network_interface,
 					input.mouse.position,
@@ -1824,40 +1757,78 @@ impl Fsm for PathToolFsmState {
 					tool_data.frontier_handles_info.clone(),
 				);
 
+				let nearest_segment = tool_data.segment.clone();
+
 				if let Some(segment) = &mut tool_data.segment {
 					let segment_mode = tool_options.path_editing_mode.segment_editing_mode;
 					if !drag_occurred && !tool_data.molding_segment && !segment_mode {
 						if tool_data.delete_segment_pressed {
 							if let Some(vector_data) = document.network_interface.compute_modified_vector(segment.layer()) {
 								shape_editor.dissolve_segment(responses, segment.layer(), &vector_data, segment.segment(), segment.points());
-								responses.add(DocumentMessage::EndTransaction);
 							}
 						} else {
 							segment.adjusted_insert_and_select(shape_editor, responses, extend_selection);
-							responses.add(DocumentMessage::EndTransaction);
 						}
-					} else {
-						responses.add(DocumentMessage::EndTransaction);
 					}
 
 					tool_data.segment = None;
 					tool_data.molding_info = None;
 					tool_data.molding_segment = false;
 					tool_data.temporary_adjacent_handles_while_molding = None;
-
-					return PathToolFsmState::Ready;
 				}
 
+				let segment_mode = tool_options.path_editing_mode.segment_editing_mode;
+
 				if let Some((layer, nearest_point)) = nearest_point {
+					let clicked_selected = shape_editor.selected_points().any(|&point| nearest_point == point);
 					if !drag_occurred && extend_selection {
-						let clicked_selected = shape_editor.selected_points().any(|&point| nearest_point == point);
+						log::info!("yes here occured");
 						if clicked_selected && tool_data.last_clicked_point_was_selected {
 							shape_editor.selected_shape_state.entry(layer).or_default().deselect_point(nearest_point);
 						} else {
 							shape_editor.selected_shape_state.entry(layer).or_default().select_point(nearest_point);
 						}
 						responses.add(OverlaysMessage::Draw);
 					}
+					if !drag_occurred && !extend_selection {
+						if clicked_selected {
+							if tool_data.saved_points_before_anchor_convert_smooth_sharp.is_empty() {
+								tool_data.saved_points_before_anchor_convert_smooth_sharp = shape_editor.selected_points().copied().collect::<HashSet<_>>();
+							}
+							shape_editor.deselect_all_points();
+							shape_editor.selected_shape_state.entry(layer).or_default().select_point(nearest_point);
+							responses.add(OverlaysMessage::Draw);
+						}
+					}
+				}
+				// Segment editing mode
+				else if let Some(nearest_segment) = nearest_segment {
+					//Condition this upon whether user has selected segment editing mode or not
+					if segment_mode {
+						let clicked_selected = shape_editor.selected_segments().any(|&segment| segment == nearest_segment.segment());
+						if !drag_occurred && extend_selection {
+							if clicked_selected && tool_data.last_clicked_segment_was_selected {
+								shape_editor
+									.selected_shape_state
+									.entry(nearest_segment.layer())
+									.or_default()
+									.deselect_segment(nearest_segment.segment());
+							} else {
+								shape_editor.selected_shape_state.entry(nearest_segment.layer()).or_default().select_segment(nearest_segment.segment());
+							}
+							responses.add(OverlaysMessage::Draw);
+						}
+						if !drag_occurred && !extend_selection && clicked_selected {
+							shape_editor.deselect_all_segments();
+							shape_editor.selected_shape_state.entry(nearest_segment.layer()).or_default().select_segment(nearest_segment.segment());
+							responses.add(OverlaysMessage::Draw);
+						}
+					}
+				}
+				// Deselect all points if the user clicks the filled region of the shape
+				else if tool_data.drag_start_pos.distance(input.mouse.position) <= DRAG_THRESHOLD {
+					shape_editor.deselect_all_points();
+					shape_editor.deselect_all_segments();
 				}
 
 				if tool_data.temporary_colinear_handles {
@@ -1883,25 +1854,6 @@ impl Fsm for PathToolFsmState {
 					tool_data.select_anchor_toggled = false;
 				}
 
-				if let Some((layer, nearest_point)) = nearest_point {
-					if !drag_occurred && !extend_selection {
-						let clicked_selected = shape_editor.selected_points().any(|&point| nearest_point == point);
-						if clicked_selected {
-							if tool_data.saved_points_before_anchor_convert_smooth_sharp.is_empty() {
-								tool_data.saved_points_before_anchor_convert_smooth_sharp = shape_editor.selected_points().copied().collect::<HashSet<_>>();
-							}
-
-							shape_editor.deselect_all_points();
-							shape_editor.selected_shape_state.entry(layer).or_default().select_point(nearest_point);
-							responses.add(OverlaysMessage::Draw);
-						}
-					}
-				}
-				// Deselect all points if the user clicks the filled region of the shape
-				else if tool_data.drag_start_pos.distance(input.mouse.position) <= DRAG_THRESHOLD {
-					shape_editor.deselect_all_points();
-				}
-
 				if tool_data.snapping_axis.is_some() {
 					tool_data.snapping_axis = None;
 				}