redvox.tests.api900.test_location_analyzer API documentation
Description: Location Analyzer test module

# Module `redvox.tests.api900.test_location_analyzer`

Location Analyzer test module

Expand source code

    """
    Location Analyzer test module
    """

    import unittest
    import os
    import pandas as pd
    import numpy as np
    import redvox.api900.location_analyzer as la
    import redvox.api900.reader as reader
    from redvox.tests import LA_TEST_DATA_DIR

    SURVEY_LAT = 19.72833   # lat degrees of survey point
    SURVEY_LON = -156.0592  # lon degrees of survey point
    SURVEY_ALT = 11.9       # altitude in meters of survey point
    SURVEY_BAR = 101.61     # barometer reading of survey point
    SEA_PRESSURE = 101.92   # A fair estimate of the sea level pressure (in Hawaii)

    SURVEY = {"lat": SURVEY_LAT, "lon": SURVEY_LON, "alt": SURVEY_ALT, "bar": SURVEY_BAR, "sea_bar": SEA_PRESSURE}
    blacklist_point1 = {"lat": 19.735, "lon": -156.035, "alt": 26}
    blacklist_point2 = {"lat": 19.700, "lon": -156.008, "alt": 143}
    BLACKLIST = [blacklist_point1, blacklist_point2]

    class LoadRedvoxTestFiles(unittest.TestCase):
        def setUp(self) -> None:
            self.redvox_packets = reader.read_rdvxz_file_range(LA_TEST_DATA_DIR)
            self.wrapped_packets = list(self.redvox_packets.values())

    class DataHolderClassTests(unittest.TestCase):
        def setUp(self) -> None:
            self.new_dh = la.DataHolder("test")
            self.new_dh.set_data([12, -6, 0.0])

        def test_dh_init(self):
            self.assertEqual(self.new_dh.id, "test")
            self.assertIsNone(self.new_dh.best_value)

        def test_dh_add(self):
            self.new_dh.add(101.1)
            self.assertEqual(self.new_dh.get_len_data(), 4)

        def test_dh_set_data(self):
            self.new_dh.set_data([-300, 2.5, 0.0])
            self.assertEqual(self.new_dh.get_len_data(), 3)
            self.assertEqual(self.new_dh.get_data()[0], -300)

        def test_dh_replace_zeroes_with_epsilon(self):
            self.new_dh.replace_zeroes_with_epsilon()
            self.assertNotEqual(self.new_dh.get_data()[2], 0.0)

        def test_dh_get_mean(self):
            mean = self.new_dh.get_mean()
            self.assertAlmostEqual(mean, 2.0, 3)

        def test_dh_get_std(self):
            std = self.new_dh.get_std()
            self.assertAlmostEqual(std, 7.483, 3)

    class GPSDataHolderClassTests(unittest.TestCase):
        def setUp(self) -> None:
            data = [[1., 2., 3.], [1., 2., 3.], [10., 15., 20.], [100., 50., 15.]]
            bar = la.DataHolder("test")
            bar.set_data([12, -6, 0.0])
            self.new_gps = la.GPSDataHolder("test", "iOS", data, 800.0, bar)

        def test_gps_empty_init(self):
            new_gps = la.GPSDataHolder("test", "testOS")
            self.assertIsNone(new_gps.barometer)
            self.assertEqual(new_gps.id, "test")
            self.assertEqual(new_gps.os_type, "testOS")
            self.assertEqual(new_gps.mic_samp_rate_hz, 80.0)
            self.assertEqual(new_gps.best_data_index, 0.0)

        def test_gps_data_init(self):
            data = [[1., 2.], [1., 2.], [10., 15.], [100., 50.]]
            new_gps = la.GPSDataHolder("test", "testOS", data)
            self.assertEqual(new_gps.gps_df.size, 8)

        def test_gps_mic_init(self):
            new_gps = la.GPSDataHolder("test", "testOS", mic_samp_rate_hz=80.0)
            self.assertEqual(new_gps.mic_samp_rate_hz, 80.0)

        def test_gps_bar_init(self):
            new_dh = la.DataHolder("test")
            new_dh.set_data([12, -6, 0.0, 5.0])
            new_gps = la.GPSDataHolder("test", "testOS", bar=new_dh)
            self.assertEqual(new_gps.get_size(), (0, 4))
            self.assertEqual(new_gps.barometer.get_data()[3], 5.0)

        def test_gps_clone(self):
            new_gps = self.new_gps.clone()
            self.assertEqual(new_gps.gps_df.size, 12)
            self.assertEqual(new_gps.mic_samp_rate_hz, 800.0)
            self.assertEqual(new_gps.get_size(), (3, 3))

        def test_gps_set_data(self):
            data = [[-1., 2., 3., 1.5], [1., -2., 3., 4.2], [-10., 15., 20., 0.35], [100., 50., 15., 1.]]
            self.new_gps.set_data(data)
            self.assertEqual(self.new_gps.gps_df.size, 16)
            self.assertEqual(self.new_gps.get_size(), (4, 3))

        def test_gps_set_metadata(self):
            new_id = "new test"
            new_os = "new os"
            new_mic_sr = 80.0
            self.new_gps.set_metadata(new_id, new_os, new_mic_sr)
            self.assertEqual(self.new_gps.id, "new test")
            self.assertEqual(self.new_gps.os_type, "new os")
            self.assertEqual(self.new_gps.mic_samp_rate_hz, 80.0)

        def test_gps_get_mean_all(self):
            means = self.new_gps.get_mean_all()
            self.assertEqual(len(means), 5)
            self.assertEqual(means["lat"], 2.0)
            self.assertAlmostEqual(means["bar"], 2, 3)

        def test_gps_get_std_all(self):
            stds = self.new_gps.get_std_all()
            self.assertEqual(len(stds), 5)
            self.assertEqual(stds["alt"], 5.0)
            self.assertAlmostEqual(stds["bar"], 7.483, 3)

        def test_gps_set_barometer(self):
            bar = [101.1, 101.325, 101.90, 101.5]
            self.new_gps.set_barometer(bar)
            self.assertEqual(self.new_gps.get_size(), (3, 4))
            self.assertAlmostEqual(self.new_gps.barometer.get_mean(), 101.456, 3)

    class RedVoxLocationAnalyzerClassTests(LoadRedvoxTestFiles):
        def setUp(self) -> None:
            super().setUp()
            self.new_la = la.LocationAnalyzer(self.wrapped_packets, SURVEY, BLACKLIST)

        def test_la_empty_init(self):
            new_la = la.LocationAnalyzer()
            self.assertIsNone(new_la.invalid_points)
            self.assertIsNone(new_la.get_real_location())
            self.assertEqual(new_la.valid_gps_data, [])
            self.assertEqual(new_la.all_gps_data, [])

        def test_la_survey_init(self):
            new_la = la.LocationAnalyzer(real_location=SURVEY)
            self.assertIsNone(new_la.invalid_points)
            self.assertEqual(new_la.valid_gps_data, [])
            self.assertEqual(new_la.all_gps_data, [])
            self.assertEqual(new_la.get_real_location()["lat"], SURVEY_LAT)
            self.assertEqual(new_la.get_real_location()["lon"], SURVEY_LON)

        def test_la_blacklist_init(self):
            new_la = la.LocationAnalyzer(invalid_points=BLACKLIST)
            self.assertIsNone(new_la.get_real_location())
            self.assertEqual(new_la.valid_gps_data, [])
            self.assertEqual(new_la.all_gps_data, [])
            self.assertEqual(len(new_la.invalid_points), 2)
            self.assertEqual(new_la.invalid_points[0], blacklist_point1)

        def test_la_packet_init(self):
            new_la = la.LocationAnalyzer(self.wrapped_packets)
            self.assertIsNone(new_la.invalid_points)
            self.assertIsNone(new_la.get_real_location())
            self.assertEqual(new_la.all_stations_mean_df.shape, (2, 5))
            self.assertEqual(new_la.all_stations_std_df.shape, (2, 5))
            self.assertEqual(len(new_la.all_gps_data), 2)

        def test_la_set_real_location(self):
            new_la = la.LocationAnalyzer()
            new_la.set_real_location(SURVEY)
            self.assertEqual(new_la.get_real_location()["lat"], SURVEY_LAT)
            self.assertEqual(new_la.get_real_location()["lon"], SURVEY_LON)

        def test_la_get_real_location(self):
            new_la = la.LocationAnalyzer(real_location=SURVEY)
            surveyed_point = new_la.get_real_location()
            self.assertEqual(surveyed_point["lat"], SURVEY_LAT)
            self.assertEqual(surveyed_point["bar"], SURVEY_BAR)

        def test_la_get_loc_from_packets(self):
            new_la = la.LocationAnalyzer()
            for w_p in self.wrapped_packets:
                new_la.get_loc_from_packets(w_p)
            self.assertEqual(new_la.all_stations_mean_df.shape, (2, 5))
            self.assertEqual(new_la.all_stations_std_df.shape, (2, 5))
            self.assertEqual(len(new_la.all_gps_data), 2)

        def test_la_analyze_data(self):
            self.new_la.analyze_data()
            self.assertEqual(self.new_la.all_stations_mean_df.shape, (2, 5))
            self.assertEqual(self.new_la.all_stations_std_df.shape, (2, 5))
            self.assertEqual(self.new_la.all_stations_closest_df.shape, (2, 6))

            zero_gps = la.GPSDataHolder("zeroes", "iOS", [[0.0], [0.0], [0.0], [0.0]])
            zero_gps.barometer = la.DataHolder("barometer")
            zero_gps.barometer.set_data([SURVEY_BAR])
            self.new_la.all_gps_data = [zero_gps]
            self.new_la.set_real_location({"lat": 0.1, "lon": 0.1, "alt": 1.0,  "bar": SURVEY_BAR, "sea_bar": SEA_PRESSURE})
            self.new_la.analyze_data()
            self.assertEqual(self.new_la.all_stations_mean_df.shape, (1, 5))
            self.assertEqual(self.new_la.all_stations_std_df.shape, (1, 5))
            self.assertEqual(self.new_la.all_stations_closest_df.shape, (1, 6))

        def test_la_get_barometric_heights(self):
            bar_heights = self.new_la.get_barometric_heights()
            self.assertEqual(bar_heights.shape, (2, 1))
            self.assertAlmostEqual(bar_heights.iloc[0, 0], -23.279, 3)

        def test_la_validate_all(self):
            self.new_la.validate_all()
            self.assertEqual(len(self.new_la.valid_gps_data), 2)

        def test_la_compare_with_real_location(self):
            self.new_la.validate_all()
            self.new_la.compare_with_real_location()
            self.assertEqual(len(self.new_la.valid_gps_data), 2)
            self.assertEqual(self.new_la.all_stations_mean_df.shape, (2, 5))
            self.assertEqual(self.new_la.all_stations_std_df.shape, (2, 5))
            self.assertEqual(self.new_la.all_stations_closest_df.shape, (2, 6))
            self.assertEqual(self.new_la.all_stations_closest_df.iloc[0, 5], 0.0)
            self.assertEqual(self.new_la.all_stations_closest_df.iloc[1, 3], 11.9)
            self.assertEqual(self.new_la.all_stations_closest_df.iloc[0, 0], 5.0)

        def test_la_get_all_dataframes(self):
            self.new_la.analyze_data()
            result_df = self.new_la.get_all_dataframes()
            self.assertEqual(result_df.shape, (2, 18))

        def test_la_get_stats_dataframes(self):
            result_df = self.new_la.get_stats_dataframes()
            self.assertEqual(result_df.shape, (2, 12))

        def test_la_print_to_csv(self):
            self.new_la.analyze_data()
            current_csv_path = os.path.join(LA_TEST_DATA_DIR, "all.csv")
            self.new_la.print_to_csv(current_csv_path)
            test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master.csv"))
            contents = pd.read_csv(current_csv_path)
            for idx in contents.index:
                for clm in contents.columns:
                    self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
            os.remove(current_csv_path)
            current_csv_path = os.path.join(LA_TEST_DATA_DIR, "android.csv")
            self.new_la.print_to_csv(current_csv_path, "Android")
            test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master_android.csv"))
            contents = pd.read_csv(current_csv_path)
            for idx in contents.index:
                for clm in contents.columns:
                    self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
            os.remove(current_csv_path)
            current_csv_path = os.path.join(LA_TEST_DATA_DIR, "ios.csv")
            self.new_la.print_to_csv(current_csv_path, "iOS")
            test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master_ios.csv"))
            contents = pd.read_csv(current_csv_path)
            for idx in contents.index:
                for clm in contents.columns:
                    self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
            os.remove(current_csv_path)

    class LocationAnalyzerTests(LoadRedvoxTestFiles):
        def setUp(self) -> None:
            super().setUp()
            self.valid_gps_point = pd.Series({"latitude": SURVEY_LAT + .001, "longitude": SURVEY_LON + .01,
                                              "altitude": SURVEY_ALT + 20.})
            self.dist_gps_point = pd.Series({"latitude": SURVEY_LAT + .01, "longitude": SURVEY_LON + .01,
                                             "altitude": SURVEY_ALT + 100.})
            self.new_la = la.LocationAnalyzer(self.wrapped_packets)
            self.test_w_p = self.redvox_packets["testios1:2"]
            self.gps_data = la.load_position_data(self.test_w_p)
            self.survey = SURVEY
            self.bar_mean = la.AVG_SEA_LEVEL_PRESSURE_KPA
            self.inclusion_ranges = (la.DEFAULT_INCLUSION_HORIZONTAL_M, la.DEFAULT_INCLUSION_VERTICAL_M,
                                     la.DEFAULT_INCLUSION_VERTICAL_BAR_M)

        def test_get_all_ios_station(self):
            ios_df = la.get_all_ios_station(self.new_la.get_stats_dataframes())
            self.assertEqual(ios_df.shape, (1, 12))
            self.assertIn("iOS", ios_df["os"].to_numpy())
            self.assertNotIn("Android", ios_df["os"].to_numpy())

        def test_get_all_android_station(self):
            android_df = la.get_all_android_station(self.new_la.get_stats_dataframes())
            self.assertEqual(android_df.shape, (1, 12))
            self.assertIn("Android", android_df["os"].to_numpy())
            self.assertNotIn("iOS", android_df["os"].to_numpy())

        def test_load_position_data(self):
            self.assertEqual(self.gps_data.get_size(), (3, 3))
            self.assertEqual(self.gps_data.os_type, "iOS")
            self.assertEqual(self.gps_data.id, "testios1")

        def test_compute_barometric_height(self):
            bar_height = la.compute_barometric_height(SURVEY_BAR)
            self.assertAlmostEqual(bar_height, -23.694, 3)
            bar_height = la.compute_barometric_height(SURVEY_BAR, SEA_PRESSURE)
            self.assertAlmostEqual(bar_height, 25.697, 3)

        def test_compute_barometric_height_array(self):
            bar_data = np.array([SURVEY_BAR, SURVEY_BAR + .01, SURVEY_BAR - .01])
            bar_height = la.compute_barometric_height_array(bar_data)
            self.assertAlmostEqual(bar_height[0], -23.694, 3)
            self.assertEqual(len(bar_height), 3)
            bar_height = la.compute_barometric_height_array(bar_data, SEA_PRESSURE)
            self.assertAlmostEqual(bar_height[0], 25.697, 3)
            self.assertEqual(len(bar_height), 3)

        def test_get_component_dist_to_point(self):
            h_dist, v_dist, bar_dist = la.get_component_dist_to_point(SURVEY, self.dist_gps_point, self.bar_mean)
            self.assertAlmostEqual(h_dist, 1526.099, 3)
            self.assertAlmostEqual(v_dist, 100.000, 3)
            self.assertAlmostEqual(bar_dist, 11.900, 3)

        def test_get_gps_dist_to_location(self):
            dist = la.get_gps_dist_to_location(SURVEY, self.gps_data)
            self.assertEqual(len(dist), 3)
            self.assertAlmostEqual(np.mean(dist), 15.262, 3)
            dist = la.get_gps_dist_to_location(SURVEY, self.gps_data, self.bar_mean)
            self.assertEqual(len(dist), 3)
            self.assertAlmostEqual(np.mean(dist), 91.544, 3)

        def test_valid_blacklist(self):
            is_safe = la.validate_blacklist(self.valid_gps_point, self.survey, self.bar_mean, self.inclusion_ranges)
            self.assertTrue(is_safe)

        def test_validate_near_point(self):
            is_close = la.validate_near_point(self.valid_gps_point, self.survey, self.bar_mean, self.inclusion_ranges)
            self.assertFalse(is_close)

        def test_point_on_line_side(self):
            point1 = {"lat": 0, "lon": 0, "alt": 0}
            point2 = {"lat": 10, "lon": 10, "alt": 0}
            point_test1 = {"lat": 1.0, "lon": 10, "alt": 0}
            point_test2 = {"lat": 5, "lon": 5, "alt": 0}
            point_test3 = {"lat": 15, "lon": 2, "alt": 0}
            result = la.point_on_line_side((point1, point2), point_test1)
            self.assertLess(result, 0)     # right of line
            result = la.point_on_line_side((point1, point2), point_test2)
            self.assertEqual(result, 0)    # on the line
            result = la.point_on_line_side((point1, point2), point_test3)
            self.assertGreater(result, 0)  # left of line

        def test_validate_point_in_polygon(self):
            point1 = {"lat": 0, "lon": 0, "alt": 0}
            point2 = {"lat": 0, "lon": 10, "alt": 0}
            point3 = {"lat": 10, "lon": 10, "alt": 0}
            point4 = {"lat": 10, "lon": 0, "alt": 0}
            point_test1 = {"lat": 1.0, "lon": 10, "alt": 0}
            point_test2 = {"lat": 5, "lon": 5, "alt": 0}
            point_test3 = {"lat": 15, "lon": 2, "alt": 0}
            polygon = [point1, point2, point3, point4, point1]
            result = la.validate_point_in_polygon(point_test1, polygon)
            self.assertTrue(result)
            result = la.validate_point_in_polygon(point_test2, polygon)
            self.assertTrue(result)
            result = la.validate_point_in_polygon(point_test3, polygon)
            self.assertFalse(result)

        def test_validate(self):
            valid_data = la.validate(self.gps_data, self.inclusion_ranges, validation_points=BLACKLIST)
            self.assertEqual(valid_data.get_size(), (3, 3))

        def test_compute_solution_all(self):
            result = la.compute_distance_all(self.survey, self.new_la.all_gps_data)
            self.assertEqual(result.shape, (2, 18))
            self.assertEqual(result.iloc[0, 7], 0.0)
            self.assertEqual(result.iloc[1, 7], 0.0)
            self.assertEqual(result.iloc[0, 9], 19.72843)
            self.assertEqual(result.iloc[1, 9], 19.72843)

        def test_compute_closeness(self):
            result = la.compute_distance(self.survey, self.gps_data)
            self.assertIn("testios1", result.keys())
            self.assertEqual(len(result["testios1"]), 18)
            self.assertEqual(result["testios1"][7], 0.0)
            self.assertAlmostEqual(result["testios1"][17], 0.004, 3)

        def test_load_kml(self):
            data = la.load_kml(os.path.join(LA_TEST_DATA_DIR, "master.kml"))
            self.assertIn("testandroid1", data.keys())
            self.assertIn("testios1", data.keys())
            self.assertEqual(len(data["testandroid1"]), 3)

        def test_write_kml(self):
            new_la = la.LocationAnalyzer(self.wrapped_packets)
            data_dict = new_la.get_stats_dataframes().T.to_dict()
            current_kml_path = os.path.join(LA_TEST_DATA_DIR, "all.kml")
            la.write_kml(current_kml_path, data_dict)
            kml_test_data = la.load_kml(os.path.join(LA_TEST_DATA_DIR, "master.kml"))
            data = la.load_kml(current_kml_path)
            self.assertEqual(data, kml_test_data)
            os.remove(current_kml_path)

