def noIK_6dof(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM2\\cgm2.4\\fullBody\\"
staticFilename = "PN01OP01S01STAT.c3d"
gaitFilename = "PN01OP01S01STAT.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_4.translators")
acqStatic = btkTools.applyTranslators(acqStatic, translators)
model = cgm2.CGM2_4()
model.configure()
model.addAnthropoInputParameters(mp)
# ---- Calibration ----
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
print "----"
print model.getSegment("Left Shank").getReferential(
"TF").relativeMatrixAnatomic
print "----"
# # 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()
btkTools.smartWriter(acqGait, "cgm24_noIK6dof_staticMotion.c3d")
def cgm24(cls):
"""
"""
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "operations\\markerDecomposition\\CGM24decomposeTracking\\"
#
staticFilename = "PN01OP01S01STAT.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model=cgm2.CGM2_4LowerLimbs()
model.setVersion("CGM2.4e")
model.configure()
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,
}
model.addAnthropoInputParameters(mp)
# CALIBRATION
scp=modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,
leftFlatFoot = 1, rightFlatFoot = 1,
markerDiameter=markerDiameter,
).compute()
modelDecorator.KneeCalibrationDecorator(model).midCondyles(acqStatic, markerDiameter=markerDiameter, side="left")
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(acqStatic, markerDiameter=markerDiameter, side="left")
modelDecorator.KneeCalibrationDecorator(model).midCondyles(acqStatic, markerDiameter=markerDiameter, side="right")
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(acqStatic, markerDiameter=markerDiameter, side="right")
modelDecorator.HipJointCenterDecorator(model).hara(side = "Both")
scp=modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,
leftFlatFoot = 1, rightFlatFoot = 1,
markerDiameter=markerDiameter,
).compute()
# --- Test 1 Motion Axe X -------
gaitFilename="PN01OP01S01SS01.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
modMotion=modelFilters.ModelMotionFilter(scp,acqGait,model,pyCGM2Enums.motionMethod.Sodervisk )
modMotion.compute()
mtf = modelFilters.TrackingMarkerDecompositionFilter(model,acqGait)
mtf.decompose()
btkTools.smartWriter(acqGait, "cgm24-decompose.c3d")
def noIK_6dof_Garches(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "Datasets Tests\\didier\\08_02_18_Vincent Pere\\"
staticFilename = "08_02_18_Vincent_Pere_Statique_000_MOKKA.c3d"
gaitFilename = "08_02_18_Vincent_Pere_Statique_000_MOKKA.c3d"
markerDiameter = 14
mp = {
'Bodymass': 70.0,
'LeftLegLength': 890.0,
'RightLegLength': 890.0,
'LeftKneeWidth': 150.0,
'RightKneeWidth': 150.0,
'LeftAnkleWidth': 88.0,
'RightAnkleWidth': 99.0,
'LeftSoleDelta': 0,
'RightSoleDelta': 0,
}
# --- Calibration ---
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm2.CGM2_4()
model.configure()
model.addAnthropoInputParameters(mp)
# ---- Calibration ----
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
print "----"
print model.getSegment("Left Shank").getReferential(
"TF").relativeMatrixAnatomic
print "----"
# # 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, enums.motionMethod.Sodervisk)
modMotion.compute()
btkTools.smartWriter(acqGait,
"cgm24_noIK6dof_staticMotion_Garches.c3d")
def basicCGM1_bodyBuilderFoot(cls):
"""
goal : know effet on Foot kinematics of a foot referential built according ta sequence metionned in some bodybuilder code:
LFoot = [LTOE,LAJC-LTOE,LAJC-LKJC,zyx]
"""
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\basic\\"
staticFilename = "MRI-US-01, 2008-08-08, 3DGA 02.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model=cgm.CGM1LowerLimbs()
model.configure()
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,
}
model.addAnthropoInputParameters(mp)
scp=modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,
useBodyBuilderFoot=True).compute()
# ------ Test 1 Motion Axe X -------
gaitFilename="MRI-US-01, 2008-08-08, 3DGA 14.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
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","LPSI","RASI","RPSI"])
modelFilters.ModelAbsoluteAnglesFilter(model,acqGait,
segmentLabels=["Left Foot","Right Foot","Pelvis"],
angleLabels=["LFootProgress", "RFootProgress","Pelvis"],
eulerSequences=["TOR","TOR", "TOR"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix="cgm1_6dof")
btkTools.smartWriter(acqGait, "testuseBodyBuilderFoot.c3d")
def CGM1_UpperLimb(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\full-PiG\\"
staticFilename = "PN01NORMSTAT.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model=cgm.CGM1()
model.configure(bodyPart=enums.BodyPart.UpperLimb)
markerDiameter=14
mp={
'LeftShoulderOffset' : 50,
'LeftElbowWidth' : 91,
'LeftWristWidth' : 56 ,
'LeftHandThickness' : 28 ,
'RightShoulderOffset' : 45,
'RightElbowWidth' : 90,
'RightWristWidth' : 55 ,
'RightHandThickness' : 30 }
model.addAnthropoInputParameters(mp)
# -----------CGM STATIC CALIBRATION--------------------
scp=modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,acqStatic,model,headFlat= True).compute()
csp = modelFilters.ModelCoordinateSystemProcedure(model)
# --- motion ----
gaitFilename="PN01NORMSS01.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
modMotion=modelFilters.ModelMotionFilter(scp,acqGait,model,enums.motionMethod.Determinist)
modMotion.compute()
csdf = modelFilters.CoordinateSystemDisplayFilter(csp,model,acqGait)
csdf.setStatic(False)
csdf.display()
# thorax
R_thorax= model.getSegment("Thorax").anatomicalFrame.motion[10].getRotation()
R_thorax_vicon = getViconRmatrix(10, acqGait, "TRXO", "TRXA", "TRXL", "XZY")
np.testing.assert_almost_equal( R_thorax,
R_thorax_vicon, decimal =3)
# head
R_head= model.getSegment("Head").anatomicalFrame.motion[10].getRotation()
R_head_vicon = getViconRmatrix(10, acqGait, "HEDO", "HEDA", "HEDL", "XZY")
np.testing.assert_almost_equal( R_head,
R_head_vicon, decimal =2)
def cgm1(cls):
"""
GOAL : compare Joint centres and foot Offset
"""
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "operations\\markerDecomposition\\CGM1decomposeTracking\\"
#
staticFilename = "static.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm.CGM1LowerLimbs()
model.configure()
markerDiameter = 14
mp = {
'Bodymass': 36.9,
'LeftLegLength': 665,
'RightLegLength': 655.0,
'LeftKneeWidth': 102.7,
'RightKneeWidth': 100.2,
'LeftAnkleWidth': 64.5,
'RightAnkleWidth': 63.4,
'LeftSoleDelta': 0,
'RightSoleDelta': 0,
}
model.addAnthropoInputParameters(mp)
# CALIBRATION
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
print model.m_useRightTibialTorsion
# --- Test 1 Motion Axe X -------
gaitFilename = "gait trial 01.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
modMotion = modelFilters.ModelMotionFilter(
scp,
acqGait,
model,
pyCGM2Enums.motionMethod.Determinist,
useForMotionTest=True)
modMotion.compute()
mtf = modelFilters.TrackingMarkerDecompositionFilter(model, acqGait)
mtf.decompose()
btkTools.smartWriter(acqGait, "cgm1-decompose.c3d")
def GeneralScoreTest(cls):
"""
GOAL : compare Joint centres and foot Offset
"""
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\basic\\"
staticFilename = "MRI-US-01, 2008-08-08, 3DGA 02.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm.CGM1LowerLimbs()
model.configure()
markerDiameter = 14
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,
}
model.addAnthropoInputParameters(mp)
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# ------ Test 1 Motion Axe X -------
gaitFilename = "MRI-US-01, 2008-08-08, 3DGA 14.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, enums.motionMethod.Determinist)
modMotion.compute()
# score
msrp = modelQualityFilter.GeneralScoreResidualProcedure(model)
msrp.setDefinition("LHJC", "Pelvis", "Left Thigh")
srf = modelQualityFilter.ScoreResidualFilter(acqGait, msrp)
srf.compute()
def fitting(model, DATA_PATH, reconstructFilenameLabelled, translators,
markerDiameter, pointSuffix, mfpa, momentProjection, **kwargs):
"""
Fitting of the CGM1.1
: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(
(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)
scp = modelFilters.StaticCalibrationProcedure(model) # procedure
# ---Motion filter----
modMotion = modelFilters.ModelMotionFilter(scp,
acqGait,
model,
enums.motionMethod.Determinist,
markerDiameter=markerDiameter)
modMotion.compute()
if "displayCoordinateSystem" in kwargs.keys(
) and kwargs["displayCoordinateSystem"]:
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(csp, model, acqGait)
csdf.setStatic(False)
csdf.display()
if "NaimKneeCorrection" in kwargs.keys() and kwargs["NaimKneeCorrection"]:
# Apply Naim 2019 method
if type(kwargs["NaimKneeCorrection"]) is float:
nmacp = modelFilters.Naim2019ThighMisaligmentCorrectionProcedure(
model, "Both", threshold=(kwargs["NaimKneeCorrection"]))
else:
nmacp = modelFilters.Naim2019ThighMisaligmentCorrectionProcedure(
model, "Both")
mmcf = modelFilters.ModelMotionCorrectionFilter(nmacp)
mmcf.correct()
# btkTools.smartAppendPoint(acqGait,"LNaim",mmcf.m_procedure.m_virtual["Left"])
# btkTools.smartAppendPoint(acqGait,"RNaim",mmcf.m_procedure.m_virtual["Right"])
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model,
acqGait).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(acqGait, pfp)
pff.compute()
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
if model.m_bodypart != enums.BodyPart.UpperLimb:
modelFilters.ModelAbsoluteAnglesFilter(
model,
acqGait,
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,
acqGait,
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,
acqGait,
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, acqGait).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(
acqGait, mfpa=mfpa)
forceplates.addForcePlateGeneralEvents(acqGait, mappedForcePlate)
logging.warning("Manual Force plate assignment : %s" %
mappedForcePlate)
# assembly foot and force plate
modelFilters.ForcePlateAssemblyFilter(
model,
acqGait,
mappedForcePlate,
leftSegmentLabel="Left Foot",
rightSegmentLabel="Right Foot").compute(
pointLabelSuffix=pointSuffix)
#---- Joint kinetics----
idp = modelFilters.CGMLowerlimbInverseDynamicProcedure()
modelFilters.InverseDynamicFilter(
model,
acqGait,
procedure=idp,
projection=momentProjection,
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix=pointSuffix)
#---- Joint energetics----
modelFilters.JointPowerFilter(
model, acqGait).compute(pointLabelSuffix=pointSuffix)
#---- zero unvalid frames ---
btkTools.applyValidFramesOnOutput(acqGait, validFrames)
return acqGait
def calibrate(DATA_PATH, calibrateFilenameLabelled, translators, required_mp,
optional_mp, leftFlatFoot, rightFlatFoot, headFlat,
markerDiameter, pointSuffix, **kwargs):
"""
Calibration of the CGM1.1
: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 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 pointSuffix [str]: suffix to add to model outputs
"""
# --------------------------ACQUISITION ------------------------------------
# --- 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)
# ---detectedCalibrationMethods----
dcm = cgm.CGM.detectCalibrationMethods(acqStatic)
# ---definition---
model = cgm.CGM1()
model.setVersion("CGM1.1")
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----
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
leftFlatFoot=leftFlatFoot,
rightFlatFoot=rightFlatFoot,
headFlat=headFlat,
markerDiameter=markerDiameter,
).compute()
# ---- Decorators -----
decorators.applyBasicDecorators(dcm, model, acqStatic, optional_mp,
markerDiameter)
# ----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----
# notice : viconCGM1compatible option duplicate error on Construction of the foot coordinate system
modMotion = modelFilters.ModelMotionFilter(scp,
acqStatic,
model,
enums.motionMethod.Determinist,
markerDiameter=markerDiameter)
modMotion.compute()
if "displayCoordinateSystem" in kwargs.keys(
) and kwargs["displayCoordinateSystem"]:
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(
csp, model, acqStatic)
csdf.setStatic(False)
csdf.display()
if "noKinematicsCalculation" in kwargs.keys(
) and kwargs["noKinematicsCalculation"]:
logging.warning(
"[pyCGM2] No Kinematic calculation done for the static file")
return model, acqStatic
else:
#---- Joint kinematics----
# relative angles
modelFilters.ModelJCSFilter(model, acqStatic).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(acqStatic, pfp)
pff.compute()
globalFrame = pff.outputs["globalFrame"]
forwardProgression = pff.outputs["forwardProgression"]
if model.m_bodypart != enums.BodyPart.UpperLimb:
modelFilters.ModelAbsoluteAnglesFilter(
model,
acqStatic,
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,
acqStatic,
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,
acqStatic,
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, acqStatic).compute(pointLabelSuffix=pointSuffix)
return model, acqStatic
}
model.addAnthropoInputParameters(mp)
#----CALIBRATION----
# initial calibration
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# motion
gaitFilename = "MRI-US-01, 2008-08-08, 3DGA 14.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
modMotion = modelFilters.ModelMotionFilter(scp,
acqGait,
model,
enums.motionMethod.Determinist,
usePyCGM2_coordinateSystem=True)
modMotion.compute()
# calibration decorators
modelDecorator.KneeCalibrationDecorator(model).calibrate2dof("Left")
modelDecorator.KneeCalibrationDecorator(model).calibrate2dof("Right")
# final calibration
modelFilters.ModelCalibrationFilter(scp,
acqStatic,
model,
RotateLeftThigh=True,
RotateRightThigh=True).compute()
def sara(model, DATA_PATH, reconstructFilenameLabelled, translators, side,
beginFrame, endFrame, **kwargs):
# --- btk acquisition ----
if "forceBtkAcq" in kwargs.keys():
acqFunc = kwargs["forceBtkAcq"]
else:
acqFunc = btkTools.smartReader(
str(DATA_PATH + reconstructFilenameLabelled))
btkTools.checkMultipleSubject(acqFunc)
acqFunc = btkTools.applyTranslators(acqFunc, translators)
#---get frame range of interest---
ff = acqFunc.GetFirstFrame()
lf = acqFunc.GetLastFrame()
start, end = btkTools.getStartEndEvents(acqFunc, side)
if start is not None:
logging.info("Start event detected")
initFrame = start
else:
initFrame = beginFrame if beginFrame is not None else ff
if end is not None:
logging.info("End event detected")
endFrame = end
else:
endFrame = endFrame if endFrame is not None else lf
iff = initFrame - ff
ilf = endFrame - ff
#---motion side of the lower limb---
if side is None:
side = detectSide(acqFunc, "LANK", "RANK")
logging.info("Detected motion side : %s" % (side))
# --------------------------RESET OF THE STATIC File---------
# load btkAcq from static file
staticFilename = model.m_staticFilename
acqStatic = btkTools.smartReader(str(DATA_PATH + staticFilename))
btkTools.checkMultipleSubject(acqStatic)
acqStatic = btkTools.applyTranslators(acqStatic, translators)
# initial calibration ( i.e calibration from Calibration operation)
leftFlatFoot = model.m_properties["CalibrationParameters"]["leftFlatFoot"]
rightFlatFoot = model.m_properties["CalibrationParameters"][
"rightFlatFoot"]
markerDiameter = model.m_properties["CalibrationParameters"][
"markerDiameter"]
headFlat = model.m_properties["CalibrationParameters"]["headFlat"]
if side == "Left":
model.mp_computed["LeftKneeFuncCalibrationOffset"] = 0
if side == "Right":
model.mp_computed["RightKneeFuncCalibrationOffset"] = 0
# initial calibration ( zero previous KneeFunc offset on considered side )
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
leftFlatFoot=leftFlatFoot,
rightFlatFoot=rightFlatFoot,
headFlat=headFlat,
markerDiameter=markerDiameter).compute()
if model.version in ["CGM2.3", "CGM2.4", "CGM2.5"]:
if side == "Left":
thigh_markers = model.getSegment("Left Thigh").m_tracking_markers
shank_markers = model.getSegment("Left Shank").m_tracking_markers
elif side == "Right":
thigh_markers = model.getSegment("Right Thigh").m_tracking_markers
shank_markers = model.getSegment("Right Shank").m_tracking_markers
validFrames, vff, vlf = btkTools.findValidFrames(
acqFunc, thigh_markers + shank_markers)
proximalSegmentLabel = str(side + " Thigh")
distalSegmentLabel = str(side + " Shank")
# segment Motion
modMotion = modelFilters.ModelMotionFilter(
scp, acqFunc, model, enums.motionMethod.Sodervisk)
modMotion.segmentalCompute([proximalSegmentLabel, distalSegmentLabel])
# decorator
modelDecorator.KneeCalibrationDecorator(model).sara(
side, indexFirstFrame=iff, indexLastFrame=ilf)
# --------------------------FINAL CALIBRATION OF THE STATIC File---------
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
leftFlatFoot=leftFlatFoot,
rightFlatFoot=rightFlatFoot,
headFlat=headFlat,
markerDiameter=markerDiameter).compute()
return model, acqFunc, side
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 CGM1_upperLimb(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\full-PiG\\"
staticFilename = "PN01NORMSTAT.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm.CGM1()
model.configure(bodyPart=enums.BodyPart.UpperLimb)
markerDiameter = 14
mp = {
'LeftShoulderOffset': 50,
'LeftElbowWidth': 91,
'LeftWristWidth': 56,
'LeftHandThickness': 28,
'RightShoulderOffset': 45,
'RightElbowWidth': 90,
'RightWristWidth': 55,
'RightHandThickness': 30
}
model.addAnthropoInputParameters(mp)
# -----------CGM STATIC CALIBRATION--------------------
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,
acqStatic,
model,
headHorizontal=False).compute()
# --- motion ----
gaitFilename = "PN01NORMSS01.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, enums.motionMethod.Determinist)
modMotion.compute()
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(csp, model, acqGait)
csdf.setStatic(False)
csdf.display()
modelFilters.ModelJCSFilter(model, acqGait).compute(
description="vectoriel", pointLabelSuffix="cgm1_6dof")
#plot("LNeckAngles",acqGait,"cgm1_6dof")
np.testing.assert_almost_equal(
acqGait.GetPoint("LShoulderAngles").GetValues(),
acqGait.GetPoint("LShoulderAngles_cgm1_6dof").GetValues(),
decimal=3)
np.testing.assert_almost_equal(
acqGait.GetPoint("RShoulderAngles").GetValues(),
acqGait.GetPoint("RShoulderAngles_cgm1_6dof").GetValues(),
decimal=3)
np.testing.assert_almost_equal(
acqGait.GetPoint("RElbowAngles").GetValues(),
acqGait.GetPoint("RElbowAngles_cgm1_6dof").GetValues(),
decimal=3)
np.testing.assert_almost_equal(
acqGait.GetPoint("LElbowAngles").GetValues(),
acqGait.GetPoint("LElbowAngles_cgm1_6dof").GetValues(),
decimal=3)
np.testing.assert_almost_equal(
acqGait.GetPoint("RWristAngles").GetValues(),
acqGait.GetPoint("RWristAngles_cgm1_6dof").GetValues(),
decimal=3) # fail on transverse
np.testing.assert_almost_equal(
acqGait.GetPoint("LWristAngles").GetValues(),
acqGait.GetPoint("LWristAngles_cgm1_6dof").GetValues(),
decimal=3) # fail on transverse
np.testing.assert_almost_equal(
acqGait.GetPoint("RNeckAngles").GetValues(),
acqGait.GetPoint("RNeckAngles_cgm1_6dof").GetValues(),
decimal=1) # fail on coronal
np.testing.assert_almost_equal(
acqGait.GetPoint("LNeckAngles").GetValues(),
acqGait.GetPoint("LNeckAngles_cgm1_6dof").GetValues(),
decimal=1) # fail on coronal
btkTools.smartWriter(acqGait, "upperLimb_angle.c3d")
def advancedCGM11_KadMed_TrueEquinus(cls):
"""
"""
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\kad-med-TrueEquinus\\"
staticFilename = "static.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model=cgm.CGM1LowerLimbs()
model.configure()
markerDiameter=14
mp={
'Bodymass' : 36.9,
'LeftLegLength' : 665.0,
'RightLegLength' : 655.0 ,
'LeftKneeWidth' : 102.7,
'RightKneeWidth' : 100.2,
'LeftAnkleWidth' : 64.5,
'RightAnkleWidth' : 63.0,
'LeftSoleDelta' : 0,
'RightSoleDelta' : 0,
}
optional_mp={
'InterAsisDistance' : 0,
'LeftAsisTrocanterDistance' : 0,
'LeftThighRotation' : 0,
'LeftShankRotation' : 0 ,
'LeftTibialTorsion' : 0,
'RightAsisTrocanterDistance' : 0,
'RightThighRotation' : 0,
'RightShankRotation' : 0,
'RightTibialTorsion' : 0
}
model.addAnthropoInputParameters(mp,optional=optional_mp)
# -----------CGM STATIC CALIBRATION--------------------
scp=modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,acqStatic,model).compute()
# cgm decorator
modelDecorator.Kad(model,acqStatic).compute()
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(acqStatic, side="both")
modelFilters.ModelCalibrationFilter(scp,acqStatic,model).compute()
# tibial torsion
ltt_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("LTibialTorsion").value().GetInfo().ToDouble()[0])
rtt_vicon =np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("RTibialTorsion").value().GetInfo().ToDouble()[0])
logging.info(" LTibialTorsion : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(ltt_vicon,model.mp_computed["LeftTibialTorsionOffset"]))
logging.info(" RTibialTorsion : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(rtt_vicon,model.mp_computed["RightTibialTorsionOffset"]))
# thigh and shank Offsets
lto = model.getViconThighOffset("Left")
lso = model.getViconShankOffset("Left")
rto = model.getViconThighOffset("Right")
rso = model.getViconShankOffset("Right")
lto_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("LThighRotation").value().GetInfo().ToDouble()[0])
lso_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("LShankRotation").value().GetInfo().ToDouble()[0])
rto_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("RThighRotation").value().GetInfo().ToDouble()[0])
rso_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("RShankRotation").value().GetInfo().ToDouble()[0])
logging.info(" LThighRotation : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(lto_vicon,lto))
logging.info(" LShankRotation : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(lso_vicon,lso))
logging.info(" RThighRotation : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(rto_vicon,rto))
logging.info(" RShankRotation : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(rso_vicon,rso))
btkTools.smartWriter(acqStatic,"Kad-med-TrueEquinus.c3d")
gaitFilename="gait trial 01.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
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","LPSI","RASI","RPSI"])
modelFilters.ModelAbsoluteAnglesFilter(model,acqGait,
segmentLabels=["Left Foot","Right Foot","Pelvis"],
angleLabels=["LFootProgress", "RFootProgress","Pelvis"],
eulerSequences=["TOR","TOR", "TOR"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix="cgm1_6dof")
btkTools.smartWriter(acqGait, "Kad-med-TrueEquinus-angles.c3d")
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 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 kad_midMaleolus(cls):
"""
"""
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\KAD-Med\\"
staticFilename = "MRI-US-01, 2008-08-08, 3DGA 02.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model=cgm.CGM1LowerLimbs()
model.configure()
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,
}
model.addAnthropoInputParameters(mp)
scp=modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,acqStatic,model).compute()
# cgm decorator
modelDecorator.Kad(model,acqStatic).compute()
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(acqStatic, side="both")
modelFilters.ModelCalibrationFilter(scp,acqStatic,model).compute()
# tibial torsion
ltt_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("LTibialTorsion").value().GetInfo().ToDouble()[0])
rtt_vicon =np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("RTibialTorsion").value().GetInfo().ToDouble()[0])
logging.info(" LTibialTorsion : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(ltt_vicon,model.mp_computed["LeftTibialTorsionOffset"]))
logging.info(" RTibialTorsion : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(rtt_vicon,model.mp_computed["RightTibialTorsionOffset"]))
# foot offsets
spf_l,sro_l = model.getViconFootOffset("Left")
spf_r,sro_r = model.getViconFootOffset("Right")
vicon_spf_l = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("LStaticPlantFlex").value().GetInfo().ToDouble()[0])
vicon_spf_r = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("RStaticPlantFlex").value().GetInfo().ToDouble()[0])
vicon_sro_l = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("LStaticRotOff").value().GetInfo().ToDouble()[0])
vicon_sro_r = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("RStaticRotOff").value().GetInfo().ToDouble()[0])
logging.info(" LStaticPlantFlex : Vicon (%.6f) Vs bodyBuilderFoot (%.6f)" %(spf_l,vicon_spf_l))
logging.info(" RStaticPlantFlex : Vicon (%.6f) Vs bodyBuilderFoot (%.6f)" %(spf_r,vicon_spf_r))
logging.info(" LStaticRotOff : Vicon (%.6f) Vs bodyBuilderFoot (%.6f)" %(sro_l,vicon_sro_l))
logging.info(" RStaticRotOff : Vicon (%.6f) Vs bodyBuilderFoot (%.6f)" %(sro_r,vicon_sro_r))
# thigh and shank Offsets
lto = model.getViconThighOffset("Left")
lso = model.getViconShankOffset("Left")
rto = model.getViconThighOffset("Right")
rso = model.getViconShankOffset("Right")
lto_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("LThighRotation").value().GetInfo().ToDouble()[0])
lso_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("LShankRotation").value().GetInfo().ToDouble()[0])
rto_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("RThighRotation").value().GetInfo().ToDouble()[0])
rso_vicon = np.rad2deg(acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild("RShankRotation").value().GetInfo().ToDouble()[0])
logging.info(" LThighRotation : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(lto_vicon,lto))
logging.info(" LShankRotation : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(lso_vicon,lso))
logging.info(" RThighRotation : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(rto_vicon,rto))
logging.info(" RShankRotation : Vicon (%.6f) Vs pyCGM2 (%.6f)" %(rso_vicon,rso))
# ------ Test 1 Motion Axe X -------
gaitFilename="MRI-US-01, 2008-08-08, 3DGA 14.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
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","LPSI","RASI","RPSI"])
modelFilters.ModelAbsoluteAnglesFilter(model,acqGait,
segmentLabels=["Left Foot","Right Foot","Pelvis"],
angleLabels=["LFootProgress", "RFootProgress","Pelvis"],
eulerSequences=["TOR","TOR", "TOR"],
globalFrameOrientation = globalFrame,
forwardProgression = forwardProgression).compute(pointLabelSuffix="cgm1_6dof")
btkTools.smartWriter(acqGait, "advancedCGM1_kad_midMaleolus-14.c3d")
# tests on joint angles
np.testing.assert_almost_equal( acqGait.GetPoint("RHipAngles").GetValues(),
acqGait.GetPoint("RHipAngles_cgm1_6dof").GetValues(), decimal =3)
np.testing.assert_almost_equal( acqGait.GetPoint("LHipAngles").GetValues(),
acqGait.GetPoint("LHipAngles_cgm1_6dof").GetValues(), decimal =3)
np.testing.assert_almost_equal( acqGait.GetPoint("RKneeAngles").GetValues(),
acqGait.GetPoint("RKneeAngles_cgm1_6dof").GetValues(), decimal =2)
np.testing.assert_almost_equal( acqGait.GetPoint("LKneeAngles").GetValues(),
acqGait.GetPoint("LKneeAngles_cgm1_6dof").GetValues(), decimal =2)
np.testing.assert_almost_equal( acqGait.GetPoint("RPelvisAngles").GetValues(),
acqGait.GetPoint("RPelvisAngles_cgm1_6dof").GetValues(), decimal =3)
np.testing.assert_almost_equal( acqGait.GetPoint("LPelvisAngles").GetValues(),
acqGait.GetPoint("LPelvisAngles_cgm1_6dof").GetValues(), decimal =3)
# # tests on angles influence by Vicon error
# np.testing.assert_almost_equal( acqGait.GetPoint("RAnkleAngles").GetValues(),
# acqGait.GetPoint("RAnkleAngles_cgm1_6dof").GetValues(), decimal =3)
# np.testing.assert_almost_equal( acqGait.GetPoint("LAnkleAngles").GetValues(),
# acqGait.GetPoint("LAnkleAngles_cgm1_6dof").GetValues(), decimal =3)
#
# np.testing.assert_almost_equal( acqGait.GetPoint("LFootProgressAngles").GetValues(),
# acqGait.GetPoint("LFootProgressAngles_cgm1_6dof").GetValues(), decimal =3)
# np.testing.assert_almost_equal( acqGait.GetPoint("RFootProgressAngles").GetValues(),
# acqGait.GetPoint("RFootProgressAngles_cgm1_6dof").GetValues(), decimal =3)
# ------ Test 2 Motion Axe -X -------
gaitFilename="MRI-US-01, 2008-08-08, 3DGA 12.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
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","LPSI","RASI","RPSI"])
modelFilters.ModelAbsoluteAnglesFilter(model,acqGait,
segmentLabels=["Left Foot","Right Foot","Pelvis"],
angleLabels=["LFootProgress", "RFootProgress","Pelvis"],
globalFrameOrientation = globalFrame,
eulerSequences=["TOR","TOR", "TOR"],
forwardProgression = forwardProgression).compute(pointLabelSuffix="cgm1_6dof")
#btkTools.smartWriter(acqGait, "test.c3d")
# tests on joint angles
np.testing.assert_almost_equal( acqGait.GetPoint("RHipAngles").GetValues(),
acqGait.GetPoint("RHipAngles_cgm1_6dof").GetValues(), decimal =3)
np.testing.assert_almost_equal( acqGait.GetPoint("LHipAngles").GetValues(),
acqGait.GetPoint("LHipAngles_cgm1_6dof").GetValues(), decimal =3)
np.testing.assert_almost_equal( acqGait.GetPoint("RKneeAngles").GetValues(),
acqGait.GetPoint("RKneeAngles_cgm1_6dof").GetValues(), decimal =2)
np.testing.assert_almost_equal( acqGait.GetPoint("LKneeAngles").GetValues(),
acqGait.GetPoint("LKneeAngles_cgm1_6dof").GetValues(), decimal =2)
np.testing.assert_almost_equal( acqGait.GetPoint("RPelvisAngles").GetValues(),
acqGait.GetPoint("RPelvisAngles_cgm1_6dof").GetValues(), decimal =3)
np.testing.assert_almost_equal( acqGait.GetPoint("LPelvisAngles").GetValues(),
acqGait.GetPoint("LPelvisAngles_cgm1_6dof").GetValues(), decimal =3)
def basicCGM1(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\basic_static_StaticVsDynamicAngles\\"
staticFilename = "MRI-US-01, 2008-08-08, 3DGA 02.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm.CGM1LowerLimbs()
model.configure()
markerDiameter = 14
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,
}
model.addAnthropoInputParameters(mp)
# -----------CGM STATIC CALIBRATION--------------------
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
spf_l, sro_l = model.getViconFootOffset("Left")
spf_r, sro_r = model.getViconFootOffset("Right")
# TESTS ------------------------------------------------
np.testing.assert_equal(model.m_useRightTibialTorsion, False)
np.testing.assert_equal(model.m_useLeftTibialTorsion, False)
# joint centres
np.testing.assert_almost_equal(
acqStatic.GetPoint("LFEP").GetValues().mean(axis=0),
acqStatic.GetPoint("LHJC").GetValues().mean(axis=0),
decimal=3)
np.testing.assert_almost_equal(
acqStatic.GetPoint("RFEP").GetValues().mean(axis=0),
acqStatic.GetPoint("RHJC").GetValues().mean(axis=0),
decimal=3)
np.testing.assert_almost_equal(
acqStatic.GetPoint("LFEO").GetValues().mean(axis=0),
acqStatic.GetPoint("LKJC").GetValues().mean(axis=0),
decimal=3)
np.testing.assert_almost_equal(
acqStatic.GetPoint("RFEO").GetValues().mean(axis=0),
acqStatic.GetPoint("RKJC").GetValues().mean(axis=0),
decimal=3)
np.testing.assert_almost_equal(
acqStatic.GetPoint("LTIO").GetValues().mean(axis=0),
acqStatic.GetPoint("LAJC").GetValues().mean(axis=0),
decimal=3)
np.testing.assert_almost_equal(
acqStatic.GetPoint("RTIO").GetValues().mean(axis=0),
acqStatic.GetPoint("RAJC").GetValues().mean(axis=0),
decimal=3)
# foot offsets
vicon_spf_l = np.rad2deg(
acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild(
"LStaticPlantFlex").value().GetInfo().ToDouble()[0])
vicon_spf_r = np.rad2deg(
acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild(
"RStaticPlantFlex").value().GetInfo().ToDouble()[0])
vicon_sro_l = np.rad2deg(
acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild(
"LStaticRotOff").value().GetInfo().ToDouble()[0])
vicon_sro_r = np.rad2deg(
acqStatic.GetMetaData().FindChild("PROCESSING").value().FindChild(
"RStaticRotOff").value().GetInfo().ToDouble()[0])
logging.info(" LStaticPlantFlex : Vicon (%.6f) Vs pyCGM2 (%.6f)" %
(spf_l, vicon_spf_l))
logging.info(" RStaticPlantFlex : Vicon (%.6f) Vs pyCGM2 (%.6f)" %
(spf_r, vicon_spf_r))
logging.info(" LStaticRotOff : Vicon (%.6f) Vs pyCGM2 (%.6f)" %
(sro_l, vicon_sro_l))
logging.info(" RStaticRotOff : Vicon (%.6f) Vs pyCGM2 (%.6f)" %
(sro_r, vicon_sro_r))
np.testing.assert_almost_equal(spf_l, vicon_spf_l, decimal=3)
np.testing.assert_almost_equal(spf_r, vicon_spf_r, decimal=3)
np.testing.assert_almost_equal(sro_l, vicon_sro_l, decimal=3)
np.testing.assert_almost_equal(sro_r, vicon_sro_r, decimal=3)
# -------- CGM FITTING -------------------------------------------------
# ---- on c3d processed vicon static-pig operation
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
modMotion = modelFilters.ModelMotionFilter(
scp,
acqStatic,
model,
pyCGM2Enums.motionMethod.Determinist,
markerDiameter=markerDiameter,
pigStatic=True,
viconCGM1compatible=False)
modMotion.compute()
# relative angles
modelFilters.ModelJCSFilter(model, acqStatic).compute(
description="vectoriel", pointLabelSuffix="cgm1_6dof")
btkTools.smartWriter(acqStatic, "test_basicCGM1_staticAngles.c3d")
# ---- on c3d processed vicon dynamic-pig operation
gaitFilename = "MRI-US-01, 2008-08-08, 3DGA 02-dynamics.c3d" #"staticComparisonPipelines.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# # output and plot
#btkTools.smartWriter(acqGait, "test_basicCGM1_staticAngles.c3d")
plotComparison(acqGait, acqStatic, "LHipAngles")
plotComparison(acqGait, acqStatic, "LKneeAngles")
plotComparison(acqGait, acqStatic, "LAnkleAngles")
plt.figure()
plt.plot(
acqStatic.GetPoint("LAnkleAngles").GetValues()[:, 0] -
acqStatic.GetPoint("LAnkleAngles" + "_cgm1_6dof").GetValues()[:,
0])
plt.figure()
plt.plot(
acqStatic.GetPoint("LAnkleAngles").GetValues()[:, 2] -
acqStatic.GetPoint("LAnkleAngles" + "_cgm1_6dof").GetValues()[:,
2])
def CGM1_upperLimb_absoluteAngles_static(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\full-PiG\\"
staticFilename = "PN01NORMSTAT.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm.CGM1()
model.configure(bodyPart=enums.BodyPart.UpperLimb)
markerDiameter = 14
mp = {
'LeftShoulderOffset': 50,
'LeftElbowWidth': 91,
'LeftWristWidth': 56,
'LeftHandThickness': 28,
'RightShoulderOffset': 45,
'RightElbowWidth': 90,
'RightWristWidth': 55,
'RightHandThickness': 30
}
model.addAnthropoInputParameters(mp)
# -----------CGM STATIC CALIBRATION--------------------
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,
acqStatic,
model,
headHorizontal=False).compute()
# --- motion ----
gaitFilename = "PN01NORMSTAT.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, enums.motionMethod.Determinist)
modMotion.compute()
longitudinalAxis, forwardProgression, globalFrame = btkTools.findProgressionAxisFromLongAxis(
acqGait, "C7", "CLAV")
modelFilters.ModelAbsoluteAnglesFilter(
model,
acqGait,
segmentLabels=["Thorax"],
angleLabels=[
"Thorax",
],
eulerSequences=["YXZ"],
globalFrameOrientation=globalFrame,
forwardProgression=forwardProgression).compute(
pointLabelSuffix="cgm1_6dof")
np.testing.assert_equal(longitudinalAxis, "X")
np.testing.assert_equal(forwardProgression, True)
np.testing.assert_equal(globalFrame, "XYZ")
# plot("LHeadAngles",acqGait,"cgm1_6dof")
# plot("RHeadAngles",acqGait,"cgm1_6dof")
plot("RThoraxAngles", acqGait, "cgm1_6dof")
plot("LThoraxAngles", acqGait, "cgm1_6dof")
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 calibration2Dof(model, DATA_PATH, reconstructFilenameLabelled, translators,
side, beginFrame, endFrame, jointRange, **kwargs):
# --- btk acquisition ----
if "forceBtkAcq" in kwargs.keys():
acqFunc = kwargs["forceBtkAcq"]
else:
acqFunc = btkTools.smartReader(
(DATA_PATH + reconstructFilenameLabelled))
btkTools.checkMultipleSubject(acqFunc)
acqFunc = btkTools.applyTranslators(acqFunc, translators)
# filtering
# -----------------------
if "fc_lowPass_marker" in kwargs.keys(
) and kwargs["fc_lowPass_marker"] != 0:
trackingMarkers = model.getTrackingMarkers(acqFunc)
fc = kwargs["fc_lowPass_marker"]
order = 4
if "order_lowPass_marker" in kwargs.keys():
order = kwargs["order_lowPass_marker"]
signal_processing.markerFiltering(acqFunc,
trackingMarkers,
order=order,
fc=fc)
#---get frame range of interest---
ff = acqFunc.GetFirstFrame()
lf = acqFunc.GetLastFrame()
# motion
if side is None:
side = detectSide(acqFunc, "LANK", "RANK")
LOGGER.logger.info("Detected motion side : %s" % (side))
start, end = btkTools.getStartEndEvents(acqFunc, side)
if start is not None:
LOGGER.logger.info("Start event detected")
initFrame = start
else:
initFrame = beginFrame if beginFrame is not None else ff
if end is not None:
LOGGER.logger.info("End event detected")
endFrame = end
else:
endFrame = endFrame if endFrame is not None else lf
iff = initFrame - ff
ilf = endFrame - ff
if model.version in ["CGM1.0", "CGM1.1", "CGM2.1", "CGM2.2"]:
validFrames, vff, vlf = btkTools.findValidFrames(
acqFunc, cgm.CGM1.LOWERLIMB_TRACKING_MARKERS)
# --------------------------RESET OF THE STATIC File---------
# load btkAcq from static file
staticFilename = model.m_staticFilename
acqStatic = btkTools.smartReader((DATA_PATH + staticFilename))
btkTools.checkMultipleSubject(acqStatic)
acqStatic = btkTools.applyTranslators(acqStatic, translators)
# initial calibration ( i.e calibration from Calibration operation)
leftFlatFoot = model.m_properties["CalibrationParameters"]["leftFlatFoot"]
rightFlatFoot = model.m_properties["CalibrationParameters"][
"rightFlatFoot"]
headFlat = model.m_properties["CalibrationParameters"]["headFlat"]
markerDiameter = model.m_properties["CalibrationParameters"][
"markerDiameter"]
if side == "Left":
# remove other functional calibration
model.mp_computed["LeftKneeFuncCalibrationOffset"] = 0
if side == "Right":
# remove other functional calibration
model.mp_computed["RightKneeFuncCalibrationOffset"] = 0
# no rotation on both thigh - re init anatonical frame
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
leftFlatFoot=leftFlatFoot,
rightFlatFoot=rightFlatFoot,
headFlat=headFlat,
markerDiameter=markerDiameter).compute()
if model.version in ["CGM1.0", "CGM1.1", "CGM2.1", "CGM2.2"]:
modMotion = modelFilters.ModelMotionFilter(
scp, acqFunc, model, enums.motionMethod.Determinist)
modMotion.compute()
elif model.version in ["CGM2.3", "CGM2.4", "CGM2.5"]:
if side == "Left":
thigh_markers = model.getSegment("Left Thigh").m_tracking_markers
shank_markers = model.getSegment("Left Shank").m_tracking_markers
elif side == "Right":
thigh_markers = model.getSegment("Right Thigh").m_tracking_markers
shank_markers = model.getSegment("Right Shank").m_tracking_markers
validFrames, vff, vlf = btkTools.findValidFrames(
acqFunc, thigh_markers + shank_markers)
proximalSegmentLabel = (side + " Thigh")
distalSegmentLabel = (side + " Shank")
# Motion
modMotion = modelFilters.ModelMotionFilter(
scp, acqFunc, model, enums.motionMethod.Sodervisk)
modMotion.segmentalCompute([proximalSegmentLabel, distalSegmentLabel])
# calibration decorators
modelDecorator.KneeCalibrationDecorator(model).calibrate2dof(
side, indexFirstFrame=iff, indexLastFrame=ilf, jointRange=jointRange)
# --------------------------FINAL CALIBRATION OF THE STATIC File---------
# ---- Calibration
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
leftFlatFoot=leftFlatFoot,
rightFlatFoot=rightFlatFoot,
headFlat=headFlat,
markerDiameter=markerDiameter).compute()
return model, acqFunc, side
def kadMedCGM1_proximal(cls, plotFlag=False):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\PIG advanced\\KAD-tibialTorsion\\"
staticFilename = "MRI-US-01, 2008-08-08, 3DGA 02.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm.CGM1
model.configure()
markerDiameter = 14
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,
}
model.addAnthropoInputParameters(mp)
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# cgm decorator
modelDecorator.Kad(model, acqStatic).compute()
modelDecorator.AnkleCalibrationDecorator(model).midMaleolus(
acqStatic, side="both")
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# ------ Test 1 Motion Axe X -------
gaitFilename = "MRI-US-01, 2008-08-08, 3DGA 14.Proximal.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
modMotion = modelFilters.ModelMotionFilter(
scp,
acqGait,
model,
pyCGM2Enums.motionMethod.Determinist,
viconCGM1compatible=False)
modMotion.compute()
# Joint kinematics
modelFilters.ModelJCSFilter(model, acqGait).compute(
description="vectoriel", pointLabelSuffix="cgm1_6dof")
# BSP model
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
# force plate -- construction du wrench attribue au pied
forceplates.appendForcePlateCornerAsMarker(acqGait)
mappedForcePlate = forceplates.matchingFootSideOnForceplate(acqGait)
modelFilters.ForcePlateAssemblyFilter(
model,
acqGait,
"RL",
leftSegmentLabel="Left Foot",
rightSegmentLabel="Right Foot").compute()
idp = modelFilters.CGMLowerlimbInverseDynamicProcedure()
modelFilters.InverseDynamicFilter(
model,
acqGait,
procedure=idp,
projection=pyCGM2Enums.MomentProjection.Proximal,
viconCGM1compatible=True).compute(pointLabelSuffix="cgm1_6dof")
modelFilters.JointPowerFilter(
model, acqGait).compute(pointLabelSuffix="cgm1_6dof")
# writer
btkTools.smartWriter(acqGait, "testInvDyn_kadMed.c3d")
if plotFlag:
plotMoment(acqGait, "LAnkleMoment", "LAnkleMoment_cgm1_6dof",
"kadMedCGM1_proximal-LAnkleMoment")
plotMoment(acqGait, "RAnkleMoment", "RAnkleMoment_cgm1_6dof",
"kadMedCGM1_proximal-RAnkleMoment")
plt.show()
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 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_4()
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")
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, enums.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, enums.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).compute()
# save static c3d with update KJC
btkTools.smartWriter(acqStatic, "Static-SARA.c3d")
# print functional Offsets
print model.mp_computed["LeftKneeFuncCalibrationOffset"]
print model.mp_computed["RightKneeFuncCalibrationOffset"]
def basicCGM1_global(cls, plotFlag=False):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\basic-filtered\\"
staticFilename = "MRI-US-01, 2008-08-08, 3DGA 02.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm.CGM1
model.configure()
markerDiameter = 14
mp = {
'Bodymass': 71.0,
'LeftLegLength': 860.0,
'RightLegLength': 865.0,
'LeftKneeWidth': 102.0,
'RightKneeWidth': 103.4,
'LeftAnkleWidth': 75.3,
'RightAnkleWidth': 72.9,
}
model.addAnthropoInputParameters(mp)
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# ------ Test 1 Motion Axe X -------
gaitFilename = "MRI-US-01, 2008-08-08, 3DGA 14.global.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, pyCGM2Enums.motionMethod.Determinist)
modMotion.compute()
# Joint kinematics
modelFilters.ModelJCSFilter(model, acqGait).compute(
description="vectoriel", pointLabelSuffix="cgm1_6dof")
# BSP model
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
# force plate -- construction du wrench attribue au pied
forceplates.appendForcePlateCornerAsMarker(acqGait)
mappedForcePlate = forceplates.matchingFootSideOnForceplate(acqGait)
modelFilters.ForcePlateAssemblyFilter(
model,
acqGait,
"RL",
leftSegmentLabel="Left Foot",
rightSegmentLabel="Right Foot").compute()
idp = modelFilters.CGMLowerlimbInverseDynamicProcedure()
modelFilters.InverseDynamicFilter(
model,
acqGait,
procedure=idp,
projection=pyCGM2Enums.MomentProjection.Global).compute(
pointLabelSuffix="cgm1_6dof")
modelFilters.JointPowerFilter(
model, acqGait).compute(pointLabelSuffix="cgm1_6dof")
#btkTools.smartWriter(acqGait,"testInvDyn.c3d")
if plotFlag:
plotMoment(acqGait, "LHipMoment", "LHipMoment_cgm1_6dof")
plotMoment(acqGait, "LKneeMoment", "LKneeMoment_cgm1_6dof")
plotMoment(acqGait, "LAnkleMoment", "LAnkleMoment_cgm1_6dof")
plotMoment(acqGait, "RHipMoment", "RHipMoment_cgm1_6dof")
plotMoment(acqGait, "RKneeMoment", "RKneeMoment_cgm1_6dof")
plotMoment(acqGait, "RAnkleMoment", "RAnkleMoment_cgm1_6dof")
plt.show()
# TEST ------
compareKinetics(acqGait, 5, -5, 0.2, 40.0, 0.1)
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 basicCGM1_global(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\basic_pathologicalSubject\\"
staticFilename = "BOVE Vincent Cal 01.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model = cgm.CGM1
model.configure()
markerDiameter = 14
mp = {
'Bodymass': 72.0,
'LeftLegLength': 840.0,
'RightLegLength': 850.0,
'LeftKneeWidth': 105.0,
'RightKneeWidth': 110.4,
'LeftAnkleWidth': 74.0,
'RightAnkleWidth': 74.0,
}
model.addAnthropoInputParameters(mp)
scp = modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp, acqStatic, model).compute()
# ------ Travelling Axis Y -------
gaitFilename = "20120213_BV-PRE-S-NNNN-I-dyn 04.global2.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
modMotion = modelFilters.ModelMotionFilter(
scp, acqGait, model, pyCGM2Enums.motionMethod.Determinist)
modMotion.compute()
# Joint kinematics
modelFilters.ModelJCSFilter(model, acqGait).compute(
description="vectoriel", pointLabelSuffix="cgm1_6dof")
# BSP model
bspModel = bodySegmentParameters.Bsp(model)
bspModel.compute()
# force plate -- construction du wrench attribue au pied
forceplates.appendForcePlateCornerAsMarker(acqGait)
mappedForcePlate = forceplates.matchingFootSideOnForceplate(acqGait)
modelFilters.ForcePlateAssemblyFilter(
model,
acqGait,
mappedForcePlate,
leftSegmentLabel="Left Foot",
rightSegmentLabel="Right Foot").compute()
idp = modelFilters.CGMLowerlimbInverseDynamicProcedure()
modelFilters.InverseDynamicFilter(
model,
acqGait,
procedure=idp,
projection=pyCGM2Enums.MomentProjection.Global).compute(
pointLabelSuffix="cgm1_6dof")
modelFilters.JointPowerFilter(
model, acqGait).compute(pointLabelSuffix="cgm1_6dof")
btkTools.smartWriter(acqGait, "testInvDynPatho.c3d")
# TEST ------
compareKinetics(acqGait, 5, -5, 0.2, 40.0, 0.1)
def basicCGM1_absoluteAngles_pelikin(cls):
"""
"""
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\Pelikin\\"
staticFilename = "MRI-US-01, 2008-08-08, 3DGA 02.c3d"
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
model=cgm.CGM1LowerLimbs()
model.configure()
markerDiameter=14
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,
}
model.addAnthropoInputParameters(mp)
scp=modelFilters.StaticCalibrationProcedure(model)
modelFilters.ModelCalibrationFilter(scp,acqStatic,model).compute()
# ------ Test 1 Motion Axe X -------
gaitFilename="MRI-US-01, 2008-08-08, 3DGA 14.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
modMotion=modelFilters.ModelMotionFilter(scp,acqGait,model,pyCGM2Enums.motionMethod.Determinist)
modMotion.compute()
longitudinalAxis,forwardProgression,globalFrame = btkTools.findProgressionAxisFromPelvicMarkers(acqGait,["LASI","LPSI","RASI","RPSI"])
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")
#btkTools.smartWriter(acqGait, "verifX.c3d")
# --- tests on angles
np.testing.assert_almost_equal( acqGait.GetPoint("RNewPelAngles").GetValues(),
acqGait.GetPoint("RPelvisAngles_cgm1_6dof").GetValues(), decimal =3)
np.testing.assert_almost_equal( acqGait.GetPoint("LNewPelAngles").GetValues(),
acqGait.GetPoint("LPelvisAngles_cgm1_6dof").GetValues(), decimal =3)
# ------ Test 2 Motion Axe -X -------
gaitFilename="MRI-US-01, 2008-08-08, 3DGA 12.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
# Motion FILTER
# optimisation segmentaire et calibration fonctionnel
modMotion=modelFilters.ModelMotionFilter(scp,acqGait,model,pyCGM2Enums.motionMethod.Determinist)
modMotion.compute()
longitudinalAxis,forwardProgression,globalFrame = btkTools.findProgressionAxisFromPelvicMarkers(acqGait,["LASI","LPSI","RASI","RPSI"])
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")
# --- tests on angles
np.testing.assert_almost_equal( acqGait.GetPoint("RNewPelAngles").GetValues(),
acqGait.GetPoint("RPelvisAngles_cgm1_6dof").GetValues(), decimal =3)
np.testing.assert_almost_equal( acqGait.GetPoint("LNewPelAngles").GetValues(),
acqGait.GetPoint("LPelvisAngles_cgm1_6dof").GetValues(), decimal =3)
def main(args):
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------------PATH + FILE ------------------------------------
DATA_PATH, reconstructedFilenameLabelledNoExt = NEXUS.GetTrialName()
reconstructFilenameLabelled = reconstructedFilenameLabelledNoExt + ".c3d"
logging.info("data Path: " + DATA_PATH)
logging.info("reconstructed file: " + reconstructFilenameLabelled)
# --------------------------SUBJECT -----------------------------------
# Notice : Work with ONE subject by session
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.checkActivatedSubject(NEXUS, subjects)
logging.info("Subject name : " + subject)
# --------------------pyCGM2 MODEL ------------------------------
model = files.loadModel(DATA_PATH, subject)
logging.info("loaded model : %s" % (model.version))
# --------------------------CONFIG ------------------------------------
# --------------------CHECKING ------------------------------
if model.version in ["CGM1.0", "CGM1.1", "CGM2.1", "CGM2.2"]:
raise Exception(
"Can t use SARA method with your model %s [minimal version : CGM2.3]"
% (model.version))
elif model.version == "CGM2.3":
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH +
"CGM2_3-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_3-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM2_3-pyCGM2.settings")
elif model.version in ["CGM2.4"]:
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH +
"CGM2_4-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_4-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM2_4-pyCGM2.settings")
elif model.version in ["CGM2.5"]:
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH +
"CGM2_5-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_5-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM2_5-pyCGM2.settings")
else:
raise Exception("model version not found [contact admin]")
# --------------------------SESSION INFOS ------------------------------------
mpInfo, mpFilename = files.getMpFileContent(DATA_PATH, "mp.pyCGM2",
subject)
# translators management
if model.version in ["CGM2.3"]:
translators = files.getTranslators(DATA_PATH, "CGM2-3.translators")
elif model.version in ["CGM2.4"]:
translators = files.getTranslators(DATA_PATH, "CGM2-4.translators")
elif model.version in ["CGM2.5"]:
translators = files.getTranslators(DATA_PATH, "CGM2-5.translators")
if not translators:
translators = settings["Translators"]
# btkAcq builder
nacf = nexusFilters.NexusConstructAcquisitionFilter(
DATA_PATH, reconstructedFilenameLabelledNoExt, subject)
acq = nacf.build()
# --------------------------MODEL PROCESSING----------------------------
model, acqFunc, side = kneeCalibration.sara(
model,
DATA_PATH,
reconstructFilenameLabelled,
translators,
args.side,
args.beginFrame,
args.endFrame,
forceBtkAcq=acq)
# ----------------------SAVE-------------------------------------------
files.saveModel(model, DATA_PATH, subject)
logging.warning(
"model updated with a %s knee calibrated with SARA method" %
(side))
# save mp
files.saveMp(mpInfo, model, DATA_PATH, mpFilename)
# ----------------------VICON INTERFACE-------------------------------------------
#--- update mp
nexusUtils.updateNexusSubjectMp(NEXUS, model, subject)
# -- add nexus Bones
if side == "Left":
nexusTools.appendBones(
NEXUS,
subject,
acqFunc,
"LFE0",
model.getSegment("Left Thigh"),
OriginValues=acqFunc.GetPoint("LKJC").GetValues())
elif side == "Right":
nexusTools.appendBones(
NEXUS,
subject,
acqFunc,
"RFE0",
model.getSegment("Right Thigh"),
OriginValues=acqFunc.GetPoint("RKJC").GetValues())
proximalSegmentLabel = str(side + " Thigh")
distalSegmentLabel = str(side + " Shank")
# add modelled markers
meanOr_inThigh = model.getSegment(proximalSegmentLabel).getReferential(
"TF").getNodeTrajectory("KJC_Sara")
meanAxis_inThigh = model.getSegment(
proximalSegmentLabel).getReferential("TF").getNodeTrajectory(
"KJC_SaraAxis")
btkTools.smartAppendPoint(acqFunc, side + "_KJC_Sara", meanOr_inThigh)
btkTools.smartAppendPoint(acqFunc, side + "_KJC_SaraAxis",
meanAxis_inThigh)
nexusTools.appendModelledMarkerFromAcq(NEXUS, subject,
side + "_KJC_Sara", acqFunc)
nexusTools.appendModelledMarkerFromAcq(NEXUS, subject,
side + "_KJC_SaraAxis", acqFunc)
#---Second model motion filter
# consider new anatomical frame
scp = modelFilters.StaticCalibrationProcedure(model)
modMotion = modelFilters.ModelMotionFilter(
scp, acqFunc, model, enums.motionMethod.Sodervisk)
modMotion.segmentalCompute([proximalSegmentLabel, distalSegmentLabel])
# projection of the Sara axis in the transversale plane
# -- add nexus Bones
if side == "Left":
nexusTools.appendBones(
NEXUS,
subject,
acqFunc,
"LFE1",
model.getSegment("Left Thigh"),
OriginValues=acqFunc.GetPoint("LKJC").GetValues())
print model.mp_computed["LeftKneeFuncCalibrationOffset"]
logging.warning(
"offset %s" %
(str(model.mp_computed["LeftKneeFuncCalibrationOffset"])))
elif side == "Right":
nexusTools.appendBones(
NEXUS,
subject,
acqFunc,
"RFE1",
model.getSegment("Right Thigh"),
OriginValues=acqFunc.GetPoint("RKJC").GetValues())
logging.warning(
"offset %s" %
(str(model.mp_computed["RightKneeFuncCalibrationOffset"])))
print model.mp_computed["RightKneeFuncCalibrationOffset"]
else:
raise Exception("NO Nexus connection. Turn on Nexus")
def CGM1_fullbody_static(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1-TESTS\\full-PiG\\"
staticFilename = "PN01NORMSTAT.c3d"
# CALIBRATION ###############################
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
markerDiameter = 14
# Lower Limb
mp = {
'Bodymass': 83,
'LeftLegLength': 874,
'RightLegLength': 876.0,
'LeftKneeWidth': 106.0,
'RightKneeWidth': 103.0,
'LeftAnkleWidth': 74.0,
'RightAnkleWidth': 72.0,
'LeftSoleDelta': 0,
'RightSoleDelta': 0,
'LeftShoulderOffset': 50,
'LeftElbowWidth': 91,
'LeftWristWidth': 56,
'LeftHandThickness': 28,
'RightShoulderOffset': 45,
'RightElbowWidth': 90,
'RightWristWidth': 55,
'RightHandThickness': 30
}
model = cgm.CGM1()
model.configure(bodyPart=enums.BodyPart.FullBody)
model.addAnthropoInputParameters(mp)
scp = modelFilters.StaticCalibrationProcedure(
model) # load calibration procedure
modelFilters.ModelCalibrationFilter(
scp,
acqStatic,
model,
leftFlatFoot=True,
rightFlatFoot=True,
markerDiameter=14,
viconCGM1compatible=True).compute()
# MOTION ###############################
gaitFilename = "PN01NORMSTAT.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
modMotion = modelFilters.ModelMotionFilter(
scp,
acqGait,
model,
enums.motionMethod.Determinist,
markerDiameter=14,
viconCGM1compatible=False)
modMotion.compute()
csp = modelFilters.ModelCoordinateSystemProcedure(model)
csdf = modelFilters.CoordinateSystemDisplayFilter(csp, model,
acqGait).display()
modelFilters.ModelJCSFilter(model, acqGait).compute(
description="vectoriel", pointLabelSuffix="cgm1_6dof")
plot("RSpineAngles", acqGait, "cgm1_6dof")
plot("LSpineAngles", acqGait, "cgm1_6dof")
np.testing.assert_almost_equal(
acqGait.GetPoint("RSpineAngles").GetValues(),
acqGait.GetPoint("RSpineAngles_cgm1_6dof").GetValues(),
decimal=2)
np.testing.assert_almost_equal(
acqGait.GetPoint("LSpineAngles").GetValues(),
acqGait.GetPoint("LSpineAngles_cgm1_6dof").GetValues(),
decimal=2)
btkTools.smartWriter(acqGait, "fullbody.c3d")