import json
from multiprocessing import Process
import os
import LeapRecord
from AnyPy import AnyPy
from config.Configuration import env
from BVHAnimation import bvh_animation
from resources.pymo.pymo.parsers import BVHParser as Pymo_BVHParser
from gooey.gui import application
from gooey.gui import processor
from gooey.gui.containers import application as containers_application
from gooey.python_bindings import gooey_decorator, gooey_parser
# strings for the actions in the Gooey side-menu
ACTION_RECORD = 'Record'
ACTION_ANYBODY = 'AnyBody'
ACTION_CONVERTER = 'Converter'
ACTION_ANIMATION = 'Animation'
EXECUTED_COMMAND = 'command'
class GooeyModification:
# overwrite the Gooey default stop method to cancel Leap Motion recording
def on_stop(self):
"""Overload the stop method to allow stopping of Leap Motion Recording"""
executed_command = LeapGui.StoredArgs().load().stored_args[EXECUTED_COMMAND]
if executed_command == ACTION_RECORD:
return self.clientRunner.stop_leap()
self.clientRunner.stop()
def stop_leap(self):
if not self._process.stdin.closed:
"""Send Keyboard Interrupt to stop Leap Motion recording and parse bvh / interpolation"""
self._process.stdin.write(b"\n")
self._process.stdin.close()
return
self.stop()
# overwrite classes and methods of the stop button
containers_application.GooeyApplication.onStopExecution = on_stop
processor.ProcessController.stop_leap = stop_leap
containers_application.ProcessController = processor.ProcessController
application.GooeyApplication = containers_application.GooeyApplication
gooey_decorator.application = application
# create alias
Gooey = gooey_decorator.Gooey
GooeyParser = gooey_parser.GooeyParser
class LeapGui:
"""Implementation of the Gooey including some adaptions"""
Gooey = GooeyModification.Gooey
GooeyParser = GooeyModification.GooeyParser
@staticmethod
@Gooey(program_name="Leap Motion Recorder (c) Robin, Sean",
sidebar_title='Actions',
# return_to_config=True,
image_dir='config/gooey',
tabbed_groups=True,
default_size=(1000, 700))
def parse_args():
""" Use GooeyParser to build up the arguments we will use in our script
Save the arguments in a default json file so that we can retrieve them
every time we run the script.
"""
# load default values from json (saved from last run)
stored_args = LeapGui.StoredArgs().load()
parser = LeapGui.GooeyParser(description='Record Leap Motion data and export to BVH or AnyBody')
env.add_parser(parser)
subs = parser.add_subparsers(help='Tools', dest='command')
# === record === #
record_parser = subs.add_parser(ACTION_RECORD, help='Leap Recording')
# settings Group
settings_group = record_parser.add_argument_group(
"Settings",
gooey_options={
'show_border': True,
'columns': 1
}
)
basis_group = settings_group.add_mutually_exclusive_group(
required=True,
gooey_options={
'initial_selection': 0
})
settings_group.add_argument('frames_per_second',
metavar='Frames per second',
action='store',
default=stored_args.get(ACTION_RECORD, 'frames_per_second', '30'),
gooey_options={
'validator': {
'test': '1 <= int(user_input) <= 150',
'message': 'Must be between 1 and 150'
}
}
)
settings_group.add_argument('-show_animation',
metavar='Animate',
help='Show motion animation after recording',
action='store_true')
basis_group.add_argument('-anybody_basis',
metavar='Calculate joint angles to AnyBody basis',
action='store_true')
basis_group.add_argument('-firstframe_basis',
metavar='Calculate joint angles to initial recorded basis (first frame)',
action='store_true')
# bvh Group
bvh_group = record_parser.add_argument_group(
"BVH Export",
gooey_options={
'show_border': True,
'columns': 1
}
)
bvh_group.add_argument('-bvh',
metavar='Write BVH-File',
action='store_true')
bvh_group.add_argument('-bvh_path',
metavar='BVH File',
action='store',
default=stored_args.get(
ACTION_RECORD, 'bvh_path', LeapGui.StoredArgs.path('../output/BVH/RightHand.bvh')),
widget='FileSaver',
help='Choose location, where to save the BVH File')
bvh_group.add_argument('channels',
metavar='BVH Channels',
action='store',
default=stored_args.get(ACTION_RECORD, 'channels', 'rotation'),
widget='Dropdown',
help='Rotation: (X,Y,Z) rotation only (default)\n'
'Position: (X,Y,Z) rotation and position for all channels',
choices=['rotation', 'position'],
gooey_options={
'validator': {
'test': 'user_input != "Select Option"',
'message': 'Choose a channel setting'
}
})
# interpol Group
interpol_group = record_parser.add_argument_group(
"Interpolation Vector",
gooey_options={
'show_border': True,
'columns': 1
}
)
interpol_group.add_argument('-anybody',
metavar='Write interpolation files for AnyBody',
action='store_true')
interpol_group.add_argument('-anybody_template_path',
metavar='AnyBody templates',
action='store',
default=stored_args.get(
ACTION_RECORD, 'anybody_template_path',
LeapGui.StoredArgs.path('config/anybody_templates')),
widget='DirChooser',
help='Source directory that contains *.template files for AnyBody')
interpol_group.add_argument('-anybody_output_path',
metavar='Output directory',
action='store',
default=stored_args.get(
ACTION_RECORD, 'anybody_output_path',
LeapGui.StoredArgs.path('../output/Anybody')),
widget='DirChooser',
help='Output directory for interpolation files')
# # c3d Group
# c3d_group = record_parser.add_argument_group(
# "C3D",
# gooey_options={
# 'show_border': True,
# 'columns': 2
# }
# )
# c3d_group.add_argument('-c3d',
# metavar='Write C3D-File',
# action='store_true')
#
# c3d_group.add_argument('-c3d_filename',
# metavar=' ',
# action='store',
# default=stored_args.get(ACTION_RECORD, 'c3d_filename', 'RightHand'),
# help='Filename')
#
# c3d_group.add_argument('-c3d_path',
# metavar=' ',
# action='store',
# default=stored_args.get(
# ACTION_RECORD, 'c3d_path', LeapGui.StoredArgs.path('../output/C3D')),
# widget='DirChooser',
# help='Output directory for c3d file')
# === anybody === #
anybody_parser = subs.add_parser(ACTION_ANYBODY, help='Anybody Simulation')
anybody_group = anybody_parser.add_argument_group(
"Source files",
"Make a selection for the source files used for the AnyBody analysis",
gooey_options={
'show_border': True,
'columns': 1
}
)
anybody_file_group = anybody_group.add_mutually_exclusive_group(
required=True,
gooey_options={
'initial_selection': 0
})
anybody_file_group.add_argument('-any_interpol_files',
metavar='Use existing vector files (in {})'.format(AnyPy.INTERPOL_DIR),
help='Use interpolation vector files from AnyBody project default directory',
action='store_true')
anybody_file_group.add_argument('-any_bvh_file',
metavar='Source of the *.bvh file',
action='store',
default=stored_args.get(
ACTION_ANYBODY, 'any_bvh_file',
LeapGui.StoredArgs.path('../output/BVH/RightHand.bvh')),
widget='FileChooser',
help='Choose a bvh file to be converted to the interpolation vector files')
anybody_file_group.add_argument('-any_files_dir',
metavar='Source (.any)',
action='store',
default=stored_args.get(
ACTION_ANYBODY, 'any_files_dir',
LeapGui.StoredArgs.path('../output/Anybody')),
widget='DirChooser',
help='Source directory that contains interpolation *.any files for AnyBody')
anybody_group.add_argument('any_main_file',
metavar='Source of HAND.Main.any',
action='store',
default=stored_args.get(ACTION_ANYBODY, 'any_main_file', ''),
widget='FileChooser',
help='Choose the main AnyBody file for the calculation')
anybody_group.add_argument('-start_frame',
metavar='Start Frame',
help='default: 1',
action='store',
# default=stored_args.get(ACTION_ANYBODY, 'start_frame', '1'),
gooey_options={
'validator': {
'test': '1 <= int(user_input)',
'message': 'Must be greater or equal than 1'
}
},
type=int)
anybody_group.add_argument('-end_frame',
metavar='End Frame',
help='default: end',
action='store',
# default=stored_args.get(ACTION_ANYBODY, 'end_frame', 'end'),
gooey_options={
'validator': {
'test': '("end" in user_input.lower()) or (1 <= int(user_input))',
'message': 'Must be a positive value and greater than the start frame'
}
})
operation_group = anybody_parser.add_argument_group(
"Operations",
"Select which operations should be executed by AnyBody",
gooey_options={
'show_border': True,
'columns': 1
}
)
operation_group.add_argument('-load',
metavar='Load AnyBody model',
action='store_true')
operation_group.add_argument('-initial_conditions',
metavar='Calc initial conditions',
action='store_true')
operation_group.add_argument('-kinematic',
metavar='Calc kinematic analysis',
action='store_true')
operation_group.add_argument('-inverse_dynamics',
metavar='Calc inverse dynamics',
action='store_true')
operation_group.add_argument('-nstep',
metavar='Time steps',
help='Number of equally spaced time steps\n'
'(leave empty for not changing the setting)',
action='store',
# default=stored_args.get(ACTION_ANYBODY, 'nstep', '50'),
gooey_options={
'validator': {
'test': '1 <= int(user_input)',
'message': 'Must be greater or equal than 1'
}
},
type=int)
# operation_group.add_argument('-order',
# metavar='Order of B-spline interpolation',
# help='Interpolates between the data points with a B-spline using this order'
# '\n(leave empty for using the default value)',
# action='store',
# # default=stored_args.get(ACTION_ANYBODY, 'order', '4'),
# gooey_options={
# 'validator': {
# 'test': '1 <= int(user_input)',
# 'message': 'Must be greater or equal than 1'
# }
# },
# type=int)
result_group = anybody_parser.add_argument_group(
"Results",
gooey_options={
'show_border': True,
'columns': 1
}
)
result_group.add_argument('-plot',
metavar='Open the plot after the analysis',
action='store_true')
result_group.add_argument('-output_file_path',
metavar='Save .anydata.h5 file',
action='store',
default=stored_args.get(
ACTION_ANYBODY, 'output_file_path',
LeapGui.StoredArgs.path('../output/Anybody/FreeHand.anydata.h5')),
widget='FileSaver',
help='Save .anydata.h5 file to save the analysis results')
result_group.add_argument('-replay_output',
metavar='Open AnyBody and load the results',
action='store_true')
# === converter === #
converter_parser = subs.add_parser(ACTION_CONVERTER, help='Convert a BVH-File in .any-Files')
converter_group = converter_parser.add_argument_group(
"Converter",
"Convert a BVH-File in .any-Files",
gooey_options={
'show_border': True,
'columns': 1
}
)
converter_group.add_argument('bvh_file',
metavar='Source: *.bvh',
action='store',
default=stored_args.get(
ACTION_CONVERTER, 'bvh_file',
LeapGui.StoredArgs.path('../output/BVH/RightHand.bvh')),
widget='FileChooser',
help='Source bvh-file to convert')
# converter_group.add_argument('-any_file',
# metavar='Convert to .any files',
# action='store_true')
# converter_group.add_argument('-c3d',
# metavar='Convert to .c3d files',
# action='store_true')
converter_group.add_argument('file_dir',
metavar='Target: store files',
action='store',
default=stored_args.get(
ACTION_CONVERTER, 'file_dir', LeapGui.StoredArgs.path('../output')),
widget='DirChooser',
help='Directory to store the converted files')
# === bvh animation === #
animation_parser = subs.add_parser(ACTION_ANIMATION, help='Show an animation for a BVH file')
animation_group = animation_parser.add_argument_group(
"Animation",
"Select a BVH file to be animated",
gooey_options={
'show_border': True,
'columns': 1
}
)
animation_group.add_argument('bvh_animation',
metavar='BVH file path',
action='store',
default=stored_args.get(
ACTION_ANIMATION, 'bvh_animation',
LeapGui.StoredArgs.path('../output/BVH/RightHand.bvh')),
widget='FileChooser')
# start the UI and save arguments to json for next run
stored_args.save(parser.parse_args())
class StoredArgs:
"""class for loading and saving arguments from/to json, also to handle default values"""
def __init__(self):
self.stored_args = {}
self.loaded_actions = {}
# get the script name without the extension & use it to build up the json filename
script_name = os.path.splitext(os.path.basename(__file__))[0]
self.args_file = "{}-args.json".format(script_name)
def load(self):
# Read in the prior arguments as a dictionary
if os.path.isfile(self.args_file):
with open(self.args_file) as data_file:
self.stored_args = json.load(data_file)
self.loaded_actions = self.stored_args.keys()
return self
def get(self, action, arg, default):
return self.stored_args[action].get(arg) if action in self.loaded_actions else default
@staticmethod
def path(relative_path):
return os.path.normpath(os.path.join(os.getcwd(), relative_path))
def save(self, args):
# Store the values of the arguments to the environment to access them in the code
env.save_arguments(args)
# Store the values of the arguments so we have them next time we run
with open(self.args_file, 'w') as data_file:
# Using vars(args) returns the data as a dictionary
self.stored_args[EXECUTED_COMMAND] = args.command
self.stored_args[args.command] = vars(args)
json.dump(self.stored_args, data_file)
@staticmethod
def run():
"""Open the Gooey GUI and then run the selected action with the chosen arguments"""
LeapGui.parse_args()
# Record, Anybody, Converter
if env.config.command == ACTION_RECORD:
from GuiControl import GuiControl
gui = GuiControl()
gui.set_windows_record()
import time
countdown = 5
for ii in range(countdown):
print("Record starting in {} seconds ...".format(countdown-ii))
time.sleep(1)
LeapRecord.start_recording()
gui.end_record()
print("End of recording\n")
if env.config.show_animation:
print("Loading the animation ...")
p = Process(target=bvh_animation.animate)
p.start()
# wait for bvh_animation to be closed
p.join()
return True
if env.config.command == ACTION_ANYBODY:
from LogWatcher import log_watcher
anypy = AnyPy(env.config.any_main_file, env.config.any_files_dir)
log_watcher.start(os.path.join(anypy.any_path, anypy.LOG_FILE))
run_status = anypy.run()
log_watcher.stop()
if not run_status:
# AnyBody operations were not successful
return False
if env.config.replay_output:
anypy.post_operations()
if env.config.plot:
anypy.plot()
return True
if env.config.command == ACTION_CONVERTER:
from AnyWriter import AnyWriter
any_writer = AnyWriter(template_directory='config/anybody_templates/',
output_directory=env.config.file_dir + '/')
any_writer.write(Pymo_BVHParser().parse(env.config.bvh_file))
return True
if env.config.command == ACTION_ANIMATION:
print("Loading the animation ...")
bvh_animation.bvh_data = Pymo_BVHParser().parse(env.config.bvh_animation)
bvh_animation.animate()
if __name__ == "__main__":
LeapGui.run()
Datasets
Models