## Classes

`class DataHolderClassTests (methodName='runTest')`

  A class whose instances are single test cases.

  By default, the test code itself should be placed in a method named 'runTest'.

  If the fixture may be used for many test cases, create as many test methods as are needed. When instantiating such a TestCase subclass, specify in the constructor arguments the name of the test method that the instance is to execute.

  Test authors should subclass TestCase for their own tests. Construction and deconstruction of the test's environment ('fixture') can be implemented by overriding the 'setUp' and 'tearDown' methods respectively.

  If it is necessary to override the init method, the base class init method must always be called. It is important that subclasses should not change the signature of their init method, since instances of the classes are instantiated automatically by parts of the framework in order to be run.

  When subclassing TestCase, you can set these attributes: * failureException: determines which exception will be raised when the instance's assertion methods fail; test methods raising this exception will be deemed to have 'failed' rather than 'errored'. * longMessage: determines whether long messages (including repr of objects used in assert methods) will be printed on failure in addition to any explicit message passed. * maxDiff: sets the maximum length of a diff in failure messages by assert methods using difflib. It is looked up as an instance attribute so can be configured by individual tests if required.

  Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.

  Expand source code

      class DataHolderClassTests(unittest.TestCase):
          def setUp(self) -> None:
              self.new_dh = la.DataHolder("test")
              self.new_dh.set_data([12, -6, 0.0])

          def test_dh_init(self):
              self.assertEqual(self.new_dh.id, "test")
              self.assertIsNone(self.new_dh.best_value)

          def test_dh_add(self):
              self.new_dh.add(101.1)
              self.assertEqual(self.new_dh.get_len_data(), 4)

          def test_dh_set_data(self):
              self.new_dh.set_data([-300, 2.5, 0.0])
              self.assertEqual(self.new_dh.get_len_data(), 3)
              self.assertEqual(self.new_dh.get_data()[0], -300)

          def test_dh_replace_zeroes_with_epsilon(self):
              self.new_dh.replace_zeroes_with_epsilon()
              self.assertNotEqual(self.new_dh.get_data()[2], 0.0)

          def test_dh_get_mean(self):
              mean = self.new_dh.get_mean()
              self.assertAlmostEqual(mean, 2.0, 3)

          def test_dh_get_std(self):
              std = self.new_dh.get_std()
              self.assertAlmostEqual(std, 7.483, 3)

  ### Ancestors

  - unittest.case.TestCase

  ### Methods

  `def setUp(self) ‑> NoneType`

    Hook method for setting up the test fixture before exercising it.

    Expand source code

        def setUp(self) -> None:
            self.new_dh = la.DataHolder("test")
            self.new_dh.set_data([12, -6, 0.0])

  `def test_dh_add(self)`
    Expand source code

        def test_dh_add(self):
            self.new_dh.add(101.1)
            self.assertEqual(self.new_dh.get_len_data(), 4)

  `def test_dh_get_mean(self)`
    Expand source code

        def test_dh_get_mean(self):
            mean = self.new_dh.get_mean()
            self.assertAlmostEqual(mean, 2.0, 3)

  `def test_dh_get_std(self)`
    Expand source code

        def test_dh_get_std(self):
            std = self.new_dh.get_std()
            self.assertAlmostEqual(std, 7.483, 3)

  `def test_dh_init(self)`
    Expand source code

        def test_dh_init(self):
            self.assertEqual(self.new_dh.id, "test")
            self.assertIsNone(self.new_dh.best_value)

  `def test_dh_replace_zeroes_with_epsilon(self)`
    Expand source code

        def test_dh_replace_zeroes_with_epsilon(self):
            self.new_dh.replace_zeroes_with_epsilon()
            self.assertNotEqual(self.new_dh.get_data()[2], 0.0)

  `def test_dh_set_data(self)`
    Expand source code

        def test_dh_set_data(self):
            self.new_dh.set_data([-300, 2.5, 0.0])
            self.assertEqual(self.new_dh.get_len_data(), 3)
            self.assertEqual(self.new_dh.get_data()[0], -300)

