xarray-behave 0.35.4__tar.gz → 0.35.7__tar.gz

{xarray-behave-0.35.4 → xarray-behave-0.35.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xarray-behave
-Version: 0.35.4
+Version: 0.35.7
 Summary: xarray tools for behavioral data.
 Author-email: Jan Clemens <clemensjan@googlemail.com>
 Requires-Python: >3.6

{xarray-behave-0.35.4 → xarray-behave-0.35.7}/src/xarray_behave/__init__.py

@@ -1,6 +1,6 @@
 """xarray tools for behavioral data."""
 
-__version__ = "0.35.4"
+__version__ = "0.35.7"
 
 from .xarray_behave import assemble, assemble_metrics, load, save
 import os

{xarray-behave-0.35.4 → xarray-behave-0.35.7}/src/xarray_behave/annot.py

@@ -87,7 +87,7 @@ class Events(UserDict):
     ):
         if possible_event_names is None:
             possible_event_names = []
-        unique_names = list(set(names))
+        unique_names = list(np.unique(names))  # use `np.unique` instead of `set` to have reproducible order of names for now
         unique_names.extend(possible_event_names)
         dct = {name: [] for name in unique_names}
 
@@ -548,6 +548,18 @@ class Events(UserDict):
         self[name] = np.delete(self[name], indices, axis=0)
         return indices
 
+    def sort(self, names: Optional[List[str]] = None):
+        """Sort annotations by start time.
+
+        Args:
+            names (Optional[List[str]], optional): _description_. Defaults to None.
+        """
+        if names is None:
+            names = self.names
+
+        for name in names:
+            self[name] = self[name][np.argsort(self[name][:, 0]), :]
+
     def find_next(self, t: float, names: Optional[List[str]] = None):
         """Find event starting after `t` of type in names.
 
@@ -564,7 +576,9 @@ class Events(UserDict):
             names = self.names
 
         nxt = []
+
         for name in names:
+            self.sort([name])
             cmp = self[name][:, 0] > t
             if np.any(cmp):
                 nxt.append(self[name][np.argmax(cmp), 0])
@@ -588,6 +602,7 @@ class Events(UserDict):
 
         nxt = []
         for name in names:
+            self.sort([name])
             cmp = self[name][:, 1] < t
             if np.any(cmp):
                 nxt.append(self[name][np.argmin(cmp) - 1, 0])

{xarray-behave-0.35.4 → xarray-behave-0.35.7}/src/xarray_behave/gui/app.py

@@ -674,6 +674,10 @@ class MainWindow(QtWidgets.QMainWindow):
             if form_data["segment_minlen"] is None:
                 form_data["segment_minlen"] = 0
 
+            if form_data["filter_song"] == "no":
+                form_data["bandpass_low_freq"] = None
+                form_data["bandpass_up_freq"] = None
+
             if form_data["file"] != "Current file":
                 if form_data["folder"] != " ":
                     file_path = form_data["folder"]
@@ -696,6 +700,9 @@ class MainWindow(QtWidgets.QMainWindow):
                     segment_thres=form_data["event_thres"],
                     segment_fillgap=form_data["segment_fillgap"],
                     segment_minlen=form_data["segment_minlen"],
+                    bandpass_low_freq=form_data["bandpass_low_freq"],
+                    bandpass_up_freq=form_data["bandpass_up_freq"],
+                    resample=form_data["resample"],
                 )
                 return
             elif hasattr(self, "ds") and form_data["file"] == "Current file":
@@ -721,10 +728,10 @@ class MainWindow(QtWidgets.QMainWindow):
                 # select batch size so that at least 10 batches are run
                 # minimizes loss of annotations from batch size "quantization" errors
                 batch_size = 32
-                nb_batches = lambda batch_size: int(
+                nb_batches = int(
                     np.floor((audio.shape[0] - ((batch_size - 1) + params["nb_hist"])) / (params["stride"] * (batch_size)))
                 )
-                while nb_batches(batch_size) < 10 and batch_size > 1:
+                while nb_batches < 10 and batch_size > 1:
                     batch_size -= 1
 
                 logger.info("   Running inference on audio.")
@@ -733,10 +740,13 @@ class MainWindow(QtWidgets.QMainWindow):
                 fs_model = params["samplerate_x_Hz"]
                 fs_audio = self.ds.song_raw.attrs["sampling_rate_Hz"]
 
-                if form_data["resample_audio"] and fs_audio and fs_audio != fs_model:
+                if form_data["resample"] and fs_audio and fs_audio != fs_model:
                     logger.info(f"   Resampling. Audio rate is {fs_audio}Hz but model was trained on data with {fs_model}Hz.")
                     audio = das.utils.resample(audio, fs_audio, fs_model)
 
+                import rich
+
+                rich.print(form_data)
                 events, segments, _, _ = das.predict.predict(
                     audio,
                     model_path,
@@ -749,6 +759,10 @@ class MainWindow(QtWidgets.QMainWindow):
                     segment_thres=form_data["event_thres"],
                     segment_fillgap=form_data["segment_fillgap"],
                     segment_minlen=form_data["segment_minlen"],
+                    bandpass_low_freq=form_data["bandpass_low_freq"],
+                    bandpass_up_freq=form_data["bandpass_up_freq"],
+                    resample=form_data["resample"],
+                    fs_audio=fs_audio,
                 )
 
                 # Process detected song
@@ -2070,24 +2084,26 @@ class PSV(MainWindow):
             self.update_frame()
 
     def set_prev_cuepoint(self, qt_keycode):
-        if self.edit_only_current_events:  # of the currently active type
-            names = [self.current_event_name]
-        else:  # of any type
-            names = self.event_times.names
-
+        # if self.edit_only_current_events:  # of the currently active type
+        #     names = [self.current_event_name]
+        # else:  # of any type
+        #     names = self.event_times.names
+        names = [self.current_event_name]
         t = (self.t0 - 1) / self.fs_song
         nxt = self.event_times.find_prev(t, names)
+
         if nxt is not None:
             self.t0 = nxt * self.fs_song
 
     def set_next_cuepoint(self, qt_keycode):
-        if self.edit_only_current_events:  # of the currently active type
-            names = [self.current_event_name]
-        else:  # of any type
-            names = self.event_times.names
-
+        # if self.edit_only_current_events:  # of the currently active type
+        #     names = [self.current_event_name]
+        # else:  # of any type
+        #     names = self.event_times.names
+        names = [self.current_event_name]
         t = (self.t0 + 1) / self.fs_song
         nxt = self.event_times.find_next(t, names)
+
         if nxt is not None:
             self.t0 = nxt * self.fs_song
 

{xarray-behave-0.35.4 → xarray-behave-0.35.7}/src/xarray_behave/gui/forms/das_predict.yaml

@@ -65,11 +65,32 @@ main:
   default: True
   help: Appends '_proposals' to song name. Individual proposals can be corrected and approved.
 
-- name: resample_audio
+- name: resample
   label: Resample audio to rate used for training
   type: bool
   default: True
 
+- name: filter_song
+  label: Bandpass filter audio
+  type: stacked
+  default: "no"
+  options: "no,yes"
+
+  "no":
+
+  "yes":
+  - name: bandpass_low_freq
+    label: Lower cutoff
+    type: double
+    default: 50.0
+    range: 0.0, 1000000.0
+
+  - name: bandpass_up_freq
+    label: Upper cutoff
+    type: double
+    default: 10000.0
+    range: 0.0, 1000000.0
+
 - type: text
   text: '<b>Event detection</b>'
 

{xarray-behave-0.35.4 → xarray-behave-0.35.7}/src/xarray_behave/gui/utils.py

@@ -115,8 +115,7 @@ class FastImageWidget(pg.GraphicsLayoutWidget):
             image_format ([type], optional): [description]. Defaults to QtGui.QImage.Format_RGB888.
             auto_scale (bool, optional): [description]. Defaults to False.
         """
