compat: simplify angle handling with normalize_angle

Replace the bidirectional convert_angle_from_xmile_to_canvas and
convert_angle_from_canvas_to_xmile functions with a single
normalize_angle function that ensures angles are in [0, 360).

This approach is simpler and more deterministic:
- On import: normalize whatever angle format we read to [0, 360)
- Internal storage: always [0, 360)
- On export: output directly (already normalized)

The previous approach had confusing naming (the "xmile" vs "canvas"
coordinate systems) and introduced floating point precision issues
during roundtrips due to multiple conversions. The new approach just
normalizes once and maintains that representation throughout.

For straight-line detection, both the input angle and calculated
straight-line angle are normalized before comparison, so angles like
-45 and 315 (which represent the same direction) compare correctly.

Author: bpowers

src/simlin-compat/src/xmile.rs

@@ -1220,32 +1220,17 @@ pub mod view_element {
     use simlin_core::datamodel::StockFlow;
     use simlin_core::datamodel::view_element::LinkShape;
 
-    // converts an angle associated with a connector (in degrees) into an
-    // angle in the coordinate system of SVG canvases where the origin is
-    // in the upper-left of the screen and Y grows down, and the domain is
-    // -180 to 180.
-    fn convert_angle_from_xmile_to_canvas(in_degrees: f64) -> f64 {
-        let out_degrees = (360.0 - in_degrees) % 360.0;
-        if out_degrees > 180.0 {
-            out_degrees - 360.0
+    /// Normalize an angle to the range [0, 360).
+    /// This ensures consistent representation regardless of input format.
+    fn normalize_angle(degrees: f64) -> f64 {
+        let normalized = degrees % 360.0;
+        if normalized < 0.0 {
+            normalized + 360.0
         } else {
-            out_degrees
+            normalized
         }
     }
 
-    // converts an angle associated with a connector (in degrees) into an
-    // angle in the coordinate system of SVG canvases where the origin is
-    // in the upper-left of the screen and Y grows down, and the domain is
-    // -180 to 180.
-    fn convert_angle_from_canvas_to_xmile(in_degrees: f64) -> f64 {
-        let out_degrees = if in_degrees < 0.0 {
-            in_degrees + 360.0
-        } else {
-            in_degrees
-        };
-        (360.0 - out_degrees) % 360.0
-    }
-
     /// Get the position (x, y) of a view element by its uid.
     fn get_element_position(view: &datamodel::StockFlow, uid: i32) -> Option<(f64, f64)> {
         for element in &view.elements {
@@ -1262,42 +1247,56 @@ pub mod view_element {
         None
     }
 
-    /// Calculate the straight-line angle (in canvas coordinates, degrees) between two points.
+    /// Calculate the straight-line angle (in degrees, normalized to [0, 360)) between two points.
     /// Returns the angle from (from_x, from_y) to (to_x, to_y).
     fn calculate_straight_line_angle(from_x: f64, from_y: f64, to_x: f64, to_y: f64) -> f64 {
         let dx = to_x - from_x;
         let dy = to_y - from_y;
-        dy.atan2(dx).to_degrees()
+        normalize_angle(dy.atan2(dx).to_degrees())
     }
 
     /// Epsilon for comparing angles - angles within this threshold are considered equal.
     /// This is tight to ensure roundtrip fidelity (original angles are preserved).
     const ANGLE_EPSILON_DEGREES: f64 = 0.01;
 
-    /// Check if an angle (in canvas coordinates) is effectively equal to the straight-line
-    /// angle between two points. Uses a tight epsilon to ensure roundtrip fidelity.
+    /// Check if an angle is effectively equal to the straight-line angle between two points.
+    /// Both angles are normalized to [0, 360) before comparison.
+    /// Uses a tight epsilon to ensure roundtrip fidelity.
     fn is_straight_line_angle(
         angle_degrees: f64,
         from_x: f64,
         from_y: f64,
         to_x: f64,
         to_y: f64,
     ) -> bool {
+        let angle = normalize_angle(angle_degrees);
         let straight_angle = calculate_straight_line_angle(from_x, from_y, to_x, to_y);
-        let diff = (angle_degrees - straight_angle).abs();
-        // Handle wraparound (e.g., -179 vs 179 should be close)
+        let diff = (angle - straight_angle).abs();
+        // Handle wraparound (e.g., 1° vs 359° should be 2° apart, not 358°)
         let diff = if diff > 180.0 { 360.0 - diff } else { diff };
         diff < ANGLE_EPSILON_DEGREES
     }
 
     #[test]
-    fn test_convert_angles() {
-        let cases: &[(f64, f64)] = &[(0.0, 0.0), (45.0, -45.0), (270.0, 90.0)];
+    fn test_normalize_angle() {
+        // Already in range
+        assert_eq!(0.0, normalize_angle(0.0));
+        assert_eq!(45.0, normalize_angle(45.0));
+        assert_eq!(359.0, normalize_angle(359.0));
 
-        for (input, output) in cases {
-            assert_eq!(*output, convert_angle_from_xmile_to_canvas(*input));
-            assert_eq!(*input, convert_angle_from_canvas_to_xmile(*output));
-        }
+        // Negative angles
+        assert_eq!(315.0, normalize_angle(-45.0));
+        assert_eq!(270.0, normalize_angle(-90.0));
+        assert_eq!(180.0, normalize_angle(-180.0));
+        assert_eq!(1.0, normalize_angle(-359.0));
+
+        // Angles >= 360
+        assert_eq!(0.0, normalize_angle(360.0));
+        assert_eq!(45.0, normalize_angle(405.0));
+        assert_eq!(90.0, normalize_angle(450.0));
+
+        // Large negative
+        assert_eq!(320.0, normalize_angle(-400.0));
     }
 
     #[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
@@ -1958,9 +1957,8 @@ pub mod view_element {
                         .collect(),
                 )
             } else {
-                datamodel::view_element::LinkShape::Arc(convert_angle_from_canvas_to_xmile(
-                    v.angle.unwrap_or(0.0),
-                ))
+                // Normalize angle to [0, 360) for consistent internal representation
+                datamodel::view_element::LinkShape::Arc(normalize_angle(v.angle.unwrap_or(0.0)))
             };
             datamodel::view_element::Link {
                 uid: v.uid.unwrap_or(-1),
@@ -1993,24 +1991,24 @@ pub mod view_element {
                     .collect(),
             )
         } else if let Some(angle) = v.angle {
+            // Normalize angle to [0, 360) for consistent comparison and storage
+            let normalized_angle = normalize_angle(angle);
             // Check if this angle represents a straight line
             if let (Some(&(from_x, from_y)), Some(&(to_x, to_y))) =
                 (positions.get(&from_uid), positions.get(&to_uid))
             {
-                if is_straight_line_angle(angle, from_x, from_y, to_x, to_y) {
+                if is_straight_line_angle(normalized_angle, from_x, from_y, to_x, to_y) {
                     datamodel::view_element::LinkShape::Straight
                 } else {
-                    datamodel::view_element::LinkShape::Arc(convert_angle_from_canvas_to_xmile(
-                        angle,
-                    ))
+                    datamodel::view_element::LinkShape::Arc(normalized_angle)
                 }
             } else {
                 // Can't look up positions, treat as arc
-                datamodel::view_element::LinkShape::Arc(convert_angle_from_canvas_to_xmile(angle))
+                datamodel::view_element::LinkShape::Arc(normalized_angle)
             }
         } else {
             // No angle specified, default to arc at 0
-            datamodel::view_element::LinkShape::Arc(convert_angle_from_canvas_to_xmile(0.0))
+            datamodel::view_element::LinkShape::Arc(0.0)
         };
 
         datamodel::view_element::Link {
@@ -2057,7 +2055,8 @@ pub mod view_element {
                     }
                 }
                 LinkShape::Arc(angle) => {
-                    (None, Some(convert_angle_from_xmile_to_canvas(angle)), None)
+                    // Internal angles are already normalized to [0, 360), output directly
+                    (None, Some(angle), None)
                 }
                 LinkShape::MultiPoint(points) => (
                     None,
@@ -2312,11 +2311,10 @@ pub mod view_element {
         // Should stay as Arc, not Straight
         match dm_link.shape {
             LinkShape::Arc(angle) => {
-                // The angle should be converted to XMILE format (0-360)
-                // canvas 45 -> xmile: convert_angle_from_canvas_to_xmile(45) = 315
+                // The angle should be normalized to [0, 360) - 45 is already in range
                 assert!(
-                    (angle - 315.0).abs() < 0.001,
-                    "expected arc angle ~315, got {}",
+                    (angle - 45.0).abs() < 0.001,
+                    "expected arc angle ~45, got {}",
                     angle
                 );
             }