Draft: Develop

Improvements:

• Normalization using AIS_Points now raise exception if given a bad dictionary

New features:

• Added choosing fields for generating images for adding channels
• Added centering of image on last point
• Added chosing bounding box of image
• Added selecting range of values for features

skais/ais/ais_trajectory.py

+import numbers
 import random
+from copy import copy
 
 import pandas as pd
 import numpy as np
@@ -7,7 +9,7 @@ from scipy.interpolate import interp1d
 
 from skais.utils.geography import great_circle, position_from_distance, get_coord
 from skais.ais.ais_points import AISPoints
-from skais.utils.geometry import bresenham
+from skais.utils.geometry import bresenham, dist_on_grid
 
 
 @jit(nopython=True)
@@ -59,6 +61,143 @@ def apply_time_sequence(dat, time, func):
     return result
 
 
+@jit(nopython=True)
+def __get_image_value__(features, bounds):
+    value = np.zeros((len(features)))
+    i = 0
+    for f, b in zip(features, bounds):
+        value[i] = (1 - (b[1] - f - b[0]) / (b[1] - b[0]))
+        i = i + 1
+    return value
+
+
+def __get_bounding_box__(bounding_box, positions, ref_index):
+    if bounding_box == 'fit':
+        lower_lon, upper_lon = (min(positions[:, 0]), max(positions[:, 0]))
+        lower_lat, upper_lat = (min(positions[:, 1]), max(positions[:, 1]))
+    elif bounding_box == 'centered':
+        center_lon, center_lat = positions[ref_index]
+        min_lon, max_lon = (min(positions[:, 0]), max(positions[:, 0]))
+        min_lat, max_lat = (min(positions[:, 1]), max(positions[:, 1]))
+
+        distance_to_center = max(center_lon - min_lon, max_lon - center_lon, center_lat - min_lat,
+                                 max_lat - center_lat)
+
+        upper_lat = center_lat + distance_to_center
+        lower_lat = center_lat - distance_to_center
+        upper_lon = center_lon + distance_to_center
+        lower_lon = center_lon - distance_to_center
+    elif type(bounding_box) is list:
+        if not isinstance(bounding_box[0], numbers.Number):
+            upper_lon = bounding_box[1][0]
+            lower_lon = bounding_box[0][0]
+            upper_lat = bounding_box[1][1]
+            lower_lat = bounding_box[0][1]
+        else:
+            center_lon, center_lat = positions[ref_index]
+            distance_to_center_lon = bounding_box[0]
+            distance_to_center_lat = bounding_box[1]
+            upper_lat = center_lat + distance_to_center_lat
+            lower_lat = center_lat - distance_to_center_lat
+            upper_lon = center_lon + distance_to_center_lon
+            lower_lon = center_lon - distance_to_center_lon
+    else:
+        raise ValueError(f"Option not supported: {bounding_box}")
+
+    if lower_lat == upper_lat:
+        lower_lat -= 1
+        upper_lat += 1
+    if lower_lon == upper_lon:
+        lower_lon -= 1
+        upper_lon += 1
+
+    return lower_lon, upper_lon, lower_lat, upper_lat
+
+
+@jit(nopython=True)
+def generate_points(data, positions, height, width, node_size, lower_lat, upper_lat, lower_lon, upper_lon):
+    for longitude, latitude in positions:
+        x_coord, y_coord = get_coord(latitude, longitude, height, width, lower_lat, upper_lat, lower_lon,
+                                     upper_lon)
+
+        x_lower_bound = max(0, x_coord - node_size)
+        x_upper_bound = min(height - 1, x_coord + node_size)
+
+        y_lower_bound = max(0, y_coord - node_size)
+        y_upper_bound = min(width - 1, y_coord + node_size)
+
+        for x in range(x_lower_bound, x_upper_bound + 1):
+            for y in range(y_lower_bound, y_upper_bound + 1):
+                data[x, y] = [1]
+
+
+@jit(nopython=True)
+def generate_points_with_features(data, positions, features_vectors, bounds, node_size, height, width,
+                                  lower_lat, upper_lat, lower_lon, upper_lon):
+    for pos, f in zip(positions, features_vectors):
+        latitude = pos[1]
+        longitude = pos[0]
+        x_coord, y_coord = get_coord(latitude, longitude, height, width, lower_lat, upper_lat, lower_lon,
+                                     upper_lon)
+        value = __get_image_value__(f, bounds)
+        x_lower_bound = max(0, x_coord - node_size)
+        x_upper_bound = min(height - 1, x_coord + node_size)
+
+        y_lower_bound = max(0, y_coord - node_size)
+        y_upper_bound = min(width - 1, y_coord + node_size)
+
+        for x in range(x_lower_bound, x_upper_bound + 1):
+            for y in range(y_lower_bound, y_upper_bound + 1):
+                for i, v in enumerate(value):
+                    data[x, y, i] = v
+
+
+@jit(nopython=True)
+def generate_links(data, positions, height, width, lower_lat, upper_lat, lower_lon, upper_lon, values,
+                   link_type=None):
+    lon, lat = positions[0, 0], positions[0, 1]
+
+    current_value = values[0]
+    for pos, nxt_value in zip(positions[1:], values[1:]):
+        latitude = pos[1]
+        longitude = pos[0]
+        x_prv, y_prev = get_coord(lat, lon, height, width, lower_lat, upper_lat, lower_lon, upper_lon)
+        x_nxt, y_nxt = get_coord(latitude, longitude, height, width, lower_lat, upper_lat, lower_lon,
+                                 upper_lon)
+        lon, lat = longitude, latitude
+
+        dist = dist_on_grid(x_prv, y_prev, x_nxt, y_nxt)
+        for x, y in bresenham(x_prv, y_prev, x_nxt, y_nxt):
+            dist_prev = dist_on_grid(x_prv, y_prev, x, y)
+            dist_next = dist_on_grid(x, y, x_nxt, y_nxt)
+
+            pixel_color = current_value * (1 - dist_prev / dist) + nxt_value * (1 - dist_next / dist)
+            for i in range(len(pixel_color)):
+                if nxt_value[i] == current_value[i]:
+                    data[x, y, i] = current_value[i]
+                elif link_type == 'interpolate':
+                    data[x, y, i] = pixel_color[i]
+                elif link_type == 'previous':
+                    data[x, y, i] = current_value[i]
+                elif link_type == 'next':
+                    data[x, y, i] = nxt_value[i]
+                elif link_type == 'solid':
+                    data[x, y, i] = 1
+        current_value = nxt_value
+
+
+@jit(nopython=True)
+def generate_values(features_vectors, bounds):
+    result = np.zeros(features_vectors.shape)
+    for i in range(len(features_vectors)):
+        features = features_vectors[i]
+        value = __get_image_value__(features, bounds)
+        for j in range(len(value)):
+            v = value[j]
+            result[i, j] = v
+    return result
+
+
 class AISTrajectory(AISPoints):
     def __init__(self, df, mmsi=0, interpolation_time=None):
         df = df.drop_duplicates(subset=['ts_sec'])
