diff --git a/skais/ais/ais_trajectory.py b/skais/ais/ais_trajectory.py
index aa105a756e7e8c5660c02ec95a2c4cc51ee0f715..81a26b73d98b2d38a0f99468df7fe3bc97a2f831 100644
--- a/skais/ais/ais_trajectory.py
+++ b/skais/ais/ais_trajectory.py
@@ -1,68 +1,28 @@
-import math
-
import pandas as pd
import numpy as np
from numba import jit
from scipy.interpolate import interp1d
from skais.ais.ais_points import AISPoints
-from skais.process.basic_features_operations import angular_dispersion
+from skais.process.geography import bearing
from skais.utils.geography import great_circle
from skais.utils.stats import calc_std_dev
-PI = math.pi
-
-
-@jit(nopython=True)
-def compute_trajectory(times, time_gap, size_limit):
- n_samples = len(times)
-
- previous_date = times[0]
-
- i = 0
- for i in range(size_limit):
- if i >= n_samples:
- break
- if (times[i] - previous_date) / 60 > time_gap:
- break
- previous_date = times[i]
-
- return i
-
-
-@jit(nopython=True)
-def compute_std(dat, radius):
- stds = np.empty(dat.shape[0])
-
- dat = np.concatenate([np.full(radius, dat[0]), dat, np.full(radius, dat[-1])])
- for i in range(radius, dat.shape[0] - radius):
- stds[i - radius] = np.std(dat[i - radius:i + radius + 1])
-
- return stds
-
-
-@jit(nopython=True)
-def to_rad(degree):
- return (degree / 360.0) * (2 * PI)
-
-
-@jit(nopython=True)
-def to_deg(rad):
- return (rad * 360.0) / (2 * PI)
-
-
-@jit(nopython=True)
-def bearing(p1, p2):
- long1 = to_rad(p1[0])
- long2 = to_rad(p2[0])
-
- lat1 = to_rad(p1[1])
- lat2 = to_rad(p2[1])
-
- y = np.sin(long2 - long1) * np.cos(lat2)
- x = np.cos(lat1) * np.sin(lat2) - np.sin(lat1) * np.cos(lat2) * np.cos(long2 - long1)
- return to_deg(np.arctan2(y, x))
-
+# @jit(nopython=True)
+# def compute_trajectory(times, time_gap, size_limit):
+# n_samples = len(times)
+#
+# previous_date = times[0]
+#
+# i = 0
+# for i in range(size_limit):
+# if i >= n_samples:
+# break
+# if (times[i] - previous_date) / 60 > time_gap:
+# break
+# previous_date = times[i]
+#
+# return i
# @jit(nopython=True)
def compute_position_angle_std(dat, radius):
@@ -138,62 +98,38 @@ def compute_position_dist_std(dat, radius):
return dist_means
-@jit(nopython=True)
-def angle_between_three_points(p1, p2, p3):
- alpha = bearing(p2, p1)
- beta = bearing(p2, p3)
- result = alpha - beta
- if result > 180:
- return 180 - result
- else:
- return result
-
-
-def compute_point_angles(dat):
- angles = np.zeros(dat.shape[0])
-
- p1 = (dat[0][0], dat[0][1])
- p2 = (dat[1][0], dat[1][1])
- angles[0] = bearing(p1, p2)
- for i in range(1, dat.shape[0] - 1):
- p1 = (dat[i - 1][0], dat[i - 1][1])
- p2 = (dat[i][0], dat[i][1])
- p3 = (dat[i + 1][0], dat[i + 1][1])
-
- angles[i] = angle_between_three_points(p1, p2, p3)
- return angles
-
-
-def l1_angle(dat, radius):
- l1 = np.zeros(dat.shape)
-
- dat = np.concatenate([np.full(radius, dat[0]), dat, np.full(radius, dat[-1])])
- for i in range(radius, dat.shape[0] - radius):
- data = dat[i - radius:i + radius + 1]
- l1[i - radius] = np.linalg.norm(data, ord=1)
- return l1
-
-def l2_angle(dat, radius):
- l2 = np.zeros(dat.shape)
-
- dat = np.concatenate([np.full(radius, dat[0]), dat, np.full(radius, dat[-1])])
- for i in range(radius, dat.shape[0] - radius):
- data = dat[i - radius:i + radius + 1]
- l2[i - radius] = np.linalg.norm(data, ord=2)
- return l2
-
-
-def angle_dispersion(dat, radius):
- disp = np.zeros(dat.shape)
-
- dat = np.concatenate([np.full(radius, dat[0]), dat, np.full(radius, dat[-1])])
- for i in range(radius, dat.shape[0] - radius):
- data = dat[i - radius:i + radius + 1]
- disp[i - radius] = angular_dispersion(np.radians(data))
-
- return disp
+# def l1_angle(dat, radius):
+# l1 = np.zeros(dat.shape)
+#
+# dat = np.concatenate([np.full(radius, dat[0]), dat, np.full(radius, dat[-1])])
+# for i in range(radius, dat.shape[0] - radius):
+# data = dat[i - radius:i + radius + 1]
+# l1[i - radius] = np.linalg.norm(data, ord=1)
+#
+# return l1
+#
+#
+# def l2_angle(dat, radius):
+# l2 = np.zeros(dat.shape)
+#
+# dat = np.concatenate([np.full(radius, dat[0]), dat, np.full(radius, dat[-1])])
+# for i in range(radius, dat.shape[0] - radius):
+# data = dat[i - radius:i + radius + 1]
+# l2[i - radius] = np.linalg.norm(data, ord=2)
+# return l2
+#
+#
+# def angle_dispersion(dat, radius):
+# disp = np.zeros(dat.shape)
+#
+# dat = np.concatenate([np.full(radius, dat[0]), dat, np.full(radius, dat[-1])])
+# for i in range(radius, dat.shape[0] - radius):
+# data = dat[i - radius:i + radius + 1]
+# disp[i - radius] = angular_dispersion(np.radians(data))
+#
+# return disp
def apply_func_on_window(dat, func, radius, on_edge='copy'):
@@ -210,7 +146,7 @@ def apply_time_sequence(dat, time, func):
result = np.empty(dat.shape[0])
result[0] = func(dat[0], dat[1], time[0], time[1])
for i in range(1, dat.shape[0]):
- result[i] = func(dat[i-1], dat[i], time[i-1], time[i])
+ result[i] = func(dat[i - 1], dat[i], time[i - 1], time[i])
return result
@@ -244,138 +180,11 @@ class AISTrajectory(AISPoints):
df = new_df
# self.df = df.dropna()
- AISPoints.__init__(df)
+ AISPoints.__init__(self, df)
def __eq__(self, other):
return self.df.equals(other.df)
- def compute_angle_l1(self, radius):
- dat = self.df['angles_diff'].to_numpy()
- l1 = l1_angle(dat, radius)
- self.df[f"angle_l1"] = l1
-
- def compute_angle_l2(self, radius):
- dat = self.df['angles_diff'].to_numpy()
- l2 = l2_angle(dat, radius)
- self.df[f"angle_l2"] = l2
-
- def normalize(self, features, normalization_type="min-max", dictionary=None):
- normalization_dict = None
- if dictionary is not None:
- if dictionary["type"] == "min-max":
- for f in features:
- minimum = dictionary[f"{f}_minimum"]
- maximum = dictionary[f"{f}_maximum"]
- self.df[f] = (self.df[f] - minimum) / (maximum - minimum)
-
- elif dictionary["type"] == "standardization":
- for f in features:
- mean = dictionary[f"{f}_mean"]
- std = dictionary[f"{f}_std"]
- self.df[f] = (self.df[f] - mean) / std
- else:
- normalization_dict = {"type": normalization_type}
- if normalization_type == "min-max":
- for f in features:
- minimum = self.df[f].min()
- maximum = self.df[f].max()
- self.df[f] = (self.df[f] - minimum) / (maximum - minimum)
- normalization_dict[f"{f}_minimum"] = minimum
- normalization_dict[f"{f}_maximum"] = maximum
-
- elif normalization_type == "standardization":
- for f in features:
- mean = self.df[f].mean()
- std = self.df[f].std()
- if std == 0:
- print("Warning: std = %d", std)
- std = 1
- self.df[f] = (self.df[f] - mean) / std
- normalization_dict[f"{f}_mean"] = mean
- normalization_dict[f"{f}_std"] = std
-
- else:
- raise ValueError(f"{normalization_type} not a valid normalization method. Must be on of [min-max, "
- f"standardization]")
-
- return normalization_dict
-
- def compute_derivative(self, field):
- dt = self.df['ts_sec'].diff() / 60
-
- dv = self.df[field].diff().div(dt, axis=0, )
-
- self.df['d_' + field] = dv
-
- def compute_diff(self, field1, field2):
- self.df["diff"] = self.df.apply(lambda x: 180 - abs(abs(x[field1] - x[field2]) - 180),
- axis=1)
-
- def compute_all_derivatives(self):
- fields = ['cog', 'sog', 'rot', 'heading']
-
- for field in fields:
- self.compute_derivative(field)
-
- def compute_all_stds(self, radius):
- fields = ['cog', 'sog', 'rot', 'heading', 'latitude', 'longitude']
-
- for field in fields:
- dat = self.df[field].to_numpy()
- stds = compute_std(dat, radius)
- stds[-radius:] = np.nan
- stds[:radius] = np.nan
- self.df[f"{field}_std"] = stds
-
- def compute_all_dispersions(self, radius):
- fields = ['cog', 'heading', 'angles_diff']
- for field in fields:
- if field in self.df.columns:
- dat = self.df[field].to_numpy()
- disp = angle_dispersion(dat, radius)
- self.df[f"{field}_disp"] = disp
-
- def compute_position_features(self, radius):
- dat = np.stack([self.df.longitude.to_numpy(), self.df.latitude.to_numpy()], axis=1)
- std = compute_position_angle_std(dat, radius)
- std[-radius:] = np.nan
- std[:radius] = np.nan
- self.df[f"angle_std"] = std
-
- mean = compute_position_angle_mean(dat, radius)
- mean[-radius:] = np.nan
- mean[:radius] = np.nan
- self.df[f"angle_mean"] = mean
-
- mean_dist = compute_position_dist_mean(dat, radius)
- mean_dist[-radius:] = np.nan
- mean_dist[:radius] = np.nan
- self.df[f"dist_mean"] = mean_dist
-
- std_dist = compute_position_dist_std(dat, radius)
- std_dist[-radius:] = np.nan
- std_dist[:radius] = np.nan
- self.df[f"dist_std"] = std_dist
-
- angles = compute_point_angles(dat)
- angles[0] = np.nan
- angles[-1] = np.nan
- self.df[f"angles_diff"] = angles
-
- def compute_sqrt_sog(self):
- sog = self.df['sog'].to_numpy()
- sog[sog < 0] = 0
- self.df["sog_sqrt"] = np.sqrt(sog)
-
- def to_numpy(self, fields=None):
-
- if fields:
- df = self.df[fields]
- else:
- df = self.df
-
- return np.squeeze(df.to_numpy())
-
def sliding_window(self, size=10, offset=1, fields=None):
result = []
@@ -388,30 +197,6 @@ class AISTrajectory(AISPoints):
return result
- def to_geojson(self):
- coordinates = []
- for index, row in self.df.iterrows():
- coordinates.append([row['longitude'], row['latitude']])
-
- return {"type": "LineString", "coordinates": coordinates}
-
- def get_stopped_snippets(self, column, exclude_label=0, time_gap=5, size_limit=10000):
- df = self.df.drop(self.df[self.df[column] == exclude_label].index)
-
- work_df = df.copy()
- n_sample = len(df.index)
- result = []
-
- index = 0
- while index < n_sample:
- i = compute_trajectory(df['ts_sec'][index:].to_numpy(), time_gap, size_limit)
- trajectory = AISTrajectory(work_df[:i])
- result.append(trajectory)
- work_df = work_df[i:]
- index += i
-
- return result
-
def apply_func_on_time_window(self, func, radius, column, new_column=None):
dat = self.df[column].to_numpy()
result = apply_func_on_window(dat, func, radius, on_edge='copy')
@@ -431,3 +216,107 @@ class AISTrajectory(AISPoints):
self.df[column] = result
else:
self.df[new_column] = result
+
+ def apply_func_on_points(self, func, column, new_column=None):
+ dat = self.df[column].to_numpy()
+
+ result = np.array(list(map(func, dat)))
+
+ if new_column is None:
+ self.df[column] = result
+ else:
+ self.df[new_column] = result
+
+ def to_numpy(self, fields=None):
+
+ if fields:
+ df = self.df[fields]
+ else:
+ df = self.df
+
+ return np.squeeze(df.to_numpy())
+
+ def to_geojson(self):
+ coordinates = []
+ for index, row in self.df.iterrows():
+ coordinates.append([row['longitude'], row['latitude']])
+
+ return {"type": "LineString", "coordinates": coordinates}
+
+ #
+ # def compute_angle_l1(self, radius):
+ # dat = self.df['angles_diff'].to_numpy()
+ # l1 = l1_angle(dat, radius)
+ # self.df[f"angle_l1"] = l1
+ #
+ # def compute_angle_l2(self, radius):
+ # dat = self.df['angles_diff'].to_numpy()
+ # l2 = l2_angle(dat, radius)
+ # self.df[f"angle_l2"] = l2
+
+ # def compute_derivative(self, field):
+ # dt = self.df['ts_sec'].diff() / 60
+ #
+ # dv = self.df[field].diff().div(dt, axis=0, )
+ #
+ # self.df['d_' + field] = dv
+ #
+ # def compute_diff(self, field1, field2):
+ # self.df["diff"] = self.df.apply(lambda x: 180 - abs(abs(x[field1] - x[field2]) - 180),
+ # axis=1)
+ #
+ # def compute_all_derivatives(self):
+ # fields = ['cog', 'sog', 'rot', 'heading']
+ #
+ # for field in fields:
+ # self.compute_derivative(field)
+ #
+ # def compute_all_stds(self, radius):
+ # fields = ['cog', 'sog', 'rot', 'heading', 'latitude', 'longitude']
+ #
+ # for field in fields:
+ # dat = self.df[field].to_numpy()
+ # stds = compute_std(dat, radius)
+ # stds[-radius:] = np.nan
+ # stds[:radius] = np.nan
+ # self.df[f"{field}_std"] = stds
+ #
+ # def compute_all_dispersions(self, radius):
+ # fields = ['cog', 'heading', 'angles_diff']
+ # for field in fields:
+ # if field in self.df.columns:
+ # dat = self.df[field].to_numpy()
+ # disp = angle_dispersion(dat, radius)
+ # self.df[f"{field}_disp"] = disp
+ #
+ # def compute_position_features(self, radius):
+ # dat = np.stack([self.df.longitude.to_numpy(), self.df.latitude.to_numpy()], axis=1)
+ # std = compute_position_angle_std(dat, radius)
+ # std[-radius:] = np.nan
+ # std[:radius] = np.nan
+ # self.df[f"angle_std"] = std
+ #
+ # mean = compute_position_angle_mean(dat, radius)
+ # mean[-radius:] = np.nan
+ # mean[:radius] = np.nan
+ # self.df[f"angle_mean"] = mean
+ #
+ # mean_dist = compute_position_dist_mean(dat, radius)
+ # mean_dist[-radius:] = np.nan
+ # mean_dist[:radius] = np.nan
+ # self.df[f"dist_mean"] = mean_dist
+ #
+ # std_dist = compute_position_dist_std(dat, radius)
+ # std_dist[-radius:] = np.nan
+ # std_dist[:radius] = np.nan
+ # self.df[f"dist_std"] = std_dist
+ #
+ # angles = compute_point_angles(dat)
+ # angles[0] = np.nan
+ # angles[-1] = np.nan
+ # self.df[f"angles_diff"] = angles
+ #
+ # def compute_sqrt_sog(self):
+ # sog = self.df['sog'].to_numpy()
+ # sog[sog < 0] = 0
+ # self.df["sog_sqrt"] = np.sqrt(sog)
diff --git a/skais/process/geography.py b/skais/process/geography.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f19bb3a9eb4cc20937ba6b9e8f9e34e60ee96b7
--- /dev/null
+++ b/skais/process/geography.py
@@ -0,0 +1,55 @@
+import math
+
+import numpy as np
+from numba import jit
+
+PI = math.pi
+
+
+@jit(nopython=True)
+def to_rad(degree):
+ return (degree / 360.0) * (2 * PI)
+
+
+@jit(nopython=True)
+def to_deg(rad):
+ return (rad * 360.0) / (2 * PI)
+
+
+@jit(nopython=True)
+def bearing(p1, p2):
+ long1 = to_rad(p1[0])
+ long2 = to_rad(p2[0])
+
+ lat1 = to_rad(p1[1])
+ lat2 = to_rad(p2[1])
+
+ y = np.sin(long2 - long1) * np.cos(lat2)
+ x = np.cos(lat1) * np.sin(lat2) - np.sin(lat1) * np.cos(lat2) * np.cos(long2 - long1)
+ return to_deg(np.arctan2(y, x))
+
+
+@jit(nopython=True)
+def angle_between_three_points(p1, p2, p3):
+ alpha = bearing(p2, p1)
+ beta = bearing(p2, p3)
+ result = alpha - beta
+ if result > 180:
+ return 180 - result
+ else:
+ return result
+
+
+def compute_point_angles(dat):
+ angles = np.zeros(dat.shape[0])
+
+ p1 = (dat[0][0], dat[0][1])
+ p2 = (dat[1][0], dat[1][1])
+ angles[0] = bearing(p1, p2)
+ for i in range(1, dat.shape[0] - 1):
+ p1 = (dat[i - 1][0], dat[i - 1][1])
+ p2 = (dat[i][0], dat[i][1])
+ p3 = (dat[i + 1][0], dat[i + 1][1])
+
+ angles[i] = angle_between_three_points(p1, p2, p3)
+ return angles
diff --git a/skais/tests/ais/__init__.py b/skais/tests/ais/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/skais/tests/ais/test_ais_trajectory.py b/skais/tests/ais/test_ais_trajectory.py
index e8100e31a9b1c6051d15c7e5260eb8bfdfbd6ca3..404244a96b01418cc37486b69eb89e51a09ff02d 100644
--- a/skais/tests/ais/test_ais_trajectory.py
+++ b/skais/tests/ais/test_ais_trajectory.py
@@ -1,63 +1,58 @@
-import math
import unittest
-import pandas as pd
-import numpy as np
-
-from skais.ais.ais_trajectory import AISTrajectory, compute_std, to_rad, bearing, to_deg, compute_point_angles, \
- angle_between_three_points
+from skais.ais.ais_trajectory import *
class TestAISTrajectory(unittest.TestCase):
- def test_get_stopped_snippets_simple(self):
- ais_trajectory = AISTrajectory(pd.DataFrame(
- {
- "label": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
- "ts_sec": [i for i in range(21)]
- }
- ))
-
- expected = pd.DataFrame(
- {
- "label": [1, 1, 1, 1, 1, 1, 1, 1],
- "ts_sec": [i for i in range(13, 21)]
- }
- )
-
- snippets = ais_trajectory.get_stopped_snippets('label')
-
- self.assertEqual(len(snippets), 1)
- pd.testing.assert_frame_equal(expected, snippets[0].df.reset_index(drop=True))
-
- def test_get_stopped_snippets_multi_snippets(self):
- ais_trajectory = AISTrajectory(pd.DataFrame(
- {
- "label": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
- "ts_sec": [i * 60 for i in range(31)]
- }
- ))
-
- expected = [
- pd.DataFrame(
- {
- "label": [1, 1, 1, 1, 1, 1, 1, 1],
- "ts_sec": [i * 60 for i in range(13, 21)]
- }
- ),
- pd.DataFrame(
- {
- "label": [1, 1, 1, ],
- "ts_sec": [i * 60 for i in range(25, 28)]
- }
- ),
- ]
-
- snippets = ais_trajectory.get_stopped_snippets('label', time_gap=1)
-
- self.assertEqual(len(expected), len(snippets))
- for e, s in zip(expected, snippets):
- pd.testing.assert_frame_equal(e, s.df.reset_index(drop=True))
+ # def test_get_stopped_snippets_simple(self):
+ # ais_trajectory = AISTrajectory(pd.DataFrame(
+ # {
+ # "label": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+ # "ts_sec": [i for i in range(21)]
+ # }
+ # ))
+ #
+ # expected = pd.DataFrame(
+ # {
+ # "label": [1, 1, 1, 1, 1, 1, 1, 1],
+ # "ts_sec": [i for i in range(13, 21)]
+ # }
+ # )
+ #
+ # snippets = ais_trajectory.get_stopped_snippets('label')
+ #
+ # self.assertEqual(len(snippets), 1)
+ # pd.testing.assert_frame_equal(expected, snippets[0].df.reset_index(drop=True))
+
+ # def test_get_stopped_snippets_multi_snippets(self):
+ # ais_trajectory = AISTrajectory(pd.DataFrame(
+ # {
+ # "label": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
+ # "ts_sec": [i * 60 for i in range(31)]
+ # }
+ # ))
+ #
+ # expected = [
+ # pd.DataFrame(
+ # {
+ # "label": [1, 1, 1, 1, 1, 1, 1, 1],
+ # "ts_sec": [i * 60 for i in range(13, 21)]
+ # }
+ # ),
+ # pd.DataFrame(
+ # {
+ # "label": [1, 1, 1, ],
+ # "ts_sec": [i * 60 for i in range(25, 28)]
+ # }
+ # ),
+ # ]
+ #
+ # snippets = ais_trajectory.get_stopped_snippets('label', time_gap=1)
+ #
+ # self.assertEqual(len(expected), len(snippets))
+ # for e, s in zip(expected, snippets):
+ # pd.testing.assert_frame_equal(e, s.df.reset_index(drop=True))
def test_to_geojson(self):
trajectory = AISTrajectory(
@@ -126,22 +121,22 @@ class TestAISTrajectory(unittest.TestCase):
np.testing.assert_array_equal(result, expected)
- def test_compute_sqrt_sog(self):
- trajectory = AISTrajectory(
- pd.DataFrame(
- {
- "sog": [i for i in range(4)],
- "ts_sec": [i for i in range(4)]
- }
- )
- )
-
- trajectory.compute_sqrt_sog()
-
- result = trajectory.df["sog_sqrt"].to_numpy()
- expected = np.array([math.sqrt(i) for i in range(4)])
-
- np.testing.assert_array_equal(result, expected)
+ # def test_compute_sqrt_sog(self):
+ # trajectory = AISTrajectory(
+ # pd.DataFrame(
+ # {
+ # "sog": [i for i in range(4)],
+ # "ts_sec": [i for i in range(4)]
+ # }
+ # )
+ # )
+ #
+ # trajectory.compute_sqrt_sog()
+ #
+ # result = trajectory.df["sog_sqrt"].to_numpy()
+ # expected = np.array([math.sqrt(i) for i in range(4)])
+ #
+ # np.testing.assert_array_equal(result, expected)
def test_interpolation(self):
trajectory = AISTrajectory(
@@ -187,202 +182,50 @@ class TestAISTrajectory(unittest.TestCase):
pd.testing.assert_frame_equal(trajectory.df, expected)
- def test_compute_angle_l1(self):
- trajectory = AISTrajectory(
- pd.DataFrame(
- {
- "ts_sec": [i for i in range(15)],
- "angles_diff": [0 for _ in range(5)] + [1 for _ in range(5)] + [-1 for i in range(5)]
- }
- )
- )
-
- trajectory.compute_angle_l1(2)
-
- result = trajectory.df["angle_l1"].to_numpy()
- expected = np.array([0, 0, 0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5])
-
- np.testing.assert_array_equal(result, expected)
-
- def test_compute_angle_l2(self):
- trajectory = AISTrajectory(
- pd.DataFrame(
- {
- "ts_sec": [i for i in range(15)],
- "angles_diff": [0 for _ in range(5)] + [1 for _ in range(5)] + [-1 for i in range(5)]
- }
- )
- )
-
- trajectory.compute_angle_l2(2)
-
- result = trajectory.df["angle_l2"].to_numpy()
- expected = np.array(np.sqrt([0, 0, 0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5]))
-
- np.testing.assert_array_equal(result, expected)
-
- def test_compute_std(self):
- dat = np.array([0 for _ in range(5)] + [1 for _ in range(5)] + [-1 for i in range(5)])
- radius = 2
-
- result = compute_std.py_func(dat, radius)
- expected = np.array(
- [0, 0, 0, 0.4, np.sqrt(30 / 125), np.sqrt(30 / 125), 0.4, 0, 0.8, np.sqrt(120 / 125), np.sqrt(120 / 125),
- 0.8, 0, 0, 0])
-
- np.testing.assert_almost_equal(result, expected)
-
- def test_to_rad_0(self):
- result = to_rad.py_func(0)
- expected = 0
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_rad_90(self):
- result = to_rad.py_func(90)
- expected = np.pi / 2
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_rad_180(self):
- result = to_rad.py_func(180)
- expected = np.pi
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_rad_360(self):
- result = to_rad.py_func(360)
- expected = 2 * np.pi
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_rad_m180(self):
- result = to_rad.py_func(-180)
- expected = -np.pi
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_rad_m90(self):
- result = to_rad.py_func(-90)
- expected = -np.pi / 2
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_rad_270(self):
- result = to_rad.py_func(270)
- expected = 3 * np.pi / 2
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_rad_810(self):
- result = to_rad.py_func(810)
- expected = 9 * np.pi / 2
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_deg_0(self):
- result = to_deg.py_func(0)
- expected = 0
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_deg_90(self):
- result = to_deg.py_func(np.pi / 2)
- expected = 90
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_deg_180(self):
- result = to_deg.py_func(np.pi)
- expected = 180
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_deg_360(self):
- result = to_deg.py_func(2 * np.pi)
- expected = 360
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_deg_m180(self):
- result = to_deg.py_func(-np.pi)
- expected = -180
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_deg_m90(self):
- result = to_deg.py_func(-np.pi / 2)
- expected = -90
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_deg_270(self):
- result = to_deg.py_func(3 * np.pi / 2)
- expected = 270
-
- self.assertAlmostEqual(result, expected)
-
- def test_to_deg_810(self):
- result = to_deg.py_func(9 * np.pi / 2)
- expected = 810
-
- self.assertAlmostEqual(result, expected)
-
- def test_bearing_rand(self):
- paris = (2.3522, 48.8566)
- marseille = (5.3698, 43.2965)
-
- result = bearing.py_func(paris, marseille)
- expected = 158.2694
-
- self.assertAlmostEqual(result, expected, places=4)
-
- def test_bearing_along_equator(self):
- p1 = (0, 0)
- p2 = (90, 0)
-
- result = bearing.py_func(p1, p2)
- expected = 90
-
- self.assertAlmostEqual(result, expected)
-
- def test_bearing_equator_to_north_pole(self):
- p1 = (0, 0)
- p2 = (0, 90)
-
- result = bearing.py_func(p1, p2)
- expected = 0
-
- self.assertAlmostEqual(result, expected)
-
- def test_angle_between_three_points_1(self):
- p1 = (0, -10)
- p2 = (0, 0)
- p3 = (10, 0)
-
- self.assertAlmostEqual(90, angle_between_three_points.py_func(p1, p2, p3), places=3)
-
- def test_angle_between_three_points_2(self):
- p1 = (0, -10)
- p2 = (0, 0)
- p3 = (-10, 0)
-
- self.assertAlmostEqual(-90, angle_between_three_points.py_func(p1, p2, p3), places=3)
-
- def test_angle_between_three_points_3(self):
- p1 = (0, -10)
- p2 = (0, 0)
- p3 = (10, 10)
-
- self.assertAlmostEqual(180 - 44.56139, angle_between_three_points.py_func(p1, p2, p3), places=3)
-
- def test_angle_between_three_points_4(self):
- p1 = (0, 0)
- p2 = (0, 10)
- p3 = (0, 0)
-
- self.assertAlmostEqual(0, abs(angle_between_three_points.py_func(p1, p2, p3)), places=3)
-
+ # def test_compute_angle_l1(self):
+ # trajectory = AISTrajectory(
+ # pd.DataFrame(
+ # {
+ # "ts_sec": [i for i in range(15)],
+ # "angles_diff": [0 for _ in range(5)] + [1 for _ in range(5)] + [-1 for i in range(5)]
+ # }
+ # )
+ # )
+ #
+ # trajectory.compute_angle_l1(2)
+ #
+ # result = trajectory.df["angle_l1"].to_numpy()
+ # expected = np.array([0, 0, 0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5])
+ #
+ # np.testing.assert_array_equal(result, expected)
+ #
+ # def test_compute_angle_l2(self):
+ # trajectory = AISTrajectory(
+ # pd.DataFrame(
+ # {
+ # "ts_sec": [i for i in range(15)],
+ # "angles_diff": [0 for _ in range(5)] + [1 for _ in range(5)] + [-1 for i in range(5)]
+ # }
+ # )
+ # )
+ #
+ # trajectory.compute_angle_l2(2)
+ #
+ # result = trajectory.df["angle_l2"].to_numpy()
+ # expected = np.array(np.sqrt([0, 0, 0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5]))
+ #
+ # np.testing.assert_array_equal(result, expected)
+ #
+ # def test_compute_std(self):
+ # dat = np.array([0 for _ in range(5)] + [1 for _ in range(5)] + [-1 for i in range(5)])
+ # radius = 2
+ #
+ # result = compute_std.py_func(dat, radius)
+ # expected = np.array(
+ # [0, 0, 0, 0.4, np.sqrt(30 / 125), np.sqrt(30 / 125), 0.4, 0, 0.8, np.sqrt(120 / 125), np.sqrt(120 / 125),
+ # 0.8, 0, 0, 0])
+ #
+ # np.testing.assert_almost_equal(result, expected)
# def test_compute_position_angle_std(self):
# dat = [(0, i * 10) for i in range(5)] + [(0, 50 - i * 10) for i in range(5)]
@@ -406,12 +249,4 @@ class TestAISTrajectory(unittest.TestCase):
# dat = [(0, i * 10) for i in range(5)] + [(0, 50 - i * 10) for i in range(5)]
# result = compute_position_dist_std(dat, 2)
#
- # # hard to test
-
- def test_compute_point_angles(self):
- dat = np.array([(0, 0), (0, 10), (10, 10), (0, 10)])
- result = compute_point_angles(dat)
-
- expected = np.array([0, 90, 0, 0])
-
- np.testing.assert_almost_equal(expected, result, decimal=0)
+ # # hard to test
\ No newline at end of file
diff --git a/skais/tests/process/__init__.py b/skais/tests/process/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/skais/tests/process/test_geography.py b/skais/tests/process/test_geography.py
new file mode 100644
index 0000000000000000000000000000000000000000..be1f844dfd0cfdddf9bb284ab75b6f5d1c9ab30e
--- /dev/null
+++ b/skais/tests/process/test_geography.py
@@ -0,0 +1,168 @@
+import unittest
+from skais.process.geography import *
+
+
+class MyTestCase(unittest.TestCase):
+ def test_to_rad_0(self):
+ result = to_rad.py_func(0)
+ expected = 0
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_rad_90(self):
+ result = to_rad.py_func(90)
+ expected = np.pi / 2
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_rad_180(self):
+ result = to_rad.py_func(180)
+ expected = np.pi
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_rad_360(self):
+ result = to_rad.py_func(360)
+ expected = 2 * np.pi
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_rad_m180(self):
+ result = to_rad.py_func(-180)
+ expected = -np.pi
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_rad_m90(self):
+ result = to_rad.py_func(-90)
+ expected = -np.pi / 2
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_rad_270(self):
+ result = to_rad.py_func(270)
+ expected = 3 * np.pi / 2
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_rad_810(self):
+ result = to_rad.py_func(810)
+ expected = 9 * np.pi / 2
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_deg_0(self):
+ result = to_deg.py_func(0)
+ expected = 0
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_deg_90(self):
+ result = to_deg.py_func(np.pi / 2)
+ expected = 90
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_deg_180(self):
+ result = to_deg.py_func(np.pi)
+ expected = 180
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_deg_360(self):
+ result = to_deg.py_func(2 * np.pi)
+ expected = 360
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_deg_m180(self):
+ result = to_deg.py_func(-np.pi)
+ expected = -180
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_deg_m90(self):
+ result = to_deg.py_func(-np.pi / 2)
+ expected = -90
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_deg_270(self):
+ result = to_deg.py_func(3 * np.pi / 2)
+ expected = 270
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_to_deg_810(self):
+ result = to_deg.py_func(9 * np.pi / 2)
+ expected = 810
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_bearing_rand(self):
+ paris = (2.3522, 48.8566)
+ marseille = (5.3698, 43.2965)
+
+ result = bearing.py_func(paris, marseille)
+ expected = 158.2694
+
+ self.assertAlmostEqual(result, expected, places=4)
+
+ def test_bearing_along_equator(self):
+ p1 = (0, 0)
+ p2 = (90, 0)
+
+ result = bearing.py_func(p1, p2)
+ expected = 90
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_bearing_equator_to_north_pole(self):
+ p1 = (0, 0)
+ p2 = (0, 90)
+
+ result = bearing.py_func(p1, p2)
+ expected = 0
+
+ self.assertAlmostEqual(result, expected)
+
+ def test_angle_between_three_points_1(self):
+ p1 = (0, -10)
+ p2 = (0, 0)
+ p3 = (10, 0)
+
+ self.assertAlmostEqual(90, angle_between_three_points.py_func(p1, p2, p3), places=3)
+
+ def test_angle_between_three_points_2(self):
+ p1 = (0, -10)
+ p2 = (0, 0)
+ p3 = (-10, 0)
+
+ self.assertAlmostEqual(-90, angle_between_three_points.py_func(p1, p2, p3), places=3)
+
+ def test_angle_between_three_points_3(self):
+ p1 = (0, -10)
+ p2 = (0, 0)
+ p3 = (10, 10)
+
+ self.assertAlmostEqual(180 - 44.56139, angle_between_three_points.py_func(p1, p2, p3), places=3)
+
+ def test_angle_between_three_points_4(self):
+ p1 = (0, 0)
+ p2 = (0, 10)
+ p3 = (0, 0)
+
+ self.assertAlmostEqual(0, abs(angle_between_three_points.py_func(p1, p2, p3)), places=3)
+
+ def test_compute_point_angles(self):
+ dat = np.array([(0, 0), (0, 10), (10, 10), (0, 10)])
+ result = compute_point_angles(dat)
+
+ expected = np.array([0, 90, 0, 0])
+
+ np.testing.assert_almost_equal(expected, result, decimal=0)
+ self.assertTrue(True)
+
+
+if __name__ == '__main__':
+ unittest.main()