added feature of transferring points to the positive semi-axis

Author: hexqnt

src/app.rs

@@ -109,6 +109,7 @@ const RIGHT_PANEL_MIN_WIDTH: f32 = 280.0;
 const POINTS_PARSE_DEBOUNCE_MS: u64 = 180;
 const POINTS_HISTORY_LIMIT: usize = 256;
 const POINTS_PARSE_ERROR_PREFIX: &str = "Points parse error: ";
+const POINTS_POSITIVE_AXIS_EPS: f64 = 1e-6;
 const UI_CORNER_RADIUS: u8 = 6;
 const PANEL_INNER_MARGIN_X: i8 = 10;
 const PANEL_INNER_MARGIN_Y: i8 = 8;

src/app/points_state.rs

@@ -315,6 +315,52 @@ impl CurveFitApp {
         }
     }
 
+    pub(super) fn can_move_points_to_positive_xy(&mut self) -> bool {
+        matches!(
+            &self.points_cache_with_policy(false).parsed_points,
+            Ok(points) if !points.is_empty()
+        )
+    }
+
+    pub(super) fn move_points_to_positive_xy(&mut self) {
+        let points = match &self.points_cache_with_policy(true).parsed_points {
+            Ok(points) if !points.is_empty() => points,
+            Ok(_) => return,
+            Err(error) => {
+                self.status = Some(StatusMessage::Error(format!(
+                    "{POINTS_PARSE_ERROR_PREFIX}{error}"
+                )));
+                return;
+            }
+        };
+
+        let mut min_x = points[0].x();
+        let mut min_y = points[0].y();
+        for point in points.iter().skip(1) {
+            min_x = min_x.min(point.x());
+            min_y = min_y.min(point.y());
+        }
+
+        let dx = (POINTS_POSITIVE_AXIS_EPS - min_x).max(0.0);
+        let dy = (POINTS_POSITIVE_AXIS_EPS - min_y).max(0.0);
+
+        let shifted = match points
+            .iter()
+            .map(|point| Point::try_new(point.x() + dx, point.y() + dy))
+            .collect::<Result<Vec<_>, _>>()
+        {
+            Ok(points) => points,
+            Err(error) => {
+                self.status = Some(StatusMessage::Error(format!(
+                    "Failed to move points to positive x/y: {error}"
+                )));
+                return;
+            }
+        };
+
+        self.write_points_text(&shifted, true);
+    }
+
     pub(super) fn fill_points_with_residuals(&mut self) {
         if self.residual_plot_points.is_empty() {
             return;

src/app/tests.rs

@@ -32,6 +32,18 @@ fn points_from_pairs(pairs: &[(f64, f64)]) -> Points {
     Points::try_from(points).expect("points must satisfy minimum size")
 }
 
+fn parsed_point_pairs(app: &mut CurveFitApp) -> Vec<(f64, f64)> {
+    let cache = app.points_cache_with_policy(true);
+    let points = cache
+        .parsed_points
+        .as_ref()
+        .expect("points must parse successfully");
+    points
+        .iter()
+        .map(|point| (point.x(), point.y()))
+        .collect::<Vec<_>>()
+}
+
 fn assert_approx_eq(actual: f64, expected: f64, tolerance: f64) {
     assert!(
         (actual - expected).abs() <= tolerance,
@@ -1359,3 +1371,158 @@ fn fill_points_with_residuals_is_noop_when_residuals_are_absent() {
     assert!(app.points.undo_stack.is_empty());
     assert!(app.points.redo_stack.is_empty());
 }
+
+#[test]
+fn move_points_to_positive_xy_rebases_minimums_and_preserves_offsets() {
+    let original = [(-2.0, -1.0), (0.0, 3.0), (5.0, -4.0)];
+    let mut app = CurveFitApp {
+        points: super::PointsEditorState {
+            text: "-2 -1\n0 3\n5 -4\n".to_string(),
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    app.invalidate_points_cache();
+
+    app.move_points_to_positive_xy();
+
+    let shifted = parsed_point_pairs(&mut app);
+    assert_eq!(shifted.len(), original.len());
+
+    let min_x = shifted
+        .iter()
+        .map(|(x, _)| *x)
+        .fold(f64::INFINITY, f64::min);
+    let min_y = shifted
+        .iter()
+        .map(|(_, y)| *y)
+        .fold(f64::INFINITY, f64::min);
+    assert_approx_eq(min_x, super::POINTS_POSITIVE_AXIS_EPS, 1e-12);
+    assert_approx_eq(min_y, super::POINTS_POSITIVE_AXIS_EPS, 1e-12);
+
+    for index in 1..shifted.len() {
+        assert_approx_eq(
+            shifted[index].0 - shifted[0].0,
+            original[index].0 - original[0].0,
+            1e-12,
+        );
+        assert_approx_eq(
+            shifted[index].1 - shifted[0].1,
+            original[index].1 - original[0].1,
+            1e-12,
+        );
+    }
+}
+
+#[test]
+fn move_points_to_positive_xy_keeps_already_positive_points_unchanged() {
+    let mut app = CurveFitApp {
+        points: super::PointsEditorState {
+            text: "2 3\n4 5\n".to_string(),
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    app.invalidate_points_cache();
+
+    app.move_points_to_positive_xy();
+
+    let shifted = parsed_point_pairs(&mut app);
+    assert_eq!(shifted.len(), 2);
+    assert_approx_eq(shifted[0].0, 2.0, 1e-12);
+    assert_approx_eq(shifted[0].1, 3.0, 1e-12);
+    assert_approx_eq(shifted[1].0, 4.0, 1e-12);
+    assert_approx_eq(shifted[1].1, 5.0, 1e-12);
+}
+
+#[test]
+fn move_points_to_positive_xy_moves_only_axis_that_needs_it() {
+    let mut app = CurveFitApp {
+        points: super::PointsEditorState {
+            text: "-2 3\n1 5\n".to_string(),
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    app.invalidate_points_cache();
+
+    app.move_points_to_positive_xy();
+
+    let shifted = parsed_point_pairs(&mut app);
+    assert_eq!(shifted.len(), 2);
+    assert_approx_eq(shifted[0].0, super::POINTS_POSITIVE_AXIS_EPS, 1e-12);
+    assert_approx_eq(shifted[0].1, 3.0, 1e-12);
+    assert_approx_eq(shifted[1].0, 3.000001, 1e-12);
+    assert_approx_eq(shifted[1].1, 5.0, 1e-12);
+}
+
+#[test]
+fn move_points_to_positive_xy_pushes_undo_and_clears_redo() {
+    let previous_text = "-1 0\n1 2\n";
+    let mut app = CurveFitApp {
+        points: super::PointsEditorState {
+            text: previous_text.to_string(),
+            redo_stack: vec!["stale redo entry".to_string()],
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    app.invalidate_points_cache();
+
+    app.move_points_to_positive_xy();
+
+    assert_eq!(app.points.undo_stack, vec![previous_text.to_string()]);
+    assert!(app.points.redo_stack.is_empty());
+    assert_ne!(app.points.text, previous_text);
+
+    let moved_text = app.points.text.clone();
+    app.undo_points_edit();
+    assert_eq!(app.points.text, previous_text);
+    app.redo_points_edit();
+    assert_eq!(app.points.text, moved_text);
+
+    let shifted = parsed_point_pairs(&mut app);
+    let min_x = shifted
+        .iter()
+        .map(|(x, _)| *x)
+        .fold(f64::INFINITY, f64::min);
+    let min_y = shifted
+        .iter()
+        .map(|(_, y)| *y)
+        .fold(f64::INFINITY, f64::min);
+    assert_approx_eq(min_x, super::POINTS_POSITIVE_AXIS_EPS, 1e-12);
+    assert_approx_eq(min_y, super::POINTS_POSITIVE_AXIS_EPS, 1e-12);
+}
+
+#[test]
+fn can_move_points_to_positive_xy_requires_non_empty_valid_points() {
+    let mut empty = CurveFitApp {
+        points: super::PointsEditorState {
+            text: String::new(),
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    empty.invalidate_points_cache();
+    assert!(!empty.can_move_points_to_positive_xy());
+
+    let mut invalid = CurveFitApp {
+        points: super::PointsEditorState {
+            text: "1 2 3\n".to_string(),
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    invalid.invalidate_points_cache();
+    assert!(!invalid.can_move_points_to_positive_xy());
+
+    let mut valid = CurveFitApp {
+        points: super::PointsEditorState {
+            text: "0 0\n1 1\n".to_string(),
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    valid.invalidate_points_cache();
+    assert!(valid.can_move_points_to_positive_xy());
+}

src/app/ui/points_editor_panel.rs

@@ -113,6 +113,7 @@ pub(super) fn ui_points_editor(app: &mut CurveFitApp, ui: &mut egui::Ui) {
         );
     }
     let can_fill_with_residuals = can_edit_points && !app.residual_plot_points.is_empty();
+    let can_move_points_to_positive_xy = can_edit_points && app.can_move_points_to_positive_xy();
     with_toolbar_hover_style(ui, |ui| {
         ui.horizontal(|ui| {
             ui.spacing_mut().item_spacing.x = TOOLBAR_BUTTON_SPACING_X;
@@ -158,6 +159,20 @@ pub(super) fn ui_points_editor(app: &mut CurveFitApp, ui: &mut egui::Ui) {
                         app.fill_points_with_residuals();
                         ui.close();
                     }
+                    if ui
+                        .add_enabled(
+                            can_move_points_to_positive_xy,
+                            egui::Button::new(tr(
+                                language,
+                                "Move to positive x/y",
+                                "Перенести в +X/+Y",
+                            )),
+                        )
+                        .clicked()
+                    {
+                        app.move_points_to_positive_xy();
+                        ui.close();
+                    }
                 });
                 let _ = toolbar_hover_tooltip(actions_response, actions_tooltip(language));
             });