def calibrate(DATA_PATH,calibrateFilenameLabelled,translators,weights,
required_mp,optional_mp,
ik_flag,leftFlatFoot,rightFlatFoot,headFlat,
markerDiameter,hjcMethod,
pointSuffix,**kwargs):
"""
Calibration of the CGM2.3
:param DATA_PATH [str]: path to your data
:param calibrateFilenameLabelled [str]: c3d file
:param translators [dict]: translators to apply
:param required_mp [dict]: required anthropometric data
:param optional_mp [dict]: optional anthropometric data (ex: LThighOffset,...)
:param ik_flag [bool]: enable the inverse kinematic solver
:param leftFlatFoot [bool]: enable of the flat foot option for the left foot
:param rightFlatFoot [bool]: enable of the flat foot option for the right foot
:param headFlat [bool]: enable of the head flat option
:param markerDiameter [double]: marker diameter (mm)
:param hjcMethod [str or list of 3 float]: method for locating the hip joint centre
:param pointSuffix [str]: suffix to add to model outputs
"""
# --------------------------STATIC FILE WITH TRANSLATORS --------------------------------------
if "Fitting" in weights.keys():
weights = weights["Fitting"]["Weight"]
# --- btk acquisition ----
if "forceBtkAcq" in kwargs.keys():
acqStatic = kwargs["forceBtkAcq"]
else:
acqStatic = btkTools.smartReader((DATA_PATH+calibrateFilenameLabelled))
btkTools.checkMultipleSubject(acqStatic)
if btkTools.isPointExist(acqStatic,"SACR"):
translators["LPSI"] = "SACR"
translators["RPSI"] = "SACR"
logging.info("[pyCGM2] Sacrum marker detected")
acqStatic = btkTools.applyTranslators(acqStatic,translators)
# ---check marker set used----
dcm = cgm.CGM.detectCalibrationMethods(acqStatic)
# --------------------------MODEL--------------------------------------
# ---definition---
model=cgm2.CGM2_3()
model.configure(acq=acqStatic,detectedCalibrationMethods=dcm)
model.addAnthropoInputParameters(required_mp,optional=optional_mp)
# --store calibration parameters--
model.setStaticFilename(calibrateFilenameLabelled)
model.setCalibrationProperty("leftFlatFoot",leftFlatFoot)
model.setCalibrationProperty("rightFlatFoot",rightFlatFoot)
model.setCalibrationProperty("headFlat",headFlat)
model.setCalibrationProperty("markerDiameter",markerDiameter)
# --------------------------STATIC CALBRATION--------------------------
scp=modelFilters.StaticCalibrationProcedure(model) # load calibration procedure
# ---initial calibration filter----
# use if all optional mp are zero
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,
leftFlatFoot = leftFlatFoot, rightFlatFoot = rightFlatFoot,
headFlat= headFlat,
markerDiameter=markerDiameter,
).compute()
# ---- Decorators -----
decorators.applyBasicDecorators(dcm, model,acqStatic,optional_mp,markerDiameter)
decorators.applyHJCDecorators(model,hjcMethod)
# ----Final Calibration filter if model previously decorated -----
if model.decoratedModel:
# initial static filter
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,
leftFlatFoot = leftFlatFoot, rightFlatFoot = rightFlatFoot,
headFlat= headFlat,
markerDiameter=markerDiameter).compute()
# ----------------------CGM MODELLING----------------------------------
# ----motion filter----
modMotion=modelFilters.ModelMotionFilter(scp,acqStatic,model,enums.motionMethod.Sodervisk,
markerDiameter=markerDiameter)
modMotion.compute()
if "noKinematicsCalculation" in kwargs.keys() and kwargs["noKinematicsCalculation"]:
logging.warning("[pyCGM2] No Kinematic calculation done for the static file")
return model, acqStatic
else:
if model.getBodyPart() == enums.BodyPart.UpperLimb:
ik_flag = False
logging.warning("[pyCGM2] Fitting only applied for the upper limb")
if ik_flag:
# ---OPENSIM IK---
# --- opensim calibration Filter ---
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim" # osimfile
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_3\\cgm2_3-markerset.xml" # markerset
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(model) # procedure
oscf = opensimFilters.opensimCalibrationFilter(osimfile,
model,
cgmCalibrationprocedure,
(DATA_PATH))
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build()
# --- opensim Fitting Filter ---
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_3\\cgm2_3-ikSetUp_template.xml" # ik tool file
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model) # procedure
cgmFittingProcedure.updateMarkerWeight("LASI",weights["LASI"])
cgmFittingProcedure.updateMarkerWeight("RASI",weights["RASI"])
cgmFittingProcedure.updateMarkerWeight("LPSI",weights["LPSI"])
cgmFittingProcedure.updateMarkerWeight("RPSI",weights["RPSI"])
cgmFittingProcedure.updateMarkerWeight("RTHI",weights["RTHI"])
cgmFittingProcedure.updateMarkerWeight("RKNE",weights["RKNE"])
cgmFittingProcedure.updateMarkerWeight("RTIB",weights["RTIB"])
cgmFittingProcedure.updateMarkerWeight("RANK",weights["RANK"])
cgmFittingProcedure.updateMarkerWeight("RHEE",weights["RHEE"])
cgmFittingProcedure.updateMarkerWeight("RTOE",weights["RTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHI",weights["LTHI"])
cgmFittingProcedure.updateMarkerWeight("LKNE",weights["LKNE"])
cgmFittingProcedure.updateMarkerWeight("LTIB",weights["LTIB"])
cgmFittingProcedure.updateMarkerWeight("LANK",weights["LANK"])
cgmFittingProcedure.updateMarkerWeight("LHEE",weights["LHEE"])
cgmFittingProcedure.updateMarkerWeight("LTOE",weights["LTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHAP",weights["LTHAP"])
cgmFittingProcedure.updateMarkerWeight("LTHAD",weights["LTHAD"])
cgmFittingProcedure.updateMarkerWeight("LTIAP",weights["LTIAP"])
cgmFittingProcedure.updateMarkerWeight("LTIAD",weights["LTIAD"])
cgmFittingProcedure.updateMarkerWeight("RTHAP",weights["RTHAP"])
cgmFittingProcedure.updateMarkerWeight("RTHAD",weights["RTHAD"])
cgmFittingProcedure.updateMarkerWeight("RTIAP",weights["RTIAP"])
cgmFittingProcedure.updateMarkerWeight("RTIAD",weights["RTIAD"])
osrf = opensimFilters.opensimFittingFilter(iksetupFile,
scalingOsim,
cgmFittingProcedure,
(DATA_PATH) )
acqStaticIK = osrf.run(acqStatic,(DATA_PATH + calibrateFilenameLabelled ))
# eventual static acquisition to consider for joint kinematics
finalAcqStatic = acqStaticIK if ik_flag else acqStatic
# --- final pyCGM2 model motion Filter ---
# use fitted markers
modMotionFitted=modelFilters.ModelMotionFilter(scp,finalAcqStatic,model,enums.motionMethod.Sodervisk)
modMotionFitted.compute()
if "displayCoordinateSystem" in kwargs.keys() and kwargs["displayCoordinateSystem"]:
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(csp,model,finalAcqStatic)
csdf.setStatic(False)
csdf.display()
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model,finalAcqStatic).compute(description="vectoriel", pointLabelSuffix=pointSuffix)
# detection of traveling axis + absolute angle
if model.m_bodypart != enums.BodyPart.UpperLimb:
pfp = progressionFrame.PelvisProgressionFrameProcedure()
else:
pfp = progressionFrame.ThoraxProgressionFrameProcedure()
pff = progressionFrame.ProgressionFrameFilter(finalAcqStatic,pfp)
pff.compute()
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
if model.m_bodypart != enums.BodyPart.UpperLimb:
modelFilters.ModelAbsoluteAnglesFilter(model,finalAcqStatic,
segmentLabels=["Left Foot","Right Foot","Pelvis"],
angleLabels=["LFootProgress", "RFootProgress","Pelvis"],
eulerSequences=["TOR","TOR", "ROT"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix=pointSuffix)
if model.m_bodypart == enums.BodyPart.LowerLimbTrunk:
modelFilters.ModelAbsoluteAnglesFilter(model,finalAcqStatic,
segmentLabels=["Thorax"],
angleLabels=["Thorax"],
eulerSequences=["YXZ"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix=pointSuffix)
if model.m_bodypart == enums.BodyPart.UpperLimb or model.m_bodypart == enums.BodyPart.FullBody:
modelFilters.ModelAbsoluteAnglesFilter(model,finalAcqStatic,
segmentLabels=["Thorax","Head"],
angleLabels=["Thorax", "Head"],
eulerSequences=["YXZ","TOR"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix=pointSuffix)
# BSP model
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
if model.m_bodypart == enums.BodyPart.FullBody:
modelFilters.CentreOfMassFilter(model,finalAcqStatic).compute(pointLabelSuffix=pointSuffix)
return model, finalAcqStatic
def fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,weights,
ik_flag,markerDiameter,
pointSuffix,
mfpa,
momentProjection,**kwargs):
"""
Fitting of the CGM2.3
:param model [str]: pyCGM2 model previously calibrated
:param DATA_PATH [str]: path to your data
:param reconstructFilenameLabelled [string list]: c3d files
:param translators [dict]: translators to apply
:param ik_flag [bool]: enable the inverse kinematic solver
:param mfpa [str]: manual force plate assignement
:param markerDiameter [double]: marker diameter (mm)
:param pointSuffix [str]: suffix to add to model outputs
:param momentProjection [str]: Coordinate system in which joint moment is expressed
"""
if "Fitting" in weights.keys():
weights = weights["Fitting"]["Weight"]
# --------------------------ACQ WITH TRANSLATORS --------------------------------------
# --- btk acquisition ----
if "forceBtkAcq" in kwargs.keys():
acqGait = kwargs["forceBtkAcq"]
else:
acqGait = btkTools.smartReader((DATA_PATH + reconstructFilenameLabelled))
btkTools.checkMultipleSubject(acqGait)
if btkTools.isPointExist(acqGait,"SACR"):
translators["LPSI"] = "SACR"
translators["RPSI"] = "SACR"
logging.info("[pyCGM2] Sacrum marker detected")
acqGait = btkTools.applyTranslators(acqGait,translators)
trackingMarkers = model.getTrackingMarkers(acqGait)
validFrames,vff,vlf = btkTools.findValidFrames(acqGait,trackingMarkers)
# filtering
# -----------------------
if "fc_lowPass_marker" in kwargs.keys() and kwargs["fc_lowPass_marker"]!=0 :
fc = kwargs["fc_lowPass_marker"]
order = 4
if "order_lowPass_marker" in kwargs.keys():
order = kwargs["order_lowPass_marker"]
signal_processing.markerFiltering(acqGait,trackingMarkers,order=order, fc =fc)
if "fc_lowPass_forcePlate" in kwargs.keys() and kwargs["fc_lowPass_forcePlate"]!=0 :
fc = kwargs["fc_lowPass_forcePlate"]
order = 4
if "order_lowPass_forcePlate" in kwargs.keys():
order = kwargs["order_lowPass_forcePlate"]
signal_processing.forcePlateFiltering(acqGait,order=order, fc =fc)
# --- initial motion Filter ---
scp=modelFilters.StaticCalibrationProcedure(model)
# section to remove : - copy motion of ProximalShank from Shank with Sodervisk
modMotion=modelFilters.ModelMotionFilter(scp,acqGait,model,enums.motionMethod.Sodervisk)
modMotion.compute()
# /section to remove
if model.getBodyPart() == enums.BodyPart.UpperLimb:
ik_flag = False
logging.warning("[pyCGM2] Fitting only applied for the upper limb")
if ik_flag:
# ---OPENSIM IK---
# --- opensim calibration Filter ---
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim" # osimfile
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_3\\cgm2_3-markerset.xml" # markerset
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(model) # procedure
oscf = opensimFilters.opensimCalibrationFilter(osimfile,
model,
cgmCalibrationprocedure,
(DATA_PATH))
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build()
# --- opensim Fitting Filter ---
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_3\\cgm2_3-ikSetUp_template.xml" # ik tl file
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model) # procedure
cgmFittingProcedure.updateMarkerWeight("LASI",weights["LASI"])
cgmFittingProcedure.updateMarkerWeight("RASI",weights["RASI"])
cgmFittingProcedure.updateMarkerWeight("LPSI",weights["LPSI"])
cgmFittingProcedure.updateMarkerWeight("RPSI",weights["RPSI"])
cgmFittingProcedure.updateMarkerWeight("RTHI",weights["RTHI"])
cgmFittingProcedure.updateMarkerWeight("RKNE",weights["RKNE"])
cgmFittingProcedure.updateMarkerWeight("RTIB",weights["RTIB"])
cgmFittingProcedure.updateMarkerWeight("RANK",weights["RANK"])
cgmFittingProcedure.updateMarkerWeight("RHEE",weights["RHEE"])
cgmFittingProcedure.updateMarkerWeight("RTOE",weights["RTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHI",weights["LTHI"])
cgmFittingProcedure.updateMarkerWeight("LKNE",weights["LKNE"])
cgmFittingProcedure.updateMarkerWeight("LTIB",weights["LTIB"])
cgmFittingProcedure.updateMarkerWeight("LANK",weights["LANK"])
cgmFittingProcedure.updateMarkerWeight("LHEE",weights["LHEE"])
cgmFittingProcedure.updateMarkerWeight("LTOE",weights["LTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHAP",weights["LTHAP"])
cgmFittingProcedure.updateMarkerWeight("LTHAD",weights["LTHAD"])
cgmFittingProcedure.updateMarkerWeight("LTIAP",weights["LTIAP"])
cgmFittingProcedure.updateMarkerWeight("LTIAD",weights["LTIAD"])
cgmFittingProcedure.updateMarkerWeight("RTHAP",weights["RTHAP"])
cgmFittingProcedure.updateMarkerWeight("RTHAD",weights["RTHAD"])
cgmFittingProcedure.updateMarkerWeight("RTIAP",weights["RTIAP"])
cgmFittingProcedure.updateMarkerWeight("RTIAD",weights["RTIAD"])
osrf = opensimFilters.opensimFittingFilter(iksetupFile,
scalingOsim,
cgmFittingProcedure,
(DATA_PATH) )
logging.info("-------INVERSE KINEMATICS IN PROGRESS----------")
acqIK = osrf.run(acqGait,(DATA_PATH + reconstructFilenameLabelled ))
logging.info("-------INVERSE KINEMATICS DONE-----------------")
# eventual gait acquisition to consider for joint kinematics
finalAcqGait = acqIK if ik_flag else acqGait
# --- final pyCGM2 model motion Filter ---
# use fitted markers
modMotionFitted=modelFilters.ModelMotionFilter(scp,finalAcqGait,model,enums.motionMethod.Sodervisk ,
markerDiameter=markerDiameter)
modMotionFitted.compute()
if "displayCoordinateSystem" in kwargs.keys() and kwargs["displayCoordinateSystem"]:
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(csp,model,finalAcqGait)
csdf.setStatic(False)
csdf.display()
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model,finalAcqGait).compute(description="vectoriel", pointLabelSuffix=pointSuffix)
# detection of traveling axis + absolute angle
if model.m_bodypart != enums.BodyPart.UpperLimb:
pfp = progressionFrame.PelvisProgressionFrameProcedure()
else:
pfp = progressionFrame.ThoraxProgressionFrameProcedure()
pff = progressionFrame.ProgressionFrameFilter(finalAcqGait,pfp)
pff.compute()
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
if model.m_bodypart != enums.BodyPart.UpperLimb:
modelFilters.ModelAbsoluteAnglesFilter(model,finalAcqGait,
segmentLabels=["Left Foot","Right Foot","Pelvis"],
angleLabels=["LFootProgress", "RFootProgress","Pelvis"],
eulerSequences=["TOR","TOR", "ROT"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix=pointSuffix)
if model.m_bodypart == enums.BodyPart.LowerLimbTrunk:
modelFilters.ModelAbsoluteAnglesFilter(model,finalAcqGait,
segmentLabels=["Thorax"],
angleLabels=["Thorax"],
eulerSequences=["YXZ"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix=pointSuffix)
if model.m_bodypart == enums.BodyPart.UpperLimb or model.m_bodypart == enums.BodyPart.FullBody:
modelFilters.ModelAbsoluteAnglesFilter(model,finalAcqGait,
segmentLabels=["Thorax","Head"],
angleLabels=["Thorax", "Head"],
eulerSequences=["YXZ","TOR"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix=pointSuffix)
#---- Body segment parameters----
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
if model.m_bodypart == enums.BodyPart.FullBody:
modelFilters.CentreOfMassFilter(model,finalAcqGait).compute(pointLabelSuffix=pointSuffix)
# Inverse dynamics
if btkTools.checkForcePlateExist(acqGait):
if model.m_bodypart != enums.BodyPart.UpperLimb:
# --- force plate handling----
# find foot in contact
mappedForcePlate = forceplates.matchingFootSideOnForceplate(finalAcqGait,mfpa=mfpa)
forceplates.addForcePlateGeneralEvents(finalAcqGait,mappedForcePlate)
logging.warning("Manual Force plate assignment : %s" %mappedForcePlate)
# assembly foot and force plate
modelFilters.ForcePlateAssemblyFilter(model,finalAcqGait,mappedForcePlate,
leftSegmentLabel="Left Foot",
rightSegmentLabel="Right Foot").compute(pointLabelSuffix=pointSuffix)
#---- Joint kinetics----
idp = modelFilters.CGMLowerlimbInverseDynamicProcedure()
modelFilters.InverseDynamicFilter(model,
finalAcqGait,
procedure = idp,
projection = momentProjection,
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression
).compute(pointLabelSuffix=pointSuffix)
#---- Joint energetics----
modelFilters.JointPowerFilter(model,finalAcqGait).compute(pointLabelSuffix=pointSuffix)
#---- zero unvalid frames ---
btkTools.applyValidFramesOnOutput(finalAcqGait,validFrames)
return finalAcqGait
def CGM2_4_SARA_test(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM2\\cgm2.4\\Knee Calibration\\"
staticFilename = "static.c3d"
funcFilename = "functional.c3d"
gaitFilename = "gait trial 01.c3d"
markerDiameter = 14
mp = {
'Bodymass': 69.0,
'LeftLegLength': 930.0,
'RightLegLength': 930.0,
'LeftKneeWidth': 94.0,
'RightKneeWidth': 64.0,
'LeftAnkleWidth': 67.0,
'RightAnkleWidth': 62.0,
'LeftSoleDelta': 0,
'RightSoleDelta': 0,
"LeftToeOffset": 0,
"RightToeOffset": 0,
}
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm2.CGM2_4LowerLimbs()
model.configure()
model.addAnthropoInputParameters(mp)
# --- INITIAL CALIBRATION ---
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# cgm decorator
modelDecorator.HipJointCenterDecorator(model).hara()
modelDecorator.KneeCalibrationDecorator(model).midCondyles(
acqStatic,
markerDiameter=markerDiameter,
side="both",
cgm1Behaviour=True)
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(
acqStatic, markerDiameter=markerDiameter, side="both")
# final
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
seLeftHJCnode="LHJC_Hara",
useRightHJCnode="RHJC_Hara",
useLeftKJCnode="LKJC_mid",
useLeftAJCnode="LAJC_mid",
useRightKJCnode="RKJC_mid",
useRightAJCnode="RAJC_mid",
markerDiameter=markerDiameter).compute()
# ------ LEFT KNEE CALIBRATION -------
acqFunc = btkTools.smartReader(str(MAIN_PATH + funcFilename))
# Motion of only left
modMotionLeftKnee = modelFilters.ModelMotionFilter(
scp, acqFunc, model, pyCGM2Enums.motionMethod.Sodervisk)
modMotionLeftKnee.segmentalCompute(["Left Thigh", "Left Shank"])
# decorator
modelDecorator.KneeCalibrationDecorator(model).sara(
"Left", indexFirstFrame=831, indexLastFrame=1280)
# ----add Point into the c3d----
Or_inThigh = model.getSegment("Left Thigh").getReferential(
"TF").getNodeTrajectory("KneeFlexionOri")
axis_inThigh = model.getSegment("Left Thigh").getReferential(
"TF").getNodeTrajectory("KneeFlexionAxis")
btkTools.smartAppendPoint(acqFunc, "Left" + "_KneeFlexionOri",
Or_inThigh)
btkTools.smartAppendPoint(acqFunc, "Left" + "_KneeFlexionAxis",
axis_inThigh)
# ------ RIGHT KNEE CALIBRATION -------
# Motion of only left
modMotionRightKnee = modelFilters.ModelMotionFilter(
scp, acqFunc, model, pyCGM2Enums.motionMethod.Sodervisk)
modMotionRightKnee.segmentalCompute(["Right Thigh", "Right Shank"])
# decorator
modelDecorator.KneeCalibrationDecorator(model).sara("Right",
indexFirstFrame=61,
indexLastFrame=551)
# ----add Point into the c3d----
Or_inThigh = model.getSegment("Right Thigh").getReferential(
"TF").getNodeTrajectory("KneeFlexionOri")
axis_inThigh = model.getSegment("Right Thigh").getReferential(
"TF").getNodeTrajectory("KneeFlexionAxis")
btkTools.smartAppendPoint(acqFunc, "Right" + "_KneeFlexionOri",
Or_inThigh)
btkTools.smartAppendPoint(acqFunc, "Right" + "_KneeFlexionAxis",
axis_inThigh)
btkTools.smartWriter(acqFunc, "acqFunc-Sara.c3d")
#--- FINAL CALIBRATION ---
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
useLeftHJCnode="LHJC_Hara",
useRightHJCnode="RHJC_Hara",
useLeftKJCnode="KJC_Sara",
useLeftAJCnode="LAJC_mid",
useRightKJCnode="KJC_Sara",
useRightAJCnode="RAJC_mid",
markerDiameter=markerDiameter,
RotateLeftThighFlag=True,
RotateRightThighFlag=True).compute()
# save static c3d with update KJC
btkTools.smartWriter(acqStatic, "Static-SARA.c3d")
# ------ Fitting -------
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, pyCGM2Enums.motionMethod.Determinist)
modMotion.compute()
# relative angles
modelFilters.ModelJCSFilter(model, acqGait).compute(
description="vectoriel", pointLabelSuffix="cgm1_6dof")
# absolute angles
longitudinalAxis, forwardProgression, globalFrame = btkTools.findProgressionAxisFromPelvicMarkers(
acqGait, ["LASI", "RASI", "RPSI", "LPSI"])
modelFilters.ModelAbsoluteAnglesFilter(
model,
acqGait,
segmentLabels=["Left HindFoot", "Right HindFoot", "Pelvis"],
angleLabels=["LFootProgress", "RFootProgress", "Pelvis"],
eulerSequences=["TOR", "TOR", "ROT"],
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix="cgm1_6dof")
# ------- OPENSIM IK --------------------------------------
# --- osim builder ---
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(
model)
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-markerset.xml"
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim"
oscf = opensimFilters.opensimCalibrationFilter(
osimfile, model, cgmCalibrationprocedure)
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build(exportOsim=False)
# --- fitting ---
#procedure
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model)
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-ikSetUp_template.xml"
osrf = opensimFilters.opensimFittingFilter(iksetupFile, scalingOsim,
cgmFittingProcedure,
MAIN_PATH)
acqIK = osrf.run(acqGait,
str(MAIN_PATH + gaitFilename),
exportSetUp=False)
# -------- NEW MOTION FILTER ON IK MARKERS ------------------
modMotion_ik = modelFilters.ModelMotionFilter(
scp,
acqIK,
model,
pyCGM2Enums.motionMethod.Sodervisk,
useForMotionTest=True)
modMotion_ik.compute()
finalJcs = modelFilters.ModelJCSFilter(model, acqIK)
finalJcs.setFilterBool(False)
finalJcs.compute(description="ik", pointLabelSuffix="2_ik") #
btkTools.smartWriter(acqIK, "gait trial 01 - Fitting.c3d")
def full_IK(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM2\\cgm2.3\\fullBody\\"
staticFilename = "PN01OP01S01STAT.c3d"
gaitFilename = "PN01OP01S01SS01.c3d"
markerDiameter = 14
mp = {
'Bodymass': 83.0,
'LeftLegLength': 874.0,
'RightLegLength': 876.0,
'LeftKneeWidth': 106.0,
'RightKneeWidth': 103.0,
'LeftAnkleWidth': 74.0,
'RightAnkleWidth': 72.0,
'LeftSoleDelta': 0,
'RightSoleDelta': 0,
}
# --- Calibration ---
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
translators = files.getTranslators(MAIN_PATH, "CGM2_3.translators")
acqStatic = btkTools.applyTranslators(acqStatic, translators)
model = cgm2.CGM2_3LowerLimbs()
model.configure()
model.addAnthropoInputParameters(mp)
# ---- Calibration ----
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# cgm decorator
modelDecorator.HipJointCenterDecorator(model).hara()
modelDecorator.KneeCalibrationDecorator(model).midCondyles(
acqStatic, markerDiameter=markerDiameter, side="both")
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(
acqStatic, markerDiameter=markerDiameter, side="both")
# final
modelFilters.ModelCalibrationFilter(
scp, acqStatic, model, markerDiameter=markerDiameter).compute()
# ------ Fitting -------
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
acqGait = btkTools.applyTranslators(acqGait, translators)
# Motion FILTER
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, enums.motionMethod.Sodervisk)
modMotion.compute()
# ------- OPENSIM IK --------------------------------------
# --- osim builder ---
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(
model)
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_3\\cgm2_3-markerset.xml"
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim"
oscf = opensimFilters.opensimCalibrationFilter(
osimfile, model, cgmCalibrationprocedure, MAIN_PATH)
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build(exportOsim=False)
# --- fitting ---
#procedure
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model)
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_3\\cgm2_3-ikSetUp_template.xml"
osrf = opensimFilters.opensimFittingFilter(iksetupFile, scalingOsim,
cgmFittingProcedure,
MAIN_PATH)
acqIK = osrf.run(acqGait,
str(MAIN_PATH + gaitFilename),
exportSetUp=False)
# -------- NEW MOTION FILTER ON IK MARKERS ------------------
modMotion_ik = modelFilters.ModelMotionFilter(
scp,
acqIK,
model,
enums.motionMethod.Sodervisk,
useForMotionTest=True)
modMotion_ik.compute()
finalJcs = modelFilters.ModelJCSFilter(model, acqIK)
finalJcs.setFilterBool(False)
finalJcs.compute(description="ik", pointLabelSuffix="2_ik") #
btkTools.smartWriter(acqIK, "cgm23_fullIK_Motion.c3d")
def fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,settings,
ik_flag,markerDiameter,
pointSuffix,
mfpa,
momentProjection):
# --- btk acquisition ----
acqGait = btkTools.smartReader(str(DATA_PATH + reconstructFilenameLabelled))
btkTools.checkMultipleSubject(acqGait)
acqGait = btkTools.applyTranslators(acqGait,translators)
validFrames,vff,vlf = btkTools.findValidFrames(acqGait,cgm2.CGM2_4LowerLimbs.TRACKING_MARKERS)
# --- initial motion Filter ---
scp=modelFilters.StaticCalibrationProcedure(model)
modMotion=modelFilters.ModelMotionFilter(scp,acqGait,model,enums.motionMethod.Sodervisk)
modMotion.compute()
if ik_flag:
# ---OPENSIM IK---
# --- opensim calibration Filter ---
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim" # osimfile
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-markerset.xml" # markerset
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(model) # procedure
oscf = opensimFilters.opensimCalibrationFilter(osimfile,
model,
cgmCalibrationprocedure,
str(DATA_PATH))
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build()
# --- opensim Fitting Filter ---
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-ikSetUp_template.xml" # ik tl file
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model) # procedure
cgmFittingProcedure.updateMarkerWeight("LASI",settings["Fitting"]["Weight"]["LASI"])
cgmFittingProcedure.updateMarkerWeight("RASI",settings["Fitting"]["Weight"]["RASI"])
cgmFittingProcedure.updateMarkerWeight("LPSI",settings["Fitting"]["Weight"]["LPSI"])
cgmFittingProcedure.updateMarkerWeight("RPSI",settings["Fitting"]["Weight"]["RPSI"])
cgmFittingProcedure.updateMarkerWeight("RTHI",settings["Fitting"]["Weight"]["RTHI"])
cgmFittingProcedure.updateMarkerWeight("RKNE",settings["Fitting"]["Weight"]["RKNE"])
cgmFittingProcedure.updateMarkerWeight("RTIB",settings["Fitting"]["Weight"]["RTIB"])
cgmFittingProcedure.updateMarkerWeight("RANK",settings["Fitting"]["Weight"]["RANK"])
cgmFittingProcedure.updateMarkerWeight("RHEE",settings["Fitting"]["Weight"]["RHEE"])
cgmFittingProcedure.updateMarkerWeight("RTOE",settings["Fitting"]["Weight"]["RTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHI",settings["Fitting"]["Weight"]["LTHI"])
cgmFittingProcedure.updateMarkerWeight("LKNE",settings["Fitting"]["Weight"]["LKNE"])
cgmFittingProcedure.updateMarkerWeight("LTIB",settings["Fitting"]["Weight"]["LTIB"])
cgmFittingProcedure.updateMarkerWeight("LANK",settings["Fitting"]["Weight"]["LANK"])
cgmFittingProcedure.updateMarkerWeight("LHEE",settings["Fitting"]["Weight"]["LHEE"])
cgmFittingProcedure.updateMarkerWeight("LTOE",settings["Fitting"]["Weight"]["LTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHAP",settings["Fitting"]["Weight"]["LTHAP"])
cgmFittingProcedure.updateMarkerWeight("LTHAD",settings["Fitting"]["Weight"]["LTHAD"])
cgmFittingProcedure.updateMarkerWeight("LTIAP",settings["Fitting"]["Weight"]["LTIAP"])
cgmFittingProcedure.updateMarkerWeight("LTIAD",settings["Fitting"]["Weight"]["LTIAD"])
cgmFittingProcedure.updateMarkerWeight("RTHAP",settings["Fitting"]["Weight"]["RTHAP"])
cgmFittingProcedure.updateMarkerWeight("RTHAD",settings["Fitting"]["Weight"]["RTHAD"])
cgmFittingProcedure.updateMarkerWeight("RTIAP",settings["Fitting"]["Weight"]["RTIAP"])
cgmFittingProcedure.updateMarkerWeight("RTIAD",settings["Fitting"]["Weight"]["RTIAD"])
cgmFittingProcedure.updateMarkerWeight("LSMH",settings["Fitting"]["Weight"]["LSMH"])
cgmFittingProcedure.updateMarkerWeight("LFMH",settings["Fitting"]["Weight"]["LFMH"])
cgmFittingProcedure.updateMarkerWeight("LVMH",settings["Fitting"]["Weight"]["LVMH"])
cgmFittingProcedure.updateMarkerWeight("RSMH",settings["Fitting"]["Weight"]["RSMH"])
cgmFittingProcedure.updateMarkerWeight("RFMH",settings["Fitting"]["Weight"]["RFMH"])
cgmFittingProcedure.updateMarkerWeight("RVMH",settings["Fitting"]["Weight"]["RVMH"])
# cgmFittingProcedure.updateMarkerWeight("LTHL",settings["Fitting"]["Weight"]["LTHL"])
# cgmFittingProcedure.updateMarkerWeight("LTHLD",settings["Fitting"]["Weight"]["LTHLD"])
# cgmFittingProcedure.updateMarkerWeight("LPAT",settings["Fitting"]["Weight"]["LPAT"])
# cgmFittingProcedure.updateMarkerWeight("LTIBL",settings["Fitting"]["Weight"]["LTIBL"])
# cgmFittingProcedure.updateMarkerWeight("RTHL",settings["Fitting"]["Weight"]["RTHL"])
# cgmFittingProcedure.updateMarkerWeight("RTHLD",settings["Fitting"]["Weight"]["RTHLD"])
# cgmFittingProcedure.updateMarkerWeight("RPAT",settings["Fitting"]["Weight"]["RPAT"])
# cgmFittingProcedure.updateMarkerWeight("RTIBL",settings["Fitting"]["Weight"]["RTIBL"])
osrf = opensimFilters.opensimFittingFilter(iksetupFile,
scalingOsim,
cgmFittingProcedure,
str(DATA_PATH) )
logging.info("-------INVERSE KINEMATICS IN PROGRESS----------")
acqIK = osrf.run(acqGait,str(DATA_PATH + reconstructFilenameLabelled ))
logging.info("-------INVERSE KINEMATICS DONE-----------------")
# eventual gait acquisition to consider for joint kinematics
finalAcqGait = acqIK if ik_flag else acqGait
# --- final pyCGM2 model motion Filter ---
# use fitted markers
modMotionFitted=modelFilters.ModelMotionFilter(scp,finalAcqGait,model,enums.motionMethod.Sodervisk ,
markerDiameter=markerDiameter)
modMotionFitted.compute()
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model,finalAcqGait).compute(description="vectoriel", pointLabelSuffix=pointSuffix)
# detection of traveling axis
longitudinalAxis,forwardProgression,globalFrame = btkTools.findProgressionAxisFromPelvicMarkers(finalAcqGait,["LASI","LPSI","RASI","RPSI"])
# absolute angles
modelFilters.ModelAbsoluteAnglesFilter(model,finalAcqGait,
segmentLabels=["Left Foot","Right Foot","Pelvis"],
angleLabels=["LFootProgress", "RFootProgress","Pelvis"],
eulerSequences=["TOR","TOR", "ROT"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix=pointSuffix)
#---- Body segment parameters----
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
# --- force plate handling----
# find foot in contact
mappedForcePlate = forceplates.matchingFootSideOnForceplate(finalAcqGait)
forceplates.addForcePlateGeneralEvents(finalAcqGait,mappedForcePlate)
logging.info("Force plate assignment : %s" %mappedForcePlate)
if mfpa is not None:
if len(mfpa) != len(mappedForcePlate):
raise Exception("[pyCGM2] manual force plate assignment badly sets. Wrong force plate number. %s force plate require" %(str(len(mappedForcePlate))))
else:
mappedForcePlate = mfpa
forceplates.addForcePlateGeneralEvents(finalAcqGait,mappedForcePlate)
logging.warning("Manual Force plate assignment : %s" %mappedForcePlate)
# assembly foot and force plate
modelFilters.ForcePlateAssemblyFilter(model,finalAcqGait,mappedForcePlate,
leftSegmentLabel="Left Foot",
rightSegmentLabel="Right Foot").compute()
#---- Joint kinetics----
idp = modelFilters.CGMLowerlimbInverseDynamicProcedure()
modelFilters.InverseDynamicFilter(model,
finalAcqGait,
procedure = idp,
projection = momentProjection
).compute(pointLabelSuffix=pointSuffix)
#---- Joint energetics----
modelFilters.JointPowerFilter(model,finalAcqGait).compute(pointLabelSuffix=pointSuffix)
#---- zero unvalid frames ---
btkTools.applyValidFramesOnOutput(finalAcqGait,validFrames)
return finalAcqGait
def calibrate(DATA_PATH,calibrateFilenameLabelled,translators,settings,
required_mp,optional_mp,
ik_flag,leftFlatFoot,rightFlatFoot,markerDiameter,hjcMethod,
pointSuffix):
# ---btk acquisition---
acqStatic = btkTools.smartReader(str(DATA_PATH+calibrateFilenameLabelled))
btkTools.checkMultipleSubject(acqStatic)
acqStatic = btkTools.applyTranslators(acqStatic,translators)
validFrames,vff,vlf = btkTools.findValidFrames(acqStatic,cgm2.CGM2_4LowerLimbs.TRACKING_MARKERS)
# --------------------------MODEL--------------------------------------
# ---definition---
model=cgm2.CGM2_4LowerLimbs()
model.configure()
model.addAnthropoInputParameters(required_mp,optional=optional_mp)
# --store calibration parameters--
model.setStaticFilename(calibrateFilenameLabelled)
model.setCalibrationProperty("leftFlatFoot",leftFlatFoot)
model.setCalibrationProperty("rightFlatFoot",rightFlatFoot)
model.setCalibrationProperty("markerDiameter",markerDiameter)
# ---check marker set used----
smc = cgm.CGM.checkCGM1_StaticMarkerConfig(acqStatic)
# --------------------------STATIC CALBRATION--------------------------
scp=modelFilters.StaticCalibrationProcedure(model) # load calibration procedure
# ---initial calibration filter----
# use if all optional mp are zero
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,
leftFlatFoot = leftFlatFoot, rightFlatFoot = rightFlatFoot,
markerDiameter=markerDiameter,
).compute()
# ---- Decorators -----
decorators.applyDecorators_CGM(smc, model,acqStatic,optional_mp,markerDiameter)
decorators.applyHJCDecorators(model,hjcMethod)
# ----Final Calibration filter if model previously decorated -----
if model.decoratedModel:
# initial static filter
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,
leftFlatFoot = leftFlatFoot, rightFlatFoot = rightFlatFoot,
markerDiameter=markerDiameter).compute()
# ----------------------CGM MODELLING----------------------------------
# ----motion filter----
modMotion=modelFilters.ModelMotionFilter(scp,acqStatic,model,enums.motionMethod.Sodervisk,
markerDiameter=markerDiameter)
modMotion.compute()
if ik_flag:
# ---OPENSIM IK---
# --- opensim calibration Filter ---
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim" # osimfile
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-markerset.xml" # markerset
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(model) # procedure
oscf = opensimFilters.opensimCalibrationFilter(osimfile,
model,
cgmCalibrationprocedure,
str(DATA_PATH))
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build()
# --- opensim Fitting Filter ---
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-ikSetUp_template.xml" # ik tool file
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model) # procedure
cgmFittingProcedure.updateMarkerWeight("LASI",settings["Fitting"]["Weight"]["LASI"])
cgmFittingProcedure.updateMarkerWeight("RASI",settings["Fitting"]["Weight"]["RASI"])
cgmFittingProcedure.updateMarkerWeight("LPSI",settings["Fitting"]["Weight"]["LPSI"])
cgmFittingProcedure.updateMarkerWeight("RPSI",settings["Fitting"]["Weight"]["RPSI"])
cgmFittingProcedure.updateMarkerWeight("RTHI",settings["Fitting"]["Weight"]["RTHI"])
cgmFittingProcedure.updateMarkerWeight("RKNE",settings["Fitting"]["Weight"]["RKNE"])
cgmFittingProcedure.updateMarkerWeight("RTIB",settings["Fitting"]["Weight"]["RTIB"])
cgmFittingProcedure.updateMarkerWeight("RANK",settings["Fitting"]["Weight"]["RANK"])
cgmFittingProcedure.updateMarkerWeight("RHEE",settings["Fitting"]["Weight"]["RHEE"])
cgmFittingProcedure.updateMarkerWeight("RTOE",settings["Fitting"]["Weight"]["RTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHI",settings["Fitting"]["Weight"]["LTHI"])
cgmFittingProcedure.updateMarkerWeight("LKNE",settings["Fitting"]["Weight"]["LKNE"])
cgmFittingProcedure.updateMarkerWeight("LTIB",settings["Fitting"]["Weight"]["LTIB"])
cgmFittingProcedure.updateMarkerWeight("LANK",settings["Fitting"]["Weight"]["LANK"])
cgmFittingProcedure.updateMarkerWeight("LHEE",settings["Fitting"]["Weight"]["LHEE"])
cgmFittingProcedure.updateMarkerWeight("LTOE",settings["Fitting"]["Weight"]["LTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHAP",settings["Fitting"]["Weight"]["LTHAP"])
cgmFittingProcedure.updateMarkerWeight("LTHAD",settings["Fitting"]["Weight"]["LTHAD"])
cgmFittingProcedure.updateMarkerWeight("LTIAP",settings["Fitting"]["Weight"]["LTIAP"])
cgmFittingProcedure.updateMarkerWeight("LTIAD",settings["Fitting"]["Weight"]["LTIAD"])
cgmFittingProcedure.updateMarkerWeight("RTHAP",settings["Fitting"]["Weight"]["RTHAP"])
cgmFittingProcedure.updateMarkerWeight("RTHAD",settings["Fitting"]["Weight"]["RTHAD"])
cgmFittingProcedure.updateMarkerWeight("RTIAP",settings["Fitting"]["Weight"]["RTIAP"])
cgmFittingProcedure.updateMarkerWeight("RTIAD",settings["Fitting"]["Weight"]["RTIAD"])
cgmFittingProcedure.updateMarkerWeight("LSMH",settings["Fitting"]["Weight"]["LSMH"])
cgmFittingProcedure.updateMarkerWeight("LFMH",settings["Fitting"]["Weight"]["LFMH"])
cgmFittingProcedure.updateMarkerWeight("LVMH",settings["Fitting"]["Weight"]["LVMH"])
cgmFittingProcedure.updateMarkerWeight("RSMH",settings["Fitting"]["Weight"]["RSMH"])
cgmFittingProcedure.updateMarkerWeight("RFMH",settings["Fitting"]["Weight"]["RFMH"])
cgmFittingProcedure.updateMarkerWeight("RVMH",settings["Fitting"]["Weight"]["RVMH"])
# cgmFittingProcedure.updateMarkerWeight("LTHL",settings["Fitting"]["Weight"]["LTHL"])
# cgmFittingProcedure.updateMarkerWeight("LTHLD",settings["Fitting"]["Weight"]["LTHLD"])
# cgmFittingProcedure.updateMarkerWeight("LPAT",settings["Fitting"]["Weight"]["LPAT"])
# cgmFittingProcedure.updateMarkerWeight("LTIBL",settings["Fitting"]["Weight"]["LTIBL"])
# cgmFittingProcedure.updateMarkerWeight("RTHL",settings["Fitting"]["Weight"]["RTHL"])
# cgmFittingProcedure.updateMarkerWeight("RTHLD",settings["Fitting"]["Weight"]["RTHLD"])
# cgmFittingProcedure.updateMarkerWeight("RPAT",settings["Fitting"]["Weight"]["RPAT"])
# cgmFittingProcedure.updateMarkerWeight("RTIBL",settings["Fitting"]["Weight"]["RTIBL"])
osrf = opensimFilters.opensimFittingFilter(iksetupFile,
scalingOsim,
cgmFittingProcedure,
str(DATA_PATH) )
acqStaticIK = osrf.run(acqStatic,str(DATA_PATH + calibrateFilenameLabelled ))
# eventual static acquisition to consider for joint kinematics
finalAcqStatic = acqStaticIK if ik_flag else acqStatic
# --- final pyCGM2 model motion Filter ---
# use fitted markers
modMotionFitted=modelFilters.ModelMotionFilter(scp,finalAcqStatic,model,enums.motionMethod.Sodervisk)
modMotionFitted.compute()
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model,finalAcqStatic).compute(description="vectoriel", pointLabelSuffix=pointSuffix)
# detection of traveling axis
longitudinalAxis,forwardProgression,globalFrame = btkTools.findProgressionAxisFromPelvicMarkers(finalAcqStatic,["LASI","RASI","RPSI","LPSI"])
# absolute angles
modelFilters.ModelAbsoluteAnglesFilter(model,finalAcqStatic,
segmentLabels=["Left Foot","Right Foot","Pelvis"],
angleLabels=["LFootProgress", "RFootProgress","Pelvis"],
eulerSequences=["TOR","TOR", "ROT"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix=pointSuffix)
return model, finalAcqStatic
def fitting(model, DATA_PATH, reconstructFilenameLabelled, translators,
weights, ik_flag, markerDiameter, pointSuffix, mfpa,
momentProjection, **kwargs):
"""
Fitting of the CGM2.5
:param model [str]: pyCGM2 model previously calibrated
:param DATA_PATH [str]: path to your data
:param reconstructFilenameLabelled [string list]: c3d files
:param translators [dict]: translators to apply
:param ik_flag [bool]: enable the inverse kinematic solver
:param mfpa [str]: manual force plate assignement
:param markerDiameter [double]: marker diameter (mm)
:param pointSuffix [str]: suffix to add to model outputs
:param momentProjection [str]: Coordinate system in which joint moment is expressed
"""
detectAnomaly = False
if "anomalyException" in kwargs.keys():
anomalyException = kwargs["anomalyException"]
else:
anomalyException = False
if "forceFoot6DoF" in kwargs.keys() and kwargs["forceFoot6DoF"]:
forceFoot6DoF_flag = True
else:
forceFoot6DoF_flag = False
if "Fitting" in weights.keys():
weights = weights["Fitting"]["Weight"]
# --- btk acquisition ----
if "forceBtkAcq" in kwargs.keys():
acqGait = kwargs["forceBtkAcq"]
else:
acqGait = btkTools.smartReader(
(DATA_PATH + reconstructFilenameLabelled))
btkTools.checkMultipleSubject(acqGait)
if btkTools.isPointExist(acqGait, "SACR"):
translators["LPSI"] = "SACR"
translators["RPSI"] = "SACR"
LOGGER.logger.info("[pyCGM2] Sacrum marker detected")
acqGait = btkTools.applyTranslators(acqGait, translators)
trackingMarkers = cgm2.CGM2_5.LOWERLIMB_TRACKING_MARKERS + cgm2.CGM2_5.THORAX_TRACKING_MARKERS + cgm2.CGM2_5.UPPERLIMB_TRACKING_MARKERS
actual_trackingMarkers, phatoms_trackingMarkers = btkTools.createPhantoms(
acqGait, trackingMarkers)
vff, vlf = btkTools.getFrameBoundaries(acqGait, actual_trackingMarkers)
if "frameInit" in kwargs.keys() and kwargs["frameInit"] is not None:
vff = kwargs["frameInit"]
LOGGER.logger.info("[pyCGM2] first frame forced to frame [%s]" %
(vff))
if "frameEnd" in kwargs.keys() and kwargs["frameEnd"] is not None:
vlf = kwargs["frameEnd"]
LOGGER.logger.info("[pyCGM2] end frame forced to frame [%s]" % (vlf))
flag = btkTools.getValidFrames(acqGait,
actual_trackingMarkers,
frameBounds=[vff, vlf])
LOGGER.logger.info("[pyCGM2] Computation from frame [%s] to frame [%s]" %
(vff, vlf))
# --------------------ANOMALY------------------------------
for marker in actual_trackingMarkers:
if marker not in model.getStaticTrackingMarkers():
LOGGER.logger.warning(
"[pyCGM2-Anomaly] marker [%s] - not used during static calibration - wrong kinematic for the segment attached to this marker. "
% (marker))
# --marker presence
markersets = [
cgm2.CGM2_5.LOWERLIMB_TRACKING_MARKERS,
cgm2.CGM2_5.THORAX_TRACKING_MARKERS,
cgm2.CGM2_5.UPPERLIMB_TRACKING_MARKERS
]
for markerset in markersets:
ipdp = InspectorProcedure.MarkerPresenceDetectionProcedure(markerset)
idf = InspectorFilter.InspectorFilter(acqGait,
reconstructFilenameLabelled,
ipdp)
inspector = idf.run()
# --marker outliers
if inspector["In"] != []:
madp = AnomalyDetectionProcedure.MarkerAnomalyDetectionRollingProcedure(
inspector["In"], plot=False, window=5, threshold=3)
adf = AnomalyFilter.AnomalyDetectionFilter(
acqGait,
reconstructFilenameLabelled,
madp,
frameRange=[vff, vlf])
anomaly = adf.run()
anomalyIndexes = anomaly["Output"]
if anomaly["ErrorState"]: detectAnomaly = True
if btkTools.checkForcePlateExist(acqGait):
afpp = AnomalyDetectionProcedure.ForcePlateAnomalyProcedure()
adf = AnomalyFilter.AnomalyDetectionFilter(acqGait,
reconstructFilenameLabelled,
afpp,
frameRange=[vff, vlf])
anomaly = adf.run()
if anomaly["ErrorState"]: detectAnomaly = True
if detectAnomaly and anomalyException:
raise Exception(
"Anomalies has been detected - Check Warning message of the log file"
)
# --------------------MODELLING------------------------------
# filtering
# -----------------------
if "fc_lowPass_marker" in kwargs.keys(
) and kwargs["fc_lowPass_marker"] != 0:
fc = kwargs["fc_lowPass_marker"]
order = 4
if "order_lowPass_marker" in kwargs.keys():
order = kwargs["order_lowPass_marker"]
signal_processing.markerFiltering(acqGait,
trackingMarkers,
order=order,
fc=fc)
if "fc_lowPass_forcePlate" in kwargs.keys(
) and kwargs["fc_lowPass_forcePlate"] != 0:
fc = kwargs["fc_lowPass_forcePlate"]
order = 4
if "order_lowPass_forcePlate" in kwargs.keys():
order = kwargs["order_lowPass_forcePlate"]
signal_processing.forcePlateFiltering(acqGait, order=order, fc=fc)
# --- initial motion Filter ---
scp = modelFilters.StaticCalibrationProcedure(model)
modMotion = modelFilters.ModelMotionFilter(scp, acqGait, model,
enums.motionMethod.Sodervisk)
modMotion.compute()
progressionFlag = False
if btkTools.isPointExist(acqGait, 'LHEE',
ignorePhantom=False) or btkTools.isPointExist(
acqGait, 'RHEE', ignorePhantom=False):
pfp = progressionFrame.PointProgressionFrameProcedure(marker="LHEE") \
if btkTools.isPointExist(acqGait, 'LHEE',ignorePhantom=False) \
else progressionFrame.PointProgressionFrameProcedure(marker="RHEE")
pff = progressionFrame.ProgressionFrameFilter(acqGait, pfp)
pff.compute()
progressionAxis = pff.outputs["progressionAxis"]
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
progressionFlag = True
elif btkTools.isPointsExist(acqGait, ['LASI', 'RASI', 'RPSI', 'LPSI'],
ignorePhantom=False) and not progressionFlag:
LOGGER.logger.info(
"[pyCGM2] - progression axis detected from Pelvic markers ")
pfp = progressionFrame.PelvisProgressionFrameProcedure()
pff = progressionFrame.ProgressionFrameFilter(acqGait, pfp)
pff.compute()
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
progressionFlag = True
elif btkTools.isPointsExist(acqGait, ['C7', 'T10', 'CLAV', 'STRN'],
ignorePhantom=False) and not progressionFlag:
LOGGER.logger.info(
"[pyCGM2] - progression axis detected from Thoracic markers ")
pfp = progressionFrame.ThoraxProgressionFrameProcedure()
pff = progressionFrame.ProgressionFrameFilter(acqGait, pfp)
pff.compute()
progressionAxis = pff.outputs["progressionAxis"]
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
else:
globalFrame = "XYZ"
progressionAxis = "X"
forwardProgression = True
LOGGER.logger.error(
"[pyCGM2] - impossible to detect progression axis - neither pelvic nor thoracic markers are present. Progression set to +X by default "
)
for target in weights.keys():
if target not in actual_trackingMarkers or target not in model.getStaticIkTargets(
):
weights[target] = 0
LOGGER.logger.warning(
"[pyCGM2] - the IK targeted marker [%s] is not labelled in the acquisition [%s]"
% (target, reconstructFilenameLabelled))
if ik_flag:
# ---OPENSIM IK---
# --- opensim calibration Filter ---
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim" # osimfile
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-markerset.xml" # markerset
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(
model) # procedure
oscf = opensimFilters.opensimCalibrationFilter(
osimfile, model, cgmCalibrationprocedure, DATA_PATH)
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build()
# --- opensim Fitting Filter ---
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-ikSetUp_template.xml" # ik tl file
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(
model) # procedure
cgmFittingProcedure.updateMarkerWeight("LASI", weights["LASI"])
cgmFittingProcedure.updateMarkerWeight("RASI", weights["RASI"])
cgmFittingProcedure.updateMarkerWeight("LPSI", weights["LPSI"])
cgmFittingProcedure.updateMarkerWeight("RPSI", weights["RPSI"])
cgmFittingProcedure.updateMarkerWeight("RTHI", weights["RTHI"])
cgmFittingProcedure.updateMarkerWeight("RKNE", weights["RKNE"])
cgmFittingProcedure.updateMarkerWeight("RTIB", weights["RTIB"])
cgmFittingProcedure.updateMarkerWeight("RANK", weights["RANK"])
cgmFittingProcedure.updateMarkerWeight("RHEE", weights["RHEE"])
cgmFittingProcedure.updateMarkerWeight("RTOE", weights["RTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHI", weights["LTHI"])
cgmFittingProcedure.updateMarkerWeight("LKNE", weights["LKNE"])
cgmFittingProcedure.updateMarkerWeight("LTIB", weights["LTIB"])
cgmFittingProcedure.updateMarkerWeight("LANK", weights["LANK"])
cgmFittingProcedure.updateMarkerWeight("LHEE", weights["LHEE"])
cgmFittingProcedure.updateMarkerWeight("LTOE", weights["LTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHAP", weights["LTHAP"])
cgmFittingProcedure.updateMarkerWeight("LTHAD", weights["LTHAD"])
cgmFittingProcedure.updateMarkerWeight("LTIAP", weights["LTIAP"])
cgmFittingProcedure.updateMarkerWeight("LTIAD", weights["LTIAD"])
cgmFittingProcedure.updateMarkerWeight("RTHAP", weights["RTHAP"])
cgmFittingProcedure.updateMarkerWeight("RTHAD", weights["RTHAD"])
cgmFittingProcedure.updateMarkerWeight("RTIAP", weights["RTIAP"])
cgmFittingProcedure.updateMarkerWeight("RTIAD", weights["RTIAD"])
cgmFittingProcedure.updateMarkerWeight("LSMH", weights["LSMH"])
cgmFittingProcedure.updateMarkerWeight("LFMH", weights["LFMH"])
cgmFittingProcedure.updateMarkerWeight("LVMH", weights["LVMH"])
cgmFittingProcedure.updateMarkerWeight("RSMH", weights["RSMH"])
cgmFittingProcedure.updateMarkerWeight("RFMH", weights["RFMH"])
cgmFittingProcedure.updateMarkerWeight("RVMH", weights["RVMH"])
# cgmFittingProcedure.updateMarkerWeight("LTHL",weights["LTHL"])
# cgmFittingProcedure.updateMarkerWeight("LTHLD",weights["LTHLD"])
# cgmFittingProcedure.updateMarkerWeight("LPAT",weights["LPAT"])
# cgmFittingProcedure.updateMarkerWeight("LTIBL",weights["LTIBL"])
# cgmFittingProcedure.updateMarkerWeight("RTHL",weights["RTHL"])
# cgmFittingProcedure.updateMarkerWeight("RTHLD",weights["RTHLD"])
# cgmFittingProcedure.updateMarkerWeight("RPAT",weights["RPAT"])
# cgmFittingProcedure.updateMarkerWeight("RTIBL",weights["RTIBL"])
osrf = opensimFilters.opensimFittingFilter(iksetupFile, scalingOsim,
cgmFittingProcedure,
DATA_PATH, acqGait)
osrf.setTimeRange(acqGait, beginFrame=vff, lastFrame=vlf)
if "ikAccuracy" in kwargs.keys():
osrf.setAccuracy(kwargs["ikAccuracy"])
LOGGER.logger.info("-------INVERSE KINEMATICS IN PROGRESS----------")
try:
acqIK = osrf.run(DATA_PATH + reconstructFilenameLabelled,
progressionAxis=progressionAxis,
forwardProgression=forwardProgression)
LOGGER.logger.info("[pyCGM2] - IK solver complete")
except:
LOGGER.logger.error("[pyCGM2] - IK solver fails")
acqIK = acqGait
detectAnomaly = True
LOGGER.logger.info(
"---------------------------------------------------")
# eventual gait acquisition to consider for joint kinematics
finalAcqGait = acqIK if ik_flag else acqGait
if "displayCoordinateSystem" in kwargs.keys(
) and kwargs["displayCoordinateSystem"]:
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(
csp, model, finalAcqGait)
csdf.setStatic(False)
csdf.display()
# --- final pyCGM2 model motion Filter ---
# use fitted markers
modMotionFitted = modelFilters.ModelMotionFilter(
scp,
finalAcqGait,
model,
enums.motionMethod.Sodervisk,
markerDiameter=markerDiameter,
forceFoot6DoF=forceFoot6DoF_flag)
modMotionFitted.compute()
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model, finalAcqGait).compute(
description="vectoriel", pointLabelSuffix=pointSuffix)
modelFilters.ModelAbsoluteAnglesFilter(
model,
finalAcqGait,
segmentLabels=["Left Foot", "Right Foot", "Pelvis", "Thorax", "Head"],
angleLabels=[
"LFootProgress", "RFootProgress", "Pelvis", "Thorax", "Head"
],
eulerSequences=["TOR", "TOR", "ROT", "YXZ", "TOR"],
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix=pointSuffix)
#---- Body segment parameters----
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
modelFilters.CentreOfMassFilter(
model, finalAcqGait).compute(pointLabelSuffix=pointSuffix)
# Inverse dynamics
if btkTools.checkForcePlateExist(acqGait):
# --- force plate handling----
# find foot in contact
mappedForcePlate = forceplates.matchingFootSideOnForceplate(
finalAcqGait, mfpa=mfpa)
forceplates.addForcePlateGeneralEvents(finalAcqGait, mappedForcePlate)
LOGGER.logger.warning("Manual Force plate assignment : %s" %
mappedForcePlate)
# assembly foot and force plate
modelFilters.ForcePlateAssemblyFilter(
model,
finalAcqGait,
mappedForcePlate,
leftSegmentLabel="Left Foot",
rightSegmentLabel="Right Foot").compute(
pointLabelSuffix=pointSuffix)
#---- Joint kinetics----
idp = modelFilters.CGMLowerlimbInverseDynamicProcedure()
modelFilters.InverseDynamicFilter(
model,
finalAcqGait,
procedure=idp,
projection=momentProjection,
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix=pointSuffix)
#---- Joint energetics----
modelFilters.JointPowerFilter(
model, finalAcqGait).compute(pointLabelSuffix=pointSuffix)
#---- zero unvalid frames ---
btkTools.cleanAcq(finalAcqGait)
btkTools.applyOnValidFrames(finalAcqGait, flag)
if detectAnomaly and not anomalyException:
LOGGER.logger.error(
"Anomalies has been detected - Check Warning messages of the log file"
)
return finalAcqGait, detectAnomaly
def full_IK(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM2\\cgm2.4\\medial\\"
staticFilename = "static.c3d"
gaitFilename = "gait Trial 01.c3d"
markerDiameter = 14
mp = {
'Bodymass': 69.0,
'LeftLegLength': 930.0,
'RightLegLength': 930.0,
'LeftKneeWidth': 94.0,
'RightKneeWidth': 64.0,
'LeftAnkleWidth': 67.0,
'RightAnkleWidth': 62.0,
'LeftSoleDelta': 0,
'RightSoleDelta': 0,
"LeftToeOffset": 0,
"RightToeOffset": 0,
}
# --- Calibration ---
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm2.CGM2_4LowerLimbs()
model.configure()
model.addAnthropoInputParameters(mp)
# ---- Calibration ----
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# cgm decorator
modelDecorator.HipJointCenterDecorator(model).hara()
modelDecorator.KneeCalibrationDecorator(model).midCondyles(
acqStatic, markerDiameter=markerDiameter, side="both")
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(
acqStatic, markerDiameter=markerDiameter, side="both")
# final
modelFilters.ModelCalibrationFilter(
scp, acqStatic, model, markerDiameter=markerDiameter).compute()
# ------ Fitting -------
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, pyCGM2Enums.motionMethod.Sodervisk)
modMotion.compute()
# relative angles
modelFilters.ModelJCSFilter(model, acqGait).compute(
description="vectoriel", pointLabelSuffix="cgm1_6dof")
# absolute angles
longitudinalAxis, forwardProgression, globalFrame = btkTools.findProgressionAxisFromPelvicMarkers(
acqGait, ["LASI", "RASI", "RPSI", "LPSI"])
modelFilters.ModelAbsoluteAnglesFilter(
model,
acqGait,
segmentLabels=["Left Foot", "Right Foot", "Pelvis"],
angleLabels=["LFootProgress", "RFootProgress", "Pelvis"],
eulerSequences=["TOR", "TOR", "ROT"],
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix="cgm1_6dof")
# ---Marker decomp filter----
mtf = modelFilters.TrackingMarkerDecompositionFilter(model, acqGait)
mtf.decompose()
# ------- OPENSIM IK --------------------------------------
# --- osim builder ---
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(
model)
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-markerset - expert.xml"
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim"
oscf = opensimFilters.opensimCalibrationFilter(
osimfile, model, cgmCalibrationprocedure, MAIN_PATH)
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build(exportOsim=False)
# --- fitting ---
#procedure
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(
model, expertMode=True)
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-expert-ikSetUp_template.xml"
osrf = opensimFilters.opensimFittingFilter(iksetupFile, scalingOsim,
cgmFittingProcedure,
MAIN_PATH)
acqIK = osrf.run(acqGait,
str(MAIN_PATH + gaitFilename),
exportSetUp=False)
# -------- NEW MOTION FILTER ON IK MARKERS ------------------
modMotion_ik = modelFilters.ModelMotionFilter(
scp,
acqIK,
model,
pyCGM2Enums.motionMethod.Sodervisk,
useForMotionTest=True)
modMotion_ik.compute()
finalJcs = modelFilters.ModelJCSFilter(model, acqIK)
finalJcs.setFilterBool(False)
finalJcs.compute(description="ik", pointLabelSuffix="2_ik") #
btkTools.smartWriter(acqIK, "cgm24e_fullIK.c3d")
def calibrate(DATA_PATH, calibrateFilenameLabelled, translators, weights,
required_mp, optional_mp, ik_flag, leftFlatFoot, rightFlatFoot,
headFlat, markerDiameter, hjcMethod, pointSuffix, **kwargs):
"""
Calibration of the CGM2.5
:param DATA_PATH [str]: path to your data
:param calibrateFilenameLabelled [str]: c3d file
:param translators [dict]: translators to apply
:param required_mp [dict]: required anthropometric data
:param optional_mp [dict]: optional anthropometric data (ex: LThighOffset,...)
:param ik_flag [bool]: enable the inverse kinematic solver
:param leftFlatFoot [bool]: enable of the flat foot option for the left foot
:param rightFlatFoot [bool]: enable of the flat foot option for the right foot
:param headFlat [bool]: enable of the head flat option
:param markerDiameter [double]: marker diameter (mm)
:param hjcMethod [str or list of 3 float]: method for locating the hip joint centre
:param pointSuffix [str]: suffix to add to model outputs
"""
detectAnomaly = False
if "anomalyException" in kwargs.keys():
anomalyException = kwargs["anomalyException"]
else:
anomalyException = False
if "Fitting" in weights.keys():
weights = weights["Fitting"]["Weight"]
# ---btk acquisition---
if "forceBtkAcq" in kwargs.keys():
acqStatic = kwargs["forceBtkAcq"]
else:
acqStatic = btkTools.smartReader(
(DATA_PATH + calibrateFilenameLabelled))
btkTools.checkMultipleSubject(acqStatic)
if btkTools.isPointExist(acqStatic, "SACR"):
translators["LPSI"] = "SACR"
translators["RPSI"] = "SACR"
LOGGER.logger.info("[pyCGM2] Sacrum marker detected")
acqStatic = btkTools.applyTranslators(acqStatic, translators)
trackingMarkers = cgm2.CGM2_5.LOWERLIMB_TRACKING_MARKERS + cgm2.CGM2_5.THORAX_TRACKING_MARKERS + cgm2.CGM2_5.UPPERLIMB_TRACKING_MARKERS
actual_trackingMarkers, phatoms_trackingMarkers = btkTools.createPhantoms(
acqStatic, trackingMarkers)
vff = acqStatic.GetFirstFrame()
vlf = acqStatic.GetLastFrame()
# vff,vlf = btkTools.getFrameBoundaries(acqStatic,actual_trackingMarkers)
flag = btkTools.getValidFrames(acqStatic,
actual_trackingMarkers,
frameBounds=[vff, vlf])
gapFlag = btkTools.checkGap(acqStatic,
actual_trackingMarkers,
frameBounds=[vff, vlf])
if gapFlag:
raise Exception(
"[pyCGM2] Calibration aborted. Gap find during interval [%i-%i]. Crop your c3d "
% (vff, vlf))
# --------------------ANOMALY------------------------------
# --Check MP
adap = AnomalyDetectionProcedure.AnthropoDataAnomalyProcedure(required_mp)
adf = AnomalyFilter.AnomalyDetectionFilter(None, None, adap)
mp_anomaly = adf.run()
if mp_anomaly["ErrorState"]: detectAnomaly = True
# --marker presence
markersets = [
cgm2.CGM2_5.LOWERLIMB_TRACKING_MARKERS,
cgm2.CGM2_5.THORAX_TRACKING_MARKERS,
cgm2.CGM2_5.UPPERLIMB_TRACKING_MARKERS
]
for markerset in markersets:
ipdp = InspectorProcedure.MarkerPresenceDetectionProcedure(markerset)
idf = InspectorFilter.InspectorFilter(acqStatic,
calibrateFilenameLabelled, ipdp)
inspector = idf.run()
# # --marker outliers
if inspector["In"] != []:
madp = AnomalyDetectionProcedure.MarkerAnomalyDetectionRollingProcedure(
inspector["In"], plot=False, window=4, threshold=3)
adf = AnomalyFilter.AnomalyDetectionFilter(
acqStatic, calibrateFilenameLabelled, madp)
anomaly = adf.run()
anomalyIndexes = anomaly["Output"]
if anomaly["ErrorState"]: detectAnomaly = True
if detectAnomaly and anomalyException:
raise Exception(
"Anomalies has been detected - Check Warning message of the log file"
)
# --------------------MODELLING------------------------------
# ---check marker set used----
dcm = cgm.CGM.detectCalibrationMethods(acqStatic)
# --------------------------MODEL--------------------------------------
# ---definition---
model = cgm2.CGM2_5()
model.configure(detectedCalibrationMethods=dcm)
model.addAnthropoInputParameters(required_mp, optional=optional_mp)
if dcm["Left Knee"] == enums.JointCalibrationMethod.KAD:
actual_trackingMarkers.append("LKNE")
if dcm["Right Knee"] == enums.JointCalibrationMethod.KAD:
actual_trackingMarkers.append("RKNE")
model.setStaticTrackingMarkers(actual_trackingMarkers)
# --store calibration parameters--
model.setStaticFilename(calibrateFilenameLabelled)
model.setCalibrationProperty("leftFlatFoot", leftFlatFoot)
model.setCalibrationProperty("rightFlatFoot", rightFlatFoot)
model.setCalibrationProperty("headFlat", headFlat)
model.setCalibrationProperty("markerDiameter", markerDiameter)
# --------------------------STATIC CALBRATION--------------------------
scp = modelFilters.StaticCalibrationProcedure(
model) # load calibration procedure
# ---initial calibration filter----
# use if all optional mp are zero
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
leftFlatFoot=leftFlatFoot,
rightFlatFoot=rightFlatFoot,
headFlat=headFlat,
markerDiameter=markerDiameter,
).compute()
# ---- Decorators -----
decorators.applyBasicDecorators(dcm, model, acqStatic, optional_mp,
markerDiameter)
decorators.applyHJCDecorators(model, hjcMethod)
# ----Final Calibration filter if model previously decorated -----
if model.decoratedModel:
# initial static filter
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
leftFlatFoot=leftFlatFoot,
rightFlatFoot=rightFlatFoot,
headFlat=headFlat,
markerDiameter=markerDiameter).compute()
# ----------------------CGM MODELLING----------------------------------
# ----motion filter----
modMotion = modelFilters.ModelMotionFilter(scp,
acqStatic,
model,
enums.motionMethod.Sodervisk,
markerDiameter=markerDiameter)
modMotion.compute()
# ----progression Frame----
progressionFlag = False
if btkTools.isPointsExist(acqStatic, ['LASI', 'RASI', 'RPSI', 'LPSI'],
ignorePhantom=False):
LOGGER.logger.info(
"[pyCGM2] - progression axis detected from Pelvic markers ")
pfp = progressionFrame.PelvisProgressionFrameProcedure()
pff = progressionFrame.ProgressionFrameFilter(acqStatic, pfp)
pff.compute()
progressionAxis = pff.outputs["progressionAxis"]
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
progressionFlag = True
elif btkTools.isPointsExist(acqStatic, ['C7', 'T10', 'CLAV', 'STRN'],
ignorePhantom=False) and not progressionFlag:
LOGGER.logger.info(
"[pyCGM2] - progression axis detected from Thoracic markers ")
pfp = progressionFrame.ThoraxProgressionFrameProcedure()
pff = progressionFrame.ProgressionFrameFilter(acqStatic, pfp)
pff.compute()
progressionAxis = pff.outputs["progressionAxis"]
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
else:
globalFrame = "XYZ"
progressionAxis = "X"
forwardProgression = True
LOGGER.logger.error(
"[pyCGM2] - impossible to detect progression axis - neither pelvic nor thoracic markers are present. Progression set to +X by default "
)
# ----manage IK Targets----
ikTargets = list()
for target in weights.keys():
if target not in actual_trackingMarkers:
weights[target] = 0
LOGGER.logger.warning(
"[pyCGM2] - the IK targeted marker [%s] is not labelled in the acquisition [%s]"
% (target, calibrateFilenameLabelled))
else:
ikTargets.append(target)
model.setStaticIkTargets(ikTargets)
if "noKinematicsCalculation" in kwargs.keys(
) and kwargs["noKinematicsCalculation"]:
LOGGER.logger.warning(
"[pyCGM2] No Kinematic calculation done for the static file")
return model, acqStatic, detectAnomaly
else:
if ik_flag:
# ---OPENSIM IK---
# --- opensim calibration Filter ---
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim" # osimfile
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-markerset.xml" # markerset
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(
model) # procedure
oscf = opensimFilters.opensimCalibrationFilter(
osimfile, model, cgmCalibrationprocedure, DATA_PATH)
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build()
# --- opensim Fitting Filter ---
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_4\\cgm2_4-ikSetUp_template.xml" # ik tool file
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(
model) # procedure
cgmFittingProcedure.updateMarkerWeight("LASI", weights["LASI"])
cgmFittingProcedure.updateMarkerWeight("RASI", weights["RASI"])
cgmFittingProcedure.updateMarkerWeight("LPSI", weights["LPSI"])
cgmFittingProcedure.updateMarkerWeight("RPSI", weights["RPSI"])
cgmFittingProcedure.updateMarkerWeight("RTHI", weights["RTHI"])
cgmFittingProcedure.updateMarkerWeight("RKNE", weights["RKNE"])
cgmFittingProcedure.updateMarkerWeight("RTIB", weights["RTIB"])
cgmFittingProcedure.updateMarkerWeight("RANK", weights["RANK"])
cgmFittingProcedure.updateMarkerWeight("RHEE", weights["RHEE"])
cgmFittingProcedure.updateMarkerWeight("RTOE", weights["RTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHI", weights["LTHI"])
cgmFittingProcedure.updateMarkerWeight("LKNE", weights["LKNE"])
cgmFittingProcedure.updateMarkerWeight("LTIB", weights["LTIB"])
cgmFittingProcedure.updateMarkerWeight("LANK", weights["LANK"])
cgmFittingProcedure.updateMarkerWeight("LHEE", weights["LHEE"])
cgmFittingProcedure.updateMarkerWeight("LTOE", weights["LTOE"])
cgmFittingProcedure.updateMarkerWeight("LTHAP", weights["LTHAP"])
cgmFittingProcedure.updateMarkerWeight("LTHAD", weights["LTHAD"])
cgmFittingProcedure.updateMarkerWeight("LTIAP", weights["LTIAP"])
cgmFittingProcedure.updateMarkerWeight("LTIAD", weights["LTIAD"])
cgmFittingProcedure.updateMarkerWeight("RTHAP", weights["RTHAP"])
cgmFittingProcedure.updateMarkerWeight("RTHAD", weights["RTHAD"])
cgmFittingProcedure.updateMarkerWeight("RTIAP", weights["RTIAP"])
cgmFittingProcedure.updateMarkerWeight("RTIAD", weights["RTIAD"])
cgmFittingProcedure.updateMarkerWeight("LSMH", weights["LSMH"])
cgmFittingProcedure.updateMarkerWeight("LFMH", weights["LFMH"])
cgmFittingProcedure.updateMarkerWeight("LVMH", weights["LVMH"])
cgmFittingProcedure.updateMarkerWeight("RSMH", weights["RSMH"])
cgmFittingProcedure.updateMarkerWeight("RFMH", weights["RFMH"])
cgmFittingProcedure.updateMarkerWeight("RVMH", weights["RVMH"])
# cgmFittingProcedure.updateMarkerWeight("LTHL",weights["LTHL"])
# cgmFittingProcedure.updateMarkerWeight("LTHLD",weights["LTHLD"])
# cgmFittingProcedure.updateMarkerWeight("LPAT",weights["LPAT"])
# cgmFittingProcedure.updateMarkerWeight("LTIBL",weights["LTIBL"])
# cgmFittingProcedure.updateMarkerWeight("RTHL",weights["RTHL"])
# cgmFittingProcedure.updateMarkerWeight("RTHLD",weights["RTHLD"])
# cgmFittingProcedure.updateMarkerWeight("RPAT",weights["RPAT"])
# cgmFittingProcedure.updateMarkerWeight("RTIBL",weights["RTIBL"])
osrf = opensimFilters.opensimFittingFilter(iksetupFile,
scalingOsim,
cgmFittingProcedure,
DATA_PATH,
acqStatic,
accuracy=1e-5)
LOGGER.logger.info(
"-------INVERSE KINEMATICS IN PROGRESS----------")
try:
acqStaticIK = osrf.run(DATA_PATH + calibrateFilenameLabelled,
progressionAxis=progressionAxis,
forwardProgression=forwardProgression)
LOGGER.logger.info("[pyCGM2] - IK solver complete")
except:
LOGGER.logger.error("[pyCGM2] - IK solver fails")
acqStaticIK = acqStatic
detectAnomaly = True
LOGGER.logger.info(
"-----------------------------------------------")
# eventual static acquisition to consider for joint kinematics
finalAcqStatic = acqStaticIK if ik_flag else acqStatic
# --- final pyCGM2 model motion Filter ---
# use fitted markers
modMotionFitted = modelFilters.ModelMotionFilter(
scp, finalAcqStatic, model, enums.motionMethod.Sodervisk)
modMotionFitted.compute()
if "displayCoordinateSystem" in kwargs.keys(
) and kwargs["displayCoordinateSystem"]:
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(
csp, model, finalAcqStatic)
csdf.setStatic(False)
csdf.display()
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model, finalAcqStatic).compute(
description="vectoriel", pointLabelSuffix=pointSuffix)
modelFilters.ModelAbsoluteAnglesFilter(
model,
finalAcqStatic,
segmentLabels=[
"Left Foot", "Right Foot", "Pelvis", "Thorax", "Head"
],
angleLabels=[
"LFootProgress", "RFootProgress", "Pelvis", "Thorax", "Head"
],
eulerSequences=["TOR", "TOR", "ROT", "YXZ", "TOR"],
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix=pointSuffix)
# BSP model
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
modelFilters.CentreOfMassFilter(
model, finalAcqStatic).compute(pointLabelSuffix=pointSuffix)
btkTools.cleanAcq(finalAcqStatic)
if detectAnomaly and not anomalyException:
LOGGER.logger.error(
"Anomalies has been detected - Check Warning messages of the log file"
)
return model, finalAcqStatic, detectAnomaly
# ------- OPENSIM IK --------------------------------------
# --- osim builder ---
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(
model)
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm1\\cgm1-markerset.xml"
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim"
oscf = opensimFilters.opensimCalibrationFilter(osimfile, model,
cgmCalibrationprocedure)
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build(exportOsim=False)
# --- fitting ---
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model)
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm1\\cgm1-ikSetUp_template.xml"
osrf = opensimFilters.opensimFittingFilter(iksetupFile, scalingOsim,
cgmFittingProcedure, MAIN_PATH)
acqIK = osrf.run(acqGait, str(MAIN_PATH + gaitFilename), exportSetUp=False)
# -------- NEW MOTION FILTER ON IK MARKERS ------------------
modMotion_ik = modelFilters.ModelMotionFilter(
scp,
acqIK,
model,
pyCGM2Enums.motionMethod.Sodervisk,
useForMotionTest=True)
modMotion_ik.compute()
def test_lowLevel(self):
DATA_PATH = pyCGM2.TEST_DATA_PATH + "GaitModels\CGM2.3\\Hannibal-medial\\"
staticFilename = "static.c3d"
gaitFilename= "gait1.c3d"
markerDiameter=14
required_mp={
'Bodymass' : 71.0,
'LeftLegLength' : 860.0,
'RightLegLength' : 865.0 ,
'LeftKneeWidth' : 102.0,
'RightKneeWidth' : 103.4,
'LeftAnkleWidth' : 75.3,
'RightAnkleWidth' : 72.9,
'LeftSoleDelta' : 0,
'RightSoleDelta' : 0,
'LeftShoulderOffset' : 0,
'RightShoulderOffset' : 0,
'LeftElbowWidth' : 0,
'LeftWristWidth' : 0,
'LeftHandThickness' : 0,
'RightElbowWidth' : 0,
'RightWristWidth' : 0,
'RightHandThickness' : 0
}
optional_mp = {
'LeftTibialTorsion' : 0,
'LeftThighRotation' : 0,
'LeftShankRotation' : 0,
'RightTibialTorsion' : 0,
'RightThighRotation' : 0,
'RightShankRotation' : 0
}
# --- Calibration ---
# ---check marker set used----
acqStatic = btkTools.smartReader(DATA_PATH + staticFilename)
dcm = cgm.CGM.detectCalibrationMethods(acqStatic)
model=cgm2.CGM2_3()
model.configure(detectedCalibrationMethods=dcm)
model.addAnthropoInputParameters(required_mp,optional=optional_mp)
# ---- Calibration ----
scp=modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,acqStatic,model).compute()
# cgm decorator
modelDecorator.HipJointCenterDecorator(model).hara()
modelDecorator.KneeCalibrationDecorator(model).midCondyles(acqStatic, markerDiameter=markerDiameter, side="both")
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(acqStatic, markerDiameter=markerDiameter, side="both")
# final
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,
markerDiameter=markerDiameter).compute()
# ------ Fitting -------
acqGait = btkTools.smartReader(DATA_PATH + gaitFilename)
# Motion FILTER
modMotion=modelFilters.ModelMotionFilter(scp,acqGait,model,enums.motionMethod.Sodervisk)
modMotion.compute()
# ------- OPENSIM IK --------------------------------------
# --- osim builder ---
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(model)
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_3\\cgm2_3-markerset.xml"
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim"
oscf = opensimFilters.opensimCalibrationFilter(osimfile,
model,
cgmCalibrationprocedure,
DATA_PATH)
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build(exportOsim=False)
# --- fitting ---
#procedure
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model)
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm2_3\\cgm2_3-ikSetUp_template.xml"
osrf = opensimFilters.opensimFittingFilter(iksetupFile,
scalingOsim,
cgmFittingProcedure,
DATA_PATH,
acqGait )
acqIK = osrf.run(str(DATA_PATH + gaitFilename ),exportSetUp=False)
# -------- NEW MOTION FILTER ON IK MARKERS ------------------
modMotion_ik=modelFilters.ModelMotionFilter(scp,acqIK,model,enums.motionMethod.Sodervisk,
useForMotionTest=True)
modMotion_ik.compute()
finalJcs =modelFilters.ModelJCSFilter(model,acqIK)
finalJcs.compute(description="ik", pointLabelSuffix = "2_ik")#
btkTools.smartWriter(acqIK,"cgm23_fullIK_Motion.c3d")
def fitting(model, DATA_PATH, reconstructFilenameLabelled, translators,
settings, markerDiameter, pointSuffix, mfpa, momentProjection,
**kwargs):
"""
Fitting of the CGM2.2
:param model [str]: pyCGM2 model previously calibrated
:param DATA_PATH [str]: path to your data
:param reconstructFilenameLabelled [string list]: c3d files
:param translators [dict]: translators to apply
:param mfpa [str]: manual force plate assignement
:param markerDiameter [double]: marker diameter (mm)
:param pointSuffix [str]: suffix to add to model outputs
:param momentProjection [str]: Coordinate system in which joint moment is expressed
"""
# --------------------------ACQUISITION ------------------------------------
# --- btk acquisition ----
if "forceBtkAcq" in kwargs.keys():
acqGait = kwargs["forceBtkAcq"]
else:
acqGait = btkTools.smartReader(
str(DATA_PATH + reconstructFilenameLabelled))
btkTools.checkMultipleSubject(acqGait)
acqGait = btkTools.applyTranslators(acqGait, translators)
trackingMarkers = model.getTrackingMarkers()
validFrames, vff, vlf = btkTools.findValidFrames(acqGait, trackingMarkers)
# --- initial motion Filter ---
scp = modelFilters.StaticCalibrationProcedure(model)
modMotion = modelFilters.ModelMotionFilter(scp, acqGait, model,
enums.motionMethod.Determinist)
modMotion.compute()
# ---OPENSIM IK---
# --- opensim calibration Filter ---
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\osim\\lowerLimb_ballsJoints.osim" # osimfile
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm1\\cgm1-markerset.xml" # markerset
cgmCalibrationprocedure = opensimFilters.CgmOpensimCalibrationProcedures(
model) # procedure
oscf = opensimFilters.opensimCalibrationFilter(osimfile, model,
cgmCalibrationprocedure,
str(DATA_PATH))
oscf.addMarkerSet(markersetFile)
scalingOsim = oscf.build()
# --- opensim Fitting Filter ---
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\settings\\cgm1\\cgm1-ikSetUp_template.xml" # ik tool file
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(
model) # procedure
cgmFittingProcedure.updateMarkerWeight(
"LASI", settings["Fitting"]["Weight"]["LASI"])
cgmFittingProcedure.updateMarkerWeight(
"RASI", settings["Fitting"]["Weight"]["RASI"])
cgmFittingProcedure.updateMarkerWeight(
"LPSI", settings["Fitting"]["Weight"]["LPSI"])
cgmFittingProcedure.updateMarkerWeight(
"RPSI", settings["Fitting"]["Weight"]["RPSI"])
cgmFittingProcedure.updateMarkerWeight(
"RTHI", settings["Fitting"]["Weight"]["RTHI"])
cgmFittingProcedure.updateMarkerWeight(
"RKNE", settings["Fitting"]["Weight"]["RKNE"])
cgmFittingProcedure.updateMarkerWeight(
"RTIB", settings["Fitting"]["Weight"]["RTIB"])
cgmFittingProcedure.updateMarkerWeight(
"RANK", settings["Fitting"]["Weight"]["RANK"])
cgmFittingProcedure.updateMarkerWeight(
"RHEE", settings["Fitting"]["Weight"]["RHEE"])
cgmFittingProcedure.updateMarkerWeight(
"RTOE", settings["Fitting"]["Weight"]["RTOE"])
cgmFittingProcedure.updateMarkerWeight(
"LTHI", settings["Fitting"]["Weight"]["LTHI"])
cgmFittingProcedure.updateMarkerWeight(
"LKNE", settings["Fitting"]["Weight"]["LKNE"])
cgmFittingProcedure.updateMarkerWeight(
"LTIB", settings["Fitting"]["Weight"]["LTIB"])
cgmFittingProcedure.updateMarkerWeight(
"LANK", settings["Fitting"]["Weight"]["LANK"])
cgmFittingProcedure.updateMarkerWeight(
"LHEE", settings["Fitting"]["Weight"]["LHEE"])
cgmFittingProcedure.updateMarkerWeight(
"LTOE", settings["Fitting"]["Weight"]["LTOE"])
osrf = opensimFilters.opensimFittingFilter(iksetupFile, scalingOsim,
cgmFittingProcedure,
str(DATA_PATH))
logging.info("-------INVERSE KINEMATICS IN PROGRESS----------")
acqIK = osrf.run(acqGait, str(DATA_PATH + reconstructFilenameLabelled))
logging.info("-------INVERSE KINEMATICS DONE-----------------")
# --- final pyCGM2 model motion Filter ---
# use fitted markers
modMotionFitted = modelFilters.ModelMotionFilter(
scp,
acqIK,
model,
enums.motionMethod.Determinist,
markerDiameter=markerDiameter)
modMotionFitted.compute()
if "displayCoordinateSystem" in kwargs.keys(
) and kwargs["displayCoordinateSystem"]:
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(csp, model, acqIK)
csdf.setStatic(False)
csdf.display()
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model,
acqIK).compute(description="vectoriel",
pointLabelSuffix=pointSuffix)
# detection of traveling axis + absolute angle
if model.m_bodypart != enums.BodyPart.UpperLimb:
longitudinalAxis, forwardProgression, globalFrame = btkTools.findProgressionAxisFromPelvicMarkers(
acqIK, ["LASI", "LPSI", "RASI", "RPSI"])
else:
longitudinalAxis, forwardProgression, globalFrame = btkTools.findProgressionAxisFromLongAxis(
acqIK, "C7", "CLAV")
if model.m_bodypart != enums.BodyPart.UpperLimb:
modelFilters.ModelAbsoluteAnglesFilter(
model,
acqIK,
segmentLabels=["Left Foot", "Right Foot", "Pelvis"],
angleLabels=["LFootProgress", "RFootProgress", "Pelvis"],
eulerSequences=["TOR", "TOR", "ROT"],
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix=pointSuffix)
if model.m_bodypart == enums.BodyPart.LowerLimbTrunk:
modelFilters.ModelAbsoluteAnglesFilter(
model,
acqIK,
segmentLabels=["Thorax"],
angleLabels=["Thorax"],
eulerSequences=["YXZ"],
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix=pointSuffix)
if model.m_bodypart == enums.BodyPart.UpperLimb or model.m_bodypart == enums.BodyPart.FullBody:
modelFilters.ModelAbsoluteAnglesFilter(
model,
acqIK,
segmentLabels=["Thorax", "Head"],
angleLabels=["Thorax", "Head"],
eulerSequences=["YXZ", "TOR"],
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix=pointSuffix)
#---- Body segment parameters----
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
if model.m_bodypart == enums.BodyPart.FullBody:
modelFilters.CentreOfMassFilter(
model, acqIK).compute(pointLabelSuffix=pointSuffix)
# Inverse dynamics
if model.m_bodypart != enums.BodyPart.UpperLimb:
# --- force plate handling----
# find foot in contact
mappedForcePlate = forceplates.matchingFootSideOnForceplate(acqIK,
mfpa=mfpa)
forceplates.addForcePlateGeneralEvents(acqIK, mappedForcePlate)
logging.warning("Manual Force plate assignment : %s" %
mappedForcePlate)
# assembly foot and force plate
modelFilters.ForcePlateAssemblyFilter(
model,
acqIK,
mappedForcePlate,
leftSegmentLabel="Left Foot",
rightSegmentLabel="Right Foot").compute()
#---- Joint kinetics----
idp = modelFilters.CGMLowerlimbInverseDynamicProcedure()
modelFilters.InverseDynamicFilter(
model,
acqIK,
procedure=idp,
projection=momentProjection,
).compute(pointLabelSuffix=pointSuffix)
#---- Joint energetics----
modelFilters.JointPowerFilter(
model, acqIK).compute(pointLabelSuffix=pointSuffix)
#---- zero unvalid frames ---
btkTools.applyValidFramesOnOutput(acqIK, validFrames)
return acqIK
def kinematicFitting_oneFile_cgmProcedure(cls):
DATA_PATH = pyCGM2.TEST_DATA_PATH + "CGM2\\LowerLimb\\subject10_S1A1_julieDataSet_noModelOutputs\\"
config = dict()
config["static"] = "StaticR010S1A1.c3d"
config["dynamicTrial"] = [
"R010S1A1Gait001.c3d", "R010S1A1Gait003.c3d",
"R010S1A1Gait004.c3d", "R010S1A1Gait005.c3d",
"R010S1A1Gait007.c3d", "R010S1A1Gait010.c3d"
]
configMP = {
"Bodymass": 64.0,
"LeftLegLength": 865.0,
"RightLegLength": 855.0,
"LeftKneeWidth": 100.0,
"RightKneeWidth": 101.0,
"LeftAnkleWidth": 69.0,
"RightAnkleWidth": 69.0
}
requiredMarkers = [
"LASI", "RASI", "LPSI", "RPSI", "RTHIAP", "RTHIAD", "RTHI", "RKNE",
"RSHN", "RTIAP", "RTIB", "RANK", "RHEE", "RTOE", "RCUN", "RD1M",
"RD5M"
]
acqStatic = btkTools.smartReader(DATA_PATH + config["static"])
# model
model = cgm2Julie.CGM2ModelInf()
model.configure()
markerDiameter = 14
mp = {
'Bodymass': configMP["Bodymass"],
'LeftLegLength': configMP["LeftLegLength"],
'RightLegLength': configMP["RightLegLength"],
'LeftKneeWidth': configMP["LeftKneeWidth"],
'RightKneeWidth': configMP["RightKneeWidth"],
'LeftAnkleWidth': configMP["LeftAnkleWidth"],
'RightAnkleWidth': configMP["RightAnkleWidth"],
}
#offset 2ndToe Joint
toe = acqStatic.GetPoint("RTOE").GetValues()[:, :].mean(axis=0)
mp["rightToeOffset"] = (toe[2] - markerDiameter / 2.0) / 2.0
model.addAnthropoInputParameters(mp)
# -----------CGM STATIC CALIBRATION--------------------
# --- Initial calibration
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(
scp, acqStatic, model,
rightFlatHindFoot=True).compute() # Initial calibration
# --- decorator
modelDecorator.KneeCalibrationDecorator(model).midCondyles(
acqStatic, leftMedialKneeLabel="LKNM", rightMedialKneeLabel="RKNM")
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(
acqStatic,
leftMedialAnkleLabel="LMMA",
rightMedialAnkleLabel="RMMA")
# --- Updated calibration
modelFilters.ModelCalibrationFilter(scp,
acqStatic,
model,
useLeftKJCnode="LKJC_mid",
useRightKJCnode="RKJC_mid",
useLeftAJCnode="LAJC_mid",
useRightAJCnode="RAJC_mid",
rightFlatHindFoot=True).compute()
# ---- optional -update static c3d
#btkTools.smartWriter(acqStatic, "StaticCalibrated.c3d")
# -----------CGM MOTION 6dof--------------------
# --- reader and checking
acqGait = btkTools.smartReader(DATA_PATH + config["dynamicTrial"][0])
btkTools.checkMarkers(acqGait, requiredMarkers)
btkTools.isGap(acqGait, requiredMarkers)
btkTools.checkFirstAndLastFrame(acqGait, "LASI")
logging.info("dyn Acquisition ---> OK ")
# --- filters
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, pyCGM2Enums.motionMethod.Determinist)
modMotion.compute()
modelFilters.ModelJCSFilter(model,
acqGait).compute(description="vectoriel",
pointLabelSuffix="2_6dof")
# --- writer
#btkTools.smartWriter(acqGait, "motionCalibrated.c3d")
# ------- OPENSIM IK --------------------------------------
cgmprocedure = opensimFilters.CgmOpensimCalibrationProcedures(model)
markersetFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\draft-opensimPreProcessing\\cgm2-markerset.xml"
osimfile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\draft-opensimPreProcessing\\cgm2-model.osim"
oscf = opensimFilters.opensimCalibrationFilter(osimfile, model,
cgmprocedure)
oscf.addMarkerSet(markersetFile)
fittingOsim = oscf.build()
filename = config["dynamicTrial"][0]
cgmFittingProcedure = opensimFilters.CgmOpensimFittingProcedure(model)
cgmFittingProcedure.updateMarkerWeight("LASI", 100)
iksetupFile = pyCGM2.OPENSIM_PREBUILD_MODEL_PATH + "models\\draft-opensimPreProcessing\\ikSetUp_template.xml"
osrf = opensimFilters.opensimFittingFilter(iksetupFile, fittingOsim,
cgmFittingProcedure,
DATA_PATH)
acqIK = osrf.run(acqGait, str(DATA_PATH + filename))
# -------- NEW MOTION FILTER ON IK MARKERS ------------------
modMotion_ik = modelFilters.ModelMotionFilter(
scp, acqIK, model, pyCGM2Enums.motionMethod.Sodervisk)
modMotion_ik.compute()
finalJcs = modelFilters.ModelJCSFilter(model, acqIK)
finalJcs.setFilterBool(False)
finalJcs.compute(description="ik", pointLabelSuffix="2_ik") #
# recup du mot file
motFilename = str(DATA_PATH + config["dynamicTrial"][0][:-4] + ".mot")
comparisonOpensimVsCGM(motFilename, acqIK, "2_ik")
