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

@@ -88,7 +88,7 @@ def __get_bounding_box__(bounding_box, positions, ref_index):
         upper_lon = center_lon + distance_to_center
         lower_lon = center_lon - distance_to_center
     elif type(bounding_box) is list:
-        if isinstance(bounding_box[0], numbers.Number):
+        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]
@@ -153,7 +153,8 @@ def generate_points_with_features(data, positions, features_vectors, bounds, nod
 
 
 @jit(nopython=True)
-def generate_links(data, positions, height, width, lower_lat, upper_lat, lower_lon, upper_lon, values, interpolate=None):
+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]
@@ -164,19 +165,24 @@ def generate_links(data, positions, height, width, lower_lat, upper_lat, lower_l
         x_nxt, y_nxt = get_coord(latitude, longitude, height, width, lower_lat, upper_lat, lower_lon,
                                  upper_lon)
         lon, lat = longitude, latitude
-        if interpolate is not None and nxt_value != current_value:
-            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)):
+
+        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]
-        else:
-            for x, y in bresenham(x_prv, y_prev, x_nxt, y_nxt):
-                for i in range(len(current_value)):
+                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
 
 
@@ -358,8 +364,8 @@ 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', ref_index=-1,
-                                      features=None, node_size=0, interpolation=None):
+    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()
 
@@ -393,14 +399,15 @@ class AISTrajectory(AISPoints):
 
             generate_points(data, positions, height, width, node_size, lower_lat, upper_lat, lower_lon, upper_lon)
 
-            if link:
+            if link is not None:
                 generate_links(data, positions, height, width, lower_lat, upper_lat, lower_lon, upper_lon,
-                               np.ones((len(positions), 1)))
+                               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:
+                                          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), interpolation)
+                               generate_values(features_vectors, bounds), link)
+
         return data