def test_StorageToPieceWiseLinearFunction():
sto = osim.Storage(os.path.join(this_file_dir, 'storage.sto'))
column_name = 'column1'
scale_factor = 2.5
time = osim.ArrayDouble()
sto.getTimeColumn(time)
state_index = sto.getStateIndex(column_name)
if type(scale_factor) == float:
sto.multiplyColumn(state_index, scale_factor)
elif scale_factor == None:
pass
else:
raise Exception('scale_factor, if specified, must be a float.')
ordinate = osim.ArrayDouble()
sto.getDataColumn(state_index, ordinate)
fcn = osim.PiecewiseLinearFunction()
for idx in range(time.getSize()):
fcn.addPoint(time.get(idx), ordinate.get(idx))
fcnName = os.path.join(this_file_dir, 'piecewiseLinearFunction.xml')
fcn.printToXML(fcnName)
assert (open(fcnName).readlines() ==
open(fcnName.replace('.xml', '_desired.xml')).readlines())
os.remove(fcnName)
def read_from_storage(file_name, to_filter=False):
"""Read OpenSim.Storage files.
Parameters
----------
file_name: (string) path to file
Returns
-------
tuple: (labels, time, data)
"""
sto = opensim.Storage(file_name)
sto.resampleLinear(0.01)
if to_filter:
sto.lowpassFIR(4, 6)
labels = osim_array_to_list(sto.getColumnLabels())
time = opensim.ArrayDouble()
sto.getTimeColumn(time)
time = np.round(osim_array_to_list(time), 3)
data = []
for i in range(sto.getSize()):
temp = osim_array_to_list(sto.getStateVector(i).getData())
temp.insert(0, time[i])
data.append(temp)
df = pd.DataFrame(data, columns=labels)
df.index = df.time
return df
def read_from_storage(model_file, file_name):
"""Read OpenSim.Storage files.
Parameters
----------
file_name: (string) path to file
Returns
-------
tuple: (labels, time, data)
"""
sto = opensim.Storage(file_name)
if sto.isInDegrees():
model = opensim.Model(model_file)
model.initSystem()
model.getSimbodyEngine().convertDegreesToRadians(sto)
# sto.resampleLinear(sampling_interval)
labels = osim_array_to_list(sto.getColumnLabels())
time = opensim.ArrayDouble()
sto.getTimeColumn(time)
time = osim_array_to_list(time)
data = []
for i in range(sto.getSize()):
temp = osim_array_to_list(sto.getStateVector(i).getData())
temp.insert(0, time[i])
data.append(temp)
df = pd.DataFrame(data, columns=labels)
df.index = df.time
return df
def read_from_storage(file_name, sampling_interval=0.01, to_filter=False):
"""Read OpenSim.Storage files.
Parameters
----------
file_name: (string) path to file
sampling_interval: resample the data with a given interval (0.01)
to_filter: use low pass 4th order FIR filter with 6Hz cut off
frequency
Returns
-------
df: pandas data frame
"""
sto = opensim.Storage(file_name)
sto.resampleLinear(sampling_interval)
if to_filter:
sto.lowpassFIR(4, 6)
labels = osim_array_to_list(sto.getColumnLabels())
time = opensim.ArrayDouble()
sto.getTimeColumn(time)
time = osim_array_to_list(time)
data = []
for i in range(sto.getSize()):
temp = osim_array_to_list(sto.getStateVector(i).getData())
temp.insert(0, time[i])
data.append(temp)
df = pd.DataFrame(data, columns=labels)
df.index = df.time
return df
def create_opensim_storage(time, data, column_names):
"""Creates a OpenSim::Storage.
Parameters
----------
time: SimTK::Vector
data: SimTK::Matrix
column_names: list of strings
Returns
-------
sto: OpenSim::Storage
"""
sto = opensim.Storage()
sto.setColumnLabels(list_to_osim_array_str(['time'] + column_names))
for i in range(data.nrow()):
row = opensim.ArrayDouble()
for j in range(data.ncol()):
row.append(data.getElt(i, j))
sto.append(time[i], row)
return sto
def time_range_from_static(self):
static = osim.MarkerData(self.static_path)
initial_time = static.getStartFrameTime()
final_time = static.getLastFrameTime()
range_time = osim.ArrayDouble()
range_time.set(0, initial_time)
range_time.set(1, final_time)
return range_time
def test_StorageToPieceWiseLinearFunction(self):
sto = osim.Storage(os.path.join(test_dir, 'storage.sto'))
column_name = 'column1'
scale_factor = 2.5
time = osim.ArrayDouble()
sto.getTimeColumn(time)
state_index = sto.getStateIndex(column_name)
if type(scale_factor) == float:
sto.multiplyColumn(state_index, scale_factor)
elif scale_factor == None:
pass
else:
raise Exception('scale_factor, if specified, must be a float.')
ordinate = osim.ArrayDouble()
sto.getDataColumn(state_index, ordinate)
fcn = osim.PiecewiseLinearFunction()
for idx in range(time.getSize()):
fcn.addPoint(time.get(idx), ordinate.get(idx))
fcnName = os.path.join(test_dir, 'piecewiseLinearFunction.xml')
fcn.printToXML(fcnName)
assert fcn.getX(0) == 0
assert_almost_equal(fcn.getX(1), 0.01)
assert_almost_equal(fcn.getX(2), 0.02)
assert_almost_equal(fcn.getX(3), 0.03)
assert_almost_equal(fcn.getX(4), 0.04)
assert_almost_equal(fcn.getY(0), 3.75)
assert_almost_equal(fcn.getY(1), 23.025)
assert_almost_equal(fcn.getY(2), 13.5575)
os.remove(fcnName)
def read_from_storage(file_name):
"""Read OpenSim.Storage files. """
sto = opensim.Storage(file_name)
labels = osim_array_to_list(sto.getColumnLabels())
time = opensim.ArrayDouble()
sto.getTimeColumn(time)
time = osim_array_to_list(time)
data = []
for i in range(sto.getSize()):
temp = osim_array_to_list(sto.getStateVector(i).getData())
temp.insert(0, time[i])
data.append(temp)
df = pd.DataFrame(data, columns=labels)
df.index = df.time
return df
def stoToDF(fileName, sampleInterval=None, filterFreq=None):
"""
Parameters
----------
fileName: filename of opensim .mot or .sto file
Returns
-------
df: pandas data frame
"""
#Load file
osimSto = osim.Storage(fileName)
#Resample
if sampleInterval != None:
osimSto.resampleLinear(sampleInterval)
#Filter
if filterFreq != None:
osimSto.lowpassFIR(4, int(filterFreq))
#Get column labels
labels = osimToList(osimSto.getColumnLabels())
#Set time values
time = osim.ArrayDouble()
osimSto.getTimeColumn(time)
time = osimToList(time)
#Allocate space for data
data = []
#Loop through columns and get data
for i in range(osimSto.getSize()):
temp = osimToList(osimSto.getStateVector(i).getData())
temp.insert(0, time[i])
data.append(temp)
#Convert to dataframe
df = pd.DataFrame(data, columns=labels)
return df
def setup_scale_xml(scale_filename: str, trial: str, model: str,
output_directory: str, input_directory: str):
'''
Rewrites the scale setup xml file for a new trial
Inputs: scale_filename: full filename for the template inverse kinematics setup xml file
trial: trial name, e.g., "_12Mar_ss_12ms_01"
model: model name, e.g., "AB08"
directory: output directory name
References: Megan Schroeder, 11/01/2014
'''
# Static trc filename
static_trc = input_directory + "\\" + model + trial + "_Static.trc"
# Create marker_data object to read starting and ending times from trc file
marker_data = osim.MarkerData(static_trc)
time_range = osim.ArrayDouble()
time_range.setitem(0, marker_data.getStartFrameTime())
time_range.setitem(1, marker_data.getLastFrameTime())
# Create scale_tool object
scale_tool = osim.ScaleTool(scale_filename)
scale_tool.setName(model)
# Modify top-level properties
# TODO, get height (optional), age (optional) and mass (required) of subject
scale_tool.setPathToSubject(model)
#scale_tool.setSubjectMass()
#scale_tool.setSubjectHeight()
#scale_tool.setSubjectAge
# Update generic_model_maker
generic_model_marker = scale_tool.getGenericModelMaker()
generic_model_marker.setModelFileName(model + ".osim")
generic_model_marker.setMarkerSetFileName(model + '_Scale_MarkerSet.xml')
# Update model_scaler
model_scaler = scale_tool.getModelScaler()
model_scaler.setApply(True)
scale_order = osim.ArrayStr()
scale_order.setitem(0, 'Measurements')
model_scaler.setScalingOrder(scale_order)
measurements_set = model_scaler.getMeasurementSet()
measurements_set.assign(
osim.MeasurementSet().makeObjectFromFile(model +
'_Scale_MarkerSet.xml'))
model_scaler.setMarkerFileName(static_trc)
model_scaler.setTimeRange(time_range)
model_scaler.setPreserveMassDist(True)
output_filename = trial + 'TempScaled.osim'
model_scaler.setOutputModelFileName(output_filename)
ouput_scale_filename = trial + '_ScaleSet.xml'
model_scaler.setOutputScaleFileName(ouput_scale_filename)
def scale():
import os
import opensim as osim
import shutil
import directories
# Global Directories
allDir = list(directories.main(directories))
parentDir = allDir[0]
paramsDir = allDir[1]
genericDir = allDir[2]
subID = allDir[4]
subResultsDir = allDir[5]
# Get generic Model
genericModel = "gait2354_LockedJoints.osim"
genericModelFile = genericDir + "/" + genericModel
if not os.path.exists(subResultsDir):
os.mkdir(subResultsDir)
# generic input XML files
scaleSetupFull = paramsDir + "/setupScale.xml"
markerSetFull = paramsDir + "/markerSet.xml"
# Make scale directory if non-existent
scaleResultsDir = subResultsDir + "/scale"
if os.path.exists(scaleResultsDir):
shutil.rmtree(scaleResultsDir, ignore_errors=True)
if not os.path.exists(scaleResultsDir):
os.mkdir(scaleResultsDir)
# Output XML Files
outputScaleFile = subID + "_scaleFactors.xml"
adjustedMarkerSet = subID + "_movedMarkers.xml"
# Output Model Files
outputModelFile = subID + ".osim"
# Input Data Files
dataFiles = parentDir + "/data/osDemo"
staticMarkerFile = "subject01_static.trc"
staticMarkerFull = dataFiles + "/" + staticMarkerFile
shutil.copy(staticMarkerFull, scaleResultsDir + "/" + staticMarkerFile)
# Output Data Files
staticCoordinates = subID + "_staticCoordinates.mot"
# Subject Measurements
subjectMass = 72.60000000
# Load Model
aModel = osim.Model(genericModelFile)
aModel.setName(subID)
# Initialize System
aModel.initSystem()
aState = aModel.initSystem()
# Add Marker Set
newMarkers = osim.MarkerSet(markerSetFull)
aModel.replaceMarkerSet(aState, newMarkers)
# Re-initialize State
aState = aModel.initSystem()
# Get Time Array for .trc file
markerData = osim.MarkerData(staticMarkerFull)
# Get Initial and Final Time
initial_time = markerData.getStartFrameTime()
final_time = markerData.getLastFrameTime()
# Create an array double and apply the time range
TimeArray = osim.ArrayDouble()
TimeArray.set(0, initial_time)
TimeArray.set(1, final_time)
# Scale Tool
scaleTool = osim.ScaleTool(scaleSetupFull)
scaleTool.setSubjectMass(subjectMass)
# GenericModelMaker-
# Tell scale tool to use the loaded model
scaleTool.getGenericModelMaker().setModelFileName(genericDir + "/" +
genericModel)
# # Set the Marker Set file (incase a markerset isnt attached to the model)
scaleTool.getGenericModelMaker().setMarkerSetFileName(markerSetFull)
# ModelScaler-
# Whether or not to use the model scaler during scale
scaleTool.getModelScaler().setApply(1)
# Set the marker file (.trc) to be used for scaling
scaleTool.getModelScaler().setMarkerFileName("/" + staticMarkerFile)
# set a time range
scaleTool.getModelScaler().setTimeRange(TimeArray)
# Indicating whether or not to preserve relative mass between segments
scaleTool.getModelScaler().setPreserveMassDist(1)
# Name of OpenSim model file (.osim) to write when done scaling.
scaleTool.getModelScaler().setOutputModelFileName("")
# Filename to write scale factors that were applied to the unscaled model (optional)
scaleTool.getModelScaler().setOutputScaleFileName(outputScaleFile)
# Run model scaler Tool
scaleTool.getModelScaler().processModel(aState, aModel, scaleResultsDir,
subjectMass)
# initialize
aState = aModel.initSystem()
# # Marker Placer
# # Whether or not to use the model scaler during scale
scaleTool.getMarkerPlacer().setApply(1)
# # Set the marker placer time range
scaleTool.getMarkerPlacer().setTimeRange(TimeArray)
# # Set the marker file (.trc) to be used for scaling
scaleTool.getMarkerPlacer().setStaticPoseFileName("/" + staticMarkerFile)
# # Return name to a variable for future use in functions
scaledAdjustedModel = scaleTool.getMarkerPlacer().setOutputModelFileName(
"/" + outputModelFile)
# # Set the output motion filename
scaleTool.getMarkerPlacer().setOutputMotionFileName("/" +
staticCoordinates)
# # Set the output xml of the marker adjustments
scaleTool.getMarkerPlacer().setOutputMarkerFileName("/" +
adjustedMarkerSet)
# # Maximum amount of movement allowed in marker data when averaging
scaleTool.getMarkerPlacer().setMaxMarkerMovement(-1)
# # Run Marker Placer
scaleTool.getMarkerPlacer().processModel(aState, aModel, scaleResultsDir)
scaleTool.printToXML(scaleResultsDir + "/" + subID + "_setupScale.xml")
# Clear Terminal
os.system('cls' if os.name == 'nt' else 'clear')
shutil.copy(scaleResultsDir + "/" + outputModelFile, subResultsDir)
return ()
def write(filename):
import opensim as osim
import csv
import numpy as np
import directories
allDir = list(directories.main(directories))
idResultsDir = allDir[7]
soResultsDir = allDir[8]
cmcResultsDir = allDir[10]
storage = osim.Storage(filename)
labels = storage.getColumnLabels()
labelSize = labels.getSize()
header = []
for i in range(labelSize):
header.append(labels.getitem(i))
nrows = storage.getSize()
data = []
dataArray = []
if header[0] == 'time':
st = 1
dataArray.append(osim.ArrayDouble())
storage.getTimeColumn(dataArray[0])
column = []
for j in range(nrows):
column.append(dataArray[0].getitem(j))
data.append(column)
else:
st = 0
for i in range(st, labelSize):
dataArray.append(osim.ArrayDouble())
storage.getDataColumn(header[i], dataArray[i])
column = []
for j in range(nrows):
column.append(dataArray[i].getitem(j))
data.append(column)
dataFixed = np.transpose(data)
headerFixed = []
headerFixed.append(header)
# Writing excel file for plotting
if filename == idResultsDir + "/" + "subject01_walk1_id.sto":
with open((idResultsDir + "/" + "idData.csv"), "wb") as fid:
csvWriter = csv.writer(fid, dialect='excel')
csvWriter.writerows(headerFixed)
csvWriter.writerows(dataFixed)
if filename == soResultsDir + "/" + "subject01_walk1_StaticOptimization_force.sto":
with open((soResultsDir + "/" + "soData.csv"), "wb") as fid:
csvWriter = csv.writer(fid, dialect='excel')
csvWriter.writerows(headerFixed)
csvWriter.writerows(dataFixed)
if filename == soResultsDir + "/" + "_Gait2354 Joint RXN_ReactionLoads.sto":
with open((soResultsDir + "/" + "soJrData.csv"), "wb") as fid:
csvWriter = csv.writer(fid, dialect='excel')
csvWriter.writerows(headerFixed)
csvWriter.writerows(dataFixed)
if filename == cmcResultsDir + "/" + "_Gait2354 Joint RXN_ReactionLoads.sto":
with open((cmcResultsDir + "/" + "cmcJrData.csv"), "wb") as fid:
csvWriter = csv.writer(fid, dialect='excel')
csvWriter.writerows(headerFixed)
csvWriter.writerows(dataFixed)
return ()
def create_scale_setup(self, file_dep, target):
# EDIT THESE FIELDS IN PARTICULAR.
# --------------------------------
time_range = osm.ArrayDouble()
time_range.append(self.init_time)
time_range.append(self.final_time)
tool = osm.ScaleTool()
tool.setName('%s_%s' % (self.study.name, self.subject.name))
tool.setSubjectMass(self.subject.mass)
# GenericModelMaker
# =================
gmm = tool.getGenericModelMaker()
gmm.setModelFileName(os.path.relpath(file_dep['generic_model'],
self.results_scale_path))
gmm.setMarkerSetFileName(os.path.relpath(self.prescale_markerset_fname))
# ModelScaler
# ===========
scaler = tool.getModelScaler()
scaler.setPreserveMassDist(True)
marker_traj_rel_fpath = os.path.relpath(file_dep['marker_traj'],
self.results_scale_path)
scaler.setMarkerFileName(marker_traj_rel_fpath)
scale_order_str = osm.ArrayStr()
scale_order_str.append('manualScale')
scale_order_str.append('measurements')
scaler.setScalingOrder(scale_order_str)
scaler.setTimeRange(time_range)
mset = scaler.getMeasurementSet()
# Manual scalings
# ---------------
sset = scaler.getScaleSet()
# MarkerPlacer
# ============
placer = tool.getMarkerPlacer()
placer.setStaticPoseFileName(marker_traj_rel_fpath)
placer.setTimeRange(time_range)
placer.setOutputModelFileName(os.path.relpath(
self.output_model_fpath, self.results_scale_path))
placer.setOutputMotionFileName(os.path.relpath(
self.output_motion_fpath, self.results_scale_path))
placer.setOutputMarkerFileName(os.path.relpath(
self.output_markerset_fpath, self.results_scale_path))
ikts = util.IKTaskSet(placer.getIKTaskSet())
self.edit_setup_function(util, mset, sset, ikts)
# Validate Scales
# ===============
model = osm.Model(file_dep['generic_model'])
bset = model.getBodySet()
for iscale in range(sset.getSize()):
segment_name = sset.get(iscale).getSegmentName()
if not bset.contains(segment_name):
raise Exception("You specified a Scale for "
"body %s but it's not in the model." % segment_name)
if not os.path.exists(self.results_scale_path):
os.makedirs(self.results_scale_path)
tool.printToXML(target['setup'])
#Set-up data adapters
c3d = osim.C3DFileAdapter()
trc = osim.TRCFileAdapter()
#Get markers
static = c3d.read(staticFile[0])
markersStatic = c3d.getMarkersTable(static)
#Write static data to file
trc.write(markersStatic, staticFile[0].split('.')[0]+'.trc')
#Set variable for static trial trc
staticTrial_trc = staticFile[0].split('.')[0]+'.trc'
#Set scale time range
scaleTimeRange = osim.ArrayDouble()
scaleTimeRange.set(0,osim.Storage(staticTrial_trc).getFirstTime())
scaleTimeRange.set(1,osim.Storage(staticTrial_trc).getFirstTime()+0.5)
#Set-up scale tool
scaleTool.append(osim.ScaleTool())
#Set mass in scale tool
scaleTool[ii-startInd].setSubjectMass(mass)
#Set generic model file
scaleTool[ii-startInd].getGenericModelMaker().setModelFileName(genModelFileName)
#Set the measurement set
scaleTool[ii-startInd].getModelScaler().setMeasurementSet(measurementSet)
# The first step is to create an XML file with all the information used to scale the model
# Load the generic musculoskeletal model
osimModel = osim.Model(generic_MM_Path)
state = osimModel.initSystem()
# Add a marker set to the model
markerSet = osim.MarkerSet(XML_markers_path)
osimModel.replaceMarkerSet(state, markerSet)
state = osimModel.initSystem()
# Get the marker data from a .trc file
markerData = osim.MarkerData(TRC_file)
initial_time = markerData.getStartFrameTime()
final_time = markerData.getLastFrameTime()
TimeArray = osim.ArrayDouble() # Time range
TimeArray.set(0,initial_time)
TimeArray.set(1,final_time)
# Scale Tool
scaleTool = osim.ScaleTool(XML_generic_ST_path)
scaleTool.setName('Subject') # Name of the subject
scaleTool.setSubjectMass(70) # Mass of the subject
scaleTool.setSubjectHeight(-1) # Only for information (not used by scaling)
scaleTool.setSubjectAge(-1) # Only for information (not used by scaling)
# Generic Model Maker
scaleTool.getGenericModelMaker().setModelFileName('Rajagopal2015.osim')
scaleTool.getGenericModelMaker().setMarkerSetFileName(XML_markers_path)
# Model Scaler
#Set marker file
#Add the virtual markers and create a new .trc file to use in scaling
osimHelper.addVirtualMarkersStatic('static.trc','staticVirtualMarkers.trc')
#Place in scale tool
scaleTool.getMarkerPlacer().setMarkerFileName('staticVirtualMarkers.trc')
scaleTool.getModelScaler().setMarkerFileName('staticVirtualMarkers.trc')
#Set options
scaleTool.getModelScaler().setPreserveMassDist(True)
scaleOrder = osim.ArrayStr(); scaleOrder.set(0,'measurements')
scaleTool.getModelScaler().setScalingOrder(scaleOrder)
#Set time ranges
timeRange = osim.ArrayDouble()
timeRange.set(0,0.5); timeRange.set(1,1.5)
scaleTool.getMarkerPlacer().setTimeRange(timeRange)
scaleTool.getModelScaler().setTimeRange(timeRange)
#Set output files
scaleTool.getModelScaler().setOutputModelFileName('scaledModel.osim')
scaleTool.getModelScaler().setOutputScaleFileName('scaleSet.xml')
#Set marker adjuster parameters
scaleTool.getMarkerPlacer().setOutputMotionFileName('static_motion.mot')
scaleTool.getMarkerPlacer().setOutputModelFileName('scaledModelAdjusted.osim')
#Save and run scale tool
scaleTool.printToXML('scaleSetup.xml')
scaleTool.run()
