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 test_CGM24_FullBody_noOptions_uncorrectLowerLimbMarker(self):
DATA_PATH = pyCGM2.TEST_DATA_PATH + "Scenarii\\different static and dynamic marker set\\CGM24-fullBody\\"
staticFilename = "static.c3d"
acqStatic = btkTools.smartReader(DATA_PATH + staticFilename)
markerDiameter=14
leftFlatFoot = False
rightFlatFoot = False
headStraight = False
pointSuffix = "test"
vskFile = vskTools.getVskFiles(DATA_PATH)
vsk = vskTools.Vsk(DATA_PATH + "PN07.vsk")
required_mp,optional_mp = vskTools.getFromVskSubjectMp(vsk, resetFlag=True)
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,"CGM2_4-pyCGM2.settings")
hjcMethod = settings["Calibration"]["HJC"]
translators = files.getTranslators(DATA_PATH,"CGM2_4.translators")
# if not translators: translators = settings["Translators"]
model,finalAcqStatic = cgm2_4.calibrate(DATA_PATH,
staticFilename,
translators,
settings,
required_mp,
optional_mp,
False,
leftFlatFoot,
rightFlatFoot,
headStraight,
markerDiameter,
hjcMethod,
pointSuffix,
displayCoordinateSystem=True)
# btkTools.smartWriter(finalAcqStatic, str( staticFilename[:-4]+"-pyCGM2modelled.c3d"))
logging.info("Static Calibration -----> Done")
gaitFilename="gait1_noLASI.c3d"
mfpa = None
reconstructFilenameLabelled = gaitFilename
acqGait = cgm2_4.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,
settings,
False,
markerDiameter,
pointSuffix,
mfpa,
enums.MomentProjection.Proximal,
displayCoordinateSystem=True)
assert model.m_bodypart == enums.BodyPart.UpperLimb
def cgm1_sacrum(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "operations\\Translators\\cgm1-sacr\\"
staticFilename = "static.c3d"
translators = files.getTranslators(MAIN_PATH,
translatorType="CGM1.translators")
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
acqStatic2 = btkTools.applyTranslators(acqStatic, translators)
btkTools.smartWriter(acqStatic2, "staticCGM1Sacrum.c3d")
np.testing.assert_equal(
acqStatic2.GetPoint("LPSI").GetValues(),
acqStatic.GetPoint("SACR").GetValues())
np.testing.assert_equal(
acqStatic2.GetPoint("RPSI").GetValues(),
acqStatic.GetPoint("SACR").GetValues())
def test_cgm1_sacrum(self):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "LowLevel\\translators\\cgm1-sacr\\"
staticFilename = "static.c3d"
DATA_PATH_OUT = pyCGM2.TEST_DATA_PATH_OUT + "LowLevel\\translators\\cgm1-sacr\\"
files.createDir(DATA_PATH_OUT)
translators = files.getTranslators(MAIN_PATH,
translatorType="CGM1.translators")
acqStatic = btkTools.smartReader(str(MAIN_PATH + staticFilename))
acqStatic2 = btkTools.applyTranslators(acqStatic, translators)
btkTools.smartWriter(acqStatic2,
DATA_PATH_OUT + "staticCGM1Sacrum.c3d")
np.testing.assert_equal(
acqStatic2.GetPoint(utils.str("LPSI")).GetValues(),
acqStatic.GetPoint(utils.str("SACR")).GetValues())
np.testing.assert_equal(
acqStatic2.GetPoint(utils.str("RPSI")).GetValues(),
acqStatic.GetPoint(utils.str("SACR")).GetValues())
def main(args):
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH +
"CGM1_1-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM1_1-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM1_1-pyCGM2.settings")
# --------------------------CONFIG ------------------------------------
argsManager = CgmArgsManager.argsManager_cgm(settings, args)
markerDiameter = argsManager.getMarkerDiameter()
pointSuffix = argsManager.getPointSuffix("cgm1_1")
momentProjection = argsManager.getMomentProjection()
DATA_PATH, reconstructFilenameLabelledNoExt = NEXUS.GetTrialName()
reconstructFilenameLabelled = reconstructFilenameLabelledNoExt + ".c3d"
logging.info("data Path: " + DATA_PATH)
logging.info("calibration 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)
# --------------------------CHECKING -----------------------------------
# check model is the CGM1
logging.info("loaded model : %s" % (model.version))
if model.version != "CGM1.1":
raise Exception(
"%s-pyCGM2.model file was not calibrated from the CGM1.1 calibration pipeline"
% model.version)
# --------------------------SESSION INFOS ------------------------------------
# translators management
translators = files.getTranslators(DATA_PATH, "CGM1_1.translators")
if not translators: translators = settings["Translators"]
# btkAcq builder
nacf = nexusFilters.NexusConstructAcquisitionFilter(
DATA_PATH, reconstructFilenameLabelledNoExt, subject)
acq = nacf.build()
#force plate assignement from Nexus
mfpa = nexusTools.getForcePlateAssignment(NEXUS)
# --------------------------MODELLING PROCESSING -----------------------
acqGait = cgm1_1.fitting(model,
DATA_PATH,
reconstructFilenameLabelled,
translators,
markerDiameter,
pointSuffix,
mfpa,
momentProjection,
forceBtkAcq=acq)
# ----------------------SAVE-------------------------------------------
# Todo: pyCGM2 model : cpickle doesn t work. Incompatibility with Swig. ( see about BTK wrench)
# ----------------------DISPLAY ON VICON-------------------------------
nexusFilters.NexusModelFilter(NEXUS, model, acqGait, subject,
pointSuffix).run()
nexusTools.createGeneralEvents(NEXUS, subject, acqGait,
["Left-FP", "Right-FP"])
# ========END of the nexus OPERATION if run from Nexus =========
else:
raise Exception("NO Nexus connection. Turn on Nexus")
def main(sessionFilename, createPDFReport=True):
logging.info("------------------------------------------------")
logging.info("------------QTM - pyCGM2 Workflow---------------")
logging.info("------------------------------------------------")
sessionXML = files.readXml(os.getcwd() + "\\", sessionFilename)
sessionDate = files.getFileCreationDate(os.getcwd() + "\\" +
sessionFilename)
#---------------------------------------------------------------------------
#management of the Processed folder
DATA_PATH = os.getcwd() + "\\" + "processed\\"
files.createDir(DATA_PATH)
staticMeasurement = qtmTools.findStatic(sessionXML)
calibrateFilenameLabelled = qtmTools.getFilename(staticMeasurement)
if not os.path.isfile(DATA_PATH + calibrateFilenameLabelled):
shutil.copyfile(os.getcwd() + "\\" + calibrateFilenameLabelled,
DATA_PATH + calibrateFilenameLabelled)
logging.info(
"qualisys exported c3d file [%s] copied to processed folder" %
(calibrateFilenameLabelled))
dynamicMeasurements = qtmTools.findDynamic(sessionXML)
for dynamicMeasurement in dynamicMeasurements:
reconstructFilenameLabelled = qtmTools.getFilename(dynamicMeasurement)
if not os.path.isfile(DATA_PATH + reconstructFilenameLabelled):
shutil.copyfile(os.getcwd() + "\\" + reconstructFilenameLabelled,
DATA_PATH + reconstructFilenameLabelled)
logging.info(
"qualisys exported c3d file [%s] copied to processed folder" %
(reconstructFilenameLabelled))
acq = btkTools.smartReader(
str(DATA_PATH + reconstructFilenameLabelled))
acq, zeniState = eventDetector.zeni(acq)
if zeniState:
btkTools.smartWriter(
acq, str(DATA_PATH + reconstructFilenameLabelled))
cmd = "Mokka.exe \"%s\"" % (str(DATA_PATH +
reconstructFilenameLabelled))
os.system(cmd)
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM1_1-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM1_1-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM1_1-pyCGM2.settings")
# --------------------------MP ------------------------------------
required_mp, optional_mp = qtmTools.SubjectMp(sessionXML)
# --Check MP
inspectprocedure = inspectProcedures.AnthropometricDataQualityProcedure(
required_mp)
inspector = inspectFilters.QualityFilter(inspectprocedure)
inspector.run()
# translators management
translators = files.getTranslators(os.getcwd() + "\\",
"CGM1_1.translators")
if not translators: translators = settings["Translators"]
# --------------------------MODEL CALIBRATION -----------------------
logging.info(
"--------------------------MODEL CALIBRATION -----------------------")
staticMeasurement = qtmTools.findStatic(sessionXML)
calibrateFilenameLabelled = qtmTools.getFilename(staticMeasurement)
logging.info("----- CALIBRATION- static file [%s]--" %
(calibrateFilenameLabelled))
leftFlatFoot = utils.toBool(
sessionXML.Left_foot_normalised_to_static_trial.text)
rightFlatFoot = utils.toBool(
sessionXML.Right_foot_normalised_to_static_trial.text)
headFlat = utils.toBool(sessionXML.Head_normalised_to_static_trial.text)
markerDiameter = float(sessionXML.Marker_diameter.text) * 1000.0
pointSuffix = None
# Calibration checking
# --------------------
acqStatic = btkTools.smartReader(DATA_PATH + calibrateFilenameLabelled)
for key in MARKERSETS.keys():
logging.info("[pyCGM2] Checking of the %s" % (key))
# presence
ip_presence = inspectProcedures.MarkerPresenceQualityProcedure(
acqStatic, markers=MARKERSETS[key])
inspector = inspectFilters.QualityFilter(ip_presence)
inspector.run()
if ip_presence.markersIn != []:
ip_gap = inspectProcedures.GapQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_gap)
inspector.run()
ip_swap = inspectProcedures.SwappingMarkerQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_swap)
inspector.run()
ip_pos = inspectProcedures.MarkerPositionQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_pos)
# Calibration operation
# --------------------
logging.info("[pyCGM2] --- calibration operation ---")
model, acqStatic = cgm1_1.calibrate(DATA_PATH, calibrateFilenameLabelled,
translators, required_mp, optional_mp,
leftFlatFoot, rightFlatFoot, headFlat,
markerDiameter, pointSuffix)
logging.info("----- CALIBRATION- static file [%s]-----> DONE" %
(calibrateFilenameLabelled))
# --------------------------MODEL FITTING ----------------------------------
logging.info(
"--------------------------MODEL FITTING ----------------------------------"
)
dynamicMeasurements = qtmTools.findDynamic(sessionXML)
modelledC3ds = list()
eventInspectorStates = list()
for dynamicMeasurement in dynamicMeasurements:
reconstructFilenameLabelled = qtmTools.getFilename(dynamicMeasurement)
logging.info("----Processing of [%s]-----" %
(reconstructFilenameLabelled))
mfpa = qtmTools.getForcePlateAssigment(dynamicMeasurement)
momentProjection_text = sessionXML.Moment_Projection.text
if momentProjection_text == "Default":
momentProjection_text = settings["Fitting"]["Moment Projection"]
if momentProjection_text == "Distal":
momentProjection = enums.MomentProjection.Distal
elif momentProjection_text == "Proximal":
momentProjection = enums.MomentProjection.Proximal
elif momentProjection_text == "Global":
momentProjection = enums.MomentProjection.Global
elif momentProjection_text == "JCS":
momentProjection = enums.MomentProjection.JCS
acq = btkTools.smartReader(DATA_PATH + reconstructFilenameLabelled)
# Fitting checking
# --------------------
for key in MARKERSETS.keys():
if key != "Calibration markers":
logging.info("[pyCGM2] Checking of the %s" % (key))
# presence
ip_presence = inspectProcedures.MarkerPresenceQualityProcedure(
acq, markers=MARKERSETS[key])
inspector = inspectFilters.QualityFilter(ip_presence)
inspector.run()
if ip_presence.markersIn != []:
ip_gap = inspectProcedures.GapQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_gap)
inspector.run()
ip_swap = inspectProcedures.SwappingMarkerQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_swap)
inspector.run()
ip_pos = inspectProcedures.MarkerPositionQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_pos)
# filtering
# -----------------------
# marker
order_marker = int(
float(dynamicMeasurement.Marker_lowpass_filter_order.text))
fc_marker = float(
dynamicMeasurement.Marker_lowpass_filter_frequency.text)
# force plate
order_fp = int(
float(dynamicMeasurement.Forceplate_lowpass_filter_order.text))
fc_fp = float(
dynamicMeasurement.Forceplate_lowpass_filter_frequency.text)
# event checking
# -----------------------
inspectprocedureEvents = inspectProcedures.GaitEventQualityProcedure(
acq)
inspector = inspectFilters.QualityFilter(inspectprocedureEvents)
inspector.run()
eventInspectorStates.append(inspectprocedureEvents.state)
# fitting operation
# -----------------------
logging.info("[pyCGM2] --- Fitting operation ---")
acqGait = cgm1_1.fitting(model,
DATA_PATH,
reconstructFilenameLabelled,
translators,
markerDiameter,
pointSuffix,
mfpa,
momentProjection,
fc_lowPass_marker=fc_marker,
order_lowPass_marker=order_marker,
fc_lowPass_forcePlate=fc_fp,
order_lowPass_forcePlate=order_fp)
outFilename = reconstructFilenameLabelled
btkTools.smartWriter(acqGait, str(DATA_PATH + outFilename))
modelledC3ds.append(outFilename)
logging.info("----Processing of [%s]-----> DONE" %
(reconstructFilenameLabelled))
# --------------------------GAIT PROCESSING -----------------------
if not all(eventInspectorStates):
raise Exception(
"[pyCGM2] Impossible to run Gait processing. Badly gait event detection. check the log file"
)
logging.info(
"---------------------GAIT PROCESSING -----------------------")
if createPDFReport:
nds = normativeDatasets.Schwartz2008("Free")
types = qtmTools.detectMeasurementType(sessionXML)
for type in types:
modelledTrials = list()
for dynamicMeasurement in dynamicMeasurements:
if qtmTools.isType(dynamicMeasurement, type):
filename = qtmTools.getFilename(dynamicMeasurement)
modelledTrials.append(filename)
report.pdfGaitReport(DATA_PATH,
model,
modelledTrials,
nds,
pointSuffix,
title=type)
logging.info("----- Gait Processing -----> DONE")
def main(args):
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM2_2-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,"CGM2_2-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,"CGM2_2-pyCGM2.settings")
# --------------------------CONFIG ------------------------------------
argsManager = CgmArgsManager.argsManager_cgm(settings,args)
markerDiameter = argsManager.getMarkerDiameter()
pointSuffix = argsManager.getPointSuffix("cgm2.2")
momentProjection = argsManager.getMomentProjection()
# --------------------------LOADING ------------------------------------
DATA_PATH, reconstructFilenameLabelledNoExt = NEXUS.GetTrialName()
reconstructFilenameLabelled = reconstructFilenameLabelledNoExt+".c3d"
logging.info( "data Path: "+ DATA_PATH )
logging.info( "calibration file: "+ reconstructFilenameLabelled)
# --------------------------SUBJECT ------------------------------------
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.checkActivatedSubject(NEXUS,subjects)
logging.info( "Subject name : " + subject )
# --------------------pyCGM2 MODEL ------------------------------
model = files.loadModel(DATA_PATH,subject)
# check model
logging.info("loaded model : %s" %(model.version))
if model.version != "CGM2.2":
raise Exception ("%s-pyCGM2.model file was not calibrated from the CGM2.2 calibration pipeline"%subject)
# --------------------------SESSION INFOS ------------------------------------
translators = files.getTranslators(DATA_PATH,"CGM2_2.translators")
if not translators: translators = settings["Translators"]
# ikweight
ikWeight = files.getIKweightSet(DATA_PATH,"CGM2_2.ikw")
if not ikWeight: ikWeight = settings["Fitting"]["Weight"]
#force plate assignement from Nexus
mfpa = nexusTools.getForcePlateAssignment(NEXUS)
nacf = nexusFilters.NexusConstructAcquisitionFilter(DATA_PATH,reconstructFilenameLabelledNoExt,subject)
acq = nacf.build()
# --------------------------MODELLING PROCESSING -----------------------
acqIK = cgm2_2.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,settings,
markerDiameter,
pointSuffix,
mfpa,
momentProjection,
forceBtkAcq=acq)
# ----------------------DISPLAY ON VICON-------------------------------
nexusFilters.NexusModelFilter(NEXUS,model,acqIK,subject,pointSuffix).run()
nexusTools.createGeneralEvents(NEXUS,subject,acqIK,["Left-FP","Right-FP"])
# ========END of the nexus OPERATION if run from Nexus =========
else:
raise Exception("NO Nexus connection. Turn on Nexus")
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 main():
parser = argparse.ArgumentParser(description='CGM2-3 Fitting')
parser.add_argument(
'--proj',
type=str,
help='Moment Projection. Choice : Distal, Proximal, Global')
parser.add_argument('-md',
'--markerDiameter',
type=float,
help='marker diameter')
parser.add_argument('--noIk',
action='store_true',
help='cancel inverse kinematic')
parser.add_argument('-ps',
'--pointSuffix',
type=str,
help='suffix of model outputs')
parser.add_argument('--check',
action='store_true',
help='force model output suffix')
parser.add_argument('-a',
'--accuracy',
type=float,
help='Inverse Kinematics accuracy')
parser.add_argument('-ae',
'--anomalyException',
action='store_true',
help='stop if anomaly detected ')
parser.add_argument('-fi',
'--frameInit',
type=int,
help='first frame to process')
parser.add_argument('-fe',
'--frameEnd',
type=int,
help='last frame to process')
args = parser.parse_args()
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------GLOBAL SETTINGS ------------------------------
# global setting ( in user/AppData)
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")
# --------------------------CONFIG ------------------------------------
argsManager = CgmArgsManager.argsManager_cgm(settings, args)
markerDiameter = argsManager.getMarkerDiameter()
pointSuffix = argsManager.getPointSuffix("cgm2.3")
momentProjection = argsManager.getMomentProjection()
ik_flag = argsManager.enableIKflag
ikAccuracy = argsManager.getIkAccuracy()
# ----------------------LOADING-------------------------------------------
DATA_PATH, reconstructFilenameLabelledNoExt = NEXUS.GetTrialName()
reconstructFilenameLabelled = reconstructFilenameLabelledNoExt + ".c3d"
LOGGER.logger.info("data Path: " + DATA_PATH)
LOGGER.set_file_handler(DATA_PATH + "pyCGM2-Fitting.log")
LOGGER.logger.info("calibration file: " + reconstructFilenameLabelled)
# --------------------------SUBJECT -----------------------------------
# Notice : Work with ONE subject by session
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.getActiveSubject(NEXUS)
LOGGER.logger.info("Subject name : " + subject)
# --------------------pyCGM2 MODEL ------------------------------
model = files.loadModel(DATA_PATH, subject)
# -------------------------- MP ------------------------------------
# allow alteration of thigh offset
model.mp_computed[
"LeftThighRotationOffset"] = NEXUS.GetSubjectParamDetails(
subject, "LeftThighRotation")[0]
model.mp_computed[
"RightThighRotationOffset"] = NEXUS.GetSubjectParamDetails(
subject, "RightThighRotation")[0]
# --------------------------CHECKING -----------------------------------
# check model
LOGGER.logger.info("loaded model : %s" % (model.version))
if model.version != "CGM2.3":
raise Exception(
"%s-pyCGM2.model file was not calibrated from the CGM2.3 calibration pipeline"
% subject)
# --------------------------SESSION INFOS ------------------------------------
# translators management
translators = files.getTranslators(DATA_PATH, "CGM2_3.translators")
if not translators: translators = settings["Translators"]
# ikweight
ikWeight = files.getIKweightSet(DATA_PATH, "CGM2_3.ikw")
if not ikWeight: ikWeight = settings["Fitting"]["Weight"]
#force plate assignement from Nexus
mfpa = nexusTools.getForcePlateAssignment(NEXUS)
# btkAcquisition
nacf = nexusFilters.NexusConstructAcquisitionFilter(
DATA_PATH, reconstructFilenameLabelledNoExt, subject)
acq = nacf.build()
# --------------------------MODELLING PROCESSING -----------------------
finalAcqGait, detectAnomaly = cgm2_3.fitting(
model,
DATA_PATH,
reconstructFilenameLabelled,
translators,
settings,
ik_flag,
markerDiameter,
pointSuffix,
mfpa,
momentProjection,
forceBtkAcq=acq,
ikAccuracy=ikAccuracy,
anomalyException=args.anomalyException,
frameInit=args.frameInit,
frameEnd=args.frameEnd)
# ----------------------DISPLAY ON VICON-------------------------------
nexusFilters.NexusModelFilter(NEXUS, model, finalAcqGait, subject,
pointSuffix).run()
nexusTools.createGeneralEvents(NEXUS, subject, finalAcqGait,
["Left-FP", "Right-FP"])
# ========END of the nexus OPERATION if run from Nexus =========
else:
raise Exception("NO Nexus connection. Turn on Nexus")
def main(args):
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM1-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,"CGM1-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,"CGM1-pyCGM2.settings")
# --------------------------CONFIG ------------------------------------
argsManager = CgmArgsManager.argsManager_cgm1(settings,args)
leftFlatFoot = argsManager.getLeftFlatFoot()
rightFlatFoot = argsManager.getRightFlatFoot()
headFlat = argsManager.getHeadFlat()
markerDiameter = argsManager.getMarkerDiameter()
pointSuffix = argsManager.getPointSuffix("cgm1")
DATA_PATH, calibrateFilenameLabelledNoExt = NEXUS.GetTrialName()
calibrateFilenameLabelled = calibrateFilenameLabelledNoExt+".c3d"
logging.info( "data Path: "+ DATA_PATH )
logging.info( "calibration file: "+ calibrateFilenameLabelled)
# --------------------------SUBJECT ------------------------------------
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.checkActivatedSubject(NEXUS,subjects)
Parameters = NEXUS.GetSubjectParamNames(subject)
required_mp,optional_mp = nexusUtils.getNexusSubjectMp(NEXUS,subject,resetFlag=args.resetMP)
# -------------------------- INFOS ------------------------------------
mpInfo,mpFilename = files.getMpFileContent(DATA_PATH,"mp.pyCGM2",subject)
# translators management
translators = files.getTranslators(DATA_PATH,"CGM1.translators")
if not translators: translators = settings["Translators"]
# btkAcq builder
nacf = nexusFilters.NexusConstructAcquisitionFilter(DATA_PATH,calibrateFilenameLabelledNoExt,subject)
acq = nacf.build()
# --------------------------MODELLING PROCESSING -----------------------
model,acqStatic = cgm1.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,
required_mp,optional_mp,
leftFlatFoot,rightFlatFoot,headFlat,markerDiameter,
pointSuffix,forceBtkAcq=acq)
# ----------------------SAVE-------------------------------------------
#pyCGM2.model
files.saveModel(model,DATA_PATH,subject)
# save mp
files.saveMp(mpInfo,model,DATA_PATH,mpFilename)
# ----------------------DISPLAY ON VICON-------------------------------
nexusUtils.updateNexusSubjectMp(NEXUS,model,subject)
nexusFilters.NexusModelFilter(NEXUS,
model,acqStatic,subject,
pointSuffix,
staticProcessing=True).run()
def main(sessionFilename,
createPDFReport=True,
checkEventsInMokka=True,
anomalyException=False):
detectAnomaly = False
LOGGER.set_file_handler("pyCGM2-QTM-Workflow.log")
LOGGER.logger.info("------------QTM - pyCGM2 Workflow---------------")
sessionXML = files.readXml(os.getcwd() + "\\", sessionFilename)
sessionDate = files.getFileCreationDate(os.getcwd() + "\\" +
sessionFilename)
#---------------------------------------------------------------------------
#management of the Processed folder
DATA_PATH = os.getcwd() + "\\" + "processed\\"
files.createDir(DATA_PATH)
staticMeasurement = qtmTools.findStatic(sessionXML)
calibrateFilenameLabelled = qtmTools.getFilename(staticMeasurement)
if not os.path.isfile(DATA_PATH + calibrateFilenameLabelled):
shutil.copyfile(os.getcwd() + "\\" + calibrateFilenameLabelled,
DATA_PATH + calibrateFilenameLabelled)
LOGGER.logger.info(
"qualisys exported c3d file [%s] copied to processed folder" %
(calibrateFilenameLabelled))
if qtmTools.findKneeCalibration(
sessionXML, "Left") is not None or qtmTools.findKneeCalibration(
sessionXML, "Right") is not None:
LOGGER.logger.info(
" the %s not accept functional knee calibration !!" % (MODEL))
dynamicMeasurements = qtmTools.findDynamic(sessionXML)
for dynamicMeasurement in dynamicMeasurements:
reconstructFilenameLabelled = qtmTools.getFilename(dynamicMeasurement)
# marker
order_marker = int(
float(dynamicMeasurement.Marker_lowpass_filter_order.text))
fc_marker = float(
dynamicMeasurement.Marker_lowpass_filter_frequency.text)
if not os.path.isfile(DATA_PATH + reconstructFilenameLabelled):
shutil.copyfile(os.getcwd() + "\\" + reconstructFilenameLabelled,
DATA_PATH + reconstructFilenameLabelled)
LOGGER.logger.info(
"qualisys exported c3d file [%s] copied to processed folder" %
(reconstructFilenameLabelled))
acq = btkTools.smartReader(
str(DATA_PATH + reconstructFilenameLabelled))
acq, zeniState = eventDetector.zeni(
acq,
fc_lowPass_marker=fc_marker,
order_lowPass_marker=order_marker)
if zeniState:
btkTools.smartWriter(
acq, str(DATA_PATH + reconstructFilenameLabelled))
if checkEventsInMokka:
cmd = "Mokka.exe \"%s\"" % (
str(DATA_PATH + reconstructFilenameLabelled))
os.system(cmd)
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
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")
# --------------------------MP ------------------------------------
required_mp, optional_mp = qtmTools.SubjectMp(sessionXML)
# translators management
translators = files.getTranslators(os.getcwd() + "\\",
"CGM2_5.translators")
if not translators: translators = settings["Translators"]
# ikweight
ikWeight = files.getIKweightSet(DATA_PATH, "CGM2_5.ikw")
if not ikWeight: ikWeight = settings["Fitting"]["Weight"]
# --------------------------MODEL CALIBRATION -----------------------
LOGGER.logger.info(
"--------------------------MODEL CALIBRATION -----------------------")
staticMeasurement = qtmTools.findStatic(sessionXML)
calibrateFilenameLabelled = qtmTools.getFilename(staticMeasurement)
LOGGER.logger.info("----- CALIBRATION- static file [%s]--" %
(calibrateFilenameLabelled))
leftFlatFoot = utils.toBool(
sessionXML.Left_foot_normalised_to_static_trial.text)
rightFlatFoot = utils.toBool(
sessionXML.Right_foot_normalised_to_static_trial.text)
headFlat = utils.toBool(sessionXML.Head_normalised_to_static_trial.text)
markerDiameter = float(sessionXML.Marker_diameter.text) * 1000.0
hjcMethod = settings["Calibration"]["HJC"]
pointSuffix = None
# Calibration checking
# --------------------
acqStatic = btkTools.smartReader(DATA_PATH + calibrateFilenameLabelled)
# Calibration operation
# --------------------
model, acqStatic, detectAnomaly = cgm2_5.calibrate(
DATA_PATH,
calibrateFilenameLabelled,
translators,
settings,
required_mp,
optional_mp,
False,
leftFlatFoot,
rightFlatFoot,
headFlat,
markerDiameter,
hjcMethod,
pointSuffix,
anomalyException=anomalyException)
LOGGER.logger.info("----- CALIBRATION- static file [%s]-----> DONE" %
(calibrateFilenameLabelled))
# --------------------------MODEL FITTING ----------------------------------
LOGGER.logger.info(
"--------------------------MODEL FITTING ----------------------------------"
)
dynamicMeasurements = qtmTools.findDynamic(sessionXML)
ik_flag = True
modelledC3ds = list()
eventInspectorStates = list()
for dynamicMeasurement in dynamicMeasurements:
reconstructFilenameLabelled = qtmTools.getFilename(dynamicMeasurement)
LOGGER.logger.info("----Processing of [%s]-----" %
(reconstructFilenameLabelled))
mfpa = qtmTools.getForcePlateAssigment(dynamicMeasurement)
momentProjection_text = sessionXML.Moment_Projection.text
if momentProjection_text == "Default":
momentProjection_text = settings["Fitting"]["Moment Projection"]
if momentProjection_text == "Distal":
momentProjection = enums.MomentProjection.Distal
elif momentProjection_text == "Proximal":
momentProjection = enums.MomentProjection.Proximal
elif momentProjection_text == "Global":
momentProjection = enums.MomentProjection.Global
elif momentProjection_text == "JCS":
momentProjection = enums.MomentProjection.JCS
acq = btkTools.smartReader(DATA_PATH + reconstructFilenameLabelled)
# filtering
# -----------------------
# marker
order_marker = int(
float(dynamicMeasurement.Marker_lowpass_filter_order.text))
fc_marker = float(
dynamicMeasurement.Marker_lowpass_filter_frequency.text)
# force plate
order_fp = int(
float(dynamicMeasurement.Forceplate_lowpass_filter_order.text))
fc_fp = float(
dynamicMeasurement.Forceplate_lowpass_filter_frequency.text)
# ik accuracy
ikAccuracy = float(dynamicMeasurement.IkAccuracy.text)
if dynamicMeasurement.First_frame_to_process.text != "":
vff = int(dynamicMeasurement.First_frame_to_process.text)
else:
vff = None
if dynamicMeasurement.Last_frame_to_process.text != "":
vlf = int(dynamicMeasurement.Last_frame_to_process.text)
else:
vlf = None
# fitting operation
# -----------------------
LOGGER.logger.info("[pyCGM2] --- Fitting operation ---")
acqGait, detectAnomaly = cgm2_5.fitting(
model,
DATA_PATH,
reconstructFilenameLabelled,
translators,
settings,
ik_flag,
markerDiameter,
pointSuffix,
mfpa,
momentProjection,
fc_lowPass_marker=fc_marker,
order_lowPass_marker=order_marker,
fc_lowPass_forcePlate=fc_fp,
order_lowPass_forcePlate=order_fp,
anomalyException=anomalyException,
ikAccuracy=ikAccuracy,
frameInit=vff,
frameEnd=vlf)
outFilename = reconstructFilenameLabelled
btkTools.smartWriter(acqGait, str(DATA_PATH + outFilename))
modelledC3ds.append(outFilename)
LOGGER.logger.info("----Processing of [%s]-----> DONE" %
(reconstructFilenameLabelled))
LOGGER.logger.info(
"---------------------GAIT PROCESSING -----------------------")
if createPDFReport:
nds = normativeDatasets.NormativeData("Schwartz2008", "Free")
types = qtmTools.detectMeasurementType(sessionXML)
for type in types:
modelledTrials = list()
for dynamicMeasurement in dynamicMeasurements:
if qtmTools.isType(dynamicMeasurement, type):
filename = qtmTools.getFilename(dynamicMeasurement)
# event checking
# -----------------------
acq = btkTools.smartReader(DATA_PATH + filename)
geap = AnomalyDetectionProcedure.GaitEventAnomalyProcedure(
)
adf = AnomalyFilter.AnomalyDetectionFilter(
acq, filename, geap)
anomaly_events = adf.run()
if anomaly_events["ErrorState"]:
detectAnomaly = True
LOGGER.logger.warning(
"file [%s] not used for generating the gait report. bad gait event detected"
% (filename))
else:
modelledTrials.append(filename)
try:
report.pdfGaitReport(DATA_PATH,
model,
modelledTrials,
nds,
pointSuffix,
title=type)
LOGGER.logger.error("Generation of Gait report complete")
except:
LOGGER.logger.error("Generation of Gait report failed")
LOGGER.logger.info(
"-------------------------------------------------------")
if detectAnomaly:
LOGGER.logger.error(
"Anomalies has been detected - Find Error messages, then check warning message in the log file"
)
else:
LOGGER.logger.info("workflow return with no detected anomalies")
def main():
parser = argparse.ArgumentParser(description='CGM2.4 Calibration')
parser.add_argument('-l','--leftFlatFoot', type=int, help='left flat foot option')
parser.add_argument('-r','--rightFlatFoot',type=int, help='right flat foot option')
parser.add_argument('-hf','--headFlat',type=int, help='head flat option')
parser.add_argument('-md','--markerDiameter', type=float, help='marker diameter')
parser.add_argument('-ps','--pointSuffix', type=str, help='suffix of model outputs')
parser.add_argument('--check', action='store_true', help='force model output suffix')
parser.add_argument('--noIk', action='store_true', help='cancel inverse kinematic')
parser.add_argument('--resetMP', action='store_true', help='reset optional mass parameters')
parser.add_argument('--forceLHJC', nargs='+')
parser.add_argument('--forceRHJC', nargs='+')
parser.add_argument('-ae','--anomalyException', action='store_true', help='stop if anomaly detected ')
args = parser.parse_args()
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------GLOBAL SETTINGS ------------------------------
# ( in user/AppData)
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")
argsManager = CgmArgsManager.argsManager_cgm(settings,args)
leftFlatFoot = argsManager.getLeftFlatFoot()
rightFlatFoot = argsManager.getRightFlatFoot()
headFlat = argsManager.getHeadFlat()
markerDiameter = argsManager.getMarkerDiameter()
pointSuffix = argsManager.getPointSuffix("cgm2.4")
ik_flag = argsManager.enableIKflag()
hjcMethod = settings["Calibration"]["HJC"]
lhjc = argsManager.forceHjc("left")
rhjc = argsManager.forceHjc("right")
if lhjc is not None:
hjcMethod["Left"] = lhjc
if rhjc is not None:
hjcMethod["Right"] = rhjc
# --------------------------LOADING------------------------------
DATA_PATH, calibrateFilenameLabelledNoExt = NEXUS.GetTrialName()
calibrateFilenameLabelled = calibrateFilenameLabelledNoExt+".c3d"
LOGGER.logger.info( "data Path: "+ DATA_PATH )
LOGGER.set_file_handler(DATA_PATH+"pyCGM2-Calibration.log")
LOGGER.logger.info( "calibration file: "+ calibrateFilenameLabelled)
# --------------------------SUBJECT -----------------------------------
# Notice : Work with ONE subject by session
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.getActiveSubject(NEXUS)
Parameters = NEXUS.GetSubjectParamNames(subject)
required_mp,optional_mp = nexusUtils.getNexusSubjectMp(NEXUS,subject,resetFlag=args.resetMP)
# --------------------------SESSION INFOS -----------------------------
# --------------------------SESSIONS INFOS -----------------------------------
mpInfo,mpFilename = files.getMpFileContent(DATA_PATH,"mp.pyCGM2",subject)
# translators management
translators = files.getTranslators(DATA_PATH,"CGM2_4.translators")
if not translators: translators = settings["Translators"]
# btkAcq builder
nacf = nexusFilters.NexusConstructAcquisitionFilter(DATA_PATH,calibrateFilenameLabelledNoExt,subject)
acq = nacf.build()
# --------------------------CONFIG ------------------------------------
model,finalAcqStatic,detectAnomaly = cgm2_4.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,settings,
required_mp,optional_mp,
ik_flag,leftFlatFoot,rightFlatFoot,headFlat,
markerDiameter,
hjcMethod,
pointSuffix,forceBtkAcq=acq, anomalyException=args.anomalyException)
# ----------------------SAVE-------------------------------------------
files.saveModel(model,DATA_PATH,subject)
# save mp
files.saveMp(mpInfo,model,DATA_PATH,mpFilename)
# ----------------------DISPLAY ON VICON-------------------------------
nexusUtils.updateNexusSubjectMp(NEXUS,model,subject)
nexusFilters.NexusModelFilter(NEXUS,
model,finalAcqStatic,subject,
pointSuffix,
staticProcessing=True).run()
# ========END of the nexus OPERATION if run from Nexus =========
else:
raise Exception("NO Nexus connection. Turn on Nexus")
def main():
logging.info("------------------------------------------------")
logging.info("------------QTM - pyCGM2 Workflow---------------")
logging.info("------------------------------------------------")
file = "session.xml"
sessionXML = files.readXml(os.getcwd() + "\\", file)
sessionDate = files.getFileCreationDate(os.getcwd() + "\\" + file)
#---------------------------------------------------------------------------
#management of the Processed folder
DATA_PATH = os.getcwd() + "\\" + "processed\\"
files.createDir(DATA_PATH)
staticMeasurement = qtmTools.findStatic(sessionXML)
calibrateFilenameLabelled = qtmTools.getFilename(staticMeasurement)
if not os.path.isfile(DATA_PATH + calibrateFilenameLabelled):
shutil.copyfile(os.getcwd() + "\\" + calibrateFilenameLabelled,
DATA_PATH + calibrateFilenameLabelled)
logging.info(
"qualisys exported c3d file [%s] copied to processed folder" %
(calibrateFilenameLabelled))
dynamicMeasurements = qtmTools.findDynamic(sessionXML)
for dynamicMeasurement in dynamicMeasurements:
reconstructFilenameLabelled = qtmTools.getFilename(dynamicMeasurement)
if not os.path.isfile(DATA_PATH + reconstructFilenameLabelled):
shutil.copyfile(os.getcwd() + "\\" + reconstructFilenameLabelled,
DATA_PATH + reconstructFilenameLabelled)
logging.info(
"qualisys exported c3d file [%s] copied to processed folder" %
(reconstructFilenameLabelled))
acq = btkTools.smartReader(
str(DATA_PATH + reconstructFilenameLabelled))
if btkTools.checkForcePlateExist(acq):
if "5" in btkTools.smartGetMetadata(acq, "FORCE_PLATFORM",
"TYPE"):
forceplates.correctForcePlateType5(acq)
acq, zeniState = eventDetector.zeni(acq)
if zeniState:
btkTools.smartWriter(
acq, str(DATA_PATH + reconstructFilenameLabelled))
cmd = "Mokka.exe \"%s\"" % (str(DATA_PATH +
reconstructFilenameLabelled))
os.system(cmd)
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM2_2-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_2-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM2_2-pyCGM2.settings")
# --------------------------MP ------------------------------------
required_mp, optional_mp = qtmTools.SubjectMp(sessionXML)
# --Check MP
inspectprocedure = inspectProcedures.AnthropometricDataQualityProcedure(
required_mp)
inspector = inspectFilters.QualityFilter(inspectprocedure)
inspector.run()
# translators management
translators = files.getTranslators(os.getcwd() + "\\",
"CGM2_2.translators")
if not translators: translators = settings["Translators"]
# ikweight
ikWeight = files.getIKweightSet(DATA_PATH, "CGM2_2.ikw")
if not ikWeight: ikWeight = settings["Fitting"]["Weight"]
# --------------------------MODEL CALIBRATION -----------------------
logging.info(
"--------------------------MODEL CALIBRATION -----------------------")
staticMeasurement = qtmTools.findStatic(sessionXML)
calibrateFilenameLabelled = qtmTools.getFilename(staticMeasurement)
logging.info("----- CALIBRATION- static file [%s]--" %
(calibrateFilenameLabelled))
leftFlatFoot = toBool(
staticMeasurement.Left_foot_normalised_to_static_trial.text)
rightFlatFoot = toBool(
staticMeasurement.Right_foot_normalised_to_static_trial.text)
headFlat = toBool(staticMeasurement.Head_normalised_to_static_trial.text)
markerDiameter = float(staticMeasurement.Marker_diameter.text) * 1000.0
hjcMethod = settings["Calibration"]["HJC"]
pointSuffix = None
# Calibration checking
# --------------------
acqStatic = btkTools.smartReader(DATA_PATH + calibrateFilenameLabelled)
for key in MARKERSETS.keys():
logging.info("[pyCGM2] Checking of the %s" % (key))
# presence
ip_presence = inspectProcedures.MarkerPresenceQualityProcedure(
acqStatic, markers=MARKERSETS[key])
inspector = inspectFilters.QualityFilter(ip_presence)
inspector.run()
if ip_presence.markersIn != []:
ip_gap = inspectProcedures.GapQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_gap)
inspector.run()
ip_swap = inspectProcedures.SwappingMarkerQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_swap)
inspector.run()
ip_pos = inspectProcedures.MarkerPositionQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_pos)
# Calibration operation
# --------------------
logging.info("[pyCGM2] --- calibration operation ---")
model, acqStatic = cgm2_2.calibrate(DATA_PATH, calibrateFilenameLabelled,
translators, settings, required_mp,
optional_mp, False, leftFlatFoot,
rightFlatFoot, headFlat,
markerDiameter, hjcMethod, pointSuffix)
logging.info("----- CALIBRATION- static file [%s]-----> DONE" %
(calibrateFilenameLabelled))
# --------------------------MODEL FITTING ----------------------------------
logging.info(
"--------------------------MODEL FITTING ----------------------------------"
)
dynamicMeasurements = qtmTools.findDynamic(sessionXML)
modelledC3ds = list()
eventInspectorStates = list()
for dynamicMeasurement in dynamicMeasurements:
reconstructFilenameLabelled = qtmTools.getFilename(dynamicMeasurement)
logging.info("----Processing of [%s]-----" %
(reconstructFilenameLabelled))
mfpa = qtmTools.getForcePlateAssigment(dynamicMeasurement)
momentProjection_text = dynamicMeasurement.Moment_Projection.text
if momentProjection_text == "Default":
momentProjection_text = settings["Fitting"]["Moment Projection"]
if momentProjection_text == "Distal":
momentProjection = enums.MomentProjection.Distal
elif momentProjection_text == "Proximal":
momentProjection = enums.MomentProjection.Proximal
elif momentProjection_text == "Global":
momentProjection = enums.MomentProjection.Global
elif momentProjection_text == "JCS":
momentProjection = enums.MomentProjection.JCS
acq = btkTools.smartReader(DATA_PATH + reconstructFilenameLabelled)
# Fitting checking
# --------------------
for key in MARKERSETS.keys():
if key != "Calibration markers":
logging.info("[pyCGM2] Checking of the %s" % (key))
# presence
ip_presence = inspectProcedures.MarkerPresenceQualityProcedure(
acq, markers=MARKERSETS[key])
inspector = inspectFilters.QualityFilter(ip_presence)
inspector.run()
if ip_presence.markersIn != []:
ip_gap = inspectProcedures.GapQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_gap)
inspector.run()
ip_swap = inspectProcedures.SwappingMarkerQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_swap)
inspector.run()
ip_pos = inspectProcedures.MarkerPositionQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_pos)
# filtering
# -----------------------
# marker
order = int(float(dynamicMeasurement.Marker_lowpass_filter_order.text))
fc = float(dynamicMeasurement.Marker_lowpass_filter_frequency.text)
signal_processing.markerFiltering(acq, order=order, fc=fc)
# management of force plate type 5 and force plate filtering
order = int(
float(dynamicMeasurement.Forceplate_lowpass_filter_order.text))
fc = float(dynamicMeasurement.Forceplate_lowpass_filter_frequency.text)
if order != 0 and fc != 0:
acq = btkTools.smartReader(DATA_PATH + reconstructFilenameLabelled)
if btkTools.checkForcePlateExist(acq):
if "5" in btkTools.smartGetMetadata(acq, "FORCE_PLATFORM",
"TYPE"):
forceplates.correctForcePlateType5(acq)
signal_processing.markerFiltering(acq, order=order, fc=fc)
else:
if btkTools.checkForcePlateExist(acq):
if "5" in btkTools.smartGetMetadata(acq, "FORCE_PLATFORM",
"TYPE"):
forceplates.correctForcePlateType5(acq)
btkTools.smartWriter(acq, DATA_PATH + reconstructFilenameLabelled)
# event checking
# -----------------------
inspectprocedureEvents = inspectProcedures.GaitEventQualityProcedure(
acq)
inspector = inspectFilters.QualityFilter(inspectprocedureEvents)
inspector.run()
eventInspectorStates.append(inspectprocedureEvents.state)
# fitting operation
# -----------------------
logging.info("[pyCGM2] --- Fitting operation ---")
acqGait = cgm2_2.fitting(model, DATA_PATH, reconstructFilenameLabelled,
translators, settings, markerDiameter,
pointSuffix, mfpa, momentProjection)
outFilename = reconstructFilenameLabelled #[:-4] + "_CGM1.c3d"
btkTools.smartWriter(acqGait, str(DATA_PATH + outFilename))
modelledC3ds.append(outFilename)
logging.info("----Processing of [%s]-----> DONE" %
(reconstructFilenameLabelled))
# --------------------------GAIT PROCESSING -----------------------
if not all(eventInspectorStates):
raise Exception(
"[pyCGM2] Impossible to run Gait processing. Badly gait event detection. check the log file"
)
logging.info(
"---------------------GAIT PROCESSING -----------------------")
nds = normativeDatasets.Schwartz2008("Free")
types = qtmTools.detectMeasurementType(sessionXML)
for type in types:
modelledTrials = list()
for dynamicMeasurement in dynamicMeasurements:
if qtmTools.isType(dynamicMeasurement, type):
filename = qtmTools.getFilename(dynamicMeasurement)
modelledTrials.append(filename) #.replace(".c3d","_CGM1.c3d"))
subjectMd = {
"patientName":
sessionXML.find("Last_name").text + " " +
sessionXML.find("First_name").text,
"bodyHeight":
sessionXML.find("Height").text,
"bodyWeight":
sessionXML.find("Weight").text,
"diagnosis":
sessionXML.find("Diagnosis").text,
"dob":
sessionXML.find("Date_of_birth").text,
"sex":
sessionXML.find("Sex").text,
"test condition":
type,
"gmfcs":
sessionXML.find("Gross_Motor_Function_Classification").text,
"fms":
sessionXML.find("Functional_Mobility_Scale").text
}
analysisInstance = analysis.makeAnalysis(DATA_PATH,
modelledTrials,
subjectInfo=None,
experimentalInfo=None,
modelInfo=None,
pointLabelSuffix=None)
title = type
# spatiotemporal
plot.plot_spatioTemporal(DATA_PATH,
analysisInstance,
exportPdf=True,
outputName=title,
show=None,
title=title)
#Kinematics
if model.m_bodypart in [
enums.BodyPart.LowerLimb, enums.BodyPart.LowerLimbTrunk,
enums.BodyPart.FullBody
]:
plot.plot_DescriptiveKinematic(DATA_PATH,
analysisInstance,
"LowerLimb",
nds,
exportPdf=True,
outputName=title,
pointLabelSuffix=pointSuffix,
show=False,
title=title)
plot.plot_ConsistencyKinematic(DATA_PATH,
analysisInstance,
"LowerLimb",
nds,
exportPdf=True,
outputName=title,
pointLabelSuffix=pointSuffix,
show=False,
title=title)
if model.m_bodypart in [
enums.BodyPart.LowerLimbTrunk, enums.BodyPart.FullBody
]:
plot.plot_DescriptiveKinematic(DATA_PATH,
analysisInstance,
"Trunk",
nds,
exportPdf=True,
outputName=title,
pointLabelSuffix=pointSuffix,
show=False,
title=title)
plot.plot_ConsistencyKinematic(DATA_PATH,
analysisInstance,
"Trunk",
nds,
exportPdf=True,
outputName=title,
pointLabelSuffix=pointSuffix,
show=False,
title=title)
if model.m_bodypart in [
enums.BodyPart.UpperLimb, enums.BodyPart.FullBody
]:
pass # TODO plot upperlimb panel
#Kinetics
if model.m_bodypart in [
enums.BodyPart.LowerLimb, enums.BodyPart.LowerLimbTrunk,
enums.BodyPart.FullBody
]:
plot.plot_DescriptiveKinetic(DATA_PATH,
analysisInstance,
"LowerLimb",
nds,
exportPdf=True,
outputName=title,
pointLabelSuffix=pointSuffix,
show=False,
title=title)
plot.plot_ConsistencyKinetic(DATA_PATH,
analysisInstance,
"LowerLimb",
nds,
exportPdf=True,
outputName=title,
pointLabelSuffix=pointSuffix,
show=False,
title=title)
#MAP
plot.plot_MAP(DATA_PATH,
analysisInstance,
nds,
exportPdf=True,
outputName=title,
pointLabelSuffix=pointSuffix,
show=False,
title=title)
plt.show(False)
logging.info("----- Gait Processing -----> DONE")
elif model.version == "CGM2.4":
settings = files.openJson(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_4-pyCGM2.settings")
elif model.version == "CGM2.4e":
settings = files.openJson(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_4-Expert-pyCGM2.settings")
else:
raise Exception("model version not found [contact admin]")
# --------------------------SESSION INFOS ------------------------------------
mpInfo, mpFilename = files.getJsonFileContent(DATA_PATH, "mp.pyCGM2",
subject)
# translators management
if model.version in ["CGM1.0"]:
translators = files.getTranslators(DATA_PATH, "CGM1.translators")
elif model.version in ["CGM1.1"]:
translators = files.getTranslators(DATA_PATH, "CGM1_1.translators")
elif model.version in ["CGM2.1"]:
translators = files.getTranslators(DATA_PATH, "CGM2_1.translators")
elif model.version in ["CGM2.2", "CGM2.2e"]:
translators = files.getTranslators(DATA_PATH, "CGM2_2.translators")
elif model.version in ["CGM2.3", "CGM2.3e"]:
translators = files.getTranslators(DATA_PATH, "CGM2_3.translators")
elif model.version in ["CGM2.4", "CGM2.4e"]:
translators = files.getTranslators(DATA_PATH, "CGM2_4.translators")
if not translators:
translators = settings["Translators"]
# --------------------------MODEL PROCESSING----------------------------
def main():
parser = argparse.ArgumentParser(description='2Dof Knee Calibration')
parser.add_argument('-s','--side', type=str, help="Side : Left or Right")
parser.add_argument('-b','--beginFrame', type=int, help="begin frame")
parser.add_argument('-e','--endFrame', type=int, help="end frame")
args = parser.parse_args()
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
DATA_PATH, reconstructedFilenameLabelledNoExt = NEXUS.GetTrialName()
reconstructFilenameLabelled = reconstructedFilenameLabelledNoExt+".c3d"
LOGGER.logger.info( "data Path: "+ DATA_PATH )
LOGGER.logger.info( "reconstructed file: "+ reconstructFilenameLabelled)
# --------------------------SUBJECT -----------------------------------
# Notice : Work with ONE subject by session
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.getActiveSubject(NEXUS)
LOGGER.logger.info( "Subject name : " + subject )
# --------------------pyCGM2 MODEL - INIT ------------------------------
model = files.loadModel(DATA_PATH,subject)
LOGGER.logger.info("loaded model : %s" %(model.version ))
if model.version == "CGM1.0":
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM1-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,"CGM1-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,"CGM1-pyCGM2.settings")
elif model.version == "CGM1.1":
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM1_1-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,"CGM1_1-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,"CGM1_1-pyCGM2.settings")
elif model.version == "CGM2.1":
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM2_1-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,"CGM2_1-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,"CGM2_1-pyCGM2.settings")
elif model.version == "CGM2.2":
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM2_2-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,"CGM2_2-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,"CGM2_2-pyCGM2.settings")
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 ["CGM1.0"]:
translators = files.getTranslators(DATA_PATH,"CGM1.translators")
elif model.version in ["CGM1.1"]:
translators = files.getTranslators(DATA_PATH,"CGM1_1.translators")
elif model.version in ["CGM2.1"]:
translators = files.getTranslators(DATA_PATH,"CGM2_1.translators")
elif model.version in ["CGM2.2"]:
translators = files.getTranslators(DATA_PATH,"CGM2_2.translators")
elif 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.calibration2Dof(model,
DATA_PATH,reconstructFilenameLabelled,translators,
args.side,args.beginFrame,args.endFrame,None,forceBtkAcq=acq)
# ----------------------SAVE-------------------------------------------
files.saveModel(model,DATA_PATH,subject)
LOGGER.logger.warning("model updated with a %s knee calibrated with 2Dof method" %(side))
# save mp
files.saveMp(mpInfo,model,DATA_PATH,mpFilename)
# ----------------------VICON INTERFACE-------------------------------------------
#--- update mp
nexusUtils.updateNexusSubjectMp(NEXUS,model,subject)
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() )
# --------------------------NEW MOTION FILTER - DISPLAY BONES---------
scp=modelFilters.StaticCalibrationProcedure(model)
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"]:
proximalSegmentLabel=str(side+" Thigh")
distalSegmentLabel=str(side+" Shank")
# Motion
modMotion=modelFilters.ModelMotionFilter(scp,acqFunc,model,enums.motionMethod.Sodervisk)
modMotion.segmentalCompute([proximalSegmentLabel,distalSegmentLabel])
# -- add nexus Bones
if side == "Left":
nexusTools.appendBones(NEXUS,subject,acqFunc,"LFE1", model.getSegment("Left Thigh"),OriginValues = acqFunc.GetPoint("LKJC").GetValues() )
LOGGER.logger.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() )
LOGGER.logger.warning("offset %s" %(str(model.mp_computed["RightKneeFuncCalibrationOffset"] )))
else:
raise Exception("NO Nexus connection. Turn on Nexus")
def main():
parser = argparse.ArgumentParser(description='CGM1.1 Calibration')
parser.add_argument('-l',
'--leftFlatFoot',
type=int,
help='left flat foot option')
parser.add_argument('-r',
'--rightFlatFoot',
type=int,
help='right flat foot option')
parser.add_argument('-hf', '--headFlat', type=int, help='head flat option')
parser.add_argument('-md',
'--markerDiameter',
type=float,
help='marker diameter')
parser.add_argument('-ps',
'--pointSuffix',
type=str,
help='suffix of model outputs')
parser.add_argument('--check',
action='store_true',
help='force model output suffix')
parser.add_argument('--resetMP',
action='store_true',
help='reset optional mass parameters')
args = parser.parse_args()
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH +
"CGM1_1-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM1_1-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM1_1-pyCGM2.settings")
# --------------------------CONFIG ------------------------------------
argsManager = CgmArgsManager.argsManager_cgm1(settings, args)
leftFlatFoot = argsManager.getLeftFlatFoot()
rightFlatFoot = argsManager.getRightFlatFoot()
headFlat = argsManager.getHeadFlat()
markerDiameter = argsManager.getMarkerDiameter()
pointSuffix = argsManager.getPointSuffix("cgm1_1")
# --------------------------LOADING ------------------------------------
DATA_PATH, calibrateFilenameLabelledNoExt = NEXUS.GetTrialName()
calibrateFilenameLabelled = calibrateFilenameLabelledNoExt + ".c3d"
logging.info("data Path: " + DATA_PATH)
logging.info("calibration file: " + calibrateFilenameLabelled)
# --------------------------SUBJECT ------------------------------------
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.checkActivatedSubject(NEXUS, subjects)
Parameters = NEXUS.GetSubjectParamNames(subject)
required_mp, optional_mp = nexusUtils.getNexusSubjectMp(
NEXUS, subject, resetFlag=args.resetMP)
# -------------------------- INFOS ------------------------------------
mpInfo, mpFilename = files.getMpFileContent(DATA_PATH, "mp.pyCGM2",
subject)
# translators management
translators = files.getTranslators(DATA_PATH, "CGM1_1.translators")
if not translators: translators = settings["Translators"]
# btkAcq builder
nacf = nexusFilters.NexusConstructAcquisitionFilter(
DATA_PATH, calibrateFilenameLabelledNoExt, subject)
acq = nacf.build()
# --------------------------MODELLING PROCESSING -----------------------
model, acqStatic = cgm1_1.calibrate(DATA_PATH,
calibrateFilenameLabelled,
translators,
required_mp,
optional_mp,
leftFlatFoot,
rightFlatFoot,
headFlat,
markerDiameter,
pointSuffix,
forceBtkAcq=acq)
# ----------------------SAVE-------------------------------------------
#pyCGM2.model
files.saveModel(model, DATA_PATH, subject)
# save mp
files.saveMp(mpInfo, model, DATA_PATH, mpFilename)
# ----------------------DISPLAY ON VICON-------------------------------
nexusUtils.updateNexusSubjectMp(NEXUS, model, subject)
nexusFilters.NexusModelFilter(NEXUS,
model,
acqStatic,
subject,
pointSuffix,
staticProcessing=True).run()
# ========END of the nexus OPERATION if run from Nexus =========
else:
raise Exception("NO Nexus connection. Turn on Nexus")
def calculation_kindyn(filenames_stat, filenames_dyn, there_is_knee_optim):
# Definition des différents répertoires
DATA_PATH = os.path.split(filenames_stat)[0] + '\\'
DATA_PATH_OUT = os.path.join(DATA_PATH, 'Post_CGM2_1')
if not os.path.isdir(DATA_PATH_OUT):
os.mkdir(DATA_PATH_OUT)
DATA_PATH_OUT = os.path.join(DATA_PATH, 'Post_CGM2_1') + '\\'
calibrateFilenameLabelled = str(os.path.split(filenames_stat)[1])
# Setting pour la toolbox pycgm2
args = Namespace()
args.leftFlatFoot = None
args.rightFlatFoot = None
args.markerDiameter = None
args.pointSuffix = None
args.fileSuffix = None
args.mfpa = None
args.proj = None
args.check = True
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
settings = files.openJson(pyCGM2.CONFIG.PYCGM2_APPDATA_PATH,
"CGM2_1-pyCGM2.settings")
fileSuffix = None
# settings overloading
argsManager = cgmUtils.argsManager_cgm(settings, args)
# leftFlatFoot = argsManager.getLeftFlatFoot()
# rightFlatFoot = argsManager.getRightFlatFoot()
leftFlatFoot = 0
rightFlatFoot = 0
markerDiameter = argsManager.getMarkerDiameter()
markerDiameter = 12
pointSuffix = argsManager.getPointSuffix("cgm2_1")
momentProjection = argsManager.getMomentProjection()
# mfpa = argsManager.getManualForcePlateAssign()
# Translator
translators = files.getTranslators(DATA_PATH, "CGM2_1.translators")
if not translators:
translators = settings["Translators"]
# Choix de la methode de Hanche
hjcMethod = settings["Calibration"]["HJC"]
# Extraction des meta data
required_mp, optional_mp = extract_metaData_pycgm2(filenames_stat)
# Statique
model, acqStatic = cgm2_1.calibrate(DATA_PATH, calibrateFilenameLabelled,
translators, required_mp, optional_mp,
leftFlatFoot, rightFlatFoot,
markerDiameter, hjcMethod, pointSuffix)
for ind_file, filename in enumerate(filenames_dyn):
plateforme_mpa = ''
name_enf = extraction_name_enf(filename)
# on fait une copy du fichier ENF pour pouvoir utiliser la génération de rapport
copy2(name_enf, DATA_PATH_OUT)
[FP1, FP2] = extraction_enf(filename)
if FP1 == 'right':
plateforme_mpa += 'R'
elif FP1 == 'left':
plateforme_mpa += 'L'
else:
plateforme_mpa += 'X'
if FP2 == 'right':
plateforme_mpa += 'R'
elif FP2 == 'left':
plateforme_mpa += 'L'
else:
plateforme_mpa += 'X'
reconstructFilenameLabelled = os.path.split(filename)[1]
# Fitting
# Pour le premier fichier on 'décore' le modèle pour pouvoir faire
# la méthode de dynakad (il faut que le modele ait été utilisé en dynamique)
if ind_file == 0 and there_is_knee_optim:
# acqGait = cgm2_1.fitting(model, DATA_PATH, reconstructFilenameLabelled,
# translators,
# markerDiameter,
# pointSuffix,
# plateforme_mpa, momentProjection)
first_frame = None
last_frame = None
model, acqFunc_L, side_L = kneeCalibration.calibration2Dof(
model, DATA_PATH, reconstructFilenameLabelled, translators,
'Left', first_frame, last_frame)
print(model.mp_computed["RightKneeFuncCalibrationOffset"])
print(model.mp_computed["LeftKneeFuncCalibrationOffset"])
model, acqFunc_R, side_R = kneeCalibration.calibration2Dof(
model, DATA_PATH, reconstructFilenameLabelled, translators,
'Right', first_frame, last_frame)
print(model.mp_computed["RightKneeFuncCalibrationOffset"])
print(model.mp_computed["LeftKneeFuncCalibrationOffset"])
# modelDecorator.KneeCalibrationDecorator(model).calibrate2dof('Left', index_1=0)
# modelDecorator.KneeCalibrationDecorator(model).calibrate2dof('Right', index_1=0)
acqGait = cgm2_1.fitting(model, DATA_PATH, reconstructFilenameLabelled,
translators, markerDiameter, pointSuffix,
plateforme_mpa, momentProjection)
# writer
if fileSuffix is not None:
c3dFilename = str(reconstructFilenameLabelled[:-4] + "-modelled-" +
fileSuffix + ".c3d")
else:
c3dFilename = str(reconstructFilenameLabelled)
btkTools.smartWriter(acqGait, str(DATA_PATH_OUT + c3dFilename))
logging.info("c3d file (%s) generated" % (c3dFilename))
return DATA_PATH_OUT
def main():
parser = argparse.ArgumentParser(description='CGM2-1 Fitting')
parser.add_argument(
'--proj',
type=str,
help='Moment Projection. Choice : Distal, Proximal, Global')
parser.add_argument('-md',
'--markerDiameter',
type=float,
help='marker diameter')
parser.add_argument('-ps',
'--pointSuffix',
type=str,
help='suffix of model outputs')
parser.add_argument('--check',
action='store_true',
help='force model output suffix')
args = parser.parse_args()
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH +
"CGM2_1-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_1-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM2_1-pyCGM2.settings")
# --------------------------CONFIG ------------------------------------
argsManager = CgmArgsManager.argsManager_cgm(settings, args)
markerDiameter = argsManager.getMarkerDiameter()
pointSuffix = argsManager.getPointSuffix("cgm2.1")
momentProjection = argsManager.getMomentProjection()
# --------------------------LOADING ------------------------------------
DATA_PATH, reconstructFilenameLabelledNoExt = NEXUS.GetTrialName()
reconstructFilenameLabelled = reconstructFilenameLabelledNoExt + ".c3d"
logging.info("data Path: " + DATA_PATH)
logging.info("calibration file: " + reconstructFilenameLabelled)
# --------------------------SUBJECT ------------------------------------
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.checkActivatedSubject(NEXUS, subjects)
logging.info("Subject name : " + subject)
# --------------------pyCGM2 MODEL ------------------------------
model = files.loadModel(DATA_PATH, subject)
# check model
logging.info("loaded model : %s" % (model.version))
if model.version != "CGM2.1":
raise Exception(
"%s-pyCGM2.model file was not calibrated from the CGM2.1 calibration pipeline"
% subject)
# --------------------------SESSION INFOS ------------------------------------
# translators management
translators = files.getTranslators(DATA_PATH, "CGM2_1.translators")
if not translators: translators = settings["Translators"]
#force plate assignement from Nexus
mfpa = nexusTools.getForcePlateAssignment(NEXUS)
# btkAcq builder
nacf = nexusFilters.NexusConstructAcquisitionFilter(
DATA_PATH, reconstructFilenameLabelledNoExt, subject)
acq = nacf.build()
# --------------------------MODELLING PROCESSING -----------------------
acqGait = cgm2_1.fitting(model,
DATA_PATH,
reconstructFilenameLabelled,
translators,
markerDiameter,
pointSuffix,
mfpa,
momentProjection,
forceBtkAcq=acq)
# ----------------------DISPLAY ON VICON-------------------------------
nexusFilters.NexusModelFilter(NEXUS, model, acqGait, subject,
pointSuffix).run()
nexusTools.createGeneralEvents(NEXUS, subject, acqGait,
["Left-FP", "Right-FP"])
# ========END of the nexus OPERATION if run from Nexus =========
else:
raise Exception("NO Nexus connection. Turn on Nexus")
elif model.version == "CGM2.4":
settings = files.openJson(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_4-pyCGM2.settings")
elif model.version == "CGM2.4e":
settings = files.openJson(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_4-Expert-pyCGM2.settings")
else:
raise Exception("model version not found [contact admin]")
# --------------------------SESSION INFOS ------------------------------------
mpInfo, mpFilename = files.getJsonFileContent(DATA_PATH, "mp.pyCGM2",
subject)
# translators management
if model.version in ["CGM2.3", "CGM2.3e"]:
translators = files.getTranslators(DATA_PATH, "CGM2-3.translators")
elif model.version in ["CGM2.4", "CGM2.4e"]:
translators = files.getTranslators(DATA_PATH, "CGM2-4.translators")
if not translators:
translators = settings["Translators"]
# --------------------------MODEL PROCESSING----------------------------
model, acqFunc, side = kneeCalibration.sara(model, DATA_PATH,
reconstructFilenameLabelled,
translators, args.side,
args.beginFrame, args.endFrame)
if side == "Left":
logging.warning(
"offset %s" %
(str(model.mp_computed["LeftKneeFuncCalibrationOffset"])))
DATA_PATH = pyCGM2.TEST_DATA_PATH + "CGM1\\CGM1\\native\\"
calibrateFilenameLabelled = "static.c3d"
subject = "MRI-US-01 - Pig"
args.fileSuffix="cgm1"
else:
DATA_PATH =os.getcwd()+"\\"
calibrateFilenameLabelled = args.trial
logging.info( "data Path: "+ DATA_PATH )
logging.info( "calibration file: "+ calibrateFilenameLabelled)
# --------------------------SUBJECT ------------------------------------
# translators management
translators = files.getTranslators(DATA_PATH,"CGM1.translators")
if not translators: translators = settings["Translators"]
# --------------------------SUBJECT ------------------------------------
if os.path.isfile(DATA_PATH+subject+".vsk"):
logging.info("vsk file found")
vsk = vskTools.Vsk(str(DATA_PATH + subject+".vsk"))
required_mp,optional_mp = vskTools.getFromVskSubjectMp(vsk, resetFlag=args.resetMP)
mpInfo,mpFilename = files.getJsonFileContent(DATA_PATH,"mp.pyCGM2",subject)
else:
logging.info("no vsk found")
mpInfo,mpFilename = files.getJsonFileContent(DATA_PATH,"mp.pyCGM2",subject)
required_mp,optional_mp = files.getMp(mpInfo, resetFlag=args.resetMP)
#---------------------------------------------------------------------------
# --------------------------MODELLING PROCESSING ---------------------------
def test_getTranslators(self):
translators = files.getTranslators(pyCGM2.TEST_DATA_PATH +
"\\LowLevel\\IO\\Hanibal_files\\",
translatorType="CGM1.translators")
assert translators != False
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 main(args):
NEXUS = ViconNexus.ViconNexus()
NEXUS_PYTHON_CONNECTED = NEXUS.Client.IsConnected()
if NEXUS_PYTHON_CONNECTED: # run Operation
# --------------------GLOBAL SETTINGS ------------------------------
# ( in user/AppData)
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")
argsManager = CgmArgsManager.argsManager_cgm(settings, args)
leftFlatFoot = argsManager.getLeftFlatFoot()
rightFlatFoot = argsManager.getRightFlatFoot()
headFlat = argsManager.getHeadFlat()
markerDiameter = argsManager.getMarkerDiameter()
pointSuffix = argsManager.getPointSuffix("cgm2.5")
ik_flag = argsManager.enableIKflag()
hjcMethod = settings["Calibration"]["HJC"]
lhjc = argsManager.forceHjc("left")
rhjc = argsManager.forceHjc("right")
if lhjc is not None:
hjcMethod["Left"] = lhjc
if rhjc is not None:
hjcMethod["Right"] = rhjc
# --------------------------LOADING------------------------------
DATA_PATH, calibrateFilenameLabelledNoExt = NEXUS.GetTrialName()
calibrateFilenameLabelled = calibrateFilenameLabelledNoExt + ".c3d"
logging.info("data Path: " + DATA_PATH)
logging.info("calibration file: " + calibrateFilenameLabelled)
# --------------------------SUBJECT -----------------------------------
# Notice : Work with ONE subject by session
subjects = NEXUS.GetSubjectNames()
subject = nexusTools.checkActivatedSubject(NEXUS, subjects)
Parameters = NEXUS.GetSubjectParamNames(subject)
required_mp, optional_mp = nexusUtils.getNexusSubjectMp(
NEXUS, subject, resetFlag=args.resetMP)
# --------------------------SESSION INFOS -----------------------------
# --------------------------SESSIONS INFOS -----------------------------------
mpInfo, mpFilename = files.getMpFileContent(DATA_PATH, "mp.pyCGM2",
subject)
# translators management
translators = files.getTranslators(DATA_PATH, "CGM2_5.translators")
if not translators: translators = settings["Translators"]
# btkAcq builder
nacf = nexusFilters.NexusConstructAcquisitionFilter(
DATA_PATH, calibrateFilenameLabelledNoExt, subject)
acq = nacf.build()
# --------------------------CONFIG ------------------------------------
model, finalAcqStatic = cgm2_5.calibrate(DATA_PATH,
calibrateFilenameLabelled,
translators,
settings,
required_mp,
optional_mp,
ik_flag,
leftFlatFoot,
rightFlatFoot,
headFlat,
markerDiameter,
hjcMethod,
pointSuffix,
forceBtkAcq=acq)
# ----------------------SAVE-------------------------------------------
files.saveModel(model, DATA_PATH, subject)
# save mp
files.saveMp(mpInfo, model, DATA_PATH, mpFilename)
# ----------------------DISPLAY ON VICON-------------------------------
nexusUtils.updateNexusSubjectMp(NEXUS, model, subject)
nexusFilters.NexusModelFilter(NEXUS,
model,
finalAcqStatic,
subject,
pointSuffix,
staticProcessing=True).run()
# ========END of the nexus OPERATION if run from Nexus =========
else:
raise Exception("NO Nexus connection. Turn on Nexus")
def main():
logging.info("------------------------------------------------")
logging.info("------------QTM - pyCGM2 Workflow---------------")
logging.info("------------------------------------------------")
file = "session.xml"
sessionXML = files.readXml(os.getcwd() + "\\", file)
sessionDate = files.getFileCreationDate(os.getcwd() + "\\" + file)
# ---------------------------------------------------------------------------
# management of the Processed folder
DATA_PATH = os.getcwd() + "\\" + "processed\\"
files.createDir(DATA_PATH)
staticMeasurement = utils.find_static(sessionXML)
calibrateFilenameLabelled = qtmTools.getFilename(staticMeasurement)
if not os.path.isfile(DATA_PATH + calibrateFilenameLabelled):
shutil.copyfile(os.getcwd() + "\\" + calibrateFilenameLabelled,
DATA_PATH + calibrateFilenameLabelled)
logging.info(
"qualisys exported c3d file [%s] copied to processed folder" %
(calibrateFilenameLabelled))
dynamicMeasurements = qtmTools.findDynamic(sessionXML)
for dynamicMeasurement in dynamicMeasurements:
reconstructFilenameLabelled = qtmTools.getFilename(dynamicMeasurement)
if not os.path.isfile(DATA_PATH + reconstructFilenameLabelled):
shutil.copyfile(os.getcwd() + "\\" + reconstructFilenameLabelled,
DATA_PATH + reconstructFilenameLabelled)
logging.info(
"qualisys exported c3d file [%s] copied to processed folder" %
(reconstructFilenameLabelled))
acq = btkTools.smartReader(
str(DATA_PATH + reconstructFilenameLabelled))
if btkTools.checkForcePlateExist(acq):
if "5" in btkTools.smartGetMetadata(acq, "FORCE_PLATFORM",
"TYPE"):
forceplates.correctForcePlateType5(acq)
acq, zeniState = eventDetector.zeni(acq)
if zeniState:
btkTools.smartWriter(
acq, str(DATA_PATH + reconstructFilenameLabelled))
cmd = "Mokka.exe \"%s\"" % (str(DATA_PATH +
reconstructFilenameLabelled))
os.system(cmd)
# --------------------------GLOBAL SETTINGS ------------------------------------
# global setting ( in user/AppData)
if os.path.isfile(pyCGM2.PYCGM2_APPDATA_PATH + "CGM2_2-pyCGM2.settings"):
settings = files.openFile(pyCGM2.PYCGM2_APPDATA_PATH,
"CGM2_2-pyCGM2.settings")
else:
settings = files.openFile(pyCGM2.PYCGM2_SETTINGS_FOLDER,
"CGM2_2-pyCGM2.settings")
# --------------------------MP ------------------------------------
required_mp, optional_mp = qtmTools.SubjectMp(sessionXML)
# --Check MP
inspectprocedure = inspectProcedures.AnthropometricDataQualityProcedure(
required_mp)
inspector = inspectFilters.QualityFilter(inspectprocedure)
inspector.run()
# translators management
translators = files.getTranslators(os.getcwd() + "\\",
"CGM2_2.translators")
if not translators:
translators = settings["Translators"]
# ikweight
ikWeight = files.getIKweightSet(DATA_PATH, "CGM2_2.ikw")
if not ikWeight:
ikWeight = settings["Fitting"]["Weight"]
# --------------------------MODEL CALIBRATION -----------------------
logging.info(
"--------------------------MODEL CALIBRATION -----------------------")
staticMeasurement = utils.find_static(sessionXML)
calibrateFilenameLabelled = qtmTools.getFilename(staticMeasurement)
logging.info("----- CALIBRATION- static file [%s]--" %
(calibrateFilenameLabelled))
leftFlatFoot = toBool(
staticMeasurement.Left_foot_normalised_to_static_trial.text)
rightFlatFoot = toBool(
staticMeasurement.Right_foot_normalised_to_static_trial.text)
headFlat = toBool(staticMeasurement.Head_normalised_to_static_trial.text)
markerDiameter = float(staticMeasurement.Marker_diameter.text) * 1000.0
hjcMethod = settings["Calibration"]["HJC"]
pointSuffix = None
# Calibration checking
# --------------------
acqStatic = btkTools.smartReader(DATA_PATH + calibrateFilenameLabelled)
for key in MARKERSETS.keys():
logging.info("[pyCGM2] Checking of the %s" % (key))
# presence
ip_presence = inspectProcedures.MarkerPresenceQualityProcedure(
acqStatic, markers=MARKERSETS[key])
inspector = inspectFilters.QualityFilter(ip_presence)
inspector.run()
if ip_presence.markersIn != []:
ip_gap = inspectProcedures.GapQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_gap)
inspector.run()
ip_swap = inspectProcedures.SwappingMarkerQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_swap)
inspector.run()
ip_pos = inspectProcedures.MarkerPositionQualityProcedure(
acqStatic, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_pos)
# Calibration operation
# --------------------
logging.info("[pyCGM2] --- calibration operation ---")
model, acqStatic = cgm2_2.calibrate(DATA_PATH, calibrateFilenameLabelled,
translators, settings, required_mp,
optional_mp, False, leftFlatFoot,
rightFlatFoot, headFlat,
markerDiameter, hjcMethod, pointSuffix)
logging.info("----- CALIBRATION- static file [%s]-----> DONE" %
(calibrateFilenameLabelled))
# --------------------------MODEL FITTING ----------------------------------
logging.info(
"--------------------------MODEL FITTING ----------------------------------"
)
dynamicMeasurements = qtmTools.findDynamic(sessionXML)
modelledC3ds = list()
eventInspectorStates = list()
for dynamicMeasurement in dynamicMeasurements:
reconstructFilenameLabelled = qtmTools.getFilename(dynamicMeasurement)
logging.info("----Processing of [%s]-----" %
(reconstructFilenameLabelled))
mfpa = qtmTools.getForcePlateAssigment(dynamicMeasurement)
momentProjection_text = dynamicMeasurement.Moment_Projection.text
if momentProjection_text == "Default":
momentProjection_text = settings["Fitting"]["Moment Projection"]
if momentProjection_text == "Distal":
momentProjection = enums.MomentProjection.Distal
elif momentProjection_text == "Proximal":
momentProjection = enums.MomentProjection.Proximal
elif momentProjection_text == "Global":
momentProjection = enums.MomentProjection.Global
elif momentProjection_text == "JCS":
momentProjection = enums.MomentProjection.JCS
acq = btkTools.smartReader(DATA_PATH + reconstructFilenameLabelled)
# Fitting checking
# --------------------
for key in MARKERSETS.keys():
if key != "Calibration markers":
logging.info("[pyCGM2] Checking of the %s" % (key))
# presence
ip_presence = inspectProcedures.MarkerPresenceQualityProcedure(
acq, markers=MARKERSETS[key])
inspector = inspectFilters.QualityFilter(ip_presence)
inspector.run()
if ip_presence.markersIn != []:
ip_gap = inspectProcedures.GapQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_gap)
inspector.run()
ip_swap = inspectProcedures.SwappingMarkerQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_swap)
inspector.run()
ip_pos = inspectProcedures.MarkerPositionQualityProcedure(
acq, markers=ip_presence.markersIn)
inspector = inspectFilters.QualityFilter(ip_pos)
# filtering
# -----------------------
# marker
order = int(float(dynamicMeasurement.Marker_lowpass_filter_order.text))
fc = float(dynamicMeasurement.Marker_lowpass_filter_frequency.text)
signal_processing.markerFiltering(acq, order=order, fc=fc)
# management of force plate type 5 and force plate filtering
order = int(
float(dynamicMeasurement.Forceplate_lowpass_filter_order.text))
fc = float(dynamicMeasurement.Forceplate_lowpass_filter_frequency.text)
if order != 0 and fc != 0:
acq = btkTools.smartReader(DATA_PATH + reconstructFilenameLabelled)
if btkTools.checkForcePlateExist(acq):
if "5" in btkTools.smartGetMetadata(acq, "FORCE_PLATFORM",
"TYPE"):
forceplates.correctForcePlateType5(acq)
signal_processing.markerFiltering(acq, order=order, fc=fc)
else:
if btkTools.checkForcePlateExist(acq):
if "5" in btkTools.smartGetMetadata(acq, "FORCE_PLATFORM",
"TYPE"):
forceplates.correctForcePlateType5(acq)
btkTools.smartWriter(acq, DATA_PATH + reconstructFilenameLabelled)
# event checking
# -----------------------
inspectprocedureEvents = inspectProcedures.GaitEventQualityProcedure(
acq)
inspector = inspectFilters.QualityFilter(inspectprocedureEvents)
inspector.run()
eventInspectorStates.append(inspectprocedureEvents.state)
# fitting operation
# -----------------------
logging.info("[pyCGM2] --- Fitting operation ---")
acqGait = cgm2_2.fitting(model, DATA_PATH, reconstructFilenameLabelled,
translators, settings, markerDiameter,
pointSuffix, mfpa, momentProjection)
outFilename = reconstructFilenameLabelled # [:-4] + "_CGM1.c3d"
btkTools.smartWriter(acqGait, str(DATA_PATH + outFilename))
modelledC3ds.append(outFilename)
logging.info("----Processing of [%s]-----> DONE" %
(reconstructFilenameLabelled))
# --------------------------GAIT PROCESSING -----------------------
if not all(eventInspectorStates):
raise Exception(
"[pyCGM2] Impossible to run Gait processing. Badly gait event detection. check the log file"
)
logging.info(
"---------------------GAIT PROCESSING -----------------------")
return model
def modelling(manager,DATA_PATH,DATA_PATH_OUT,vskFile=None):
modelVersion = manager.getModelVersion()
logging.info("model version : %s" %(modelVersion))
# --------------------------MODELLING ------------------------------------
# manage global settings and translators
if modelVersion == "CGM1.0":
translatorFiles= "CGM1.translators"
globalPyCGM2settingFile = "CGM1-pyCGM2.settings"
elif modelVersion == "CGM1.1":
translatorFiles= "CGM1_1.translators"
globalPyCGM2settingFile = "CGM1_1-pyCGM2.settings"
elif modelVersion == "CGM2.1":
translatorFiles= "CGM2_1.translators"
globalPyCGM2settingFile = "CGM2_1-pyCGM2.settings"
elif modelVersion == "CGM2.2":
translatorFiles= "CGM2_2.translators"
globalPyCGM2settingFile = "CGM2_2-pyCGM2.settings"
elif modelVersion == "CGM2.2e":
translatorFiles= "CGM2_2.translators"
globalPyCGM2settingFile = "CGM2_2-Expert-pyCGM2.settings"
elif modelVersion == "CGM2.3":
translatorFiles= "CGM2_3.translators"
globalPyCGM2settingFile = "CGM2_3-pyCGM2.settings"
elif modelVersion == "CGM2.3e":
translatorFiles= "CGM2_3.translators"
globalPyCGM2settingFile = "CGM2_3-Expert-pyCGM2.settings"
elif modelVersion == "CGM2.4":
translatorFiles= "CGM2_4.translators"
globalPyCGM2settingFile = "CGM2_4-pyCGM2.settings"
elif modelVersion == "CGM2.4e":
translatorFiles= "CGM2_4.translators"
globalPyCGM2settingFile = "CGM2_4-Expert-pyCGM2.settings"
else:
raise Exception( "model version not known")
settings = files.openJson(pyCGM2.PYCGM2_APPDATA_PATH,globalPyCGM2settingFile)
translators = files.getTranslators(DATA_PATH,translatorFiles)
if not translators: translators = settings["Translators"]
# mp file
if vskFile is None:
logging.info("mp from pipeline file")
required_mp,optional_mp = manager.getMP()
else:
logging.warning("mp from vsk file")
vsk = vskTools.Vsk(str(DATA_PATH + vskFile))
required_mp,optional_mp = vskTools.getFromVskSubjectMp(vsk, resetFlag=True)
fileSuffix = manager.getFileSuffix()
pointSuffix = manager.getPointSuffix()
ik_flag = manager.isIkFitting()
#------calibration--------
leftFlatFoot = manager.getLeftFlatFoot()
rightFlatFoot = manager.getRightFlatFoot()
markerDiameter = manager.getMarkerDiameter()
calibrateFilenameLabelled = manager.getStaticTial()
if modelVersion == "CGM1.0":
model,finalAcqStatic = cgm1.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,required_mp,optional_mp,
leftFlatFoot,rightFlatFoot,markerDiameter,
pointSuffix)
elif modelVersion == "CGM1.1":
model,finalAcqStatic = cgm1_1.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,required_mp,optional_mp,
leftFlatFoot,rightFlatFoot,markerDiameter,
pointSuffix)
elif modelVersion == "CGM2.1":
hjcMethods = manager.getHJC()
hjcMethods["Left"] = "Hara" if hjcMethods["Left"] == [] else hjcMethods["Left"]
hjcMethods["Right"] = "Hara" if hjcMethods["Right"] == [] else hjcMethods["Right"]
model,finalAcqStatic = cgm2_1.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,required_mp,optional_mp,
leftFlatFoot,rightFlatFoot,markerDiameter,hjcMethods,
pointSuffix)
elif modelVersion == "CGM2.2":
hjcMethods = manager.getHJC()
hjcMethods["Left"] = "Hara" if hjcMethods["Left"] == [] else hjcMethods["Left"]
hjcMethods["Right"] = "Hara" if hjcMethods["Right"] == [] else hjcMethods["Right"]
model,finalAcqStatic = cgm2_2.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,settings,
required_mp,optional_mp,
True,leftFlatFoot,rightFlatFoot,markerDiameter,hjcMethods,
pointSuffix)
elif modelVersion == "CGM2.2e":
hjcMethods = manager.getHJC()
hjcMethods["Left"] = "Hara" if hjcMethods["Left"] == [] else hjcMethods["Left"]
hjcMethods["Right"] = "Hara" if hjcMethods["Right"] == [] else hjcMethods["Right"]
model,finalAcqStatic = cgm2_2e.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,settings,
required_mp,optional_mp,
True,leftFlatFoot,rightFlatFoot,markerDiameter,hjcMethods,
pointSuffix)
elif modelVersion == "CGM2.3":
hjcMethods = manager.getHJC()
hjcMethods["Left"] = "Hara" if hjcMethods["Left"] == [] else hjcMethods["Left"]
hjcMethods["Right"] = "Hara" if hjcMethods["Right"] == [] else hjcMethods["Right"]
model,finalAcqStatic = cgm2_3.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,settings,
required_mp,optional_mp,
ik_flag,leftFlatFoot,rightFlatFoot,markerDiameter,hjcMethods,
pointSuffix)
elif modelVersion == "CGM2.3e":
hjcMethods = manager.getHJC()
hjcMethods["Left"] = "Hara" if hjcMethods["Left"] == [] else hjcMethods["Left"]
hjcMethods["Right"] = "Hara" if hjcMethods["Right"] == [] else hjcMethods["Right"]
model,finalAcqStatic = cgm2_3e.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,settings,
required_mp,optional_mp,
ik_flag,leftFlatFoot,rightFlatFoot,markerDiameter,hjcMethods,
pointSuffix)
elif modelVersion == "CGM2.4":
hjcMethods = manager.getHJC()
hjcMethods["Left"] = "Hara" if hjcMethods["Left"] == [] else hjcMethods["Left"]
hjcMethods["Right"] = "Hara" if hjcMethods["Right"] == [] else hjcMethods["Right"]
model,finalAcqStatic = cgm2_4.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,settings,
required_mp,optional_mp,
ik_flag,leftFlatFoot,rightFlatFoot,markerDiameter,hjcMethods,
pointSuffix)
elif modelVersion == "CGM2.4e":
hjcMethods = manager.getHJC()
hjcMethods["Left"] = "Hara" if hjcMethods["Left"] == [] else hjcMethods["Left"]
hjcMethods["Right"] = "Hara" if hjcMethods["Right"] == [] else hjcMethods["Right"]
model,finalAcqStatic = cgm2_4e.calibrate(DATA_PATH,calibrateFilenameLabelled,translators,settings,
required_mp,optional_mp,
ik_flag,leftFlatFoot,rightFlatFoot,markerDiameter,hjcMethods,
pointSuffix)
btkTools.smartWriter(finalAcqStatic, str(DATA_PATH_OUT+"calibrated.c3d"))
logging.info("Static Calibration -----> Done")
# knee calibration
leftEnable = manager.isKneeCalibrationEnable("Left")
rightEnable = manager.isKneeCalibrationEnable("Right")
if leftEnable:
method, trial,begin,end,jointRange = manager.getKneeCalibration("Left")
if method == "Calibration2Dof":
model,acqFunc,side = kneeCalibration.calibration2Dof(model,
DATA_PATH,trial,translators,
"Left",begin,end,jointRange)
logging.info("Left knee Calibration (Calibration2Dof) -----> Done")
elif method == "SARA":
model,acqFunc,side = kneeCalibration.sara(model,
DATA_PATH,trial,translators,
"Left",begin,end)
logging.info("Left knee Calibration (SARA) -----> Done")
if rightEnable:
method, trial,begin,end,jointRange = manager.getKneeCalibration("Right")
if method == "Calibration2Dof":
model,acqFunc,side = kneeCalibration.calibration2Dof(model,
DATA_PATH,trial,translators,
"Right",begin,end,jointRange)
logging.info("Right knee Calibration (Calibration2Dof) -----> Done")
elif method == "SARA":
model,acqFunc,side = kneeCalibration.sara(model,
DATA_PATH,trial,translators,
"Right",begin,end)
logging.info("Right knee Calibration (SARA) -----> Done")
# update mp
manager.updateMp(model)
# save settings
if manager.m_pipelineFile is not None:
manager.save(DATA_PATH,str( manager.m_pipelineFile+"-saved"))
logging.info("pipeline file -----> Save")
# Fitting
trials = manager.getFittingTrials()
momentProjection = manager.getMomentProjection()
if modelVersion not in ["CGM1.0", "CGM1.1", "CGM2.1"]:
ikwf = manager.getIkWeightFile()
if ikwf is not None:
ikWeight = files.openJson(DATA_PATH,ikwf)
settings["Fitting"]["Weight"]=ikWeight["Weight"]
for trial in trials:
mfpa = None if trial["Mfpa"] == "Auto" else trial["Mfpa"]
reconstructFilenameLabelled = trial["File"]
if modelVersion == "CGM1.0":
acqGait = cgm1.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,
markerDiameter,
pointSuffix,
mfpa,momentProjection)
elif modelVersion == "CGM1.1":
acqGait = cgm1_1.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,
markerDiameter,
pointSuffix,
mfpa,momentProjection)
elif modelVersion == "CGM2.1":
acqGait = cgm2_1.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,
markerDiameter,
pointSuffix,
mfpa,momentProjection)
elif modelVersion == "CGM2.2":
acqGait = cgm2_2.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,settings,
markerDiameter,
pointSuffix,
mfpa,
momentProjection)
elif modelVersion == "CGM2.2e":
acqGait = cgm2_2e.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,settings,
markerDiameter,
pointSuffix,
mfpa,
momentProjection)
elif modelVersion == "CGM2.3":
acqGait = cgm2_3.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,settings,
ik_flag,markerDiameter,
pointSuffix,
mfpa,
momentProjection)
elif modelVersion == "CGM2.3e":
acqGait = cgm2_3e.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,settings,
ik_flag,markerDiameter,
pointSuffix,
mfpa,
momentProjection)
elif modelVersion == "CGM2.4":
acqGait = cgm2_4.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,settings,
ik_flag,markerDiameter,
pointSuffix,
mfpa,
momentProjection)
elif modelVersion == "CGM2.4e":
acqGait = cgm2_4e.fitting(model,DATA_PATH, reconstructFilenameLabelled,
translators,settings,
ik_flag,markerDiameter,
pointSuffix,
mfpa,
momentProjection)
logging.info("Fitting -----> Done")
if fileSuffix is not None:
c3dFilename = str(reconstructFilenameLabelled[:-4]+"-modelled-"+fileSuffix+".c3d")
else:
c3dFilename = str(reconstructFilenameLabelled[:-4]+"-modelled.c3d")
btkTools.smartWriter(acqGait, str(DATA_PATH_OUT+c3dFilename))
logging.info("c3d file (%s) generated" %(c3dFilename) )
