Added functionality to convert a frame range to a timeline dense point cloud.

The function get_timeline_dense_cloud() will return this as a np.array.
Also added doc strings for all functions.
Finally, renamed read_fbx.py to fbx_handler.py and moved it to the main directory because this class will be handling everything related to the FBX SDK.

app.py

@@ -7,11 +7,11 @@ from pathlib import Path
 import streamlit as st
 
 # Import custom libs.
-from labeler import read_fbx
+import fbx_handler
 
 
 def process_file(file: Path) -> bytes:
-    fbx_content = read_fbx.MarkerData(file)
+    fbx_content = fbx_handler.FBXContainer(file)
     return fbx_content.export(t='string')
 
 

fbx_handler.py

@@ -0,0 +1,564 @@
+# Import core libs.
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from typing import List, Union, Tuple
+
+# Import util libs.
+import contextlib
+import fbx
+
+# Import custom data.
+import globals
+
+
+def center_axis(a: List[float]) -> np.array:
+    """
+    Centers a list of floats.
+    :param a: List of floats to center.
+    :return: The centered list as a `np.array`.
+    """
+    # Turn list into np array for optimized math.
+    a = np.array(a)
+
+    # Find the centroid by subtracting the lowest value from the highest value.
+    _min = np.min(a)
+    _max = np.max(a)
+    _c = _max - _min
+    # Center the array by subtracting the centroid.
+    a -= _c
+    return a
+
+
+def make_ghost_markers(missing: int) -> np.array:
+    """
+    Creates a np array containing enough rows to fill a point cloud up to 1000 points.
+    Ghost markers are always unlabeled markers, therefore their actor and marker class is 0.
+    :param missing: `int` amount of missing rows in the cloud that need to be filled with this function.
+    :return: multidimensional `np.array` with the shape: (missing, 5).
+    """
+    return np.column_stack([
+        np.zeros((missing, 1), dtype=int),  # 0
+        np.zeros((missing, 1), dtype=int),  # 0
+        np.random.rand(missing, 1),  # 0.0-1.0
+        np.random.rand(missing, 1),  # 0.0-1.0
+        np.random.rand(missing, 1)  # 0.0-1.0
+    ])
+
+
+class FBXContainer:
+    # TODO: Model is currently built for training. Add testing mode.
+    def __init__(self, fbx_file: Path,
+                 volume_dims: Tuple[float] = (10., 4., 10.),
+                 max_actors: int = 10,
+                 pc_size: int = 1000,
+                 scale: float = 0.01):
+        """
+        Class that stores references to important nodes in an FBX file.
+        Offers utility functions to quickly load animation data.
+        :param fbx_file: `Path` to the file to load.
+        :param volume_dims: `tuple` of `float` that represent the dimensions of the capture volume in meters.
+        :param max_actors: `int` maximum amount of actors to expect in a point cloud.
+        :param pc_size: `int` amount of points in a point cloud.
+        """
+        if pc_size < max_actors * 73:
+            raise ValueError('Point cloud size must be large enough to contain the maximum amount of actors * 73'
+                             f' markers: {pc_size}/{max_actors * 73}.')
+
+        # Python ENUM of the C++ time modes.
+        self.time_modes = globals.get_time_modes()
+        # Ordered list of marker names. Note: rearrange this in globals.py.
+        self.marker_names = globals.get_marker_names()
+
+        # Initiate empty lists to store references to nodes.
+        self.markers = []
+        self.actors = []
+        # Store names of the actors (all parent nodes that have the first 4 markers as children).
+        self.actor_names = []
+
+        # Split the dimensions tuple into its axes for easier access.
+        self.vol_x = volume_dims[0]
+        self.vol_y = volume_dims[1]
+        self.vol_z = volume_dims[2]
+        
+        self.scale = scale
+
+        self.max_actors = max_actors
+        # Maximum point cloud size = 73 * max_actors + unlabeled markers.
+        self.pc_size = pc_size
+
+        self.fbx_file = fbx_file
+        self.valid_frames = []
+
+        self.__init_scene()
+        self.__init_anim()
+        self.__init_actors()
+        self.__init_markers()
+        self.__init_unlabeled_markers()
+
+    def __init_scene(self):
+        """
+        Stores scene, root, and time_mode properties.
+        Destroys the importer to remove the reference to the loaded file.
+        """
+        # Create an FBX manager and importer.
+        manager = fbx.FbxManager.Create()
+        importer = fbx.FbxImporter.Create(manager, '')
+
+        # Import the FBX file.
+        importer.Initialize(str(self.fbx_file))
+        self.scene = fbx.FbxScene.Create(manager, '')
+        importer.Import(self.scene)
+        self.root = self.scene.GetRootNode()
+        self.time_mode = self.scene.GetGlobalSettings().GetTimeMode()
+
+        # Destroy importer to remove reference to imported file.
+        # This will allow us to delete the uploaded file.
+        importer.Destroy()
+
+    def __init_anim(self):
+        """
+        Stores the anim_stack, num_frames, start_frame, end_frame properties.
+        """
+        # Get the animation stack and layer.
+        anim_stack = self.scene.GetCurrentAnimationStack()
+        self.anim_layer = anim_stack.GetSrcObject(fbx.FbxCriteria.ObjectType(fbx.FbxAnimLayer.ClassId), 0)
+
+        # Find the total number of frames to expect from the local time span.
+        local_time_span = anim_stack.GetLocalTimeSpan()
+        self.num_frames = int(local_time_span.GetDuration().GetFrameCount(self.time_mode))
+        self.start_frame = local_time_span.GetStart().GetFrameCount(self.time_mode)
+        self.end_frame = local_time_span.GetStop().GetFrameCount(self.time_mode)
+
+    def __init_actors(self):
+        """
+        Goes through all root children (generation 1).
+        If a child has 4 markers as children, it is considered an actor (Shogun subject) and appended to actors
+        and actor_names list properties.
+        Also initializes an empty valid_frames list for each found actor.
+        """
+        # Find all parent nodes (/System, /Unlabeled_Markers, /Actor1, etc).
+        gen1_nodes = [self.root.GetChild(i) for i in range(self.root.GetChildCount())]
+        for gen1_node in gen1_nodes:
+            gen2_nodes = [gen1_node.GetChild(i) for i in
+                          range(gen1_node.GetChildCount())]  # Actor nodes (/Mimi/Hips, /Mimi/ARIEL, etc)
+
+            # If the first 3 marker names are children of this parent, it must be an actor.
+            if all(name in [node.GetName().split(':')[-1] for node in gen2_nodes] for name in self.marker_names[:4]):
+                self.actor_names.append(gen1_node.GetName())
+                self.actors.append(gen1_node)
+
+        self.actor_count = len(self.actors)
+        self.valid_frames = [[] for _ in range(self.actor_count)]
+
+    def __init_markers(self):
+        """
+        Goes through all actor nodes and stores references to its marker nodes.
+        """
+        for actor_node in self.actors:
+            actor_markers = {}
+            for marker_name in self.marker_names:
+                for actor_idx in range(actor_node.GetChildCount()):
+                    child = actor_node.GetChild(actor_idx)
+                    # Child name might have namespaces in it like this: Vera:ARIEL
+                    # We want to match only on the actual name, so strip everything before off.
+                    child_name = child.GetName().split(':')[-1]
+                    if child_name == marker_name:
+                        actor_markers[marker_name] = child
+
+            assert len(actor_markers) == len(self.marker_names), f'{actor_node.GetName()} does not have all markers.'
+
+            self.markers.append(actor_markers)
+
+    def __init_unlabeled_markers(self):
+        """
+        Looks for the Unlabeled_Markers parent node under the root and stores references to all unlabeled marker nodes.
+        """
+        # Find the Unlabeled_Markers parent node.
+        for i in range(self.root.GetChildCount()):
+            gen1_node = self.root.GetChild(i)
+            if gen1_node.GetName() == 'Unlabeled_Markers':
+                self.unlabeled_markers_parent = gen1_node
+                self.unlabeled_markers = [gen1_node.GetChild(um) for um in range(gen1_node.GetChildCount())]
+                return
+
+    def _check_actor(self, actor: int = 0):
+        """
+        Safety check to see if the actor `int` is a valid number (to avoid out of range errors).
+        :param actor: `int` actor index, which should be between 0-max_actors.
+        """
+        assert 0 <= actor <= self.actor_count, f'Actor index must be between 0 and {self.actor_count - 1}. ' \
+                                               f'It is {actor}.'
+
+    def _set_valid_frames_for_actor(self, actor: int = 0):
+        """
+        Checks for each frame in the frame range, and for each marker, if there is a keyframe present
+        at that frame on LocalTranslation X.
+        If the keyframe is missing, removes that frame from the list of valid frames for that actor.
+        This eventually leaves a list of frames where each number is guaranteed to have a keyframe on all markers.
+        The list is appended to valid_frames, which can be indexed per actor.
+        Finally, stores a list of frames that is valid for all actors in common_frames.
+        :param actor: `int` index of the actor to find keyframes for.
+        """
+        # Make sure the actor index is in range.
+        self._check_actor(actor)
+
+        frames = self.get_frame_range()
+        for _, marker in self.markers[actor].items():
+            # Get the animation curve for local translation x.
+            t_curve = marker.LclTranslation.GetCurve(self.anim_layer, 'X')
+            # If an actor was recorded but seems to have no animation curves, we set their valid frames to nothing.
+            # Then we return, because there is no point in further checking non-existent keyframes.
+            if t_curve is None:
+                self.valid_frames[actor] = []
+                return
+
+            # Get all keyframes on the animation curve and store their frame numbers.
+            keys = [t_curve.KeyGet(i).GetTime().GetFrameCount(self.time_mode) for i in range(t_curve.KeyGetCount())]
+            # Check for each frame in frames if it is present in the list of keyframed frames.
+            for frame in frames:
+                if frame not in keys:
+                    # If the frame is not present, that means there is no keyframe with that frame number,
+                    # so we don't want to use that frame because it is invalid, so we remove it from the list.
+                    with contextlib.suppress(ValueError):
+                        frames.remove(frame)
+
+        self.valid_frames[actor] = frames
+
+        # Store all frame lists that have at least 1 frame.
+        other_lists = [r for r in self.valid_frames if r]
+        # Make one list that contains all shared frame numbers.
+        self.common_frames = [num for num in self.get_frame_range()
+                              if all(num in other_list for other_list in other_lists)]
+
+    def set_valid_frames(self):
+        """
+        For each actor, calls _set_valid_frames_for_actor().
+        """
+        for i in range(self.actor_count):
+            self._set_valid_frames_for_actor(i)
+
+    def _check_valid_frames(self, actor: int = 0):
+        """
+        Safety check to see if the given actor has any valid frames stored.
+        If not, calls _set_valid_frames_for_actor() for that actor.
+        :param actor: `int` actor index.
+        """
+        self._check_actor(actor)
+
+        if not len(self.valid_frames[actor]):
+            self._set_valid_frames_for_actor(actor)
+
+    def _modify_pose(self, actor: int = 0, frame: int = 0) -> List[float]:
+        """
+        Evaluates all marker nodes for the given actor and modifies the resulting point cloud,
+        so it is centered and scaled properly for training.
+        :param actor: `int` actor index.
+        :param frame: `int` frame to evaluate the markers at.
+        :return: 1D list of `float` that contains the tx, ty and tz for each marker, in that order.
+        """
+        # Set new frame to evaluate at.
+        time = fbx.FbxTime()
+        time.SetFrame(frame)
+        # Prepare arrays for each axis.
+        x, y, z = [], [], []
+
+        # For each marker, store the x, y and z global position.
+        for n, m in self.markers[actor].items():
+            t = m.EvaluateGlobalTransform(time).GetT()
+            x += [t[0] * self.scale]
+            y += [t[1] * self.scale]
+            z += [t[2] * self.scale]
+
+        # Move the point cloud to the center of the x and y axes. This will put the actor in the middle.
+        x = center_axis(x)
+        z = center_axis(z)
+
+        # Move the actor to the middle of the volume floor by adding volume_dim/2 to x and z.
+        x += self.vol_x / 2.
+        z += self.vol_z / 2.
+
+        # Squeeze the actor into the 1x1 plane for the neural network by dividing the axes.
+        x /= self.vol_x
+        z /= self.vol_z
+        y = np.array(y) / self.vol_y
+
+        # TODO: Optionally: Add any extra modifications to the point cloud here.
+
+        # Append all values to a new array, one axis at a time.
+        # This way it will match the column names order.
+        pose = []
+        for i in range(len(x)):
+            pose += [x[i]]
+            pose += [y[i]]
+            pose += [z[i]]
+        return pose
+
+    def extract_scaled_translation(self, m: fbx.FbxNode, time: fbx.FbxTime) -> List[float]:
+        """
+        Evaluates a node's world translation at the given time and scales the vector down by a factor of self.scale.
+        :param m: `fbx.FbxNode` node that needs to be evaluated.
+        :param time: `fbx.FbxTime` at which frame/time the node needs to be evaluated.
+        :return: Translation vector as a list of floats.
+        """
+        t = m.EvaluateGlobalTransform(time).GetT()
+        return [t[i] * self.scale for i in range(3)]
+
+    def get_frame_range(self) -> List[int]:
+        """
+        Replacement and improvement for:
+        `list(range(self.num_frames))`
+        If the animation does not start at frame 0, this will return a list that has the correct frames.
+        :return: List of `int` frame numbers that are between the start and end frame of the animation.
+        """
+        return list(range(self.start_frame, self.end_frame))
+
+    def columns_from_joints(self) -> List[str]:
+        """
+        Generates a list of column names based on the (order of the) marker names.
+        :return: List of column names, in the form of [node1_tx, node1_ty, node1_tz, node2_tx, node2_ty, node2_tz..].
+        """
+        columns = []
+        for name in self.marker_names:
+            columns += [f'{name}x', f'{name}y', f'{name}z']
+
+        return columns
+
+    def get_marker_by_name(self, actor: int, name: str):
+        """
+        Returns the reference to the actor's marker.
+        :param actor: `int` actor index.
+        :param name: `str` marker name.
+        :return: `fbx.FbxNode` reference.
+        """
+        self._check_actor(actor)
+        return self.markers[actor][name]
+
+    def print_valid_frames_stats_for_actor(self, actor: int = 0):
+        """
+        Prints: actor name, total amount of frames in the animation, amount of valid frames for the given actor,
+        number of missing frames, and the ratio of valid/total frames.
+        :param actor: `int` actor index.
+        :return: Tuple of `str` actor name, `int` total frames, `int` amount of valid frames, `float` valid frame ratio.
+        """
+        self._check_actor(actor)
+        self._check_valid_frames(actor)
+
+        len_valid = len(self.valid_frames[actor])
+        ratio = (len_valid / self.num_frames) * 100
+        print(f'Actor {self.actor_names[actor]}: Total: {self.num_frames}, valid: {len_valid}, missing: '
+              f'{self.num_frames - len_valid}, ratio: {ratio:.2f}% valid.')
+
+        return self.actor_names[actor], self.num_frames, len_valid, ratio
+
+    def get_valid_frames_for_actor(self, actor: int = 0) -> List[int]:
+        """
+        Collects the valid frames for the given actor.
+        :param actor: `int` actor index.
+        :return: List of `int` frame numbers that have a keyframe on tx for all markers.
+        """
+        self._check_valid_frames(actor)
+        return self.valid_frames[actor]
+
+    def extract_valid_translations_per_actor(self, actor: int = 0) -> List[List[float]]:
+        """
+        Assembles the poses for the valid frames for the given actor as a 2D list where each row is a pose.
+        :param actor: `int` actor index.
+        :return: List of poses, where each pose is a list of `float` translations.
+        """
+        # Ensure the actor index is within range.
+        self._check_actor(actor)
+
+        poses = []
+        # Go through all valid frames for this actor.
+        # Note that these frames can be different per actor.
+        for frame in self.valid_frames[actor]:
+            # Get the centered point cloud as a 1D list.
+            pose_at_frame = self._modify_pose(actor, frame)
+            poses.append(pose_at_frame)
+
+        return poses
+
+    def extract_all_valid_translations(self) -> pd.DataFrame:
+        """
+        Convenience method that calls self.extract_valid_translations_per_actor() for all actors
+        and returns a `DataFrame` containing all poses after each other.
+        :return: `DataFrame` where each row is a pose.
+        """
+        # Note that the column names are/must be in the same order as the markers.
+        columns = self.columns_from_joints()
+
+        all_poses = []
+        # For each actor, add their valid poses to all_poses.
+        for i in range(self.actor_count):
+            all_poses.extend(self.extract_valid_translations_per_actor(i))
+
+        return pd.DataFrame(all_poses, columns=columns)
+
+    def get_transformed_worldspace(self, m: fbx.FbxNode, time: fbx.FbxTime) -> List[float]:
+        """
+        Evaluates the world translation of the given marker at the given time,
+        scales it down by scale and turns it into a vector list.
+        :param m: `fbx.FbxNode` marker to evaluate the world translation of.
+        :param time: `fbx.FbxTime` time to evaluate at.
+        :return: Vector in the form: [tx, ty, tz].
+        """
+        t = m.EvaluateGlobalTransform(time).GetT()
+        x = t[0] * self.scale / self.vol_x
+        y = t[1] * self.scale / self.vol_y
+        z = t[2] * self.scale / self.vol_z
+
+        return [x, y, z]
+
+    def is_kf_present(self, marker: fbx.FbxNode, time: fbx.FbxTime) -> bool:
+        """
+        Returns True if a keyframe is found on the given node's local translation x animation curve.
+        Else returns False.
+        :param marker: `fbx.FbxNode` marker node to evaluate.
+        :param time: `fbx.FbxTime` time to evaluate at.
+        :return: True if a keyframe was found, False otherwise.
+        """
+        curve = marker.LclTranslation.GetCurve(self.anim_layer, 'X')
+        return False if curve is None else curve.KeyFind(time) != -1
+
+    def get_sparse_cloud(self, time: fbx.FbxTime) -> np.array:
+        """
+        For each actor,
+        :param time:
+        :return:
+        """
+        cloud = []
+        # Iterate through all actors to get their markers' world translations and add them to the cloud list.
+        for actor_idx in range(self.actor_count):
+
+            cloud.extend(
+                # This actor's point cloud is made up of all markers that have a keyframe at the given time.
+                # For each marker, we create this row: [actor class (index+1), marker class (index+1), tx, ty, tz].
+                # We use index+1 because the unlabeled markers will use index 0 for both classes.
+                [actor_idx + 1, marker_class, *self.get_transformed_worldspace(m, time)]
+                for marker_class, (marker_name, m) in enumerate(
+                    self.markers[actor_idx].items(), start=1
+                )
+                # Only add the marker if it has a keyframe. Missing keyframes on these markers are potentially
+                # among the keyframes on the unlabeled markers. The job of the labeler AI is to predict which
+                # point (unlabeled or labeled) is which marker.
+                if self.is_kf_present(m, time)
+            )
+
+        # Unlabeled markers are their own 'actor', so we only need one loop here.
+        for m in self.unlabeled_markers:
+            if self.is_kf_present(m, time):
+                # Unlabeled markers use actor class 0 and marker class 0.
+                cloud.extend([[0, 0, *self.get_transformed_worldspace(m, time)]])
+
+        # If the data is extremely noisy, it might have only a few labeled markers and a lot of unlabeled markers.
+        # The returned point cloud is not allowed to be bigger than the maximum size (self.pc_size),
+        # so return the cloud as a np array that cuts off any excessive markers.
+        return np.array(cloud)[:self.pc_size]
+
+    def get_timeline_sparse_cloud(self) -> np.array:
+        """
+        Convenience method that calls self.get_sparse_cloud() for all frames in the frame range
+        and returns the combined result.
+        :return: `np.array` that contains a sparse cloud for each frame in the frame range.
+        """
+        # We need time objects in a list to do list comprehension in the return line.
+        # The SetFrame() method is a void/in-place method, so we can't use list comprehension
+        # to create a list of fbx.FbxTime()s.
+        time = fbx.FbxTime()
+        times = []
+        for f in self.get_frame_range():
+            # Use in-place function to update the time. This returns None, so we can't append this directly.
+            time.SetFrame(f)
+            times.append(time)
+
+        return np.array([self.get_sparse_cloud(t) for t in times])
+
+    def get_timeline_dense_cloud(self, shuffle: bool = False) -> np.array:
+        """
+        For each frame in the frame range, collects the point cloud that is present in the file.
+        Then it creates a ghost cloud of random markers that are treated as unlabeled markers,
+        and adds them together to create a dense cloud whose shape is always (self.pc_size, 5).
+        Optionally shuffles this dense cloud before adding it to the final list.
+        :param shuffle: If `True`, shuffles the dense point cloud before appending it to the overall list.
+        :return: `np.array` that contains a dense point cloud for each frame,
+        with a shape of (self.num_frames, self.pc_size, 5).
+        """
+        time = fbx.FbxTime()
+        clouds = []
+        for frame in self.get_frame_range():
+            time.SetFrame(frame)
+            cloud = self.get_sparse_cloud(time)
+            missing = self.pc_size - cloud.shape[0]
+
+            # Only bother creating ghost markers if there are any missing rows.
+            if missing > 0:
+                ghost_cloud = make_ghost_markers(missing)
+                cloud = np.vstack([cloud, ghost_cloud])
+
+            # Shuffle the rows if needed. Because each row contains all dependent and independent variables,
+            # shuffling won't mess up the labels.
+            if shuffle:
+                np.random.shuffle(cloud)
+
+            clouds.append(cloud)
+
+        return np.array(clouds)
+
+    def split_timeline_dense_cloud(self, cloud: np.array = None, shuffle: bool = False) \
+            -> Tuple[np.array, np.array, np.array]:
+        """
+        Splits a timeline dense cloud with shape (self.num_frames, self.pc_size, 5) into 3 different
+        arrays:
+        1. A `np.array` with the actor classes as shape (self.num_frames, self.pc_size, 1).
+        2. A `np.array` with the marker classes as shape (self.num_frames, self.pc_size, 1).
+        3. A `np.array` with the translation floats as shape (self.num_frames, self.pc_size, 3).
+        :param cloud: `np.array` of shape (self.num_frames, self.pc_size, 5) that contains a dense point cloud
+        (self.pc_size, 5) per frame in the frame range.
+        :param shuffle: `bool` whether to shuffle the generated cloud if no cloud was given.
+        :return: Return tuple of `np.array` as (actor classes, marker classes, translation vectors).
+        """
+        if cloud is None:
+            cloud = self.get_timeline_dense_cloud(shuffle)
+
+        assert cloud.shape[1] == 1000, f"Dense cloud doesn't have enough points. {cloud.shape[1]}/1000."
+        assert cloud.shape[2] == 5, f"Dense cloud is missing columns: {cloud.shape[2]}/5."
+
+        # Return np arrays as (actor classes, marker classes, translation vectors).
+        return cloud[:, :, 0], cloud[:, :, 1], cloud[:, :, -3:]
+
+    def convert_class_to_actor(self, c: float = 0):
+        """
+        Returns the actor name based on the class value.
+        :param c: `float` actor class index.
+        :return: `str` actor name.
+        """
+        return 'UNLABELED' if c == 0. else self.actor_names[int(c) - 1]
+
+    def convert_class_to_marker(self, c: float = 0):
+        """
+        Returns the marker name based on the class value.
+        :param c: `float` marker class index.
+        :return: `str` marker name.
+        """
+        return 'UNLABELED' if c == 0. else self.marker_names[int(c) - 1]
+
+    def export(self, t: str = 'csv', output_file: Path = None) -> Union[bytes, Path]:
+        # Get the dataframe with all animation data.
+        df = self.extract_all_valid_translations()
+
+        if t == 'string':
+            return df.to_csv(index=False).encode('utf-8')
+
+        if output_file is None:
+            output_file = self.fbx_file.with_suffix('.csv')
+
+        if output_file.suffix != '.csv':
+            raise ValueError(f'{output_file} needs to be a .csv file.')
+
+        df.to_csv(output_file, index=False)
+        return output_file
+
+
+# d = FBXContainer(Path('G:/Firestorm/mocap-ai/data/fbx/dowg/TAKE_01+1_ALL_001.fbx'))
+# TODO: Make functions to write new class predictions to the fbx file.