`class GPSDataHolderClassTests (methodName='runTest')`

  A class whose instances are single test cases.

  By default, the test code itself should be placed in a method named 'runTest'.

  If the fixture may be used for many test cases, create as many test methods as are needed. When instantiating such a TestCase subclass, specify in the constructor arguments the name of the test method that the instance is to execute.

  Test authors should subclass TestCase for their own tests. Construction and deconstruction of the test's environment ('fixture') can be implemented by overriding the 'setUp' and 'tearDown' methods respectively.

  If it is necessary to override the init method, the base class init method must always be called. It is important that subclasses should not change the signature of their init method, since instances of the classes are instantiated automatically by parts of the framework in order to be run.

  When subclassing TestCase, you can set these attributes: * failureException: determines which exception will be raised when the instance's assertion methods fail; test methods raising this exception will be deemed to have 'failed' rather than 'errored'. * longMessage: determines whether long messages (including repr of objects used in assert methods) will be printed on failure in addition to any explicit message passed. * maxDiff: sets the maximum length of a diff in failure messages by assert methods using difflib. It is looked up as an instance attribute so can be configured by individual tests if required.

  Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.

  Expand source code

      class GPSDataHolderClassTests(unittest.TestCase):
          def setUp(self) -> None:
              data = [[1., 2., 3.], [1., 2., 3.], [10., 15., 20.], [100., 50., 15.]]
              bar = la.DataHolder("test")
              bar.set_data([12, -6, 0.0])
              self.new_gps = la.GPSDataHolder("test", "iOS", data, 800.0, bar)

          def test_gps_empty_init(self):
              new_gps = la.GPSDataHolder("test", "testOS")
              self.assertIsNone(new_gps.barometer)
              self.assertEqual(new_gps.id, "test")
              self.assertEqual(new_gps.os_type, "testOS")
              self.assertEqual(new_gps.mic_samp_rate_hz, 80.0)
              self.assertEqual(new_gps.best_data_index, 0.0)

          def test_gps_data_init(self):
              data = [[1., 2.], [1., 2.], [10., 15.], [100., 50.]]
              new_gps = la.GPSDataHolder("test", "testOS", data)
              self.assertEqual(new_gps.gps_df.size, 8)

          def test_gps_mic_init(self):
              new_gps = la.GPSDataHolder("test", "testOS", mic_samp_rate_hz=80.0)
              self.assertEqual(new_gps.mic_samp_rate_hz, 80.0)

          def test_gps_bar_init(self):
              new_dh = la.DataHolder("test")
              new_dh.set_data([12, -6, 0.0, 5.0])
              new_gps = la.GPSDataHolder("test", "testOS", bar=new_dh)
              self.assertEqual(new_gps.get_size(), (0, 4))
              self.assertEqual(new_gps.barometer.get_data()[3], 5.0)

          def test_gps_clone(self):
              new_gps = self.new_gps.clone()
              self.assertEqual(new_gps.gps_df.size, 12)
              self.assertEqual(new_gps.mic_samp_rate_hz, 800.0)
              self.assertEqual(new_gps.get_size(), (3, 3))

          def test_gps_set_data(self):
              data = [[-1., 2., 3., 1.5], [1., -2., 3., 4.2], [-10., 15., 20., 0.35], [100., 50., 15., 1.]]
              self.new_gps.set_data(data)
              self.assertEqual(self.new_gps.gps_df.size, 16)
              self.assertEqual(self.new_gps.get_size(), (4, 3))

          def test_gps_set_metadata(self):
              new_id = "new test"
              new_os = "new os"
              new_mic_sr = 80.0
              self.new_gps.set_metadata(new_id, new_os, new_mic_sr)
              self.assertEqual(self.new_gps.id, "new test")
              self.assertEqual(self.new_gps.os_type, "new os")
              self.assertEqual(self.new_gps.mic_samp_rate_hz, 80.0)

          def test_gps_get_mean_all(self):
              means = self.new_gps.get_mean_all()
              self.assertEqual(len(means), 5)
              self.assertEqual(means["lat"], 2.0)
              self.assertAlmostEqual(means["bar"], 2, 3)

          def test_gps_get_std_all(self):
              stds = self.new_gps.get_std_all()
              self.assertEqual(len(stds), 5)
              self.assertEqual(stds["alt"], 5.0)
              self.assertAlmostEqual(stds["bar"], 7.483, 3)

          def test_gps_set_barometer(self):
              bar = [101.1, 101.325, 101.90, 101.5]
              self.new_gps.set_barometer(bar)
              self.assertEqual(self.new_gps.get_size(), (3, 4))
              self.assertAlmostEqual(self.new_gps.barometer.get_mean(), 101.456, 3)

  ### Ancestors

  - unittest.case.TestCase

  ### Methods

  `def setUp(self) ‑> NoneType`

    Hook method for setting up the test fixture before exercising it.

    Expand source code

        def setUp(self) -> None:
            data = [[1., 2., 3.], [1., 2., 3.], [10., 15., 20.], [100., 50., 15.]]
            bar = la.DataHolder("test")
            bar.set_data([12, -6, 0.0])
            self.new_gps = la.GPSDataHolder("test", "iOS", data, 800.0, bar)

  `def test_gps_bar_init(self)`
    Expand source code

        def test_gps_bar_init(self):
            new_dh = la.DataHolder("test")
            new_dh.set_data([12, -6, 0.0, 5.0])
            new_gps = la.GPSDataHolder("test", "testOS", bar=new_dh)
            self.assertEqual(new_gps.get_size(), (0, 4))
            self.assertEqual(new_gps.barometer.get_data()[3], 5.0)

  `def test_gps_clone(self)`
    Expand source code

        def test_gps_clone(self):
            new_gps = self.new_gps.clone()
            self.assertEqual(new_gps.gps_df.size, 12)
            self.assertEqual(new_gps.mic_samp_rate_hz, 800.0)
            self.assertEqual(new_gps.get_size(), (3, 3))

  `def test_gps_data_init(self)`
    Expand source code

        def test_gps_data_init(self):
            data = [[1., 2.], [1., 2.], [10., 15.], [100., 50.]]
            new_gps = la.GPSDataHolder("test", "testOS", data)
            self.assertEqual(new_gps.gps_df.size, 8)

  `def test_gps_empty_init(self)`
    Expand source code

        def test_gps_empty_init(self):
            new_gps = la.GPSDataHolder("test", "testOS")
            self.assertIsNone(new_gps.barometer)
            self.assertEqual(new_gps.id, "test")
            self.assertEqual(new_gps.os_type, "testOS")
            self.assertEqual(new_gps.mic_samp_rate_hz, 80.0)
            self.assertEqual(new_gps.best_data_index, 0.0)

  `def test_gps_get_mean_all(self)`
    Expand source code

        def test_gps_get_mean_all(self):
            means = self.new_gps.get_mean_all()
            self.assertEqual(len(means), 5)
            self.assertEqual(means["lat"], 2.0)
            self.assertAlmostEqual(means["bar"], 2, 3)

  `def test_gps_get_std_all(self)`
    Expand source code

        def test_gps_get_std_all(self):
            stds = self.new_gps.get_std_all()
            self.assertEqual(len(stds), 5)
            self.assertEqual(stds["alt"], 5.0)
            self.assertAlmostEqual(stds["bar"], 7.483, 3)

  `def test_gps_mic_init(self)`
    Expand source code

        def test_gps_mic_init(self):
            new_gps = la.GPSDataHolder("test", "testOS", mic_samp_rate_hz=80.0)
            self.assertEqual(new_gps.mic_samp_rate_hz, 80.0)

  `def test_gps_set_barometer(self)`
    Expand source code

        def test_gps_set_barometer(self):
            bar = [101.1, 101.325, 101.90, 101.5]
            self.new_gps.set_barometer(bar)
            self.assertEqual(self.new_gps.get_size(), (3, 4))
            self.assertAlmostEqual(self.new_gps.barometer.get_mean(), 101.456, 3)

  `def test_gps_set_data(self)`
    Expand source code

        def test_gps_set_data(self):
            data = [[-1., 2., 3., 1.5], [1., -2., 3., 4.2], [-10., 15., 20., 0.35], [100., 50., 15., 1.]]
            self.new_gps.set_data(data)
            self.assertEqual(self.new_gps.gps_df.size, 16)
            self.assertEqual(self.new_gps.get_size(), (4, 3))

  `def test_gps_set_metadata(self)`
    Expand source code

        def test_gps_set_metadata(self):
            new_id = "new test"
            new_os = "new os"
            new_mic_sr = 80.0
            self.new_gps.set_metadata(new_id, new_os, new_mic_sr)
            self.assertEqual(self.new_gps.id, "new test")
            self.assertEqual(self.new_gps.os_type, "new os")
            self.assertEqual(self.new_gps.mic_samp_rate_hz, 80.0)

