Merge pull request #67 from EveCharbie/dev

Fix: mesh file scaling

Author: EveCharbie

biobuddy/components/model_utils.py

@@ -90,7 +90,10 @@ def children_segment_names(self, parent_name: str):
 
     def get_chain_between_segments(self, first_segment_name: str, last_segment_name: str) -> list[str]:
         """
-        Get the name of the segments in the kinematic chain between first_segment_name and last_segment_name
+        Get the name of the segments in the kinematic chain between first_segment_name and last_segment_name.
+        WARNING: This list does not include brother/sister segments.
+        So for example, if s_geom_1 and s_geom_2 both have s_offset_parent as parent, and only s_geom_1 has a child,
+        only s_geom_1 will  be included in the chain.
         """
         chain = []
         this_segment = last_segment_name
@@ -101,6 +104,30 @@ def get_chain_between_segments(self, first_segment_name: str, last_segment_name:
         chain.reverse()
         return chain
 
+    def get_full_segment_chain(self, segment_name: str) -> list[str]:
+        """
+        Get the name of the segments in the complete fake kinematic chain derived from this segment.
+        This includes all ghost segments if they exist, including brother/sister segments.
+        """
+        if segment_name + "_parent_offset" in self.segment_names:
+            first_segment_name = segment_name + "_parent_offset"
+        else:
+            first_segment_name = segment_name
+        last_segment_name = segment_name
+        first_segment_index = self.segment_index(first_segment_name)
+        last_segment_index = self.segment_index(last_segment_name)
+        segment_list = self.segment_names[first_segment_index : last_segment_index + 1]
+
+        # Check that the segments were in "order" (meaning that only parent-child relationships were used)
+        for this_segment_name in segment_list.copy()[::-1]:
+            if this_segment_name == first_segment_name:
+                break
+            if self.segments[this_segment_name].parent_name not in segment_list:
+                raise NotImplementedError(
+                    f"The segments in the model are not in the correct order to get the full segment chain for {segment_name}."
+                )
+        return segment_list
+
     @property
     def nb_segments(self) -> int:
         return len(self.segments)

biobuddy/components/real/rigidbody/segment_scaling.py

@@ -143,8 +143,7 @@ def compute_scale_factors(
     ) -> ScaleFactor:
 
         original_marker_names = original_model.marker_names
-        q_zeros = np.zeros((original_model.nb_q, 1))
-        markers = original_model.markers_in_global(q_zeros)
+        markers = original_model.markers_in_global()
 
         scale_factor = []
         for marker_pair in self.marker_pairs:
@@ -153,7 +152,7 @@ def compute_scale_factors(
             marker1_position_subject = marker_positions[:, marker_names.index(marker_pair[0]), :]
             marker2_position_subject = marker_positions[:, marker_names.index(marker_pair[1]), :]
             mean_distance_subject = np.nanmean(
-                np.linalg.norm(marker2_position_subject - marker1_position_subject, axis=0)
+                np.linalg.norm(marker2_position_subject[:3, :] - marker1_position_subject[:3, :], axis=0)
             )
 
             # Distance between the marker pairs in the original model

biobuddy/model_modifiers/scale_tool.py

@@ -345,21 +345,6 @@ def scale_model_geometrically(self, marker_positions: np.ndarray, marker_names:
                         )
                         self.scaled_model.segments[segment_name + ghost_key].segment_coordinate_system = scs_scaled
 
-                    # Scale the meshes of the intermediary ghost segments
-                    looping_parent_name = self.original_model.segments[
-                        segment_name
-                    ].parent_name  # The current segment's mesh will be scaled later
-                    scale_factor = scaling_factors[segment_name].to_vector()
-                    while ghost_key not in looping_parent_name:
-                        mesh_file = deepcopy(self.original_model.segments[looping_parent_name].mesh_file)
-                        if mesh_file is not None:
-                            mesh_file.mesh_scale *= scale_factor
-                            mesh_file.mesh_translation *= scale_factor
-                        self.scaled_model.segments[looping_parent_name].mesh_file = mesh_file
-                        looping_parent_name = self.original_model.segments[looping_parent_name].parent_name
-                    # Apply it to only one of the ghost segments recognized
-                    break
-
             # Apply scaling to the current segment
             if self.original_model.segments[segment_name].parent_name in self.scaling_segments.keys():
                 parent_scale_factor = scaling_factors[
@@ -396,6 +381,17 @@ def scale_model_geometrically(self, marker_positions: np.ndarray, marker_names:
             else:
                 self.scaled_model.segments[segment_name] = deepcopy(self.original_model.segments[segment_name])
 
+            # Scale the meshes from all intermediary ghost segments
+            if segment_name in scaling_factors.keys():
+                segment_name_list = self.original_model.get_full_segment_chain(segment_name)
+                scale_factor = scaling_factors[segment_name].to_vector()
+                for this_segment_name in segment_name_list:
+                    mesh_file = deepcopy(self.original_model.segments[this_segment_name].mesh_file)
+                    if mesh_file is not None:
+                        mesh_file.mesh_scale *= scale_factor
+                        mesh_file.mesh_translation *= scale_factor
+                    self.scaled_model.segments[this_segment_name].mesh_file = mesh_file
+
         # Scale muscles
         for muscle_group in self.original_model.muscle_groups:
 
@@ -500,11 +496,6 @@ def scale_segment(
         if mesh_scaled is not None:
             mesh_scaled.positions *= scale_factor
 
-        mesh_file_scaled = deepcopy(original_segment.mesh_file)
-        if mesh_file_scaled is not None:
-            mesh_file_scaled.mesh_scale *= scale_factor
-            mesh_file_scaled.mesh_translation *= scale_factor
-
         return SegmentReal(
             name=deepcopy(original_segment.name),
             parent_name=deepcopy(original_segment.parent_name),
@@ -515,7 +506,9 @@ def scale_segment(
             qdot_ranges=deepcopy(original_segment.qdot_ranges),
             inertia_parameters=inertia_parameters_scaled,
             mesh=mesh_scaled,
-            mesh_file=mesh_file_scaled,
+            mesh_file=deepcopy(
+                original_segment.mesh_file
+            ),  # Mesh file scaling is handled later to scale all meshes from ghost segments
         )
 
     def scale_marker(self, original_marker: MarkerReal, scale_factor: Point) -> MarkerReal:

examples/scaling_model.py

@@ -7,7 +7,15 @@
 import numpy as np
 import biorbd
 
-from biobuddy import BiomechanicalModelReal, MuscleType, MuscleStateType, MeshParser, MeshFormat, ScaleTool
+from biobuddy import (
+    BiomechanicalModelReal,
+    MuscleType,
+    MuscleStateType,
+    MeshParser,
+    MeshFormat,
+    ScaleTool,
+    C3dData,
+)
 
 
 def main(visualization):
@@ -94,10 +102,9 @@ def main(visualization):
     # )
 
     # Scale the model
+    static_c3d = C3dData(static_filepath, first_frame=100, last_frame=200)
     scaled_model = scale_tool.scale(
-        filepath=static_filepath,
-        first_frame=100,
-        last_frame=200,
+        static_c3d=static_c3d,
         mass=80,
         q_regularization_weight=0.01,
         make_static_pose_the_models_zero=True,

tests/test_biomechanical_model_real.py

@@ -339,3 +339,97 @@ def test_change_mesh_directories():
     # Check that the mesh directories have been changed
     assert model.segments["parent"].mesh_file.mesh_file_directory == "new_geometry"
     assert model.segments["child"].mesh_file.mesh_file_directory == "new_geometry"
+
+
+def test_get_full_segment_chain():
+    # Make sure one segment works
+    model = create_simple_model()
+    segment_chain = model.get_full_segment_chain(segment_name="child")
+    assert segment_chain == ["child"]
+
+    # Test for a logical chain of segments
+    model = create_simple_model()
+    model.add_segment(
+        SegmentReal(
+            name="new_parent_offset",
+            parent_name="child",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="new_translation",
+            parent_name="new_parent_offset",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="new_rotation",
+            parent_name="new_translation",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="new_geom1",
+            parent_name="new_rotation",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="new_geom2",
+            parent_name="new_rotation",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="new_reset_axis",
+            parent_name="new_geom1",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="new",
+            parent_name="new_reset_axis",
+        )
+    )
+    segment_chain = model.get_full_segment_chain(segment_name="new")
+    assert segment_chain == [
+        "new_parent_offset",
+        "new_translation",
+        "new_rotation",
+        "new_geom1",
+        "new_geom2",
+        "new_reset_axis",
+        "new",
+    ]
+
+    # Test for a not supported chain of segments
+    model = create_simple_model()
+    model.add_segment(
+        SegmentReal(
+            name="new_parent_offset",
+            parent_name="child",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="bad_segment",
+            parent_name="parent",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="new_rotation",
+            parent_name="new_parent_offset",
+        )
+    )
+    model.add_segment(
+        SegmentReal(
+            name="new",
+            parent_name="new_rotation",
+        )
+    )
+    with pytest.raises(
+        NotImplementedError,
+        match="The segments in the model are not in the correct order to get the full segment chain for new.",
+    ):
+        model.get_full_segment_chain(segment_name="new")