@@ -225,44 +364,50 @@ class AISTrajectory(AISPoints):
                 result.append((row['ts_sec'], current_label))
         return result
 
-    def generate_array_from_positions(self, height=256, width=256, link=True, bounding_box='fit', features=None,
-                                      node_size=0):
-        nb_channels = 1
-        if features is not None:
-            nb_channels = len(features)
-        data = np.zeros((height, width, nb_channels), dtype=np.uint8)
-        if bounding_box != 'fit':
-            raise ValueError("feature not implemented")
+    def generate_array_from_positions(self, height=256, width=256, link=None, bounding_box='fit', ref_index=-1,
+                                      features=None, node_size=0):
+
         positions = self.df[['longitude', 'latitude']].to_numpy()
-        min_lon, max_lon = (min(positions[:, 0]), max(positions[:, 0]))
-        min_lat, max_lat = (min(positions[:, 1]), max(positions[:, 1]))
-        if min_lat == max_lat:
-            min_lat -= 1
-            max_lat += 1
-        if min_lon == max_lon:
-            min_lon -= 1
-            max_lon += 1
-
-        for longitude, latitude in positions:
-            x_coord, y_coord = get_coord(latitude, longitude, height, width, min_lat, max_lat, min_lon, max_lon)
-
-            x_lower_bound = max(0, x_coord - node_size)
-            x_upper_bound = min(height - 1, x_coord + node_size)
-
-            y_lower_bound = max(0, y_coord - node_size)
-            y_upper_bound = min(width - 1, y_coord + node_size)
-
-            for x in range(x_lower_bound, x_upper_bound + 1):
-                for y in range(y_lower_bound, y_upper_bound + 1):
-                    data[x, y] = [1]
-
-        if link:
-            lon, lat = positions[0, 0], positions[0, 1]
-            for longitude, latitude in positions[1:]:
-                x_prv, y_prev = get_coord(lat, lon, height, width, min_lat, max_lat, min_lon, max_lon)
-                x_nxt, y_nxt = get_coord(latitude, longitude, height, width, min_lat, max_lat, min_lon, max_lon)
-
-                lon, lat = longitude, latitude
-                for x, y in bresenham(x_prv, y_prev, x_nxt, y_nxt):
-                    data[x, y] = [1]
+
+        lower_lon, upper_lon, lower_lat, upper_lat = __get_bounding_box__(bounding_box, positions, ref_index)
+
+        bounds = []
+        if features is None:
+            features_vectors = None
+        elif type(features) is list:
+            features_vectors = self.df[features].to_numpy()
+            for c in features_vectors.T:
+                bounds.append([0, max(c)])
+        elif type(features) is str:
+            features_vectors = self.df[[features]].to_numpy()
+            for c in features_vectors.T:
+                bounds.append([0, max(c)])
+        elif type(features) is dict:
+            bounds = list(features.values())
+            features_vectors = self.df[features.keys()].to_numpy()
+        else:
+            raise TypeError("Type not supported")
+
+        if features_vectors is not None:
+            nb_channels = len(features_vectors.T)
+            bounds = np.array(bounds)
+        else:
+            nb_channels = 1
+        data = np.zeros((height, width, nb_channels), dtype=float)
+
+        if features_vectors is None:
+
+            generate_points(data, positions, height, width, node_size, lower_lat, upper_lat, lower_lon, upper_lon)
+
+            if link is not None:
+                generate_links(data, positions, height, width, lower_lat, upper_lat, lower_lon, upper_lon,
+                               np.ones((len(positions), 1)), link)
+
+        else:
+            generate_points_with_features(data, positions, features_vectors, np.array(bounds), node_size, height, width,
+                                          lower_lat, upper_lat, lower_lon, upper_lon)
+            if link is not None:
+                generate_links(data, positions, height, width, lower_lat, upper_lat, lower_lon, upper_lon,
+                               generate_values(features_vectors, bounds), link)
+
         return data