ipuch / bionc Goto Github PK

Three versions has to be considered:

• no muscles, no articulation constraints, intersegmental forces express in global
• no muscles, no articulation constraints, intersegmental forces express in euler basis (WIP) #74
• no muscles, with articular constraints, project, and rigid constraint null space
• with muscles, requires optimization.

Make the docstrings of Hinge and Spherical joints as for Universal joints

This needs to be implemented in NaturalSegement and BiomechanicalModel.

from enum import Enum

class TransformationMatrix(Enum):
VW = "VW"
UV = "UV"
WU = "WU"

if transformmation_matrix == TransformationMatrix.VW:
# do something
elif transformmation_matrix == TransformationMatrix.UV:
# do something
elif transformmation_matrix == TransformationMatrix.WU:
# do something

see naturalcoordinates

natural_coordinates_to_joint_angle method should be renamed

And proper methods should be renamed to

model.natural_coordinates_to_minimal_coordinates(Q)

or

model.natural_coordinates_to_relative_coordinates(Q) 

It should be tested by the way.

following #74,

• unit test for numpy
• Translate the feature for casadi backend

see

• bionc/bionc_numpy/external_force.py
• bionc/bionc_casadi/external_force.py

Hey,

As i have a gold fish memory, i do not recall where is the example of a new constraint in your code (as we are trying to implement new motor constraint with a PhD student) Is it in test_utlimate_inverse_kinematics ?

Thanks :)

Focus on mass properties to compare to the example. @ANaaim

While working on refactoring the inertial parameters, I've realized and acted upon some inadequacies in how I initially coded the segments. After addressing concerns raised by @ANaaim in #96, I've managed to improve the code. Here's a brief of what I've done and what's still pending.

I've added methods to easily set inertial parameters at the segment level in #99
Example:

biomechmodel["thigh"].set_inertial_parameters(mass=..., center_of_mass=..., inertia_matrix=..., transformation_matrix_type=...)

Pending Tasks:

• Implement methods for the entire biomech model, e.g., Biomech.set_inertia_parameters(segment_name=..., ...). This method should also update the mass matrix.
• Create links between the model creator and these new methods to allow direct value specification.
• Introduce functions related to inertial parameters (from anthropometric tables) that can auto-adjust based on segment length during model creation. This will eliminate the need to manually input these values.

I am doing full coevrage for this function

How to implement this, it looks cool to preserve momentum.

Understood:

• Discretize the Lagrangian
• solving it implicitly through newton descent
• integrate

Source: https://arxiv.org/pdf/2002.11245.pdf

https://zacmanchester.github.io/docs/Variational_Integrator.pdf

I am aware that c3d data should not be in a git repository : Should we still offer some real c3d data in a outside repertory from which user could download and that they would have to add themselves to a specific repertory ?

==> I think it would definitely allow to offer ''meningfull'' example.

We could use data already available on a open data-set (for example : https://www.nature.com/articles/s41597-019-0124-4)

Hello,

I do not found any function to automatically calculate naturalVelocities and naturalAccelerations from a naturalsegment (from experimental data). Is there any ? I might have not looked properly.

If not might be interesting for beginner user in order to have them only to give the Q extracted in the inverse function. In that case we would calculate ourselve the qdot and qddot.

Best regards

This c3d should contain :

• Everything that was in the initial c3d
• The Q value after the optimisation process
• The technical marker associated with the Q post optim
• Kinematics calcultad for all the different joint in the model.
• Maybe in the metadata all the additional information on the joint used in the model, any parameters

Different aim in this function :

• Could replace the visualisation in bioviz for controlling data and using any c3d reader such as Mokka.
• Have a file that could be analysed without using bioNC for example for people not very used to using code it would only be needed to program them a c3d reader to extract the data.

(That it is clearly inspired fro what it is done in any gait analysis software).

Any comment, comment, or opignon on this ?

We should add a method to get post computations stats, such as most far marker, objective function value, did it converge, is my frame direct, etc...

A to-do is commented in the script with some ideas.
https://github.com/Ipuch/bioNC/blob/cdbcc8a12c26c7999bb6a3c81397cc5e2bbd14e5/bionc/bionc_numpy/inverse_kinematics.py#L422C5-L445C37

Current Behavior:
The default behavior of the InverseKinematics class aims to compute initial guesses for joint angles using marker data. The approach relies on a function defined by the model_creator from the c3d module.

This function is invoked internally using the method model.Q_from_markers, which approximates joint angles Q based on the marker positions. An optimization process further refines these initial guesses to ensure that they adhere to specified constraints.

self.model.Q_from_markers(self.experimental_markers[:, :, :])

For users, the interface is kept simple and does not require any manual initialization for the initial guesses:

ik_solver = InverseKinematics(
        model, markers, solve_frame_per_frame=True, 
        active_direct_frame_constraints=False, use_sx=True, Q_init=None
    )
Qopt_ipopt = ik_solver.solve(method="ipopt")

Proposed Enhancement:
To provide more flexibility, we can introduce multiple modes for initial guesses. I propose the following initial guess modes:

• Experimental:
  Usage: InverseKinematics(..., initial_guess_mode=InitialGuessMode.FROM_CURRENT_MARKERS)
  Description: This is the default behavior. It uses the experimental marker data to form initial guesses. No Q_init input is needed.
• Experimental First Frame:
  Usage: InverseKinematics(..., initial_guess_mode=InitialGuessMode.FROM_FIRST_FRAME_MARKERS)
  Description: This mode takes the experimental data from the first frame as the initial guess. This guess is then used as a starting point or "warm start" for subsequent frame optimizations. This approach is iterative, refining the guess with each frame until the entire sequence is processed. No Q_init is required here either.
• Custom:
  Usage: InverseKinematics(..., initial_guess_mode=InitialGuessMode.USER_PROVIDED)
  Description: In this mode, users can provide their custom initial guesses for joint angles with the Q_init argument.

Here is the Enum to implement:

class InitialGuessMode(Enum):
    FROM_CURRENT_MARKERS = "From Current Markers"
    FROM_FIRST_FRAME_MARKERS = "From First Frame Markers"
    USER_PROVIDED = "User Provided"

Referring to the email discussion we had this summer @anmuller :)

