move kaggle funcs to android.py and test

Author: betaBison

gnss_lib_py/parsers/android.py

@@ -15,7 +15,9 @@
 
 from gnss_lib_py.parsers.navdata import NavData
 from gnss_lib_py.utils.coordinates import geodetic_to_ecef
+from gnss_lib_py.utils.coordinates import ecef_to_geodetic
 from gnss_lib_py.utils.time_conversions import unix_to_gps_millis
+from gnss_lib_py.utils.time_conversions import gps_to_unix_millis
 
 class AndroidDerived2021(NavData):
     """Class handling derived measurements from Android dataset.
@@ -491,3 +493,71 @@ def make_csv(input_path, output_directory, field, show_path=False):
         print(output_path)
 
     return output_path
+
+def solve_kaggle_baseline(navdata):
+    """Convert Decimeter challenge baseline into state_estimate.
+
+    The baseline solution was provided in 2022, but not in 2021.
+
+    Parameters
+    ----------
+    navdata : gnss_lib_py.parsers.android.AndroidDerived2022
+        Instance of the AndroidDerived2022 class.
+
+    """
+
+    columns = ["unix_millis",
+               "x_rx_m",
+               "y_rx_m",
+               "z_rx_m",
+               ]
+    data_df = (navdata.pandas_df().drop_duplicates(subset='unix_millis')[columns]
+               .reset_index(drop=True))
+    lat,lon,alt = ecef_to_geodetic(data_df[["x_rx_m",
+                                            "y_rx_m",
+                                            "z_rx_m",
+                                            ]].to_numpy().T)
+
+    state_estimate = NavData()
+    state_estimate["gps_millis"] = unix_to_gps_millis(
+                                     data_df["unix_millis"].to_numpy())
+    state_estimate["lat_rx_deg"] = lat
+    state_estimate["lon_rx_deg"] = lon
+    state_estimate["alt_rx_deg"] = alt
+
+    return state_estimate
+
+def prepare_kaggle_submission(state_wls, trip_id):
+    """Converts from gnss_lib_py receiver state to Kaggle submission.
+
+
+    receiver_state : gnss_lib_py.parsers.navdata.NavData
+        Estimated receiver position in latitude and longitude as an
+        instance of the NavData class with the following
+        rows: ``lat_*_deg``, ``lon_*_deg``.
+    tripId : string
+        Value for the tripId column in kaggle submission which is a
+        fusion of the data and phone type
+
+    Returns
+    -------
+    output : gnss_lib_py.parsers.navdata.NavData
+        NavData structure ready for Kaggle submission
+
+    """
+
+    state_wls.in_rows("gps_millis")
+    wildcards = state_wls.find_wildcard_indexes(["lat_*_deg",
+                            "lon_*_deg"],max_allow = 1)
+
+    output = NavData()
+    output["tripId"] = np.array([trip_id] * state_wls.shape[1])
+    output["UnixTimeMillis"] = gps_to_unix_millis(state_wls["gps_millis"])
+    output.orig_dtypes["UnixTimeMillis"] = np.int64
+    output["LatitudeDegrees"] = state_wls[wildcards["lat_*_deg"]]
+    output["LongitudeDegrees"] = state_wls[wildcards["lon_*_deg"]]
+
+    output.interpolate("UnixTimeMillis",["LatitudeDegrees",
+                                         "LongitudeDegrees"])
+
+    return output

gnss_lib_py/parsers/kaggle.py

@@ -695,6 +695,8 @@ def interpolate(self, x_row, y_rows, inplace=False, *args):
             new_navdata = self.copy()
         for y_row in y_rows:
             nan_idxs = self.argwhere(y_row,np.nan)
+            if len(nan_idxs) == 0:
+                continue
             not_nan_idxs = self.argwhere(y_row,np.nan,"neq")
             x_vals = self[x_row,nan_idxs]
             xp_vals = self[x_row,not_nan_idxs]

gnss_lib_py/parsers/navdata.py

@@ -261,7 +261,6 @@ def datetime_to_gps_millis(t_datetime, add_leap_secs=True):
     gps_millis = tow_to_gps_millis(gps_week, tow)
     return gps_millis
 
-
 def unix_millis_to_datetime(unix_millis):
     """Convert milliseconds since UNIX epoch (1/1/1970) to UTC datetime.
 
@@ -275,7 +274,9 @@ def unix_millis_to_datetime(unix_millis):
     t_utc : datetime.datetime
         UTC time as a datetime object.
     """
-    t_utc = UNIX_EPOCH_0 + timedelta(milliseconds=float(unix_millis))
+    if np.issubdtype(type(unix_millis),int):
+        unix_millis = float(unix_millis)
+    t_utc = UNIX_EPOCH_0 + timedelta(milliseconds=unix_millis)
     t_utc = t_utc.replace(tzinfo=timezone.utc)
     return t_utc
 
@@ -318,7 +319,7 @@ def unix_to_gps_millis(unix_millis, add_leap_secs=True):
 
     Returns
     -------
-    gps_millis : float
+    gps_millis : int
         Milliseconds since GPS Epoch (6th January 1980 GPS).
     """
     # Add leapseconds should always be true here