-        qimg = QtGui.QImage(image, image.shape[1], image.shape[0], image_format)
-        # qimg = QtGui.QImage(image.ctypes.data, image.shape[1], image.shape[0], image_format)
+        qimg = QtGui.QImage(image, image.shape[1], image.shape[0], 3 * image.shape[1], image_format)
 
         qpix = QtGui.QPixmap(qimg)
         self.pixmapItem.setPixmap(qpix)

{xarray-behave-0.35.4 → xarray-behave-0.35.7}/src/xarray_behave/xarray_behave.py

@@ -177,6 +177,7 @@ def assemble(
         ss_ball, last_sample_number_ball, sampling_rate_ball = ld.load_times(filepath_timestamps_ball, filepath_daq)
 
     filepath_timestamps_movie = Path(root, res_path, datename, f"{datename}_movieframes.csv")
+    ss_movie = None
     if os.path.exists(filepath_daq) and os.path.exists(filepath_timestamps_movie):
         ss_movie, last_sample_number_movie, sampling_rate_movie = ld.load_movietimes(filepath_timestamps_movie, filepath_daq)
 
@@ -284,20 +285,23 @@ def assemble(
     with_movieparams = False
     if include_movieparams:
         logger.info("Loading movie params:")
-        movieparams_loader = io.get_loader(kind="movieparams", basename=os.path.join(root, dat_path, datename, datename))
-        if movieparams_loader:
-            try:
-                xr_movieparams = movieparams_loader.make(movieparams_loader.path)
-                xr_movieparams = add_time(xr_movieparams, ss_movie, dim="frame_number_movie", suffix="_movie")
-
-                logger.info(f"   {movieparams_loader.path} loaded.")
-                with_movieparams = True
-            except Exception as e:
-                logger.info(f"   Loading {movieparams_loader.path} failed.")
-                logger.exception(e)
+        if ss_movie is None:
+            logger.warning("   Failed loading movie params - no ss_movie")
         else:
-            logger.info("   Found no movie params data.")
-        logger.info("Done.")
+            movieparams_loader = io.get_loader(kind="movieparams", basename=os.path.join(root, dat_path, datename, datename))
+            if movieparams_loader:
+                try:
+                    xr_movieparams = movieparams_loader.make(movieparams_loader.path)
+                    xr_movieparams = add_time(xr_movieparams, ss_movie, dim="frame_number_movie", suffix="_movie")
+
+                    logger.info(f"   {movieparams_loader.path} loaded.")
+                    with_movieparams = True
+                except Exception as e:
+                    logger.info(f"   Loading {movieparams_loader.path} failed.")
+                    logger.exception(e)
+            else:
+                logger.warning("   Found no movie params data.")
+            logger.info("Done.")
 
     # Init empty and event data
     auto_event_seconds: Dict[str, Any] = {}