121 lines
5.1 KiB
Python
121 lines
5.1 KiB
Python
"""This module asserts correct runtime behaviour of various additional helpers."""
|
|
|
|
# Python Standard Library
|
|
from math import tau
|
|
|
|
# Generic testing
|
|
from unittest import TestCase
|
|
|
|
# Hypothesis testing
|
|
import hypothesis.extra.numpy as st_numpy
|
|
from hypothesis import given
|
|
import hypothesis.strategies as st
|
|
|
|
# Scientific
|
|
import numpy as np
|
|
from numpy.testing import assert_almost_equal
|
|
|
|
# Module under test
|
|
from pyrate.plan.geometry.helpers import cartesian_to_spherical
|
|
from pyrate.plan.geometry.helpers import difference_latitude
|
|
from pyrate.plan.geometry.helpers import difference_longitude
|
|
from pyrate.plan.geometry.helpers import mean_angle
|
|
from pyrate.plan.geometry.helpers import mean_coordinate
|
|
from pyrate.plan.geometry.helpers import meters2rad
|
|
from pyrate.plan.geometry.helpers import rad2meters
|
|
|
|
# Own strategies
|
|
from pyrate.common.testing.strategies.geometry import geo_bearings
|
|
|
|
|
|
_POSITIVE_FLOATS = st.floats(min_value=0.0, max_value=1e9, allow_infinity=False, allow_nan=False)
|
|
|
|
|
|
class TestRadiansAndMeterConversion(TestCase):
|
|
"""Makes sure the conversion between meters and radians works."""
|
|
|
|
@given(_POSITIVE_FLOATS)
|
|
def test_is_reversible_float(self, meters: float) -> None:
|
|
"""Tests that the two functions are the reverse of each other."""
|
|
self.assertAlmostEqual(meters, rad2meters(meters2rad(meters)), places=5)
|
|
|
|
@given(st_numpy.arrays(dtype=float, shape=st_numpy.array_shapes(), elements=_POSITIVE_FLOATS))
|
|
def test_is_reversible_numpy(self, meters: np.ndarray) -> None: # pylint: disable=no-self-use
|
|
"""Tests that the two functions are the reverse of each other."""
|
|
assert_almost_equal(meters, rad2meters(meters2rad(meters)), decimal=5)
|
|
|
|
|
|
class TestCartesianToSpherical(TestCase):
|
|
"""Makes sure the conversion from cartesian to spherical coordinates works."""
|
|
|
|
def test_raises_if_not_on_unit_sphere(self) -> None:
|
|
"""Asserts that an exception is raised if values are not on the unit sphere."""
|
|
with self.assertRaises(AssertionError):
|
|
cartesian_to_spherical(np.array([(10, 20, 30)]))
|
|
|
|
def test_specific_values(self) -> None: # pylint: disable=no-self-use
|
|
"""Asserts that an exception is raised if values are not on the unit sphere."""
|
|
data_in = np.array([(1, 0, 0), (0, 1, 0), (0, 0, 1), (0.5, 0.5, np.sqrt(1 - 0.5**2 - 0.5**2))])
|
|
expected_data_out = np.array([(0, 0), (0, np.pi / 2), (-np.pi / 2, 0), (-np.pi / 4, np.pi / 4)]).T
|
|
|
|
assert_almost_equal(cartesian_to_spherical(data_in), expected_data_out)
|
|
|
|
|
|
class TestAngleAndCoordinateMean(TestCase):
|
|
"""Makes sure the mean computation and angles and coordinates works correctly."""
|
|
|
|
@given(geo_bearings(), st.floats(min_value=0.0, max_value=1e-9))
|
|
def test_raises_if_ambiguous(self, angle: float, noise: float) -> None:
|
|
"""Asserts that an exception is raised if no sensible mean can be calculated."""
|
|
|
|
ambiguous_pair = np.array([angle, (angle + 180 + noise) % 360])
|
|
with self.assertRaises(ValueError):
|
|
mean_angle(np.radians(ambiguous_pair))
|
|
with self.assertRaises(ValueError):
|
|
mean_coordinate(np.array([0.0, 67.2]), ambiguous_pair)
|
|
|
|
# But the methods should recover from an exception on the latitude mean computation
|
|
latitude, _ = mean_coordinate(ambiguous_pair, np.array([0.0, 67.2]))
|
|
self.assertAlmostEqual(latitude, 0.0)
|
|
|
|
@given(
|
|
st_numpy.arrays(
|
|
elements=st.floats(min_value=0.0, max_value=np.pi), dtype=float, shape=st_numpy.array_shapes()
|
|
)
|
|
)
|
|
def test_mean_angle_is_in_valid_range(self, data: np.ndarray) -> None:
|
|
"""Asserts that means are never negative and always between ``0°`` and ``360°``."""
|
|
|
|
try:
|
|
mean = mean_angle(data)
|
|
self.assertGreaterEqual(mean, 0.0)
|
|
self.assertLessEqual(mean, np.pi)
|
|
|
|
except ValueError:
|
|
pass # this might happen with the generated values and is okay
|
|
|
|
@given(geo_bearings(), st.floats(min_value=0.0, max_value=170))
|
|
def test_obvious_values_angle(self, angle: float, difference: float) -> None:
|
|
"""Asserts that the result is sensible for known values."""
|
|
|
|
mean = mean_angle(np.radians(np.array([angle, (angle + difference) % 360])))
|
|
self.assertAlmostEqual(mean, np.radians((angle + difference / 2)) % tau, delta=1e-6)
|
|
|
|
@given(
|
|
st.floats(min_value=-80.0, max_value=+80.0),
|
|
st.floats(min_value=-170.0, max_value=+170.0),
|
|
st.floats(min_value=-9.0, max_value=9.0),
|
|
st.floats(min_value=-9.0, max_value=9.0),
|
|
)
|
|
def test_obvious_values_coordinate(
|
|
self, latitude: float, longitude: float, lat_delta: float, lon_delta: float
|
|
) -> None:
|
|
"""Asserts that the result is sensible for known values."""
|
|
|
|
lat_mean, lon_mean = mean_coordinate(
|
|
latitudes=np.array([latitude, latitude + lat_delta]),
|
|
longitudes=np.array([longitude, longitude + lon_delta]),
|
|
)
|
|
self.assertLessEqual(difference_latitude(lat_mean, (latitude + lat_delta / 2)), 1e-6)
|
|
self.assertLessEqual(difference_longitude(lon_mean, (longitude + lon_delta / 2)), 1e-6)
|