Start basic tools for network manipulation

Author: AntSimi

examples/16_network/pet_relative.py

@@ -0,0 +1,40 @@
+"""
+Network basic manipulation
+==========================
+"""
+
+from matplotlib import pyplot as plt
+
+import py_eddy_tracker.gui
+from py_eddy_tracker import data
+from py_eddy_tracker.observations.network import NetworkObservations
+from py_eddy_tracker.observations.tracking import TrackEddiesObservations
+
+# %%
+# Load data
+# ---------
+# Load data where observations are put in same network but no segmentation
+e = TrackEddiesObservations.load_file(data.get_path("c568803.nc"))
+n = NetworkObservations.from_split_network(e, e.split_network(intern=False, window=5))
+
+# %%
+# Timeline
+# --------
+
+# %%
+# Display timeline
+fig = plt.figure(figsize=(15, 8))
+ax = fig.add_axes([0.04, 0.04, 0.92, 0.92])
+n.display_timeline(ax)
+
+# %%
+# Display timeline with event
+fig = plt.figure(figsize=(15, 8))
+ax = fig.add_axes([0.04, 0.04, 0.92, 0.92])
+n.display_timeline(ax, event=True)
+plt.show()
+
+# %%
+# Keep close relative
+# -------------------
+# First choose an observation in the network

src/py_eddy_tracker/__init__.py

@@ -374,15 +374,35 @@ def parse_args(self, *args, **kwargs):
             long_name="Trajectory number", comment="Trajectory identification number"
         ),
     ),