`class LoadRedvoxTestFiles (methodName='runTest')`

  A class whose instances are single test cases.

  By default, the test code itself should be placed in a method named 'runTest'.

  If the fixture may be used for many test cases, create as many test methods as are needed. When instantiating such a TestCase subclass, specify in the constructor arguments the name of the test method that the instance is to execute.

  Test authors should subclass TestCase for their own tests. Construction and deconstruction of the test's environment ('fixture') can be implemented by overriding the 'setUp' and 'tearDown' methods respectively.

  If it is necessary to override the init method, the base class init method must always be called. It is important that subclasses should not change the signature of their init method, since instances of the classes are instantiated automatically by parts of the framework in order to be run.

  When subclassing TestCase, you can set these attributes: * failureException: determines which exception will be raised when the instance's assertion methods fail; test methods raising this exception will be deemed to have 'failed' rather than 'errored'. * longMessage: determines whether long messages (including repr of objects used in assert methods) will be printed on failure in addition to any explicit message passed. * maxDiff: sets the maximum length of a diff in failure messages by assert methods using difflib. It is looked up as an instance attribute so can be configured by individual tests if required.

  Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.

  Expand source code

      class LoadRedvoxTestFiles(unittest.TestCase):
          def setUp(self) -> None:
              self.redvox_packets = reader.read_rdvxz_file_range(LA_TEST_DATA_DIR)
              self.wrapped_packets = list(self.redvox_packets.values())

  ### Ancestors

  - unittest.case.TestCase

  ### Subclasses

  - LocationAnalyzerTests
  - RedVoxLocationAnalyzerClassTests

  ### Methods

  `def setUp(self) ‑> NoneType`

    Hook method for setting up the test fixture before exercising it.

    Expand source code

        def setUp(self) -> None:
            self.redvox_packets = reader.read_rdvxz_file_range(LA_TEST_DATA_DIR)
            self.wrapped_packets = list(self.redvox_packets.values())