Minimum Joints need to be implemented to handle articulated kinematic chains. A draft has been begun but it needs to interact with the BioemchanicalModel

To build a python package, we need to respect some standards:

Every methods needs to be in snake case, for example:

def rigidBodyConstraint(...)

should be changed into:

def rigidbody_constraint(...)

Test if it is easy for an user to create a segment

see how it has been done for biomech_test and joints

Implement in protocol folder the function

@property
def mass(self)
...

Here :

Interesting to learn about the structure of bionc

• 1. Joints with the grounds

• 2. Forward dynamics with biomechanical model O(n3) see if (On) is easy to implement.
  https://youtu.be/tBGkfLL2Vs8

• 2.2 Pendulum without forces

• 3.1 external forces and torque applied on any point for any segment.

• 3.2 Internal generalized forces along joint axis (WIP)) #74

need to implement more joints with the ground. Only hinge, cardan and spherical joints are implemented

• natural segment
• segment
• biomechanical model
• templates for model creation from c3d

Once we have this, I think the rest will follow 👌🏼

Inspiration codes:

https://github.com/ANaaim/Kinetics_LBMC/blob/master/Kinetics_LBMC/multi_body_optimisation.py

https://github.com/pyomeca/biorbd/blob/master/binding/python3/rigid_body.py

ip = SegmentInertiaParameter.from_scs(mass, ...)
ip = SegmentInertiaParameter.from_ncs(mass, ...)
mass, center_of_mass, J = ip.to_natural_system()
ip_thigh = Dumas.Thigh

Also, they should be given from natural coordinate system in the class ̀NaturalSegment`

@Ipuch : Just to be sure and not break everything this time :)

Thanks

following #78

We should consider a kwarg to pass any entry to the joint:

• Invert all matrix B in WolframAlpha.
• copy the script https://github.com/Ipuch/bioNC/blob/another_fext_xp/bionc/bionc_numpy/transformation_matrix.py
• reimplement all inverse
• replace all occurrences of inv(B) in the code.

NaturalSegment docstrings are not up to date, each attribute and method need to be listed.

After the #85 the following was discussed :

"Super" calls the parent class JointBase that has common entries for every joint. As all joints doesn't have a parent and child point yet.
It's not relevant to initialize them now. But this would be a great idea in the future !
Then, to initialize parent and child point with proximal and distal point would be automated for every joint, in the parent class JointBase to avoid redundancy.

In the following adding of a joint is it possible to add the option ground_application point to be able to construct a spherical joint not exclusively at the rd point of the proximal segment ?
to have :

    model.add_joint(
        name="left_hip",
        joint_type=JointType.SPHERICAL,
        ground_application_point=left_hip_joint,
        parent="PELVIS",
        child="LTHIGH",)

Instead of this :

    model.add_joint(
        name="left_hip",
        joint_type=JointType.SPHERICAL,
        parent="PELVIS",
        child="LTHIGH",)

But maybe I missed something (i have adapted the function in the repertory bionc \examples\model_creation to test it on true data and see the results)

Todo:

• Read the chapter of jalon and Garcia
• answer: do I need to use augmented lagrangian ?
• use baumgarte stabilization

i want this

defects = biomechmodel.marker_cosntrains(markers, Q)

When creating a segment in a model using the following :

    model["RSHANK"] = SegmentTemplate(
        natural_segment=NaturalSegmentTemplate(
            u_axis=AxisFunctionTemplate(
                function=lambda m, bio: MarkerTemplate.normal_to(m, bio, right_knee_joint(m, bio), "RFAL", "RTAM")
            ),
            proximal_point=right_knee_joint,
            # the knee joint computed from the medial femoral epicondyle and the lateral femoral epicondyle
            distal_point=lambda m, bio: MarkerTemplate.middle_of(m, bio, "RFAL", "RTAM"),
            w_axis=AxisTemplate(start="RTAM", end="RFAL"),
        ),
        inertia_parameters=InertiaParametersTemplate(mass=1,
            center_of_mass=np.array([0, -0.5, 0]),  # in segment coordinates system
            inertia=np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])

    )

The inertia parameters are not given to the natural segment later on. I have the following error later on in the code (in inverse_dynamic class):

  File "----------------------------------------\bioNC\bioNC\bionc\bionc_casadi\natural_segment.py", line 768, in inverse_dynamics
    (self.mass_matrix @ Qddoti)
     ~~~~~~~~~~~~~~~~~^~~~~~~~

because self.mass_matrix is None.

Should the segment constructed differently or a specific command should be run for the segmentTemplate to update the different value ? I saw that for the examples three_link_pendulum.py, you are directly creating natural segment with the inertia properties which is different from creating from c3d data i suppose.

I will continue to investigate ... 🕵️

Thanks

Need to check up why.

Hello, @ANaaim

• We need to check the values of torques and forces in global coordinate system.
• And in joint coordinate system, euler basis.

https://github.com/Ipuch/bioNC/blob/8b61d7c3770f560881428562b1f47a52e73db27b/bionc/bionc_numpy/biomechanical_model.py#L811-L827C40

• when integrating natural coordinates we have to make sure the u and w axis keep their norm equal to 1, like when we integrate quaternions.

• question: when actuating joints, do we have to care about the constraints? Can we actuate the model along the free dofs of joints ?