-    sub_track=dict(
+    segment=dict(
         attr_name=None,
-        nc_name="sub_track",
+        nc_name="segment",
         nc_type="uint32",
         nc_dims=("obs",),
         nc_attr=dict(
             long_name="Segment Number", comment="Segment number inside a group"
         ),
     ),
+    previous_obs=dict(
+        attr_name=None,
+        nc_name="previous_obs",
+        nc_type="int32",
+        nc_dims=("obs",),
+        nc_attr=dict(
+            long_name="Previous obs index",
+            comment="Index of previous obs, if there are a spliting",
+        ),
+    ),
+    next_obs=dict(
+        attr_name=None,
+        nc_name="next_obs",
+        nc_type="int32",
+        nc_dims=("obs",),
+        nc_attr=dict(
+            long_name="Next obs index",
+            comment="Index of next obs, if there are a merging",
+        ),
+    ),
     n=dict(
         attr_name=None,
         nc_name="observation_number",

src/py_eddy_tracker/appli/network.py

@@ -51,6 +51,6 @@ def divide_network():
         include_vars=("time", "track", "latitude", "longitude", *contour_name),
     )
     ids = e.split_network(intern=args.intern, window=args.window, minimal_area=False)
-    e = e.add_fields(("sub_track",))
-    e.sub_track[:] = ids["track"]
+    e = e.add_fields(("segment",))
+    e.segment[:] = ids["track"]
     e.write_file(filename=args.out)

src/py_eddy_tracker/observations/network.py

@@ -6,7 +6,7 @@
 from glob import glob
 
 from numba import njit
-from numpy import arange, array, bincount, empty, uint32, unique
+from numpy import arange, array, bincount, empty, ones, uint32, unique
 
 from ..poly import bbox_intersection, vertice_overlap
 from .observation import EddiesObservations
@@ -58,6 +58,97 @@ def load_contour(self, filename):
         return self.DATA[filename]
 
 
+class NetworkObservations(EddiesObservations):
+
+    __slots__ = tuple()
+
+    NOGROUP = 0
+
+    @property
+    def elements(self):
+        elements = super().elements
+        elements.extend(["track", "segment", "next_obs", "previous_obs"])
+        return list(set(elements))
+
+    @classmethod
+    def from_split_network(cls, group_dataset, indexs, **kwargs):
+        """
+        Build a NetworkObservations object with Group dataset and indexs
+
+        :param TrackEddiesObservations group_dataset: Group dataset
+        :param indexs: result from split_network
+        return NetworkObservations
+        """
+        index_order = indexs.argsort(order=("group", "track", "time"))
+        network = cls.new_like(group_dataset, len(group_dataset), **kwargs)
+        network.sign_type = group_dataset.sign_type
+        for field in group_dataset.elements:
+            if field not in network.elements:
+                continue
+            network[field][:] = group_dataset[field][index_order]
+        network.segment[:] = indexs["track"][index_order]
+        # n & p must be re-index
+        n, p = indexs["next_obs"][index_order], indexs["previous_obs"][index_order]
+        translate = empty(index_order.max() + 1, dtype="i4")
+        translate[index_order] = arange(index_order.shape[0])
+        m = n != -1
+        n[m] = translate[n[m]]
+        m = p != -1
+        p[m] = translate[p[m]]
+        network.next_obs[:] = n
+        network.previous_obs[:] = p
+        return network
+
+    def relative(self, i_obs, order=2, direct=True, only_past=False, only_future=False):
+        pass
+
+    def only_one_network(self):
+        """
+        Raise a warning or error?
+        if there are more than one network
+        """
+        # TODO
+        pass
+
+    def display_timeline(self, ax, event=False):
+        """
+        Must be call on only one network
+        """
+        self.only_one_network()
+        j = 0
+        line_kw = dict(
+            ls="-",
+            marker=".",
+            markersize=6,
+            zorder=1,
+            lw=3,
+        )
+        for i, b0, b1 in self.iter_on("segment"):
+            x = self.time[i]
+            if x.shape[0] == 0:
+                continue
+            y = b0 * ones(x.shape)
+            line = ax.plot(x, y, **line_kw, color=self.COLORS[j % self.NB_COLORS])[0]
+            if event:
+                event_kw = dict(color=line.get_color(), ls="-", zorder=1)
+                i_n, i_p = (
+                    self.next_obs[i.stop - 1],
+                    self.previous_obs[i.start],
+                )
+                if i_n != -1:
+                    ax.plot(
+                        (x[-1], self.time[i_n]), (b0, self.segment[i_n]), **event_kw
+                    )
+                    ax.plot(x[-1], b0, color="k", marker=">", markersize=10, zorder=-1)
+                if i_p != -1:
+                    ax.plot((x[0], self.time[i_p]), (b0, self.segment[i_p]), **event_kw)
+                    ax.plot(x[0], b0, color="k", marker="*", markersize=12, zorder=-1)
+            j += 1
+
+    def insert_virtual(self):
+        pass
+
+
 class Network:
     __slots__ = (
         "window",

src/py_eddy_tracker/observations/observation.py

@@ -144,6 +144,27 @@ class EddiesObservations(object):
         "height_inner_contour",
     ]
 
+    COLORS = [
+        "sienna",
+        "red",
+        "darkorange",
+        "gold",
+        "palegreen",
+        "limegreen",
+        "forestgreen",
+        "mediumblue",
+        "dodgerblue",
+        "lightskyblue",
+        "violet",
+        "blueviolet",
+        "darkmagenta",
+        "darkgrey",
+        "dimgrey",
+        "steelblue",
+    ]
+
+    NB_COLORS = len(COLORS)
+
     def __init__(
         self,
         size=0,
@@ -553,9 +574,9 @@ def __copy__(self):
     def copy(self):
         return self.__copy__()
 
-    @staticmethod
-    def new_like(eddies, new_size: int):
-        return eddies.__class__(
+    @classmethod
+    def new_like(cls, eddies, new_size: int):
+        return cls(
             new_size,
             track_extra_variables=eddies.track_extra_variables,
             track_array_variables=eddies.track_array_variables,

src/py_eddy_tracker/observations/tracking.py

@@ -620,9 +620,9 @@ def split_network(self, intern=True, **kwargs):
             sl = slice(i_s, i_e)
             local_ids = ids[sl]
             self.set_tracks(self[xname][sl], self[yname][sl], local_ids, **kwargs)
-            m = local_ids["previous_obs"] == -1
+            m = local_ids["previous_obs"] != -1
             local_ids["previous_obs"][m] += i_s
-            m = local_ids["next_obs"] == -1
+            m = local_ids["next_obs"] != -1
             local_ids["next_obs"][m] += i_s
         return ids