Fix issue with solution line drawing.

Author: john-michaelburke

console_backend/src/solution_tab.rs

@@ -23,6 +23,28 @@ pub enum LatLonUnits {
 }
 
 impl LatLonUnits {
+    pub fn convert_lat(&self, lat: f64, sf: f64, offset: f64) -> f64 {
+        match self {
+            LatLonUnits::Degrees => {
+                lat / sf + offset
+            },
+            LatLonUnits::Meters => {
+                (lat - offset) * sf
+            },
+        }
+    }
+
+    pub fn convert_lon(&self, lon: f64, sf: f64, offset: f64) -> f64 {
+        match self {
+            LatLonUnits::Degrees => {
+                lon / sf + offset
+            },
+            LatLonUnits::Meters => {
+                (lon - offset) * sf
+            },
+        }
+    }
+    
     /// Retrieve the velocity unit as string slice.
     pub fn as_str(&self) -> &'static str {
         match self {
@@ -695,7 +717,7 @@ impl SolutionTab {
                     if let Some(lats) = self.slns.get_mut(lat_str.as_str()) {
                         let lats_counts = lats.iter().filter(|&x| !x.is_nan()).count();
                         let lat_offset =
-                            lats.iter().fold(0.0, |acc, x| acc + x) / lats_counts as f64;
+                            lats.iter().filter(|&x| !x.is_nan()).fold(0.0, |acc, x| acc + x) / lats_counts as f64;
                         let (lat_sf, lon_sf) = self.unit.get_sig_figs(lat_offset);
                         (lat_offset, lat_sf, lon_sf)
                     } else {
@@ -706,36 +728,37 @@ impl SolutionTab {
                 let lon_str = format!("lon_{}", mode_string);
                 let lon_offset = if let Some(lons) = self.slns.get_mut(lon_str.as_str()) {
                     let lons_counts = lons.iter().filter(|&x| !x.is_nan()).count();
-                    lons.iter().fold(0.0, |acc, x| acc + x) / lons_counts as f64
+                    lons.iter().filter(|&x| !x.is_nan()).fold(0.0, |acc, x| acc + x) / lons_counts as f64
                 } else {
                     0.0
                 };
 
                 (lat_offset, lat_sf, lon_offset, lon_sf)
             };
+        let (lat_sf_temp, lat_offset_temp, lon_sf_temp, lon_offset_temp) = if matches!(&self.unit, &LatLonUnits::Degrees) {
+            (old_lat_sf, old_lat_offset, old_lon_sf, old_lon_offset)
+        } else {
+            (lat_sf, lat_offset, lon_sf, lon_offset)
+        };
+        let (slns, unit) = (&mut self.slns, &self.unit);
         for mode in self.mode_strings.iter() {
             let lat_str = format!("lat_{}", mode);
             let lon_str = format!("lon_{}", mode);
-            if matches!(&self.unit, &LatLonUnits::Degrees) {
-                if let Some(lats) = self.slns.get_mut(lat_str.as_str()) {
+            slns.get_mut(lat_str.as_str())
+                .map(|lats| {
                     lats.iter_mut()
-                        .for_each(|x| *x = *x / old_lat_sf + old_lat_offset);
-                }
-                if let Some(lons) = self.slns.get_mut(lon_str.as_str()) {
+                        .for_each(|x| *x = unit.convert_lat(*x, lat_sf_temp, lat_offset_temp));
+                });
+            slns.get_mut(lon_str.as_str())
+                .map(|lons| {
                     lons.iter_mut()
-                        .for_each(|x| *x = *x / old_lon_sf + old_lon_offset);
-                }
-            } else {
-                if let Some(lats) = self.slns.get_mut(lat_str.as_str()) {
-                    lats.iter_mut()
-                        .for_each(|x| *x = (*x - lat_offset) * lat_sf);
-                }
-                if let Some(lons) = self.slns.get_mut(lon_str.as_str()) {
-                    lons.iter_mut()
-                        .for_each(|x| *x = (*x - lon_offset) * lon_sf);
-                }
-            }
+                        .for_each(|x| *x = unit.convert_lon(*x, lon_sf_temp, lon_offset_temp));
+                });
         }
+        self.sln_line.iter_mut().for_each(|(lon, lat)| {
+            *lon = unit.convert_lon(*lon, lon_sf_temp, lon_offset_temp);
+            *lat = unit.convert_lat(*lat, lat_sf_temp, lat_offset_temp);
+        });
         self.lat_sf = lat_sf;
         self.lon_sf = lon_sf;
         self.lat_offset = lat_offset;