Example 'aeon/analysis/' refactor

aeon/processing/core/__init__.py

@@ -0,0 +1 @@
+#

aeon/analysis/utils.py → aeon/processing/core/core.py

@@ -1,25 +1,6 @@
 import numpy as np
 import pandas as pd
 
-def distancetravelled(angle, radius=4.0):
-    '''
-    Calculates the total distance travelled on the wheel, by taking into account
-    its radius and the total number of turns in both directions across time.
-
-    :param Series angle: A series of magnetic encoder measurements.
-    :param float radius: The radius of the wheel, in metric units.
-    :return: The total distance travelled on the wheel, in metric units.
-    '''
-    maxvalue = int(np.iinfo(np.uint16).max >> 2)
-    jumpthreshold = maxvalue // 2
-    turns = angle.astype(int).diff()
-    clickup = (turns < -jumpthreshold).astype(int)
-    clickdown = (turns > jumpthreshold).astype(int) * -1
-    turns = (clickup + clickdown).cumsum()
-    distance = 2 * np.pi * radius * (turns + angle / maxvalue)
-    distance = distance - distance[0]
-    return distance
-
 def visits(data, onset='Enter', offset='Exit'):
     '''
     Computes duration, onset and offset times from paired events. Allows for missing data
@@ -119,16 +100,3 @@ def sessiontime(index, start=None):
 def distance(position, target):
     """Computes the euclidean distance to a specified target."""
     return np.sqrt(np.square(position[['x','y']] - target).sum(axis=1))
-
-def activepatch(wheel, in_patch):
-    '''
-    Computes a decision boundary for when a patch is active based on wheel movement.
-
-    :param Series wheel: A pandas Series containing the cumulative distance travelled on the wheel.
-    :param Series in_patch: A Series of type bool containing whether the specified patch may be active.
-    :return: A pandas Series specifying for each timepoint whether the patch is active.
-    '''
-    exit_patch = in_patch.astype(np.int8).diff() < 0
-    in_wheel = (wheel.diff().rolling('1s').sum() > 1).reindex(in_patch.index, method='pad')
-    epochs = exit_patch.cumsum()
-    return in_wheel.groupby(epochs).apply(lambda x:x.cumsum()) > 0

aeon/analysis/movies.py → aeon/processing/core/video.py

@@ -1,8 +1,67 @@
 import cv2
 import math
+
 import numpy as np
 import pandas as pd
-import aeon.io.video as video
+
+
+def frames(data):
+    '''
+    Extracts the raw frames corresponding to the provided video metadata.
+
+    :param DataFrame data:
+    A pandas DataFrame where each row specifies video acquisition path and frame number.
+    :return:
+    An object to iterate over numpy arrays for each row in the DataFrame,
+    containing the raw video frame data.
+    '''
+    capture = None
+    filename = None
+    index = 0
+    try:
+        for frameidx, path in zip(data._frame, data._path):
+            if filename != path:
+                if capture is not None:
+                    capture.release()
+                capture = cv2.VideoCapture(path)
+                filename = path
+                index = 0
+
+            if frameidx != index:
+                capture.set(cv2.CAP_PROP_POS_FRAMES, frameidx)
+                index = frameidx
+            success, frame = capture.read()
+            if not success:
+                raise ValueError('Unable to read frame {0} from video path "{1}".'.format(frameidx, path))
+            yield frame
+            index = index + 1
+    finally:
+        if capture is not None:
+            capture.release()
+
+
+def export(frames, file, fps, fourcc=None):
+    '''
+    Exports the specified frame sequence to a new video file.
+
+    :param iterable frames: An object to iterate over the raw video frame data.
+    :param str file: The path to the exported video file.
+    :param fps: The frame rate of the exported video.
+    :param optional fourcc:
+    Specifies the four character code of the codec used to compress the frames.
+    '''
+    writer = None
+    try:
+        for frame in frames:
+            if writer is None:
+                if fourcc is None:
+                    fourcc = cv2.VideoWriter_fourcc('m','p','4','v')
+                writer = cv2.VideoWriter(file, fourcc, fps, (frame.shape[1], frame.shape[0]))
+            writer.write(frame)
+    finally:
+        if writer is not None:
+            writer.release()
+
 
 def gridframes(frames, width, height, shape=None):
     '''
@@ -99,7 +158,7 @@ def collatemovie(clipdata, fun):
     :return: The sequence of processed frames representing the collated movie.
     '''
     clipcount = len(clipdata.groupby('clip_sequence').frame_sequence.count())
-    allframes = video.frames(clipdata.sort_values(by=['frame_sequence', 'clip_sequence']))
+    allframes = frames(clipdata.sort_values(by=['frame_sequence', 'clip_sequence']))
     return groupframes(allframes, clipcount, fun)
 
 def gridmovie(clipdata, width, height, shape=None):

aeon/processing/foraging.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+
+def distancetravelled(angle, radius=4.0):
+    '''
+    Calculates the total distance travelled on the wheel, by taking into account
+    its radius and the total number of turns in both directions across time.
+
+    :param Series angle: A series of magnetic encoder measurements.
+    :param float radius: The radius of the wheel, in metric units.
+    :return: The total distance travelled on the wheel, in metric units.
+    '''
+    maxvalue = int(np.iinfo(np.uint16).max >> 2)
+    jumpthreshold = maxvalue // 2
+    turns = angle.astype(int).diff()
+    clickup = (turns < -jumpthreshold).astype(int)
+    clickdown = (turns > jumpthreshold).astype(int) * -1
+    turns = (clickup + clickdown).cumsum()
+    distance = 2 * np.pi * radius * (turns + angle / maxvalue)
+    distance = distance - distance[0]
+    return distance
+
+def activepatch(wheel, in_patch):
+    '''
+    Computes a decision boundary for when a patch is active based on wheel movement.
+
+    :param Series wheel: A pandas Series containing the cumulative distance travelled on the wheel.
+    :param Series in_patch: A Series of type bool containing whether the specified patch may be active.
+    :return: A pandas Series specifying for each timepoint whether the patch is active.
+    '''
+    exit_patch = in_patch.astype(np.int8).diff() < 0
+    in_wheel = (wheel.diff().rolling('1s').sum() > 1).reindex(in_patch.index, method='pad')
+    epochs = exit_patch.cumsum()
+    return in_wheel.groupby(epochs).apply(lambda x:x.cumsum()) > 0

aeon/processing/social/__init__.py

@@ -0,0 +1 @@
+#

aeon/processing/social/social.py

@@ -0,0 +1 @@
+# Functions related to training multianimal sleap ID model from Aeon videos would live here.