labeler/read_fbx.py

@@ -1,238 +0,0 @@
-import pandas as pd
-import numpy as np
-from pathlib import Path
-
-import contextlib
-import fbx
-from typing import List, Union
-
-# Import custom data.
-import globals
-
-
-class MarkerData:
-    # TODO: Model is currently built for training. Add testing mode.
-    def __init__(self, fbx_file: Path):
-        """
-        Class that stores references to important nodes in an FBX file.
-        Offers utility functions to quickly load animation data.
-        :param fbx_file: `str` Path to the file to load.
-        """
-        self.time_modes = globals.get_time_modes()
-        self.marker_names = globals.get_marker_names()
-
-        self.markers = []
-        self.actor_names = []
-        self.actors = []
-
-        self.volume_dim_x = 10.
-        self.volume_dim_y = 4.
-
-        self.fbx_file = fbx_file
-        self.valid_frames = []
-
-        self.__init_scene()
-        self.__init_anim()
-        self.__init_actors()
-        self.__init_markers()
-
-    def __init_scene(self):
-        # Create an FBX manager and importer
-        manager = fbx.FbxManager.Create()
-        importer = fbx.FbxImporter.Create(manager, '')
-
-        # Import the FBX file
-        importer.Initialize(str(self.fbx_file))
-        self.scene = fbx.FbxScene.Create(manager, '')
-        importer.Import(self.scene)
-        self.root = self.scene.GetRootNode()
-        self.time_mode = self.scene.GetGlobalSettings().GetTimeMode()
-
-        # Destroy importer to remove reference to imported file.
-        # This will allow us to delete the uploaded file.
-        importer.Destroy()
-
-    def __init_anim(self):
-        # Get the animation stack and layer.
-        anim_stack = self.scene.GetCurrentAnimationStack()
-        self.anim_layer = anim_stack.GetSrcObject(fbx.FbxCriteria.ObjectType(fbx.FbxAnimLayer.ClassId), 0)
-
-        # Find the total number of frames to expect from the local time span.
-        local_time_span = anim_stack.GetLocalTimeSpan()
-        self.num_frames = int(local_time_span.GetDuration().GetFrameCount(self.time_mode))
-
-    def __init_actors(self):
-
-        # Find all parent nodes (/System, /_Unlabeled_Markers, /Actor1, etc).
-        gen1_nodes = [self.root.GetChild(i) for i in range(self.root.GetChildCount())]
-        for gen1_node in gen1_nodes:
-            gen2_nodes = [gen1_node.GetChild(i) for i in
-                          range(gen1_node.GetChildCount())]  # Actor nodes (/Mimi/Hips, /Mimi/ARIEL, etc)
-
-            # If the first 3 marker names are children of this parent, it must be an actor.
-            if all(name in [node.GetName().split(':')[-1] for node in gen2_nodes] for name in self.marker_names[:4]):
-                self.actor_names.append(gen1_node.GetName())
-                self.actors.append(gen1_node)
-
-        self.actor_count = len(self.actors)
-        self.valid_frames = [[] for _ in range(self.actor_count)]
-
-    def __init_markers(self):
-        for actor_node in self.actors:
-            actor_markers = {}
-            for marker_name in self.marker_names:
-                for actor_idx in range(actor_node.GetChildCount()):
-                    child = actor_node.GetChild(actor_idx)
-                    # Child name might have namespaces in it like this: Vera:ARIEL
-                    # We want to match only on the actual name, so strip everything before off.
-                    child_name = child.GetName().split(':')[-1]
-                    if child_name == marker_name:
-                        actor_markers[marker_name] = child
-
-            assert len(actor_markers) == len(self.marker_names), f'{actor_node.GetName()} does not have all markers.'
-
-            self.markers.append(actor_markers)
-
-    def _check_actor(self, actor: int = 0):
-        assert 0 <= actor <= self.actor_count, f'Actor number must be between 0 and {self.actor_count - 1}. ' \
-                                               f'It is {actor}.'
-
-    def _set_valid_frames_for_actor(self, actor: int = 0):
-        self._check_actor(actor)
-
-        frames = list(range(self.num_frames))
-        for marker_name in self.marker_names:
-            marker = self.markers[actor][marker_name]
-            t_curve = marker.LclTranslation.GetCurve(self.anim_layer, 'X')
-            # If an actor was recorded but seems to have no animation curves, we set their valid frames to nothing.
-            if t_curve is None:
-                self.valid_frames[actor] = []
-                return
-
-            keys = [t_curve.KeyGet(i).GetTime().GetFrameCount(self.time_mode) for i in range(t_curve.KeyGetCount())]
-            for frame in frames:
-                if frame not in keys:
-                    with contextlib.suppress(ValueError):
-                        frames.remove(frame)
-
-        self.valid_frames[actor] = frames
-        return
-
-    def _check_valid_frames(self, actor: int = 0):
-        if not len(self.valid_frames[actor]):
-            self._set_valid_frames_for_actor(actor)
-
-    def _modify_pose(self, actor, frame) -> List[float]:
-        # Set new frame to evaluate at.
-        time = fbx.FbxTime()
-        time.SetFrame(frame)
-        # Prepare arrays for each axis.
-        x, y, z = [], [], []
-
-        # For each marker, store the x, y and z global position.
-        for n, m in self.markers[actor].items():
-            t = m.EvaluateGlobalTransform(time).GetRow(3)
-            x += [t[0] * 0.01]
-            y += [t[1] * 0.01]
-            z += [t[2] * 0.01]
-
-        # Move the point cloud to the center of the x and y axes. This will put the actor in the middle.
-        x = self.center_axis(x)
-        z = self.center_axis(z)
-
-        # Move the actor to the middle of the volume floor by adding volume_dim_x/2 to x and z.
-        x += self.volume_dim_x / 2.
-        z += self.volume_dim_x / 2.
-
-        # Squeeze the actor into the 1x1 plane for the neural network by dividing the axes.
-        x /= self.volume_dim_x
-        z /= self.volume_dim_x
-        y = np.array(y) / self.volume_dim_y
-
-        # TODO: Optionally: Add any extra modifications to the point cloud here.
-
-        # Append all values to a new array, one axis at a time.
-        # This way it will match the column names order.
-        pose = []
-        for i in range(len(x)):
-            pose += [x[i]]
-            pose += [y[i]]
-            pose += [z[i]]
-        return pose
-
-    def get_marker_by_name(self, actor: int, name: str):
-        self._check_actor(actor)
-        return self.markers[actor][name]
-
-    def get_valid_frames_for_actor(self, actor: int = 0):
-        self._check_valid_frames(actor)
-        return self.valid_frames[actor]
-
-    def print_valid_frames_stats_for_actor(self, actor: int = 0):
-        self._check_actor(actor)
-        self._check_valid_frames(actor)
-
-        len_valid = len(self.valid_frames[actor])
-        ratio = (len_valid / self.num_frames) * 100
-        print(f'Actor {self.actor_names[actor]}: Total: {self.num_frames}, valid: {len_valid}, missing: '
-              f'{self.num_frames - len_valid}, ratio: {ratio:.2f}% valid.')
-
-        return self.actor_names[actor], self.num_frames, len_valid, ratio
-
-    def columns_from_joints(self):
-        columns = []
-        for name in self.marker_names:
-            columns += [f'{name}x', f'{name}y', f'{name}z']
-
-        return columns
-
-    @staticmethod
-    def center_axis(a) -> np.array:
-        a = np.array(a)
-        _min = np.min(a)
-        _max = np.max(a)
-
-        _c = _max - _min
-        a -= _c
-        return a
-
-    def extract_translations_per_actor(self, actor: int = 0):
-        self._check_actor(actor)
-        self._check_valid_frames(actor)
-
-        poses = []
-        # Go through all valid frames for this actor.
-        # Note that these frames can be different per actor.
-        for frame in self.valid_frames[actor]:
-            # Get the centered point cloud as an array.
-            pose_at_frame = self._modify_pose(actor, frame)
-            poses.append(pose_at_frame)
-
-        return poses
-
-    def extract_all_translations(self) -> pd.DataFrame:
-
-        columns = self.columns_from_joints()
-
-        all_poses = []
-
-        for i in range(self.actor_count):
-            all_poses.extend(self.extract_translations_per_actor(i))
-
-        return pd.DataFrame(all_poses, columns=columns)
-
-    def export(self, t: str = 'csv', output_file: Path = None) -> Union[bytes, Path]:
-        # Get the dataframe with all animation data.
-        df = self.extract_all_translations()
-
-        if t == 'string':
-            return df.to_csv(index=False).encode('utf-8')
-
-        if output_file is None:
-            output_file = self.fbx_file.with_suffix('.csv')
-
-        if output_file.suffix != '.csv':
-            raise ValueError(f'{output_file} needs to be a .csv file.')
-
-        df.to_csv(output_file, index=False)
-        return output_file