@@ -327,9 +328,10 @@ def unix_to_gps_millis(unix_millis, add_leap_secs=True):
         for t_idx, unix in enumerate(unix_millis):
             t_utc = unix_millis_to_datetime(unix)
             gps_millis[t_idx] = datetime_to_gps_millis(t_utc, add_leap_secs=add_leap_secs)
+        gps_millis = gps_millis.astype(int)
     else:
         t_utc = unix_millis_to_datetime(unix_millis)
-        gps_millis = datetime_to_gps_millis(t_utc, add_leap_secs=add_leap_secs)
+        gps_millis = int(datetime_to_gps_millis(t_utc, add_leap_secs=add_leap_secs))
     return gps_millis
 
 
@@ -373,7 +375,7 @@ def gps_to_unix_millis(gps_millis, rem_leap_secs=True):
 
     Returns
     -------
-    unix_millis : float
+    unix_millis : int
         Milliseconds since UNIX Epoch (1/1/1970 UTC)
 
     """
@@ -384,9 +386,10 @@ def gps_to_unix_millis(gps_millis, rem_leap_secs=True):
         for t_idx, gps in enumerate(gps_millis):
             t_utc = gps_millis_to_datetime(gps, rem_leap_secs=rem_leap_secs)
             unix_millis[t_idx] = datetime_to_unix_millis(t_utc)
+        gps_millis = gps_millis.astype(int)
     else:
         t_utc = gps_millis_to_datetime(gps_millis, rem_leap_secs=rem_leap_secs)
-        unix_millis = datetime_to_unix_millis(t_utc)
+        unix_millis = int(datetime_to_unix_millis(t_utc))
     return unix_millis
 
 def _check_tzinfo(t_datetime):

gnss_lib_py/utils/time_conversions.py

@@ -588,17 +588,23 @@ def fixture_gt_2022_path(root_path_2022):
     gt_path = os.path.join(root_path_2022, 'ground_truth.csv')
     return gt_path
 
-
+@pytest.fixture(name="derived_2022")
 def test_derived_2022(derived_2022_path):
     """Testing that Android Derived 2022 is created without errors.
 
     Parameters
     ----------
     derived_2022_path : string
         Location for the unit_test Android derived 2022 measurements
+
+    Returns
+    -------
+    derived_2022 :
+
     """
     derived_2022 = android.AndroidDerived2022(derived_2022_path)
     assert isinstance(derived_2022, NavData)
+    return derived_2022
 
 
 def test_gt_2022(gt_2022_path):
@@ -643,3 +649,52 @@ def test_remove_all_data(derived_path_xl):
                                    remove_timing_outliers=True)
 
     assert derived.shape[1] == 0
+
+@pytest.fixture(name="state_estimate")
+def test_solve_kaggle_baseline(derived_2022):
+    """Testing Kaggle baseline solution.
+
+    Parameters
+    ----------
+    derived_2022 : gnss_lib_py.parsers.android.AndroidDerived2022
+        Android derived 2022 measurements
+
+    Returns
+    -------
+    state_estimate : gnss_lib_py.parsers.navdata.NavData
+        Baseline state estimate.
+    """
+
+    state_estimate = android.solve_kaggle_baseline(derived_2022)
+
+    state_estimate.in_rows(["gps_millis","lat_rx_deg",
+                            "lon_rx_deg","alt_rx_deg"])
+
+    assert state_estimate.shape[1] == 6
+
+    expected = np.array([1303770943999,1303770944999,1303770945999,
+                         1303770946999,1303770947999,1303770948999])
+    np.testing.assert_array_equal(state_estimate["gps_millis"],expected)
+
+    return state_estimate
+
+def test_prepare_kaggle_submission(state_estimate):
+    """Prepare Kaggle baseline solution.
+
+    Parameters
+    ----------
+    state_estimate : gnss_lib_py.parsers.navdata.NavData
+        Baseline state estimate.
+
+    """
+
+    output = android.prepare_kaggle_submission(state_estimate,"test")
+
+    output.in_rows(["tripId","UnixTimeMillis",
+                    "LatitudeDegrees","LongitudeDegrees"])
+
+    assert output.shape[1] == 6
+
+    expected = np.array([1619735725999,1619735726999,1619735727999,
+                         1619735728999,1619735729999,1619735730999])
+    np.testing.assert_array_equal(output["UnixTimeMillis"], expected)

tests/parsers/test_android.py

@@ -2172,6 +2172,14 @@ def test_interpolate():
     """Test inerpolate nan function.
 
     """
+
+    data = NavData()
+    data["ints"] = [1,2]
+    data["floats"] = [1.,2.]
+    new_data = data.interpolate("ints","floats")
+    new_data["ints"] = np.array([1,2])
+    new_data["floats"] = np.array([1.,2.])
+
     data = NavData()
     data["UnixTimeMillis"] = [0,1,2,3,4,5,6,7,8,9,10]
     data["LatitudeDegrees"] = [0., np.nan, np.nan, np.nan, np.nan, 50.,