`class LocationAnalyzerTests (methodName='runTest')`

  A class whose instances are single test cases.

  By default, the test code itself should be placed in a method named 'runTest'.

  If the fixture may be used for many test cases, create as many test methods as are needed. When instantiating such a TestCase subclass, specify in the constructor arguments the name of the test method that the instance is to execute.

  Test authors should subclass TestCase for their own tests. Construction and deconstruction of the test's environment ('fixture') can be implemented by overriding the 'setUp' and 'tearDown' methods respectively.

  If it is necessary to override the init method, the base class init method must always be called. It is important that subclasses should not change the signature of their init method, since instances of the classes are instantiated automatically by parts of the framework in order to be run.

  When subclassing TestCase, you can set these attributes: * failureException: determines which exception will be raised when the instance's assertion methods fail; test methods raising this exception will be deemed to have 'failed' rather than 'errored'. * longMessage: determines whether long messages (including repr of objects used in assert methods) will be printed on failure in addition to any explicit message passed. * maxDiff: sets the maximum length of a diff in failure messages by assert methods using difflib. It is looked up as an instance attribute so can be configured by individual tests if required.

  Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.

  Expand source code

      class LocationAnalyzerTests(LoadRedvoxTestFiles):
          def setUp(self) -> None:
              super().setUp()
              self.valid_gps_point = pd.Series({"latitude": SURVEY_LAT + .001, "longitude": SURVEY_LON + .01,
                                                "altitude": SURVEY_ALT + 20.})
              self.dist_gps_point = pd.Series({"latitude": SURVEY_LAT + .01, "longitude": SURVEY_LON + .01,
                                               "altitude": SURVEY_ALT + 100.})
              self.new_la = la.LocationAnalyzer(self.wrapped_packets)
              self.test_w_p = self.redvox_packets["testios1:2"]
              self.gps_data = la.load_position_data(self.test_w_p)
              self.survey = SURVEY
              self.bar_mean = la.AVG_SEA_LEVEL_PRESSURE_KPA
              self.inclusion_ranges = (la.DEFAULT_INCLUSION_HORIZONTAL_M, la.DEFAULT_INCLUSION_VERTICAL_M,
                                       la.DEFAULT_INCLUSION_VERTICAL_BAR_M)

          def test_get_all_ios_station(self):
              ios_df = la.get_all_ios_station(self.new_la.get_stats_dataframes())
              self.assertEqual(ios_df.shape, (1, 12))
              self.assertIn("iOS", ios_df["os"].to_numpy())
              self.assertNotIn("Android", ios_df["os"].to_numpy())

          def test_get_all_android_station(self):
              android_df = la.get_all_android_station(self.new_la.get_stats_dataframes())
              self.assertEqual(android_df.shape, (1, 12))
              self.assertIn("Android", android_df["os"].to_numpy())
              self.assertNotIn("iOS", android_df["os"].to_numpy())

          def test_load_position_data(self):
              self.assertEqual(self.gps_data.get_size(), (3, 3))
              self.assertEqual(self.gps_data.os_type, "iOS")
              self.assertEqual(self.gps_data.id, "testios1")

          def test_compute_barometric_height(self):
              bar_height = la.compute_barometric_height(SURVEY_BAR)
              self.assertAlmostEqual(bar_height, -23.694, 3)
              bar_height = la.compute_barometric_height(SURVEY_BAR, SEA_PRESSURE)
              self.assertAlmostEqual(bar_height, 25.697, 3)

          def test_compute_barometric_height_array(self):
              bar_data = np.array([SURVEY_BAR, SURVEY_BAR + .01, SURVEY_BAR - .01])
              bar_height = la.compute_barometric_height_array(bar_data)
              self.assertAlmostEqual(bar_height[0], -23.694, 3)
              self.assertEqual(len(bar_height), 3)
              bar_height = la.compute_barometric_height_array(bar_data, SEA_PRESSURE)
              self.assertAlmostEqual(bar_height[0], 25.697, 3)
              self.assertEqual(len(bar_height), 3)

          def test_get_component_dist_to_point(self):
              h_dist, v_dist, bar_dist = la.get_component_dist_to_point(SURVEY, self.dist_gps_point, self.bar_mean)
              self.assertAlmostEqual(h_dist, 1526.099, 3)
              self.assertAlmostEqual(v_dist, 100.000, 3)
              self.assertAlmostEqual(bar_dist, 11.900, 3)

          def test_get_gps_dist_to_location(self):
              dist = la.get_gps_dist_to_location(SURVEY, self.gps_data)
              self.assertEqual(len(dist), 3)
              self.assertAlmostEqual(np.mean(dist), 15.262, 3)
              dist = la.get_gps_dist_to_location(SURVEY, self.gps_data, self.bar_mean)
              self.assertEqual(len(dist), 3)
              self.assertAlmostEqual(np.mean(dist), 91.544, 3)

          def test_valid_blacklist(self):
              is_safe = la.validate_blacklist(self.valid_gps_point, self.survey, self.bar_mean, self.inclusion_ranges)
              self.assertTrue(is_safe)

          def test_validate_near_point(self):
              is_close = la.validate_near_point(self.valid_gps_point, self.survey, self.bar_mean, self.inclusion_ranges)
              self.assertFalse(is_close)

          def test_point_on_line_side(self):
              point1 = {"lat": 0, "lon": 0, "alt": 0}
              point2 = {"lat": 10, "lon": 10, "alt": 0}
              point_test1 = {"lat": 1.0, "lon": 10, "alt": 0}
              point_test2 = {"lat": 5, "lon": 5, "alt": 0}
              point_test3 = {"lat": 15, "lon": 2, "alt": 0}
              result = la.point_on_line_side((point1, point2), point_test1)
              self.assertLess(result, 0)     # right of line
              result = la.point_on_line_side((point1, point2), point_test2)
              self.assertEqual(result, 0)    # on the line
              result = la.point_on_line_side((point1, point2), point_test3)
              self.assertGreater(result, 0)  # left of line

          def test_validate_point_in_polygon(self):
              point1 = {"lat": 0, "lon": 0, "alt": 0}
              point2 = {"lat": 0, "lon": 10, "alt": 0}
              point3 = {"lat": 10, "lon": 10, "alt": 0}
              point4 = {"lat": 10, "lon": 0, "alt": 0}
              point_test1 = {"lat": 1.0, "lon": 10, "alt": 0}
              point_test2 = {"lat": 5, "lon": 5, "alt": 0}
              point_test3 = {"lat": 15, "lon": 2, "alt": 0}
              polygon = [point1, point2, point3, point4, point1]
              result = la.validate_point_in_polygon(point_test1, polygon)
              self.assertTrue(result)
              result = la.validate_point_in_polygon(point_test2, polygon)
              self.assertTrue(result)
              result = la.validate_point_in_polygon(point_test3, polygon)
              self.assertFalse(result)

          def test_validate(self):
              valid_data = la.validate(self.gps_data, self.inclusion_ranges, validation_points=BLACKLIST)
              self.assertEqual(valid_data.get_size(), (3, 3))

          def test_compute_solution_all(self):
              result = la.compute_distance_all(self.survey, self.new_la.all_gps_data)
              self.assertEqual(result.shape, (2, 18))
              self.assertEqual(result.iloc[0, 7], 0.0)
              self.assertEqual(result.iloc[1, 7], 0.0)
              self.assertEqual(result.iloc[0, 9], 19.72843)
              self.assertEqual(result.iloc[1, 9], 19.72843)

          def test_compute_closeness(self):
              result = la.compute_distance(self.survey, self.gps_data)
              self.assertIn("testios1", result.keys())
              self.assertEqual(len(result["testios1"]), 18)
              self.assertEqual(result["testios1"][7], 0.0)
              self.assertAlmostEqual(result["testios1"][17], 0.004, 3)

          def test_load_kml(self):
              data = la.load_kml(os.path.join(LA_TEST_DATA_DIR, "master.kml"))
              self.assertIn("testandroid1", data.keys())
              self.assertIn("testios1", data.keys())
              self.assertEqual(len(data["testandroid1"]), 3)

          def test_write_kml(self):
              new_la = la.LocationAnalyzer(self.wrapped_packets)
              data_dict = new_la.get_stats_dataframes().T.to_dict()
              current_kml_path = os.path.join(LA_TEST_DATA_DIR, "all.kml")
              la.write_kml(current_kml_path, data_dict)
              kml_test_data = la.load_kml(os.path.join(LA_TEST_DATA_DIR, "master.kml"))
              data = la.load_kml(current_kml_path)
              self.assertEqual(data, kml_test_data)
              os.remove(current_kml_path)

  ### Ancestors

  - LoadRedvoxTestFiles
  - unittest.case.TestCase

  ### Methods

  `def test_compute_barometric_height(self)`
    Expand source code

        def test_compute_barometric_height(self):
            bar_height = la.compute_barometric_height(SURVEY_BAR)
            self.assertAlmostEqual(bar_height, -23.694, 3)
            bar_height = la.compute_barometric_height(SURVEY_BAR, SEA_PRESSURE)
            self.assertAlmostEqual(bar_height, 25.697, 3)

  `def test_compute_barometric_height_array(self)`
    Expand source code

        def test_compute_barometric_height_array(self):
            bar_data = np.array([SURVEY_BAR, SURVEY_BAR + .01, SURVEY_BAR - .01])
            bar_height = la.compute_barometric_height_array(bar_data)
            self.assertAlmostEqual(bar_height[0], -23.694, 3)
            self.assertEqual(len(bar_height), 3)
            bar_height = la.compute_barometric_height_array(bar_data, SEA_PRESSURE)
            self.assertAlmostEqual(bar_height[0], 25.697, 3)
            self.assertEqual(len(bar_height), 3)

  `def test_compute_closeness(self)`
    Expand source code

        def test_compute_closeness(self):
            result = la.compute_distance(self.survey, self.gps_data)
            self.assertIn("testios1", result.keys())
            self.assertEqual(len(result["testios1"]), 18)
            self.assertEqual(result["testios1"][7], 0.0)
            self.assertAlmostEqual(result["testios1"][17], 0.004, 3)

  `def test_compute_solution_all(self)`
    Expand source code

        def test_compute_solution_all(self):
            result = la.compute_distance_all(self.survey, self.new_la.all_gps_data)
            self.assertEqual(result.shape, (2, 18))
            self.assertEqual(result.iloc[0, 7], 0.0)
            self.assertEqual(result.iloc[1, 7], 0.0)
            self.assertEqual(result.iloc[0, 9], 19.72843)
            self.assertEqual(result.iloc[1, 9], 19.72843)

  `def test_get_all_android_station(self)`
    Expand source code

        def test_get_all_android_station(self):
            android_df = la.get_all_android_station(self.new_la.get_stats_dataframes())
            self.assertEqual(android_df.shape, (1, 12))
            self.assertIn("Android", android_df["os"].to_numpy())
            self.assertNotIn("iOS", android_df["os"].to_numpy())

  `def test_get_all_ios_station(self)`
    Expand source code

        def test_get_all_ios_station(self):
            ios_df = la.get_all_ios_station(self.new_la.get_stats_dataframes())
            self.assertEqual(ios_df.shape, (1, 12))
            self.assertIn("iOS", ios_df["os"].to_numpy())
            self.assertNotIn("Android", ios_df["os"].to_numpy())

  `def test_get_component_dist_to_point(self)`
    Expand source code

        def test_get_component_dist_to_point(self):
            h_dist, v_dist, bar_dist = la.get_component_dist_to_point(SURVEY, self.dist_gps_point, self.bar_mean)
            self.assertAlmostEqual(h_dist, 1526.099, 3)
            self.assertAlmostEqual(v_dist, 100.000, 3)
            self.assertAlmostEqual(bar_dist, 11.900, 3)

  `def test_get_gps_dist_to_location(self)`
    Expand source code

        def test_get_gps_dist_to_location(self):
            dist = la.get_gps_dist_to_location(SURVEY, self.gps_data)
            self.assertEqual(len(dist), 3)
            self.assertAlmostEqual(np.mean(dist), 15.262, 3)
            dist = la.get_gps_dist_to_location(SURVEY, self.gps_data, self.bar_mean)
            self.assertEqual(len(dist), 3)
            self.assertAlmostEqual(np.mean(dist), 91.544, 3)

  `def test_load_kml(self)`
    Expand source code

        def test_load_kml(self):
            data = la.load_kml(os.path.join(LA_TEST_DATA_DIR, "master.kml"))
            self.assertIn("testandroid1", data.keys())
            self.assertIn("testios1", data.keys())
            self.assertEqual(len(data["testandroid1"]), 3)

  `def test_load_position_data(self)`
    Expand source code

        def test_load_position_data(self):
            self.assertEqual(self.gps_data.get_size(), (3, 3))
            self.assertEqual(self.gps_data.os_type, "iOS")
            self.assertEqual(self.gps_data.id, "testios1")

  `def test_point_on_line_side(self)`
    Expand source code

        def test_point_on_line_side(self):
            point1 = {"lat": 0, "lon": 0, "alt": 0}
            point2 = {"lat": 10, "lon": 10, "alt": 0}
            point_test1 = {"lat": 1.0, "lon": 10, "alt": 0}
            point_test2 = {"lat": 5, "lon": 5, "alt": 0}
            point_test3 = {"lat": 15, "lon": 2, "alt": 0}
            result = la.point_on_line_side((point1, point2), point_test1)
            self.assertLess(result, 0)     # right of line
            result = la.point_on_line_side((point1, point2), point_test2)
            self.assertEqual(result, 0)    # on the line
            result = la.point_on_line_side((point1, point2), point_test3)
            self.assertGreater(result, 0)  # left of line

  `def test_valid_blacklist(self)`
    Expand source code

        def test_valid_blacklist(self):
            is_safe = la.validate_blacklist(self.valid_gps_point, self.survey, self.bar_mean, self.inclusion_ranges)
            self.assertTrue(is_safe)

  `def test_validate(self)`
    Expand source code

        def test_validate(self):
            valid_data = la.validate(self.gps_data, self.inclusion_ranges, validation_points=BLACKLIST)
            self.assertEqual(valid_data.get_size(), (3, 3))

  `def test_validate_near_point(self)`
    Expand source code

        def test_validate_near_point(self):
            is_close = la.validate_near_point(self.valid_gps_point, self.survey, self.bar_mean, self.inclusion_ranges)
            self.assertFalse(is_close)

  `def test_validate_point_in_polygon(self)`
    Expand source code

        def test_validate_point_in_polygon(self):
            point1 = {"lat": 0, "lon": 0, "alt": 0}
            point2 = {"lat": 0, "lon": 10, "alt": 0}
            point3 = {"lat": 10, "lon": 10, "alt": 0}
            point4 = {"lat": 10, "lon": 0, "alt": 0}
            point_test1 = {"lat": 1.0, "lon": 10, "alt": 0}
            point_test2 = {"lat": 5, "lon": 5, "alt": 0}
            point_test3 = {"lat": 15, "lon": 2, "alt": 0}
            polygon = [point1, point2, point3, point4, point1]
            result = la.validate_point_in_polygon(point_test1, polygon)
            self.assertTrue(result)
            result = la.validate_point_in_polygon(point_test2, polygon)
            self.assertTrue(result)
            result = la.validate_point_in_polygon(point_test3, polygon)
            self.assertFalse(result)

  `def test_write_kml(self)`
    Expand source code

        def test_write_kml(self):
            new_la = la.LocationAnalyzer(self.wrapped_packets)
            data_dict = new_la.get_stats_dataframes().T.to_dict()
            current_kml_path = os.path.join(LA_TEST_DATA_DIR, "all.kml")
            la.write_kml(current_kml_path, data_dict)
            kml_test_data = la.load_kml(os.path.join(LA_TEST_DATA_DIR, "master.kml"))
            data = la.load_kml(current_kml_path)
            self.assertEqual(data, kml_test_data)
            os.remove(current_kml_path)

  ### Inherited members

  - `LoadRedvoxTestFiles`:
    - `setUp`
