Updated the testing workflow. Fixed some bugs. The bug with the new animation curves not connecting properly is fixed.

README.md

@@ -11,9 +11,8 @@ Functionality to load FBX files, extract animation, process the animation and wr
 # Classifier
 * Globals: file with hardcoded values like the marker names.
 * Utilities:
-  * Split dataset into train/valid/test sets.
   * Visualizations
-* Training file loader:
+* FBX Handler:
   * Load the `.fbx` file.
   * Go through each frame in the animation frame range and check if all skeleton nodes have a keyframe there.
   * If a keyframe is missing, remove that frame number from the valid frame numbers.

fbx_handler.md

@@ -0,0 +1,35 @@
+# FBX Handler
+
+## Load file:
+```python
+# Path to file to load.
+input_file = Path('/path/to/file.fbx')
+# Load file into class.
+container = FBXContainer(input_file)
+```
+
+## Training workflow:
+```python
+# Get dataframe with all valid translation numbers.
+df = container.extract_all_valid_translations()
+# Convert to dataset...
+...
+```
+
+## Testing workflow:
+```python
+# Get timeline dense cloud.
+tdc = container.get_tdc()  # wrap in shuffle_tdc() to shuffle nodes.
+# Split array into subarrays.
+actors_test, markers_test, t_test, r_test, s_test = container.split_tdc(tdc)
+# Predict the new actors and classes...
+actors_pred, markers_pred = Labeler(container.transform_translations(t_test))
+# Merge the new labels with their original translations.
+merged = merge_tdc(actors_pred, markers_pred, t_test, r_test, s_test)
+# Convert the full cloud into a dict structured for easy keyframes.
+new_dict = tsc_to_dict(merged)
+# Replace the old translation keyframes with the new values.
+container.replace_keyframes_for_all_actors(new_dict)
+# Export file.
+container.export_fbx(Path('/path/to/outputfile.fbx'))
+```

fbx_handler.py

