def twoPF_FP1left_FP2right(cls):
MAIN_PATH = pyCGM2.TEST_DATA_PATH + "operations\\forceplates\\FootAssignementAutoamticGeneralEvent\\"
# --- Motion 1
gaitFilename = "MRI-US-01, 2008-08-08, 3DGA 13.c3d"
acqGait = btkTools.smartReader(str(MAIN_PATH + gaitFilename))
#forceplates.appendForcePlateCornerAsMarker(acqGait)
mappedForcePlate = forceplates.matchingFootSideOnForceplate(acqGait)
forceplates.addForcePlateGeneralEvents(acqGait, "LR")
btkTools.smartWriter(acqGait,
str(MAIN_PATH + "twoPF_FP1left_FP2right.c3d"))
modelledFilenames = ["twoPF_FP1left_FP2right.c3d"]
#---- GAIT CYCLES FILTER PRELIMARIES
#--------------------------------------------------------------------------
# distinguishing trials for kinematic and kinetic processing
# - kinematic Trials
kinematicTrials = []
kinematicFilenames = []
for kinematicFilename in modelledFilenames:
kinematicFileNode = ma.io.read(str(MAIN_PATH + kinematicFilename))
kinematicTrial = kinematicFileNode.findChild(ma.T_Trial)
trialTools.sortedEvents(kinematicTrial)
longitudinalAxis, forwardProgression, globalFrame = trialTools.findProgression(
kinematicTrial, "LHEE")
kinematicTrials.append(kinematicTrial)
kinematicFilenames.append(kinematicFilename)
# - kinetic Trials ( check if kinetic events)
kineticTrials, kineticFilenames, flag_kinetics = trialTools.automaticKineticDetection(
MAIN_PATH, modelledFilenames)
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=kinematicTrials,
kinematicTrials=kinematicTrials,
kineticTrials=kineticTrials,
emgTrials=None)
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
# TESTING
np.testing.assert_equal(len(cycles.kineticCycles), 2)
np.testing.assert_equal(cycles.kineticCycles[0].context, "Left")
np.testing.assert_equal(cycles.kineticCycles[0].begin, 253)
np.testing.assert_equal(cycles.kineticCycles[1].context, "Right")
np.testing.assert_equal(cycles.kineticCycles[1].begin, 201)
def detailedProcess_labelNotInTrial(cls):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH + "operations\\analysis\\gait\\"
modelledFilenames = ["gait Trial 03 - viconName.c3d"]
#---- c3d manager
#--------------------------------------------------------------------------
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(
DATA_PATH, modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableEmg(False)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#---- GAIT ANALYSIS FILTER
#--------------------------------------------------------------------------
# ----INFOS-----
modelInfo = {"type": "S01"}
subjectInfo = None
experimentalInfo = None
kinematicLabelsDict = {
'Left':
["LHipAngles", "LKneeAngles", "LAnkleAngles", "LForeFootAngles"],
'Right': ["RHipAngles", "RKneeAngles", "RAnkleAngles"]
}
kineticLabelsDict = None #{ 'Left': ["LHipMoment","LKneeMoment"],
#'Right': ["RHipMoment","RKneeMoment"]}
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.setInfo(model=modelInfo)
analysisFilter.build()
analysisInstance = analysisFilter.analysis
def make_analysis(trialManager,
kinematicLabelsDict,
kineticLabelsDict,
modelInfo,
subjectInfo,
experimentalInfo,
pointLabelSuffix=""):
"""
build a Analysis instance
:Parameters:
- `cgmSkeletonEnum` (pyCGM2.enums) - type of skeleton used
- `trialManager` (pyCGM2.Processing.c3dManager.C3dManager) - organization of inputed c3d
- `modelInfo` (dict) - info about the model
- `subjectInfo` (dict) - info about the subject
- `experimentalInfo` (dict) - info about experimental conditions
- `pointLabelSuffix` (str) - suffix added to standard cgm nomenclature
:Return:
- `NoName` (pyCGM2.Processing.analysis.Analysis) - Analysis instance
"""
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.CyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#---- GAIT ANALYSIS FILTER
#--------------------------------------------------------------------------
analysisBuilder = analysis.AnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
pointlabelSuffix=pointLabelSuffix)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setInfo(subject=subjectInfo,
model=modelInfo,
experimental=experimentalInfo)
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.build()
return analysisFilter.analysis
def test_envelopPlotSingleEmg(self):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH+"GaitData\\EMG\\Hånnibøl Lecter-nerve block\\"
gaitTrial = "PRE-gait trial 01.c3d"
restTrial = "PRE-repos.c3d"
DATA_PATH_OUT = pyCGM2.TEST_DATA_PATH_OUT+"GaitData\\EMG\\Hånnibøl Lecter-nerve block\\"
files.createDir(DATA_PATH_OUT)
EMG_LABELS=['EMG1','EMG2']
acq = btkTools.smartReader(DATA_PATH +gaitTrial)
bf = emgFilters.BasicEmgProcessingFilter(acq,EMG_LABELS)
bf.setHighPassFrequencies(20.0,200.0)
bf.run()
envf = emgFilters.EmgEnvelopProcessingFilter(acq,EMG_LABELS)
envf.setCutoffFrequency(180.0)
envf.run()
btkTools.smartWriter(acq,DATA_PATH_OUT+"test_envelopPlotSingleEmg.c3d")
modelledFilenames = ["test_envelopPlotSingleEmg.c3d"]
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(DATA_PATH_OUT,modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableSpatioTemporal(False)
cmf.enableKinematic(False)
cmf.enableKinetic(False)
cmf.enableEmg(True)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials = trialManager.kinematic["Trials"],
kineticTrials = trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
modelInfo=None
subjectInfo=None
experimentalInfo=None
analysisBuilder = analysis.GaitAnalysisBuilder(cycles,
kinematicLabelsDict = None,
kineticLabelsDict = None,
emgLabelList = ['EMG1_Rectify_Env','EMG2_Rectify_Env'],
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.setInfo(model = modelInfo)
analysisFilter.build()
analysisInstance = analysisFilter.analysis
envnf = emgFilters.EmgNormalisationProcessingFilter(analysisInstance,"EMG1","Left")
envnf.setMaxMethod(enums.EmgAmplitudeNormalization.MeanMax)
envnf.run()
fig = plt.figure()
ax = plt.gca()
plot.gaitDescriptivePlot(ax,analysisInstance.emgStats,
"EMG1_Rectify_Env","Left",0,
color=None,
title="title", xlabel=None, ylabel=None,ylim=None,legendLabel=None,
customLimits=None)
footOff = analysisInstance.emgStats.pst['stancePhase', "Left"]["mean"]
plot.addNormalActivationLayer(ax,"RECFEM", footOff)
def test_envelopGaitPlotPanel(self):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH+"GaitData\\EMG\\Hånnibøl Lecter-nerve block\\"
gaitTrial = "PRE-gait trial 01.c3d"
restTrial = "PRE-repos.c3d"
DATA_PATH_OUT = pyCGM2.TEST_DATA_PATH_OUT+"GaitData\\EMG\\Hånnibøl Lecter-nerve block\\"
files.createDir(DATA_PATH_OUT)
EMG_LABELS=['EMG1','EMG2']
acq = btkTools.smartReader(DATA_PATH +gaitTrial)
bf = emgFilters.BasicEmgProcessingFilter(acq,EMG_LABELS)
bf.setHighPassFrequencies(20.0,200.0)
bf.run()
envf = emgFilters.EmgEnvelopProcessingFilter(acq,EMG_LABELS)
envf.setCutoffFrequency(180.0)
envf.run()
btkTools.smartWriter(acq,DATA_PATH_OUT+"test_envelopGaitPlotPanel.c3d")
modelledFilenames = ["test_envelopGaitPlotPanel.c3d"]
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(DATA_PATH_OUT,modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableSpatioTemporal(False)
cmf.enableKinematic(False)
cmf.enableKinetic(False)
cmf.enableEmg(True)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials = trialManager.kinematic["Trials"],
kineticTrials = trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
modelInfo=None
subjectInfo=None
experimentalInfo=None
analysisBuilder = analysis.GaitAnalysisBuilder(cycles,
kinematicLabelsDict = None,
kineticLabelsDict = None,
emgLabelList = ['EMG1_Rectify_Env','EMG2_Rectify_Env'],
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.setInfo(model = modelInfo)
analysisFilter.build()
analysisInstance = analysisFilter.analysis
envnf = emgFilters.EmgNormalisationProcessingFilter(analysisInstance,"EMG1","Right")
envnf.setMaxMethod(enums.EmgAmplitudeNormalization.MeanMax)
envnf.run()
envnf = emgFilters.EmgNormalisationProcessingFilter(analysisInstance,"EMG2","Right")
envnf.setMaxMethod(enums.EmgAmplitudeNormalization.MeanMax)
envnf.run()
data = analysisInstance.emgStats.data
# viewer
kv = emgPlotViewers.EnvEmgGaitPlotPanelViewer (analysisInstance)
kv.setEmgs([["EMG1","Right","rf"],["EMG2","Right","rf"]])
kv.setNormalActivationLabels(["RECFEM","RECFEM"])
kv.setConcretePlotFunction(plot.gaitDescriptivePlot)
# # filter
pf = plotFilters.PlottingFilter()
pf.setViewer(kv)
pf.plot()
def analysisAdvancedAndBasic_nonExistingLabel(cls):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH+"operations\\analysis\\gait\\"
modelledFilenames = ["gait Trial 03 - viconName.c3d","gait Trial 01 - viconName.c3d" ]
#---- c3d manager
#--------------------------------------------------------------------------
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(DATA_PATH,modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableEmg(False)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials = trialManager.kinematic["Trials"],
kineticTrials = trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#---- GAIT ANALYSIS FILTER
#--------------------------------------------------------------------------
# ----INFOS-----
modelInfo={"type":"S01"}
subjectInfo=None
experimentalInfo=None
kinematicLabelsDict ={ 'Left': ["LHipAngles","LKneeAngles","LAnkleAngles","LForeFootAngles"],
'Right': ["RHipAngles","RKneeAngles","RAnkleAngles"] }
kineticLabelsDict =None#{ 'Left': ["LHipMoment","LKneeMoment"],
#'Right': ["RHipMoment","RKneeMoment"]}
analysisBuilder = analysis.GaitAnalysisBuilder(cycles,
kinematicLabelsDict = kinematicLabelsDict,
kineticLabelsDict = kineticLabelsDict,
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.setInfo(model = modelInfo)
analysisFilter.build()
analysisInstance = analysisFilter.analysis
# ----INFOS-----
modelInfo={"Type":"cgm2", "hjc":"hara"}
subjectInfo={"Id":"1", "Name":"Lecter"}
experimentalInfo={"Condition":"Barefoot", "context":"block"}
exportFilter = exporter.XlsAnalysisExportFilter()
exportFilter.setAnalysisInstance(analysisInstance)
exportFilter.export("testAdvancedNan", path=DATA_PATH,excelFormat = "xls",mode="Advanced")
exportFilter2 = exporter.XlsAnalysisExportFilter()
exportFilter2.setAnalysisInstance(analysisInstance)
exportFilter2.export("testBasic2", path=DATA_PATH,excelFormat = "xls",mode="Basic")
def makeEmgAnalysis(DATA_PATH,
processedEmgFiles,
emgChannels,
subjectInfo=None,
experimentalInfo=None,
type="Gait",
openmaTrials=None):
"""
makeEmgAnalysis : create the pyCGM2.Processing.analysis.Analysis instance with only EMG signals
:param DATA_PATH [str]: path to your data
:param processedEmgFiles [string list]: c3d files with emg processed outputs
:param emgChannels [string list]: label of your emg channels
**optional**
:param subjectInfo [dict]: dictionnary gathering info about the patient (name,dob...)
:param experimentalInfo [dict]: dictionnary gathering info about the data session (orthosis, gait task,... )
:param type [str]: process files with gait events if selected type is Gait
:param openmaTrials [bool]: force the use of a list of openma trials
"""
if openmaTrials is not None:
c3dmanagerProcedure = c3dManager.UniqueOpenmaTrialSetProcedure(
DATA_PATH, processedEmgFiles, trials=openmaTrials)
else:
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(
DATA_PATH, processedEmgFiles)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableSpatioTemporal(False)
cmf.enableKinematic(False)
cmf.enableKinetic(False)
cmf.enableEmg(True)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
#----cycles
if type == "Gait":
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
else:
cycleBuilder = cycle.CyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
emgLabelList = [label + "_Rectify_Env" for label in emgChannels]
if type == "Gait":
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=None,
kineticLabelsDict=None,
emgLabelList=emgLabelList,
subjectInfos=subjectInfo,
modelInfos=None,
experimentalInfos=experimentalInfo)
else:
analysisBuilder = analysis.AnalysisBuilder(
cycles,
kinematicLabelsDict=None,
kineticLabelsDict=None,
emgLabelList=emgLabelList,
subjectInfos=subjectInfo,
modelInfos=None,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.build()
analysisInstance = analysisFilter.analysis
return analysisInstance
def makeAnalysis(DATA_PATH,
modelledFilenames,
type="Gait",
subjectInfo=None,
experimentalInfo=None,
modelInfo=None,
pointLabelSuffix=None,
kinematicLabelsDict=None,
kineticLabelsDict=None,
disableKinetics=False,
openmaTrials=None):
"""
makeAnalysis : create the pyCGM2.Processing.analysis.Analysis instance
:param DATA_PATH [str]: path to your data
:param modelledFilenames [string list]: c3d files with model outputs
**optional**
:param type [str]: process files with gait events if selected type is Gait
:param subjectInfo [dict]: dictionnary gathering info about the patient (name,dob...)
:param experimentalInfo [dict]: dictionnary gathering info about the data session (orthosis, gait task,... )
:param modelInfo [dict]: dictionnary gathering info about the used model)
:param pointLabelSuffix [string]: suffix previously added to your model outputs
:param kinematicLabelsDict [dict]: dictionnary with two entries,Left and Right, pointing to kinematic model outputs you desire processes
:param kineticLabelsDict [dict]: dictionnary with two entries,Left and Right, pointing to kinetic model outputs you desire processes
:param disableKinetics [bool]: disable kinetics processing
:param openmaTrials [bool]: force the use of a list of openma trials
.. note::
The dictionnaries (subjectInfo,experimentalInfo,modelInfo) is interesting
if you want to find these information within the xls file
"""
#---- c3d manager
if openmaTrials is not None:
c3dmanagerProcedure = c3dManager.UniqueOpenmaTrialSetProcedure(
DATA_PATH, modelledFilenames, trials=openmaTrials)
else:
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(
DATA_PATH, modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableEmg(False)
if disableKinetics: cmf.enableKinetic(False)
trialManager = cmf.generate()
#----cycles
if type == "Gait":
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
else:
cycleBuilder = cycle.CyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#----analysis
if kinematicLabelsDict is None:
kinematicLabelsDict = cgm.CGM.ANALYSIS_KINEMATIC_LABELS_DICT
if kineticLabelsDict is None:
kineticLabelsDict = cgm.CGM.ANALYSIS_KINETIC_LABELS_DICT
if type == "Gait":
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
pointlabelSuffix=pointLabelSuffix)
else:
analysisBuilder = analysis.AnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
pointlabelSuffix=pointLabelSuffix)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setInfo(subject=subjectInfo,
model=modelInfo,
experimental=experimentalInfo)
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.build()
return analysisFilter.analysis
def test_withData(cls):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH + "operations\\gaitDeviations\\gaitPig\\"
modelledFilenames = [
"gait Trial 01 - viconName.c3d", "gait Trial 03 - viconName.c3d"
]
# ----INFOS-----
modelInfo = None
subjectInfo = None
experimentalInfo = None
normativeDataSet = dict()
normativeDataSet["Author"] = "Schwartz2008"
normativeDataSet["Modality"] = "Free"
pointLabelSuffix = ""
#---- c3d manager
#--------------------------------------------------------------------------
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(
DATA_PATH, modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableEmg(False)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#---- GAIT ANALYSIS FILTER
#--------------------------------------------------------------------------
pointLabelSuffixPlus = pointLabelSuffix if pointLabelSuffix == "" else "_" + pointLabelSuffix
kinematicLabelsDict = {
'Left': [
str("LHipAngles" + pointLabelSuffixPlus),
str("LKneeAngles" + pointLabelSuffixPlus),
str("LAnkleAngles" + pointLabelSuffixPlus),
str("LFootProgressAngles" + pointLabelSuffixPlus),
str("LPelvisAngles" + pointLabelSuffixPlus)
],
'Right': [
str("RHipAngles" + pointLabelSuffixPlus),
str("RKneeAngles" + pointLabelSuffixPlus),
str("RAnkleAngles" + pointLabelSuffixPlus),
str("RFootProgressAngles" + pointLabelSuffixPlus),
str("RPelvisAngles" + pointLabelSuffixPlus)
]
}
kineticLabelsDict = {
'Left': [
str("LHipMoment" + pointLabelSuffixPlus),
str("LKneeMoment" + pointLabelSuffixPlus),
str("LAnkleMoment" + pointLabelSuffixPlus),
str("LHipPower" + pointLabelSuffixPlus),
str("LKneePower" + pointLabelSuffixPlus),
str("LAnklePower" + pointLabelSuffixPlus)
],
'Right': [
str("RHipMoment" + pointLabelSuffixPlus),
str("RKneeMoment" + pointLabelSuffixPlus),
str("RAnkleMoment" + pointLabelSuffixPlus),
str("RHipPower" + pointLabelSuffixPlus),
str("RKneePower" + pointLabelSuffixPlus),
str("RAnklePower" + pointLabelSuffixPlus)
]
}
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.build()
#---- Joint patterns
# xls Processing
RULES_PATH = pyCGM2.PYCGM2_SETTINGS_FOLDER + "jointPatterns\\"
rulesXls = RULES_PATH + "tests.xlsx"
jpp = jointPatterns.XlsJointPatternProcedure(rulesXls)
dpf = jointPatterns.JointPatternFilter(jpp, analysisFilter.analysis)
dataFrameValues = dpf.getValues()
dataFramePatterns = dpf.getPatterns()
def EnvelopCoactivationPlot(cls):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH + "EMG\\SampleNantes\\"
gaitTrial = "gait.c3d"
restTrial = "repos.c3d"
EMG_LABELS = ['EMG1', 'EMG2']
acq = btkTools.smartReader(DATA_PATH + gaitTrial)
bf = emgFilters.BasicEmgProcessingFilter(acq, EMG_LABELS)
bf.setHighPassFrequencies(20.0, 200.0)
bf.run()
envf = emgFilters.EmgEnvelopProcessingFilter(acq, EMG_LABELS)
envf.setCutoffFrequency(180.0)
envf.run()
btkTools.smartWriter(acq, DATA_PATH + "test.c3d")
modelledFilenames = ["test.c3d"]
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(
DATA_PATH, modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableSpatioTemporal(False)
cmf.enableKinematic(False)
cmf.enableKinetic(False)
cmf.enableEmg(True)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
modelInfo = None
subjectInfo = None
experimentalInfo = None
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=None,
kineticLabelsDict=None,
emgLabelList=['EMG1_Rectify_Env', 'EMG2_Rectify_Env'],
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.setInfo(model=modelInfo)
analysisFilter.build()
analysisInstance = analysisFilter.analysis
envnf = emgFilters.EmgNormalisationProcessingFilter(
analysisInstance, "EMG1", "Left")
envnf.setMaxMethod(enums.EmgAmplitudeNormalization.MeanMax)
envnf.run()
envnf = emgFilters.EmgNormalisationProcessingFilter(
analysisInstance, "EMG2", "Left")
envnf.setMaxMethod(enums.EmgAmplitudeNormalization.MeanMax)
envnf.run()
# viewer
kv = emgPlotViewers.CoactivationEmgPlotViewer(analysisInstance)
kv.setEmgs("EMG1", "EMG2")
kv.setMuscles("RF1", "RF2")
kv.setConcretePlotFunction(plot.gaitDescriptivePlot)
kv.setContext("Left")
# # filter
pf = plotFilters.PlottingFilter()
pf.setViewer(kv)
pf.plot()
plt.show()
def makeCGMGaitAnalysis(DATA_PATH,
modelledFilenames,
emgFilenames,
emgChannels,
subjectInfo=None,
experimentalInfo=None,
modelInfo=None,
pointLabelSuffix=None):
"""
makeCGMGaitAnalysis : create the pyCGM2.Processing.analysis.Analysis instance with modelled c3d and EMG c3d
"""
if modelledFilenames == []: modelledFilenames = None
if emgFilenames == []: emgFilenames = None
c3dmanagerProcedure = c3dManager.DistinctC3dSetProcedure(
DATA_PATH, modelledFilenames, modelledFilenames, modelledFilenames,
emgFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableSpatioTemporal(
True) if modelledFilenames is not None else cmf.enableSpatioTemporal(
False)
cmf.enableKinematic(
True) if modelledFilenames is not None else cmf.enableKinematic(False)
cmf.enableKinetic(
True) if modelledFilenames is not None else cmf.enableKinetic(False)
cmf.enableEmg(True) if emgFilenames is not None else cmf.enableEmg(False)
trialManager = cmf.generate()
#----cycles
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#----analysis
kinematicLabelsDict = cgm.CGM.ANALYSIS_KINEMATIC_LABELS_DICT
kineticLabelsDict = cgm.CGM.ANALYSIS_KINETIC_LABELS_DICT
emgLabelList = [label + "_Rectify_Env" for label in emgChannels]
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
pointlabelSuffix=pointLabelSuffix,
emgLabelList=emgLabelList)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setInfo(subject=subjectInfo,
model=modelInfo,
experimental=experimentalInfo)
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.build()
return analysisFilter.analysis
def test(cls):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH + "operations\\analysis\\gait\\"
modelledFilenames = [
"gait Trial 01 - viconName.c3d", "gait Trial 03 - viconName.c3d"
]
# ----INFOS-----
modelInfo = None
subjectInfo = None
experimentalInfo = None
normativeDataSet = dict()
normativeDataSet["Author"] = "Schwartz2008"
normativeDataSet["Modality"] = "Free"
pointLabelSuffix = ""
#---- c3d manager
#--------------------------------------------------------------------------
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(
DATA_PATH, modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableEmg(False)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#---- GAIT ANALYSIS FILTER
#--------------------------------------------------------------------------
pointLabelSuffixPlus = pointLabelSuffix if pointLabelSuffix == "" else "_" + pointLabelSuffix
kinematicLabelsDict = {
'Left': [
str("LHipAngles" + pointLabelSuffixPlus),
str("LKneeAngles" + pointLabelSuffixPlus),
str("LAnkleAngles" + pointLabelSuffixPlus),
str("LFootProgressAngles" + pointLabelSuffixPlus),
str("LPelvisAngles" + pointLabelSuffixPlus)
],
'Right': [
str("RHipAngles" + pointLabelSuffixPlus),
str("RKneeAngles" + pointLabelSuffixPlus),
str("RAnkleAngles" + pointLabelSuffixPlus),
str("RFootProgressAngles" + pointLabelSuffixPlus),
str("RPelvisAngles" + pointLabelSuffixPlus)
]
}
kineticLabelsDict = {
'Left': [
str("LHipMoment" + pointLabelSuffixPlus),
str("LKneeMoment" + pointLabelSuffixPlus),
str("LAnkleMoment" + pointLabelSuffixPlus),
str("LHipPower" + pointLabelSuffixPlus),
str("LKneePower" + pointLabelSuffixPlus),
str("LAnklePower" + pointLabelSuffixPlus)
],
'Right': [
str("RHipMoment" + pointLabelSuffixPlus),
str("RKneeMoment" + pointLabelSuffixPlus),
str("RAnkleMoment" + pointLabelSuffixPlus),
str("RHipPower" + pointLabelSuffixPlus),
str("RKneePower" + pointLabelSuffixPlus),
str("RAnklePower" + pointLabelSuffixPlus)
]
}
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.build()
#---- DISCRETE POINT FILTER
#-----------------------------------------------------------------------
# Benedetti Processing
dpProcedure = discretePoints.GoldbergProcedure()
dpf = discretePoints.DiscretePointsFilter(dpProcedure,
analysisFilter.analysis)
dataFrame = dpf.getOutput()
xlsExport = exporter.XlsExportDataFrameFilter()
xlsExport.setDataFrames(dataFrame)
xlsExport.export("discretePointsGoldberg", path=DATA_PATH)
def make_analysis(trialManager,
kinematicLabelsDict,
kineticLabelsDict,
modelInfo,
subjectInfo,
experimentalInfo,
modelVersion=None,
pointLabelSuffix=""):
"""
build a Analysis instance
:Parameters:
- `cgmSkeletonEnum` (pyCGM2.enums) - type of skeleton used
- `trialManager` (pyCGM2.Processing.c3dManager.C3dManager) - organization of inputed c3d
- `modelInfo` (dict) - info about the model
- `subjectInfo` (dict) - info about the subject
- `experimentalInfo` (dict) - info about experimental conditions
- `pointLabelSuffix` (str) - suffix added to standard cgm nomenclature
:Return:
- `NoName` (pyCGM2.Processing.analysis.Analysis) - Analysis instance
"""
if modelVersion is not None:
if modelVersion in [
"CGM1.0", "CGM1.1", "CGM2.1", "CGM2.2", "CGM2.2e", "CGM2.3",
"CGM2.3e", "CGM2.4", "CGM2.4e"
]:
if modelVersion in ["CGM2.4", "CGM2.4e"]:
cgm.CGM1LowerLimbs.ANALYSIS_KINEMATIC_LABELS_DICT[
"Left"].append("LForeFootAngles")
cgm.CGM1LowerLimbs.ANALYSIS_KINEMATIC_LABELS_DICT[
"Right"].append("RForeFootAngles")
kinematicLabelsDict = cgm.CGM1LowerLimbs.ANALYSIS_KINEMATIC_LABELS_DICT
kineticLabelsDict = cgm.CGM1LowerLimbs.ANALYSIS_KINETIC_LABELS_DICT
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#---- GAIT ANALYSIS FILTER
#--------------------------------------------------------------------------
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
pointlabelSuffix=pointLabelSuffix)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setInfo(subject=subjectInfo,
model=modelInfo,
experimental=experimentalInfo)
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.build()
return analysisFilter.analysis
def makeAnalysis(
DATA_PATH,
filenames,
type="Gait",
kinematicLabelsDict=cgm.CGM.ANALYSIS_KINEMATIC_LABELS_DICT,
kineticLabelsDict=cgm.CGM.ANALYSIS_KINETIC_LABELS_DICT,
emgChannels=[
"Voltage.EMG1", "Voltage.EMG2", "Voltage.EMG3", "Voltage.EMG4",
"Voltage.EMG5", "Voltage.EMG6", "Voltage.EMG7", "Voltage.EMG8",
"Voltage.EMG9", "Voltage.EMG10", "Voltage.EMG11", "Voltage.EMG12",
"Voltage.EMG13", "Voltage.EMG14", "Voltage.EMG15", "Voltage.EMG16"
],
pointLabelSuffix=None,
btkAcqs=None,
subjectInfo=None,
experimentalInfo=None,
modelInfo=None,
pstfilenames=None,
kinematicfilenames=None,
kineticfilenames=None,
emgfilenames=None,
):
"""
makeAnalysis : create the pyCGM2.Processing.analysis.Analysis instance
:param DATA_PATH [str]: path to your data
:param modelledFilenames [string list]: c3d files with model outputs
**optional**
"""
if filenames == [] or filenames is None: filenames = None
#---- c3d manager
if btkAcqs is not None:
c3dmanagerProcedure = c3dManager.UniqueBtkAcqSetProcedure(DATA_PATH,
filenames,
acqs=btkAcqs)
else:
iPstFilenames = filenames if pstfilenames is None else pstfilenames
iKinematicFilenames = filenames if kinematicfilenames is None else kinematicfilenames
iKineticFilenames = filenames if kineticfilenames is None else kineticfilenames
iEmgFilenames = filenames if emgfilenames is None else emgfilenames
c3dmanagerProcedure = c3dManager.DistinctC3dSetProcedure(
DATA_PATH, iPstFilenames, iKinematicFilenames, iKineticFilenames,
iEmgFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableKinematic(
True) if kinematicLabelsDict is not None else cmf.enableKinematic(
False)
cmf.enableKinetic(
True) if kineticLabelsDict is not None else cmf.enableKinetic(False)
cmf.enableEmg(True) if emgChannels is not None else cmf.enableEmg(False)
trialManager = cmf.generate()
#----cycles
if type == "Gait":
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalAcqs=trialManager.spatioTemporal["Acqs"],
kinematicAcqs=trialManager.kinematic["Acqs"],
kineticAcqs=trialManager.kinetic["Acqs"],
emgAcqs=trialManager.emg["Acqs"])
else:
cycleBuilder = cycle.CyclesBuilder(
spatioTemporalAcqs=trialManager.spatioTemporal["Acqs"],
kinematicAcqs=trialManager.kinematic["Acqs"],
kineticAcqs=trialManager.kinetic["Acqs"],
emgAcqs=trialManager.emg["Acqs"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
if emgChannels is not None:
emgLabelList = [label + "_Rectify_Env" for label in emgChannels]
else:
emgLabelList = None
if type == "Gait":
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
pointlabelSuffix=pointLabelSuffix,
emgLabelList=emgLabelList)
else:
analysisBuilder = analysis.AnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
pointlabelSuffix=pointLabelSuffix,
emgLabelList=emgLabelList)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setInfo(subject=subjectInfo,
model=modelInfo,
experimental=experimentalInfo)
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.build()
return analysisFilter.analysis
def cycleAnalysis(cls):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH+"EMG\\SampleNantes\\"
gaitTrial = "gait.c3d"
restTrial = "repos.c3d"
EMG_LABELS=['EMG1','EMG2']
acq = btkTools.smartReader(DATA_PATH +gaitTrial)
bf = emgFilters.BasicEmgProcessingFilter(acq,EMG_LABELS)
bf.setHighPassFrequencies(20.0,200.0)
bf.run()
envf = emgFilters.EmgEnvelopProcessingFilter(acq,EMG_LABELS)
envf.setCutoffFrequency(180.0)
envf.run()
btkTools.smartWriter(acq,DATA_PATH+"test.c3d")
modelledFilenames = ["test.c3d"]
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(DATA_PATH,modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableSpatioTemporal(False)
cmf.enableKinematic(False)
cmf.enableKinetic(False)
cmf.enableEmg(True)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials = trialManager.kinematic["Trials"],
kineticTrials = trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
modelInfo=None
subjectInfo=None
experimentalInfo=None
analysisBuilder = analysis.GaitAnalysisBuilder(cycles,
kinematicLabelsDict = None,
kineticLabelsDict = None,
emgLabelList = ['EMG1_Rectify_Env','EMG2_Rectify_Env'],
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.setInfo(model = modelInfo)
analysisFilter.build()
analysisInstance = analysisFilter.analysis
def GpsCGM1Test(cls):
# ----DATA-----
DATA_PATH = pyCGM2.TEST_DATA_PATH + "operations\\analysis\\gps\\"
reconstructedFilenameLabelledNoExt = "gait Trial 03 - viconName"
reconstructedFilenameLabelled = reconstructedFilenameLabelledNoExt + ".c3d"
logging.info("data Path: " + DATA_PATH)
logging.info("reconstructed file: " + reconstructedFilenameLabelled)
modelledFilenames = [reconstructedFilenameLabelled]
#---- c3d manager
#--------------------------------------------------------------------------
c3dmanagerProcedure = c3dManager.UniqueC3dSetProcedure(
DATA_PATH, modelledFilenames)
cmf = c3dManager.C3dManagerFilter(c3dmanagerProcedure)
cmf.enableEmg(False)
trialManager = cmf.generate()
#---- GAIT CYCLES FILTER
#--------------------------------------------------------------------------
cycleBuilder = cycle.GaitCyclesBuilder(
spatioTemporalTrials=trialManager.spatioTemporal["Trials"],
kinematicTrials=trialManager.kinematic["Trials"],
kineticTrials=trialManager.kinetic["Trials"],
emgTrials=trialManager.emg["Trials"])
cyclefilter = cycle.CyclesFilter()
cyclefilter.setBuilder(cycleBuilder)
cycles = cyclefilter.build()
#---- GAIT ANALYSIS FILTER
#--------------------------------------------------------------------------
# ----INFOS-----
modelInfo = {"type": "S01"}
subjectInfo = None
experimentalInfo = None
pointLabelSuffix = ""
pointLabelSuffixPlus = pointLabelSuffix if pointLabelSuffix == "" else "_" + pointLabelSuffix
kinematicLabelsDict = {
'Left': [
"LHipAngles" + pointLabelSuffixPlus,
"LKneeAngles" + pointLabelSuffixPlus,
"LAnkleAngles" + pointLabelSuffixPlus,
"LFootProgressAngles" + pointLabelSuffixPlus,
"LPelvisAngles" + pointLabelSuffixPlus
],
'Right': [
"RHipAngles" + pointLabelSuffixPlus,
"RKneeAngles" + pointLabelSuffixPlus,
"RAnkleAngles" + pointLabelSuffixPlus,
"RFootProgressAngles" + pointLabelSuffixPlus,
"RPelvisAngles" + pointLabelSuffixPlus
]
}
kineticLabelsDict = {
'Left': [
"LHipMoment" + pointLabelSuffixPlus,
"LKneeMoment" + pointLabelSuffixPlus,
"LAnkleMoment" + pointLabelSuffixPlus,
"LHipPower" + pointLabelSuffixPlus,
"LKneePower" + pointLabelSuffixPlus,
"LAnklePower" + pointLabelSuffixPlus
],
'Right': [
"RHipMoment" + pointLabelSuffixPlus,
"RKneeMoment" + pointLabelSuffixPlus,
"RAnkleMoment" + pointLabelSuffixPlus,
"RHipPower" + pointLabelSuffixPlus,
"RKneePower" + pointLabelSuffixPlus,
"RAnklePower" + pointLabelSuffixPlus
]
}
analysisBuilder = analysis.GaitAnalysisBuilder(
cycles,
kinematicLabelsDict=kinematicLabelsDict,
kineticLabelsDict=kineticLabelsDict,
subjectInfos=subjectInfo,
modelInfos=modelInfo,
experimentalInfos=experimentalInfo)
analysisFilter = analysis.AnalysisFilter()
analysisFilter.setBuilder(analysisBuilder)
analysisFilter.setInfo(model=modelInfo)
analysisFilter.build()
analysisInstance = analysisFilter.analysis
## --- GPS ----
ndp = normativeDatasets.Schwartz2008("Free")
gps = scores.CGM1_GPS()
scf = scores.ScoreFilter(gps, analysisInstance, ndp)
scf.compute()
xlsExport = exporter.XlsAnalysisExportFilter()
xlsExport.setAnalysisInstance(analysisInstance)
xlsExport.export("gpsTest2", path=DATA_PATH, mode="Advanced")