`class RedVoxLocationAnalyzerClassTests (methodName='runTest')`

  A class whose instances are single test cases.

  By default, the test code itself should be placed in a method named 'runTest'.

  If the fixture may be used for many test cases, create as many test methods as are needed. When instantiating such a TestCase subclass, specify in the constructor arguments the name of the test method that the instance is to execute.

  Test authors should subclass TestCase for their own tests. Construction and deconstruction of the test's environment ('fixture') can be implemented by overriding the 'setUp' and 'tearDown' methods respectively.

  If it is necessary to override the init method, the base class init method must always be called. It is important that subclasses should not change the signature of their init method, since instances of the classes are instantiated automatically by parts of the framework in order to be run.

  When subclassing TestCase, you can set these attributes: * failureException: determines which exception will be raised when the instance's assertion methods fail; test methods raising this exception will be deemed to have 'failed' rather than 'errored'. * longMessage: determines whether long messages (including repr of objects used in assert methods) will be printed on failure in addition to any explicit message passed. * maxDiff: sets the maximum length of a diff in failure messages by assert methods using difflib. It is looked up as an instance attribute so can be configured by individual tests if required.

  Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.

  Expand source code

      class RedVoxLocationAnalyzerClassTests(LoadRedvoxTestFiles):
          def setUp(self) -> None:
              super().setUp()
              self.new_la = la.LocationAnalyzer(self.wrapped_packets, SURVEY, BLACKLIST)

          def test_la_empty_init(self):
              new_la = la.LocationAnalyzer()
              self.assertIsNone(new_la.invalid_points)
              self.assertIsNone(new_la.get_real_location())
              self.assertEqual(new_la.valid_gps_data, [])
              self.assertEqual(new_la.all_gps_data, [])

          def test_la_survey_init(self):
              new_la = la.LocationAnalyzer(real_location=SURVEY)
              self.assertIsNone(new_la.invalid_points)
              self.assertEqual(new_la.valid_gps_data, [])
              self.assertEqual(new_la.all_gps_data, [])
              self.assertEqual(new_la.get_real_location()["lat"], SURVEY_LAT)
              self.assertEqual(new_la.get_real_location()["lon"], SURVEY_LON)

          def test_la_blacklist_init(self):
              new_la = la.LocationAnalyzer(invalid_points=BLACKLIST)
              self.assertIsNone(new_la.get_real_location())
              self.assertEqual(new_la.valid_gps_data, [])
              self.assertEqual(new_la.all_gps_data, [])
              self.assertEqual(len(new_la.invalid_points), 2)
              self.assertEqual(new_la.invalid_points[0], blacklist_point1)

          def test_la_packet_init(self):
              new_la = la.LocationAnalyzer(self.wrapped_packets)
              self.assertIsNone(new_la.invalid_points)
              self.assertIsNone(new_la.get_real_location())
              self.assertEqual(new_la.all_stations_mean_df.shape, (2, 5))
              self.assertEqual(new_la.all_stations_std_df.shape, (2, 5))
              self.assertEqual(len(new_la.all_gps_data), 2)

          def test_la_set_real_location(self):
              new_la = la.LocationAnalyzer()
              new_la.set_real_location(SURVEY)
              self.assertEqual(new_la.get_real_location()["lat"], SURVEY_LAT)
              self.assertEqual(new_la.get_real_location()["lon"], SURVEY_LON)

          def test_la_get_real_location(self):
              new_la = la.LocationAnalyzer(real_location=SURVEY)
              surveyed_point = new_la.get_real_location()
              self.assertEqual(surveyed_point["lat"], SURVEY_LAT)
              self.assertEqual(surveyed_point["bar"], SURVEY_BAR)

          def test_la_get_loc_from_packets(self):
              new_la = la.LocationAnalyzer()
              for w_p in self.wrapped_packets:
                  new_la.get_loc_from_packets(w_p)
              self.assertEqual(new_la.all_stations_mean_df.shape, (2, 5))
              self.assertEqual(new_la.all_stations_std_df.shape, (2, 5))
              self.assertEqual(len(new_la.all_gps_data), 2)

          def test_la_analyze_data(self):
              self.new_la.analyze_data()
              self.assertEqual(self.new_la.all_stations_mean_df.shape, (2, 5))
              self.assertEqual(self.new_la.all_stations_std_df.shape, (2, 5))
              self.assertEqual(self.new_la.all_stations_closest_df.shape, (2, 6))

              zero_gps = la.GPSDataHolder("zeroes", "iOS", [[0.0], [0.0], [0.0], [0.0]])
              zero_gps.barometer = la.DataHolder("barometer")
              zero_gps.barometer.set_data([SURVEY_BAR])
              self.new_la.all_gps_data = [zero_gps]
              self.new_la.set_real_location({"lat": 0.1, "lon": 0.1, "alt": 1.0,  "bar": SURVEY_BAR, "sea_bar": SEA_PRESSURE})
              self.new_la.analyze_data()
              self.assertEqual(self.new_la.all_stations_mean_df.shape, (1, 5))
              self.assertEqual(self.new_la.all_stations_std_df.shape, (1, 5))
              self.assertEqual(self.new_la.all_stations_closest_df.shape, (1, 6))

          def test_la_get_barometric_heights(self):
              bar_heights = self.new_la.get_barometric_heights()
              self.assertEqual(bar_heights.shape, (2, 1))
              self.assertAlmostEqual(bar_heights.iloc[0, 0], -23.279, 3)

          def test_la_validate_all(self):
              self.new_la.validate_all()
              self.assertEqual(len(self.new_la.valid_gps_data), 2)

          def test_la_compare_with_real_location(self):
              self.new_la.validate_all()
              self.new_la.compare_with_real_location()
              self.assertEqual(len(self.new_la.valid_gps_data), 2)
              self.assertEqual(self.new_la.all_stations_mean_df.shape, (2, 5))
              self.assertEqual(self.new_la.all_stations_std_df.shape, (2, 5))
              self.assertEqual(self.new_la.all_stations_closest_df.shape, (2, 6))
              self.assertEqual(self.new_la.all_stations_closest_df.iloc[0, 5], 0.0)
              self.assertEqual(self.new_la.all_stations_closest_df.iloc[1, 3], 11.9)
              self.assertEqual(self.new_la.all_stations_closest_df.iloc[0, 0], 5.0)

          def test_la_get_all_dataframes(self):
              self.new_la.analyze_data()
              result_df = self.new_la.get_all_dataframes()
              self.assertEqual(result_df.shape, (2, 18))

          def test_la_get_stats_dataframes(self):
              result_df = self.new_la.get_stats_dataframes()
              self.assertEqual(result_df.shape, (2, 12))

          def test_la_print_to_csv(self):
              self.new_la.analyze_data()
              current_csv_path = os.path.join(LA_TEST_DATA_DIR, "all.csv")
              self.new_la.print_to_csv(current_csv_path)
              test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master.csv"))
              contents = pd.read_csv(current_csv_path)
              for idx in contents.index:
                  for clm in contents.columns:
                      self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
              os.remove(current_csv_path)
              current_csv_path = os.path.join(LA_TEST_DATA_DIR, "android.csv")
              self.new_la.print_to_csv(current_csv_path, "Android")
              test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master_android.csv"))
              contents = pd.read_csv(current_csv_path)
              for idx in contents.index:
                  for clm in contents.columns:
                      self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
              os.remove(current_csv_path)
              current_csv_path = os.path.join(LA_TEST_DATA_DIR, "ios.csv")
              self.new_la.print_to_csv(current_csv_path, "iOS")
              test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master_ios.csv"))
              contents = pd.read_csv(current_csv_path)
              for idx in contents.index:
                  for clm in contents.columns:
                      self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
              os.remove(current_csv_path)

  ### Ancestors

  - LoadRedvoxTestFiles
  - unittest.case.TestCase

  ### Methods

  `def test_la_analyze_data(self)`
    Expand source code

        def test_la_analyze_data(self):
            self.new_la.analyze_data()
            self.assertEqual(self.new_la.all_stations_mean_df.shape, (2, 5))
            self.assertEqual(self.new_la.all_stations_std_df.shape, (2, 5))
            self.assertEqual(self.new_la.all_stations_closest_df.shape, (2, 6))

            zero_gps = la.GPSDataHolder("zeroes", "iOS", [[0.0], [0.0], [0.0], [0.0]])
            zero_gps.barometer = la.DataHolder("barometer")
            zero_gps.barometer.set_data([SURVEY_BAR])
            self.new_la.all_gps_data = [zero_gps]
            self.new_la.set_real_location({"lat": 0.1, "lon": 0.1, "alt": 1.0,  "bar": SURVEY_BAR, "sea_bar": SEA_PRESSURE})
            self.new_la.analyze_data()
            self.assertEqual(self.new_la.all_stations_mean_df.shape, (1, 5))
            self.assertEqual(self.new_la.all_stations_std_df.shape, (1, 5))
            self.assertEqual(self.new_la.all_stations_closest_df.shape, (1, 6))

  `def test_la_blacklist_init(self)`
    Expand source code

        def test_la_blacklist_init(self):
            new_la = la.LocationAnalyzer(invalid_points=BLACKLIST)
            self.assertIsNone(new_la.get_real_location())
            self.assertEqual(new_la.valid_gps_data, [])
            self.assertEqual(new_la.all_gps_data, [])
            self.assertEqual(len(new_la.invalid_points), 2)
            self.assertEqual(new_la.invalid_points[0], blacklist_point1)

  `def test_la_compare_with_real_location(self)`
    Expand source code

        def test_la_compare_with_real_location(self):
            self.new_la.validate_all()
            self.new_la.compare_with_real_location()
            self.assertEqual(len(self.new_la.valid_gps_data), 2)
            self.assertEqual(self.new_la.all_stations_mean_df.shape, (2, 5))
            self.assertEqual(self.new_la.all_stations_std_df.shape, (2, 5))
            self.assertEqual(self.new_la.all_stations_closest_df.shape, (2, 6))
            self.assertEqual(self.new_la.all_stations_closest_df.iloc[0, 5], 0.0)
            self.assertEqual(self.new_la.all_stations_closest_df.iloc[1, 3], 11.9)
            self.assertEqual(self.new_la.all_stations_closest_df.iloc[0, 0], 5.0)

  `def test_la_empty_init(self)`
    Expand source code

        def test_la_empty_init(self):
            new_la = la.LocationAnalyzer()
            self.assertIsNone(new_la.invalid_points)
            self.assertIsNone(new_la.get_real_location())
            self.assertEqual(new_la.valid_gps_data, [])
            self.assertEqual(new_la.all_gps_data, [])

  `def test_la_get_all_dataframes(self)`
    Expand source code

        def test_la_get_all_dataframes(self):
            self.new_la.analyze_data()
            result_df = self.new_la.get_all_dataframes()
            self.assertEqual(result_df.shape, (2, 18))

  `def test_la_get_barometric_heights(self)`
    Expand source code

        def test_la_get_barometric_heights(self):
            bar_heights = self.new_la.get_barometric_heights()
            self.assertEqual(bar_heights.shape, (2, 1))
            self.assertAlmostEqual(bar_heights.iloc[0, 0], -23.279, 3)

  `def test_la_get_loc_from_packets(self)`
    Expand source code

        def test_la_get_loc_from_packets(self):
            new_la = la.LocationAnalyzer()
            for w_p in self.wrapped_packets:
                new_la.get_loc_from_packets(w_p)
            self.assertEqual(new_la.all_stations_mean_df.shape, (2, 5))
            self.assertEqual(new_la.all_stations_std_df.shape, (2, 5))
            self.assertEqual(len(new_la.all_gps_data), 2)

  `def test_la_get_real_location(self)`
    Expand source code

        def test_la_get_real_location(self):
            new_la = la.LocationAnalyzer(real_location=SURVEY)
            surveyed_point = new_la.get_real_location()
            self.assertEqual(surveyed_point["lat"], SURVEY_LAT)
            self.assertEqual(surveyed_point["bar"], SURVEY_BAR)

  `def test_la_get_stats_dataframes(self)`
    Expand source code

        def test_la_get_stats_dataframes(self):
            result_df = self.new_la.get_stats_dataframes()
            self.assertEqual(result_df.shape, (2, 12))

  `def test_la_packet_init(self)`
    Expand source code

        def test_la_packet_init(self):
            new_la = la.LocationAnalyzer(self.wrapped_packets)
            self.assertIsNone(new_la.invalid_points)
            self.assertIsNone(new_la.get_real_location())
            self.assertEqual(new_la.all_stations_mean_df.shape, (2, 5))
            self.assertEqual(new_la.all_stations_std_df.shape, (2, 5))
            self.assertEqual(len(new_la.all_gps_data), 2)

  `def test_la_print_to_csv(self)`
    Expand source code

        def test_la_print_to_csv(self):
            self.new_la.analyze_data()
            current_csv_path = os.path.join(LA_TEST_DATA_DIR, "all.csv")
            self.new_la.print_to_csv(current_csv_path)
            test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master.csv"))
            contents = pd.read_csv(current_csv_path)
            for idx in contents.index:
                for clm in contents.columns:
                    self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
            os.remove(current_csv_path)
            current_csv_path = os.path.join(LA_TEST_DATA_DIR, "android.csv")
            self.new_la.print_to_csv(current_csv_path, "Android")
            test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master_android.csv"))
            contents = pd.read_csv(current_csv_path)
            for idx in contents.index:
                for clm in contents.columns:
                    self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
            os.remove(current_csv_path)
            current_csv_path = os.path.join(LA_TEST_DATA_DIR, "ios.csv")
            self.new_la.print_to_csv(current_csv_path, "iOS")
            test_contents = pd.read_csv(os.path.join(LA_TEST_DATA_DIR, "master_ios.csv"))
            contents = pd.read_csv(current_csv_path)
            for idx in contents.index:
                for clm in contents.columns:
                    self.assertAlmostEqual(contents.at[idx, clm], test_contents.at[idx, clm], 4)
            os.remove(current_csv_path)

  `def test_la_set_real_location(self)`
    Expand source code

        def test_la_set_real_location(self):
            new_la = la.LocationAnalyzer()
            new_la.set_real_location(SURVEY)
            self.assertEqual(new_la.get_real_location()["lat"], SURVEY_LAT)
            self.assertEqual(new_la.get_real_location()["lon"], SURVEY_LON)

  `def test_la_survey_init(self)`
    Expand source code

        def test_la_survey_init(self):
            new_la = la.LocationAnalyzer(real_location=SURVEY)
            self.assertIsNone(new_la.invalid_points)
            self.assertEqual(new_la.valid_gps_data, [])
            self.assertEqual(new_la.all_gps_data, [])
            self.assertEqual(new_la.get_real_location()["lat"], SURVEY_LAT)
            self.assertEqual(new_la.get_real_location()["lon"], SURVEY_LON)

  `def test_la_validate_all(self)`
    Expand source code

        def test_la_validate_all(self):
            self.new_la.validate_all()
            self.assertEqual(len(self.new_la.valid_gps_data), 2)

  ### Inherited members

  - `LoadRedvoxTestFiles`:
    - `setUp`