@@ -100,6 +100,23 @@ def merge_tdc(actor_classes: np.array,
     return tdc
 
 
+def shuffle_tdc(tdc: np.array) -> np.array:
+    """
+    Shuffles the given timeline dense cloud at its second dimension, the marker rows.
+    This will not mess up the transforms.
+    :param tdc: `np.array` to shuffle.
+    :return: shuffled `np.array`.
+    """
+    # This function only works for arrays with 3 dimensions.
+    if tdc.ndim != 3:
+        raise ValueError(f'Array does not have 3 dimensions: {tdc.ndim}/3.')
+
+    # Shuffle the node rows.
+    for i in range(tdc.shape[0]):
+        np.random.shuffle(tdc[i])
+    return tdc
+
+
 def sort_cloud(cloud: np.array) -> np.array:
     """
     Convenience function to sort a timeline dense cloud by actor and marker classes.
@@ -156,16 +173,22 @@ def match_name(node: fbx.FbxNode, name: str, ignore_namespace: bool = True) -> b
     return node_name == name
 
 
-def timeline_cloud_to_dict(data: np.array, start_frame: int = 0) -> dict:
+def tsc_to_dict(tsc: np.array, start_frame: int = 0) -> dict:
+    """
+    Converts an `np.array` timeline sparse cloud to a dictionary structured for keyframed animation.
+    :param tsc: `np.array` timeline sparse cloud to process.
+    :param start_frame: Optional `int` frame at which the animation starts, useful for timecode.
+    :return: `dict` optimized for retrieving keyframe info.
+    """
     # Initialize an empty dictionary.
     result = {}
 
     # Iterate over the first dimension (frames) and second dimension (markers).
-    for frame, node in itertools.product(range(data.shape[0]), range(data.shape[1])):
+    for frame, node in itertools.product(range(tsc.shape[0]), range(tsc.shape[1])):
 
         # Extract the actor class, node class, and translation vector.
-        actor_class = int(data[frame, node, 0])
-        marker_class = int(data[frame, node, 1])
+        actor_class = int(tsc[frame, node, 0])
+        marker_class = int(tsc[frame, node, 1])
         # If actor or marker class is predicted to be 0 (unlabeled marker), then skip adding it to the dict,
         # because we only want to keyframe labeled markers.
         if actor_class == 0 or marker_class == 0:
@@ -173,10 +196,11 @@ def timeline_cloud_to_dict(data: np.array, start_frame: int = 0) -> dict:
 
         # Just to be sure, forcing the last numbers of each array to be the correct values.
         # Also check self.get_world_transform() for this.
-        translations = data[frame, node, 2:5] + np.array([0.0])
-        rotations = data[frame, node, 6:9] + np.array([0.0])
-        scales = data[frame, node, 10:13] + np.array([1.0])
+        translations = tsc[frame, node, 2:5] + np.array([0.0])
+        rotations = tsc[frame, node, 6:9] + np.array([0.0])
+        scales = tsc[frame, node, 10:13] + np.array([1.0])
 
+        # Build a world transform matrix from the transform values.
         world_matrix = fbx.FbxAMatrix()
         world_matrix.SetT(fbx.FbxVector4(*translations))
         world_matrix.SetR(fbx.FbxVector4(*rotations))
@@ -196,7 +220,16 @@ def timeline_cloud_to_dict(data: np.array, start_frame: int = 0) -> dict:
     return result
 
 
-def world_to_local_transform(node, world_transform, frame):
+def world_to_local_transform(node: fbx.FbxNode, world_transform: fbx.FbxAMatrix, frame: int) -> \
+        Tuple[List[float], List[float], List[float]]:
+    """
+    Takes a world transform and uses the node's parent world transform to calculate this node's
+    local transform at the given frame.
+    :param node: `fbx.FbxNode` that the given world transform belongs to.
+    :param world_transform: `fbx.FbxAMatrix` world transform to convert to local transform.
+    :param frame: `int` frame number at which to evaluate the parent's world transform.
+    :return:
+    """
     t = fbx.FbxTime()
     t.SetFrame(frame)
     if node.GetParent():
@@ -215,6 +248,59 @@ def world_to_local_transform(node, world_transform, frame):
     return [lcl.GetT()[t] for t in range(3)], [lcl.GetR()[r] for r in range(3)], [lcl.GetS()[s] for s in range(3)]
 
 
+def get_world_transform(m: fbx.FbxNode, time: fbx.FbxTime, axes: str = 'trs') -> np.array:
+    """
+    Evaluates the world translation of the given node 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.
+    :param axes: `str` that contains types of info to include. Options are a combination of t, r, and s.
+    :return: Vector in the form: [tx, ty, etc..].
+    """
+    matrix = m.EvaluateGlobalTransform(time)
+
+    # If axes is only the translation, we return a vector of (tx, ty, tz) only (useful for the training).
+    if axes == 't':
+        return np.array([matrix[i] for i in range(3)])
+
+    # Otherwise, we assemble the entire row depending on the axes.
+    world = []
+    if 't' in axes:
+        world += list(matrix.GetT())
+        world[3] = 0.0
+    if 'r' in axes:
+        world += list(matrix.GetR())
+        world[7] = 0.0
+    if 's' in axes:
+        world += list(matrix.GetS())
+        world[11] = 1.0
+
+    return np.array(world)
+
+
+def isolate_actor_from_tdc(tdc: np.array, actor: int) -> np.array:
+    """
+    Returns all markers of the given actor in the timeline dense cloud.
+    :param tdc: `np.array` timeline dense cloud to filter.
+    :param actor: `int` actor class, starting at 1.
+    :return: `np.array` that contains only the markers of the given actor.
+    """
+    if actor == 0:
+        raise ValueError('Second argument (actor) cannot be 0, must be higher.')
+    mask = tdc[:, :, 0] == float(actor)
+    return tdc[mask]
+
+
+def split_tdc_into_actors(tdc: np.array) -> List[np.array]:
+    """
+    Uses isolate_actor_from_tdc() to isolate all unique actors in the timeline dense cloud.
+    :param tdc: Timeline dense cloud to filter.
+    :return: List of isolated actor `np.array`.
+    """
+    actor_count = len([x for x in np.unique(tdc[:, :, 0]) if x != 0.])
+    return [isolate_actor_from_tdc(tdc, i) for i in range(1, actor_count + 1)]
+
+
 class FBXContainer:
     def __init__(self, fbx_file: Path,
                  volume_dims: Tuple[float] = (10., 4., 10.),
@@ -418,7 +504,7 @@ class FBXContainer:
         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]:
+    def get_transformed_pc(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.
@@ -580,7 +666,7 @@ class FBXContainer:
         # 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)
+            pose_at_frame = self.get_transformed_pc(actor, frame)
             poses.append(pose_at_frame)
 
         return poses
@@ -601,32 +687,29 @@ class FBXContainer:
 
         return pd.DataFrame(all_poses, columns=columns)
 
-    def get_world_transform(self, m: fbx.FbxNode, time: fbx.FbxTime, apply_transform: bool = True) -> List[float]:
+    def transform_translations(self, w: np.array) -> np.array:
         """
-        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.
-        :param apply_transform: `bool` Whether to transform the translation or not.
-        :return: Vector in the form: [tx, ty, tz].
+        Applies a scaling to the translation values in the given array.
+        :param w: `np.array` that can either be a timeline dense cloud or translation vectors.
+        :return: Modified `np.array`.
         """
-        world = m.EvaluateGlobalTransform(time)
-        world = list(world.GetT()) + list(world.GetR()) + list(world.GetS())
-        # Make sure that the last numbers of each row are the correct values.
-        world[3] = 0.0
-        world[7] = 0.0
-        world[11] = 1.0
+        if w.ndim != 3:
+            raise ValueError(f'Array does not have 3 dimensions: {w.ndim}/3.')
 
-        if not apply_transform:
-            return world
+        # If the last dimension has 3 elements, it is a translation vector of shape (tx, ty, tz).
+        # If it has 14 elements, it is a full marker row of shape (actor, marker, tx, ty, tz, rx, ry, rz, etc).
+        start = 0 if w.shape[-1] == 3 else 2
 
         # First multiply by self.scale, which turns meters to centimeters.
         # Then divide by volume dimensions, to normalize to the total area of the capture volume.
-        world[2] = np.clip(world[2], -(self.vol_x * 0.5), self.vol_x * 0.5) * self.scale / self.vol_x
-        world[3] = np.clip(world[3], -(self.vol_y * 0.5), self.vol_y * 0.5) * self.scale / self.vol_y
-        world[4] = np.clip(world[4], -(self.vol_z * 0.5), self.vol_z * 0.5) * self.scale / self.vol_z
+        w[:, :, start + 0] = np.clip(w[:, :, start + 0], -(self.vol_x * 0.5),
+                                     self.vol_x * 0.5) * self.scale / self.vol_x
+        w[:, :, start + 1] = np.clip(w[:, :, start + 1], -(self.vol_y * 0.5),
+                                     self.vol_y * 0.5) * self.scale / self.vol_y
+        w[:, :, start + 2] = np.clip(w[:, :, start + 2], -(self.vol_z * 0.5),
+                                     self.vol_z * 0.5) * self.scale / self.vol_z
 
-        return world
+        return w
 
     def is_kf_present(self, marker: fbx.FbxNode, time: fbx.FbxTime) -> bool:
         """
@@ -639,11 +722,10 @@ class FBXContainer:
         curve = marker.LclTranslation.GetCurve(self.anim_layer, 'X')
         return False if curve is None else curve.KeyFind(time) != -1
 
-    def get_sc(self, frame: int, apply_transform: bool = True) -> np.array:
+    def get_sc(self, frame: int) -> np.array:
         """
         For each actor at the given time, find all markers with keyframes and add their values to a point cloud.
         :param frame: `fbx.FbxTime` time at which to evaluate the marker.
-        :param apply_transform: `bool` Whether to transform the translation or not.
         :return: sparse point cloud as `np.array`.
         """
         time = fbx.FbxTime()
@@ -653,7 +735,7 @@ class FBXContainer:
         # because by adding the labeled markers after (which use classes 1-74),
         # we eventually return an array that doesn't need to be sorted anymore.
         cloud = [
-            [0, 0, *self.get_world_transform(m, time, apply_transform)]
+            [0, 0, *get_world_transform(m, time)]
             for m in self.unlabeled_markers
             if self.is_kf_present(m, time)
         ]
@@ -664,7 +746,7 @@ class FBXContainer:
                 # 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_world_transform(m, time, apply_transform)]
+                [actor_idx + 1, marker_class, *get_world_transform(m, time)]
                 for marker_class, (marker_name, m) in enumerate(
                     self.markers[actor_idx].items(), start=1
                 )
@@ -679,18 +761,15 @@ class FBXContainer:
         # so return the cloud as a np array that cuts off any excessive markers.
         return np.array(cloud)[:self.pc_size]
 
-    def get_tsc(self, apply_transform: bool = True) -> np.array:
+    def get_tsc(self) -> np.array:
         """
         Convenience method that calls self.get_sparse_cloud() for all frames in the frame range
         and returns the combined result.
-        :param apply_transform: `bool` Whether to transform the translation or not.
         :return: `np.array` that contains a sparse cloud for each frame in the frame range.
         """
-        return np.array([self.get_sc(f, apply_transform) for f in self.get_frame_range()])
+        return np.array([self.get_sc(f) for f in self.get_frame_range()])
 
-    def get_tdc(self, r: Union[int, Tuple[int, int]] = None,
-                shuffle: bool = False,
-                apply_transform: bool = True) -> np.array:
+    def get_tdc(self, r: Union[int, Tuple[int, int]] = None) -> 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,
@@ -698,8 +777,6 @@ class FBXContainer:
         Optionally shuffles this dense cloud before adding it to the final list.
         :param r: tuple of `int` that indicates the frame range to get. Default is None,
         resulting in the animation frame range.
-        :param shuffle: If `True`, shuffles the dense point cloud of each frame.
-        :param apply_transform: `bool` Whether to transform the translation or not.
         :return: `np.array` that contains a dense point cloud for each frame,
         with a shape of (self.num_frames, self.pc_size, 5).
         """
@@ -717,7 +794,7 @@ class FBXContainer:
             r = self.get_frame_range()
 
         for frame in r:
-            cloud = self.get_sc(frame, apply_transform)
+            cloud = self.get_sc(frame)
             missing = self.pc_size - cloud.shape[0]
 
             # Only bother creating ghost markers if there are any missing rows.
@@ -727,16 +804,11 @@ class FBXContainer:
                 ghost_cloud = make_ghost_markers(missing)
                 cloud = np.vstack([ghost_cloud, 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_tdc(self, cloud: np.array = None, shuffle: bool = False, apply_transform: bool = True) \
+    def split_tdc(self, cloud: np.array = None) \
             -> Tuple[np.array, np.array, np.array, np.array, np.array]:
         """
         Splits a timeline dense cloud with shape (self.num_frames, self.pc_size, 5) into 3 different
@@ -747,12 +819,10 @@ class FBXContainer:
         4. A `np.array` with the rotation Euler angles 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.
-        :param apply_transform: `bool` Whether to transform the translation or not.
         :return: Return tuple of `np.array` as (actor classes, marker classes, translation vectors).
         """
         if cloud is None:
-            cloud = self.get_tdc(shuffle=shuffle, apply_transform=apply_transform)
+            cloud = self.get_tdc()
 
         if cloud.shape[1] != 1000:
             raise ValueError(f"Dense cloud doesn't have enough points. {cloud.shape[1]}/1000.")
@@ -852,91 +922,133 @@ class FBXContainer:
         self.remove_node(self.unlabeled_markers_parent)
 
     def remove_system(self) -> None:
+        """
+        Removes all nodes under and including the System parent.
+        """
         system_node = self.get_parent_node_by_name('System')
         self.remove_node(system_node, recursive=True)
 
     def cleanup(self) -> None:
+        """
+        Removes all unlabeled markers and System nodes.
+        """
         self.remove_unlabeled_markers()
         self.remove_system()
 
-    def replace_animation_curves(self, node, curve_types):
-        anim_curve_dict = {
-            't': [
-                ("X", node.LclTranslation),
-                ("Y", node.LclTranslation),
-                ("Z", node.LclTranslation)
-            ],
-            'r': [
-                ("X", node.LclRotation),
-                ("Y", node.LclRotation),
-                ("Z", node.LclRotation)
-            ],
-            's': [
-                ("X", node.LclScaling),
-                ("Y", node.LclScaling),
-                ("Z", node.LclScaling)
-            ]
-        }
-
-        anim_curves = []
-        for curve_type in curve_types:
-            if curve_type in anim_curve_dict:
-                for anim_curve_name, p in anim_curve_dict[curve_type]:
-                    # Disconnect and remove existing animation curve, if any
-                    existing_anim_curve = p.GetCurve(self.anim_layer, anim_curve_name, False)
-                    # TODO: Make sure a new anim curve is properly connected.
-                    if existing_anim_curve:
-                        existing_anim_curve.KeyClear()
-                        anim_curves.append(existing_anim_curve)
-                    #     p.DisconnectSrcObject(existing_anim_curve)
-                    #     existing_anim_curve.Destroy()
-                    # del existing_anim_curve
-                    #
-                    # # Create a new animation curve and connect it to the node and animation layer
-                    # new_anim_curve = fbx.FbxAnimCurve.Create(self.manager, anim_curve_name)
-                    # p.ConnectSrcObject(new_anim_curve)
-                    # new_anim_curve.ConnectDstObject(self.anim_layer)
-                    #
-                    # anim_curves.append(new_anim_curve)
-
-        return anim_curves
+    def get_clean_translation_curves(self, marker: fbx.FbxNode) -> List[fbx.FbxAnimCurve]:
+        """
+        Gets and cleans the local translation animation curves for the given marker.
+        :param marker: `fbx.FbxNode` to get the anim curves off.
+        :return: List of `fbx.FbxAnimCurve` without keyframes.
+        """
+        curves = []
+        for axis in ['X', 'Y', 'Z']:
+            # Last argument is True, so if no anim curve was connected here,
+            # it'll automatically make a new one and connect it correctly.
+            curve = marker.LclTranslation.GetCurve(self.anim_layer, axis, True)
+            # Remove all existing keyframes.
+            curve.KeyClear()
+            curves.append(curve)
 
-    def replace_keyframes_per_marker(self, marker: fbx.FbxNode, marker_keys: dict) -> None:
+        return curves
 
-        # Collect lcl transform curves.
-        curves = self.replace_animation_curves(marker, 't')
+    def set_default_lcl_rotation(self, node: fbx.FbxNode, lcl_r: List[float]) -> None:
+        """
+        First checks if the local rotation has an animation curve. This gets destroyed if it exists.
+        Then it sets the default values.
+        :param node: `fbx.FbxNode` to set the default local rotation for.
+        :param lcl_r: List of `float` to set the default local rotation to.
+        """
+        for axis in ['X', 'Y', 'Z']:
+            curve = node.LclRotation.GetCurve(self.anim_layer, axis, False)
+            if curve:
+                curve.Destroy()
+        node.LclRotation.Set(fbx.FbxDouble3(*lcl_r))
+
+    def set_default_lcl_scaling(self, node: fbx.FbxNode, lcl_s: List[float]) -> None:
+        """
+        First checks if the local scaling has an animation curve. This gets destroyed if it exists.
+        Then it sets the default values.
+        :param node: `fbx.FbxNode` to set the default local scaling for.
+        :param lcl_s: List of `float` to set the default local scaling to.
+        """
+        for axis in ['X', 'Y', 'Z']:
+            curve = node.LclScaling.GetCurve(self.anim_layer, axis, False)
+            if curve:
+                curve.Destroy()
+        node.LclScaling.Set(fbx.FbxDouble3(*lcl_s))
+
+    def set_default_lcl_transforms(self, marker: fbx.FbxNode, marker_keys: dict) -> None:
+        """
+        Finds the first frame in the dict, calculates that frame's local transform,
+        and then sets the default values for the local rotation and scaling.
+        :param marker: `fbx.FbxNode` marker to set the default values for.
+        :param marker_keys: `dict` in the form of {'frame': [tx, ty, tz, rx, ry, rz...]}.
+        """
+        # Find the first frame in the dict.
+        frame = list(marker_keys.keys())[0]
+        # Find the FbxAMatrix stored under that frame.
+        world_transform = marker_keys[frame]
+        # Calculate the local rotation and scaling, ignore the translation.
+        _, lcl_r, lcl_s = world_to_local_transform(marker, world_transform, frame)
 
-        # TODO: Only set translation keys. Set rotation and scale as property values instead of curves.
-        for axis, curve in enumerate(curves):
+        # Set the default values for the rotation and scaling, as they don't need keyframes.
+        # Note that these functions will destroy any associated anim curves.
+        self.set_default_lcl_rotation(marker, lcl_r)
+        self.set_default_lcl_scaling(marker, lcl_s)
 
+    def replace_keyframes_per_marker(self, marker: fbx.FbxNode, marker_keys: dict) -> None:
+        # Initialize empty variables for the local rotation and scaling.
+        # These will be filled at the first keyframe
+        self.set_default_lcl_transforms(marker, marker_keys)
+
+        for axis, curve in enumerate(self.get_clean_translation_curves(marker)):
             curve.KeyModifyBegin()
 
             # The dict has frames mapped to world matrices.
             # The world_transform here is that full matrix, so we only need to convert this to local space.
             for frame, world_transform in marker_keys.items():
                 # Convert world to local transform at the given frame.
-                lcl_t, lcl_r, lcl_s = world_to_local_transform(marker, world_transform, frame)
-                # Only for translations, set keyframes.
+                lcl_t, _, _ = world_to_local_transform(marker, world_transform, frame)
+                # Only for translations set keyframes.
                 create_keyframe(curve, frame, lcl_t[axis])
 
             curve.KeyModifyEnd()
 
     def replace_keyframes_per_actor(self, actor: int, actor_keys: dict) -> None:
+        """
+        Uses self.replace_keyframes_per_marker() to keyframe all markers of given actor.
+        :param actor: `int` actor index to apply to. Index starts at 0.
+        :param actor_keys: `dict` with all marker keys for this actor.
+        """
         for marker_class, (marker_name, marker) in enumerate(self.markers[actor].items(), start=1):
-            self.replace_keyframes_per_marker(marker, actor_keys[marker_class])
+            marker_keys = actor_keys.get(marker_class)
+            if marker_keys:
+                self.replace_keyframes_per_marker(marker, marker_keys)
 
     def replace_keyframes_for_all_actors(self, key_dict: dict) -> None:
+        """
+        For all actors, uses self.replace_keyframes_per_actor() to set keyframes on each actor's marker nodes.
+        :param key_dict: `dict` with all actor keyframes.
+        """
         for actor_idx in range(self.actor_count):
-            self.replace_keyframes_per_actor(actor_idx, key_dict[actor_idx + 1])
+            actor_dict = key_dict.get(actor_idx+1)
+            if actor_dict:
+                self.replace_keyframes_per_actor(actor_idx, actor_dict)
 
 
 # d = FBXContainer(Path('G:/Firestorm/mocap-ai/data/fbx/dowg/TAKE_01+1_ALL_001.fbx'))
-# # cloud = d.get_tdc(apply_transform=False)
-# actors_train, markers_train, t_train, r_train, s_train = d.split_tdc(apply_transform=True)
-# actors_test, markers_test, t_test, r_test, s_test = d.split_tdc(apply_transform=False)
-# # splits = d.split_tdc(apply_transform=False)
-# merged = merge_tdc(actors_train, markers_train, t_test, r_test, s_test)
-# pc_dict = timeline_cloud_to_dict(merged, d.start_frame)
-# d.replace_keyframes_for_all_actors(pc_dict)
-# # d.cleanup()
+# og_cloud = d.get_tdc()
+# # print(og_cloud[0, -10:, 2:5])
+# di = tsc_to_dict(og_cloud)
+# d.replace_keyframes_for_all_actors(di)
+# # new_cloud = d.get_tdc(r=100)
+# # print(new_cloud[0, -10:, 2:5])
+# # actors_train, markers_train, t_train, r_train, s_train = d.split_tdc(cloud)
+# # # t_train_transformed = d.transform_translations(t_train)
+# # # splits = d.split_tdc(apply_transform=False)
+# # merged = merge_tdc(actors_train, markers_train, t_train, r_train, s_train)
+# # pc_dict = tsc_to_dict(merged, d.start_frame)
+# # d.replace_keyframes_for_all_actors(pc_dict)
+# # # d.cleanup()
 # d.export_fbx(Path('G:/Firestorm/mocap-ai/data/fbx/export/TAKE_01+1_ALL_001.fbx'))