"""
if __name__ == '__main__':
if __package__ is None:
print('Use -m option to run this library module as a script.')
import os
from pathlib import Path
import psutil
import time
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_kine.misc.file_utils import pretty_size
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import ViconCsvSubject
from biplane_kine.misc.json_utils import Params
config_dir = Path(
mod_arg_parser('Time database creation', __package__, __file__))
process = psutil.Process(os.getpid())
print(pretty_size(process.memory_info().rss))
params = Params.get_params(config_dir / 'parameters.json')
start = time.time()
db = create_db(params.biplane_vicon_db_dir, ViconCsvSubject)
end = time.time()
print(end - start)
print(pretty_size(process.memory_info().rss))
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.backends.backend_pdf import PdfPages
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubject
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from biplane_kine.graphing.kine_plotters import MarkerClusterAvailPlotter
from biplane_kine.misc.arg_parser import mod_arg_parser
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(mod_arg_parser('Batch plot availability of torso marker cluster', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
def trial_plotter(trial, marker_names):
marker_data = np.stack([trial.smoothed[marker_name] for marker_name in marker_names], 0)
return MarkerClusterAvailPlotter(marker_data, marker_names, trial.vicon_endpts, trial.trial_name)
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, BiplaneViconSubject)
marker_names = ['T10', 'T5', 'STRN', 'C7', 'CLAV']
db['Plotter'] = db['Trial'].apply(trial_plotter, args=[marker_names])
print('Use -m option to run this library module as a script.')
from pathlib import Path
import json
import shutil
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubject
from biplane_kine.misc.json_utils import Params
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_tasks.export.export_threejs_torso_scap_hum import no_static_dir, trial_exporter
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(mod_arg_parser('Export torso, scapula, and humerus kinematics and Vicon marker trajectories '
'for three.js',
__package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, BiplaneViconSubject)
json_export = {}
# export
for subject_name, subject_df in db.groupby('Subject_Name'):
log.info('Outputting torso, scapula, humerus kinematics for subject %s', subject_name)
import sys
import distutils.util
import matplotlib.pyplot as plt
from biplane_tasks.parameters import smoothing_exceptions_for_marker
from biplane_kine.database import create_db
from biplane_kine.database.vicon_accuracy import BiplaneMarkerSubjectEndpts
from biplane_kine.graphing.vicon_accuracy_plotters import ViconAccuracySmoothingPlotter
from biplane_kine.smoothing.kf_filtering_helpers import InsufficientDataError, DoNotUseMarkerError
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from biplane_kine.misc.arg_parser import mod_arg_parser
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(mod_arg_parser('Demonstrates the effect of smoothing for a specified trial/marker', __package__,
__file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
db = create_db(params.accuracy_db_dir, BiplaneMarkerSubjectEndpts)
add_c3d_helper(db, params.labeled_c3d_dir, params.filled_c3d_dir)
# select trial
trial_row = db.loc[params.trial_name]
marker_exceptions = smoothing_exceptions_for_marker(params.smoothing_exceptions, params.trial_name,
params.marker_name)
from pathlib import Path
import matplotlib.pyplot as plt
from matplotlib.backends.backend_pdf import PdfPages
from biokinepy.euler_angles import st_isb, ht_isb
from biokinepy.trajectory import smooth_trajectory
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubject, trajectories_from_trial
from biplane_kine.graphing.kine_plotters import RawSmoothSegmentPlotter
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from biplane_kine.misc.arg_parser import mod_arg_parser
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(mod_arg_parser('Batch plot scapula/humerus smoothed kinematics', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
def trial_plotter(trial, dt, num_frames_avg, torso_def):
torso, scap_raw, hum_raw = trajectories_from_trial(trial, dt, base_cs='vicon', torso_def=torso_def)
# smooth
scap_smooth = smooth_trajectory(scap_raw, num_frames_avg)
hum_smooth = smooth_trajectory(hum_raw, num_frames_avg)
# express in the first torso frame (I don't want to express in torso because that will add noise)
scap_raw_torso = scap_raw.in_frame(torso.ht[0])
if __name__ == '__main__':
if __package__ is None:
print('Use -m option to run this library module as a script.')
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import ViconCsvSubject
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from ..parameters import read_smoothing_exceptions
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser('Batch smooth Vicon marker data using Kalman smoothing',
__package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, ViconCsvSubject)
init_graphing()
all_exceptions = read_smoothing_exceptions(params.smoothing_exceptions)
# create plots
for subject_name, subject_df in db.groupby('Subject_Name'):
log.info('Smoothing subject %s', subject_name)
'ERa90': 'External Rotation at 90° of Abduction',
'ERaR': 'External Rotation at Rest',
'WCA': 'Weighted Coronal Plane Abduction',
'WSA': 'Weighted Scapular Plane Abduction',
'WFE': 'Weighted Forward Elevation'
}
friendly_names_keys = list(friendly_names.keys())
sorterIndex = dict(
zip(friendly_names_keys, range(len(friendly_names_keys))))
# initialize
config_dir = Path(
mod_arg_parser(
'Export torso, scapula, and humerus kinematics for three.js',
__package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, BiplaneViconSubject)
json_export = {}
# export
for subject_name, subject_df in db.groupby('Subject_Name'):
log.info(
if __name__ == '__main__':
if __package__ is None:
print('Use -m option to run this library module as a script.')
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import ViconCsvSubject
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser(
'Batch create PDF records of raw (labeled) vs filled Vicon marker data',
__package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, ViconCsvSubject)
init_graphing()
# create plots
for subject_name, subject_df in db.groupby('Subject_Name'):
log.info('Outputting subject %s', subject_name)
import quaternion
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_kine.graphing.common_graph_utils import init_graphing, make_interactive
from biokinepy.vec_ops import extended_dot
from biokinepy.cs import change_cs
from biplane_kine.kinematics.segments import StaticTorsoSegment
from biokinepy.absor import compute_trajectory
from biplane_kine.database import create_db, anthro_db
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubjectV3D
from biplane_kine.misc.json_utils import Params
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser('Compare Python vs Matlab torso kinematics',
__package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
root_path = Path(params.output_dir)
anthro = anthro_db(params.biplane_vicon_db_dir)
def armpit_thickness(subject_name):
return anthro.loc[subject_name, 'Armpit_Thickness']
db = create_db(params.biplane_vicon_db_dir,
BiplaneViconSubjectV3D,
import distutils.util
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import ViconCsvSubject
from biplane_kine.smoothing.kf_filtering_helpers import InsufficientDataError, DoNotUseMarkerError
from biplane_tasks.parameters import smoothing_exceptions_for_marker
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from .smooth_marker import marker_plotter
from biplane_kine.misc.arg_parser import mod_arg_parser
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser(
'Smooth Vicon marker data using Kalman smoothing and optionally creates a debug '
'PDF record', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, ViconCsvSubject)
# select trial
trial_row = db.loc[params.trial_name]
sel_trial = trial_row.Trial
log.info('Filtering trial %s marker %s', params.trial_name,
from matplotlib.backends.backend_pdf import PdfPages
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubject
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from biplane_kine.graphing.kine_plotters import MarkerClusterFillPlotter
from biokinepy.filling import fill_gaps_rb
from biplane_kine.smoothing.kf_filtering_helpers import piecewise_filter_with_exception
from biplane_kine.misc.arg_parser import mod_arg_parser
from ..parameters import read_filling_directives, trial_filling_directives
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser('Batch plot filled torso marker cluster', __package__,
__file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
def trial_plotter(trial, marker_nms, filling_direct_all):
log.info('Processing trial %s', trial.trial_name)
markers_to_fill = trial_filling_directives(filling_direct_all,
trial.trial_name)
gaps_filled = {}
filled_data = {}
sfs_data = {}
if not markers_to_fill:
from pathlib import Path
import pandas as pd
import numpy as np
import quaternion
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_kine.database import create_db, anthro_db
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubject
from biplane_kine.kinematics.joint_cs import torso_cs_isb, torso_cs_v3d
from biplane_kine.misc.json_utils import Params
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser('Compare torso CS as defined via Visual3D and ISB',
__package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, BiplaneViconSubject)
anthro = anthro_db(params.biplane_vicon_db_dir)
# create a dataframe of just the subjects
subjects = pd.Series(db['Subject'].unique())
subject_df = pd.DataFrame({
'Subject_Name':
import numpy as np
import quaternion
from biplane_kine.database import create_db, anthro_db
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubjectV3D
from biplane_kine.misc.json_utils import Params
from biokinepy.filling import fill_gaps_rb
from biplane_kine.smoothing.kf_filtering_helpers import piecewise_filter_with_exception
from biplane_kine.kinematics.segments import StaticTorsoSegment
from biokinepy.absor import compute_trajectory_continuous
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_tasks.parameters import read_filling_directives, trial_filling_directives
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(mod_arg_parser('Export V3D torso kinematics', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
def trial_exporter(trial, marker_names, filling_directives_all, dt, subject_folder):
log.info('Exporting trial %s', trial.trial_name)
markers_to_fill = trial_filling_directives(filling_directives_all, trial.trial_name)
smooth_marker_pos = np.stack([trial.smoothed[marker_name] for marker_name in marker_names], 0)
sfs_marker_pos = smooth_marker_pos.copy()
# fill then smooth again
for (marker_name, fill_from) in markers_to_fill.items():
from scipy.stats import ttest_rel
from matplotlib.backends.backend_pdf import PdfPages
from biplane_tasks.parameters import read_smoothing_exceptions, marker_smoothing_exceptions
from biplane_kine.database import create_db
from biplane_kine.database.vicon_accuracy import BiplaneMarkerSubjectEndpts
from biplane_kine.graphing.vicon_accuracy_plotters import ViconAccuracySmoothingPlotter
from biplane_kine.graphing.common_graph_utils import init_graphing
from biplane_kine.smoothing.kf_filtering_helpers import InsufficientDataError, DoNotUseMarkerError
from biplane_kine.misc.json_utils import Params
from .smoothing_effect_marker import add_c3d_helper, marker_accuracy_diff
from biplane_kine.misc.arg_parser import mod_arg_parser
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(mod_arg_parser('Demonstrates the effect of smoothing for all Vicon markers tracked via biplane '
'fluoroscopy', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
all_exceptions = read_smoothing_exceptions(params.smoothing_exceptions)
db = create_db(params.accuracy_db_dir, BiplaneMarkerSubjectEndpts)
add_c3d_helper(db, params.labeled_c3d_dir, params.filled_c3d_dir)
# create summary database
summary_db = []
for (subject_name, trial_name, biplane_trial, c3d_trial) in zip(db['Subject_Name'], db['Trial_Name'],
db['Biplane_Marker_Trial'], db['C3D_Trial']):
if __name__ == '__main__':
if __package__ is None:
print('Use -m option to run this library module as a script.')
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import ViconCsvSubject
from biplane_kine.misc.json_utils import Params
from biplane_tasks.parameters import read_smoothing_exceptions
from biplane_kine.misc.arg_parser import mod_arg_parser
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser('Export smoothed marker data', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, ViconCsvSubject)
all_exceptions = read_smoothing_exceptions(params.smoothing_exceptions)
# create plots
for subject_name, subject_df in db.groupby('Subject_Name'):
log.info('Smoothing subject %s', subject_name)
subject_dir = (root_path / subject_name)
from pathlib import Path
import multiprocessing as mp
from functools import partial
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import ViconCsvSubject
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from ..parameters import read_smoothing_exceptions
from .batch_kf_smoothing import trial_plotter
# initialize
config_dir = Path(
mod_arg_parser(
'Batch smooth Vicon marker data using Kalman smoothing (multi-threaded)',
__package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# ready db
root_path = Path(params.output_dir)
db = create_db(params.biplane_vicon_db_dir, ViconCsvSubject)
init_graphing()
all_exceptions = read_smoothing_exceptions(params.smoothing_exceptions)
# create plots
for subject_name, subject_df in db.groupby('Subject_Name'):
print('Smoothing subject {}'.format(subject_name))
subject_dir = (root_path / subject_name)
subject_dir.mkdir(parents=True, exist_ok=True)
subject_trial_plotter = partial(trial_plotter,
if __package__ is None:
print('Use -m option to run this library module as a script.')
from pathlib import Path
import numpy as np
from biplane_kine.database import create_db
from biokinepy.mean_smoother import smooth_quat_traj, smooth_pos_traj
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubject
from biplane_kine.misc.json_utils import Params
from biplane_kine.misc.arg_parser import mod_arg_parser
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser('Export smoothed scapula and humerus kinematics',
__package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
def export_to_csv(file_name, frame, pos_data, quat_data):
header_line = [
'frame', 'pos_x', 'pos_y', 'pos_z', 'quat_w', 'quat_x', 'quat_y',
'quat_z'
]
header_line_str = ','.join(header_line)
np.savetxt(file_name,
np.concatenate(
(frame[..., np.newaxis], pos_data, quat_data), axis=1),
import distutils.util
from typing import Union
from biplane_kine.database import create_db
from biplane_kine.graphing.smoothing_plotters import SmoothingOutputPlotter
from biplane_tasks.parameters import smoothing_exceptions_for_marker
from biplane_kine.misc.json_utils import Params
from biplane_kine.graphing.common_graph_utils import init_graphing
from biplane_kine.database.c3d_helper import C3DSubjectEndpts
from biplane_kine.smoothing.kf_filtering_helpers import InsufficientDataError, DoNotUseMarkerError
from .smooth_marker import marker_plotter
from biplane_kine.misc.arg_parser import mod_arg_parser
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(mod_arg_parser('Smooth Vicon marker data (from C3D file) using Kalman smoothing and optionally '
'creates a PDF record', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
# ready db
class C3DSubjectEndptsPrePop(C3DSubjectEndpts):
"""Proxy for C3DSubjectEndpts where the labeled_base_dir and filled_base_dir are pre-populated."""
def __init__(self, subj_dir: Union[str, Path]):
super().__init__(subj_dir, labeled_base_dir=params.labeled_c3d_dir, filled_base_dir=params.filled_c3d_dir,
c3d_trial_cls=C3DTrialEndptsNonHom)
root_path = Path(params.output_dir)
from biokinepy.filling import fill_gaps_rb
from biplane_kine.smoothing.kf_filtering_helpers import piecewise_filter_with_exception
from biplane_kine.kinematics.segments import StaticTorsoSegment
from biokinepy.cs import ht_inv, change_cs
from biokinepy.euler_angles import zxy_intrinsic
from biokinepy.absor import compute_trajectory, compute_trajectory_continuous
from biplane_kine.graphing.common_graph_utils import init_graphing
from biplane_kine.graphing.kine_plotters import TorsoTrajComparisonPlotter
from biplane_kine.misc.arg_parser import mod_arg_parser
from ..parameters import read_filling_directives, trial_filling_directives
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser('Batch plot torso kinematics', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
def trial_plotter(trial, marker_names, filling_directives_all, dt):
log.info('Processing trial %s', trial.trial_name)
markers_to_fill = trial_filling_directives(filling_directives_all,
trial.trial_name)
smooth_marker_pos = np.stack(
[trial.smoothed[marker_name] for marker_name in marker_names], 0)
prev_filled_marker_pos = np.stack(
[trial.filled[marker_name] for marker_name in marker_names], 0)
import quaternion
from biplane_kine.database import create_db
from biplane_kine.database.biplane_vicon_db import BiplaneViconSubject
from biplane_kine.misc.json_utils import Params
from biokinepy.filling import fill_gaps_rb
from biplane_kine.smoothing.kf_filtering_helpers import piecewise_filter_with_exception
from biplane_kine.kinematics.segments import StaticTorsoSegment
from biokinepy.absor import compute_trajectory_continuous
from biplane_kine.misc.arg_parser import mod_arg_parser
from biplane_tasks.parameters import read_filling_directives, trial_filling_directives
import logging
from logging.config import fileConfig
# initialize
config_dir = Path(
mod_arg_parser('Export ISB torso kinematics', __package__, __file__))
params = Params.get_params(config_dir / 'parameters.json')
# logging
fileConfig(config_dir / 'logging.ini', disable_existing_loggers=False)
log = logging.getLogger(params.logger_name)
def trial_exporter(trial, marker_names, filling_directives_all, dt,
subject_folder):
log.info('Exporting trial %s', trial.trial_name)
markers_to_fill = trial_filling_directives(filling_directives_all,
trial.trial_name)
smooth_marker_pos = np.stack(
[trial.smoothed[marker_name] for marker_name in marker_names], 0)
sfs_marker_pos = smooth_marker_pos.copy()