%matplotlib inline
from IPython.core.pylabtools import figsize
figsize(12, 8)
from IPython.display import Image
import matplotlib.pyplot as plt

import sys
sys.path.append('..')

import numpy as np
import pandas
from src import utils
from gaitanalysis.gait import GaitData
from gaitanalysis.controlid import SimpleControlSolver

df = pandas.read_csv('../data/simulated-data-with-controller-noise-and-perturbations-600-seconds.txt',
                     delimiter='\t', index_col='TimeStamp')

df.rename(columns=utils.simulated_data_header_map(), inplace=True)

walk_data = GaitData(df)

null = walk_data.grf_landmarks('FP2.ForY', 'FP1.ForY', threshold=3.0)

cycles = walk_data.split_at('right', num_samples=20)

axes = walk_data.plot_gait_cycles('FP2.ForY', 'Right.Ankle.PlantarFlexion.Angle')

axes = walk_data.gait_cycle_stats.hist()

walk_data.gait_cycle_stats.mean()

sensors, controls = utils.load_sensors_and_controls()

solver = SimpleControlSolver(cycles.iloc[:400], sensors, controls, cycles.iloc[400:])

gain_inclusion_matrix = np.zeros((len(controls), len(sensors))).astype(bool)
for i, row in enumerate(gain_inclusion_matrix):
    row[2 * i:2 * i + 2] = True

result = solver.solve(gain_inclusion_matrix=gain_inclusion_matrix)

fig, axes = utils.plot_joint_isolated_gains(sensors, controls, result[0], result[3])

np.set_printoptions(precision=0)
print(result[0].mean(axis=0))

print(result[0].std(axis=0))

total_time = float(df.index[-1] - df.index[0])
sample_rate = len(df) / total_time
num_samples_in_cycle = int(sample_rate * 1.1396)
num_samples_in_cycle = 115
num_cycles = 525
interp_percent_gait = np.linspace(0.0, 0.95, num=20)
cycles_panel = {}
df['Original Time'] = df.index.values.astype(float)
cycle_columns = df.columns

from scipy.interpolate import interp1d
for i in range(num_cycles - 10):
    cycle_values = df.iloc[i * num_samples_in_cycle : num_samples_in_cycle * (i + 1)].values
    percent_gait = np.linspace(0.0, 1.0 * (1.0 - 1.0 / cycle_values.shape[0]), cycle_values.shape[0])
    f = interp1d(percent_gait, cycle_values, axis=0)
    cycles_panel[i] = pandas.DataFrame(f(interp_percent_gait),
                                       index=interp_percent_gait,
                                       columns=cycle_columns)
cycles_panel = pandas.Panel(cycles_panel)

np.set_printoptions(precision=5)

percent_gait

from gaitanalysis.gait import plot_gait_cycles
axes = plot_gait_cycles(cycles_panel, 'FP2.ForY', 'Right.Ankle.PlantarFlexion.Angle')

solver = SimpleControlSolver(cycles_panel.iloc[:400], sensors, controls, cycles_panel.iloc[400:])
result = solver.solve(gain_inclusion_matrix=gain_inclusion_matrix)
fig, axes = utils.plot_joint_isolated_gains(sensors, controls, result[0], result[3])

df = pandas.read_csv('../data/simulated-data-with-controller-noise-600-seconds.txt',
                     delimiter='\t', index_col='TimeStamp')
df.rename(columns=utils.simulated_data_header_map(), inplace=True)
walk_data = GaitData(df)
null = walk_data.grf_landmarks('FP2.ForY', 'FP1.ForY', threshold=3.0)
cycles = walk_data.split_at('right', num_samples=20)

axes = walk_data.plot_gait_cycles('FP2.ForY', 'Right.Ankle.PlantarFlexion.Angle')
axes = walk_data.gait_cycle_stats.hist()

sensors, controls = utils.load_sensors_and_controls()
solver = SimpleControlSolver(cycles.iloc[:400], sensors, controls, cycles.iloc[400:])
gain_inclusion_matrix = np.zeros((len(controls), len(sensors))).astype(bool)
for i, row in enumerate(gain_inclusion_matrix):
    row[2 * i:2 * i + 2] = True
result = solver.solve(gain_inclusion_matrix=gain_inclusion_matrix)
fig, axes = utils.plot_joint_isolated_gains(sensors, controls, result[0], result[3])

np.set_printoptions(precision=0)
print(result[0].mean(axis=0))
print(result[0].std(axis=0))

df = pandas.read_csv('../data/simulated-data-with-perturbations-600-seconds.txt',
                     delimiter='\t', index_col='TimeStamp')
df.rename(columns=utils.simulated_data_header_map(), inplace=True)
walk_data = GaitData(df)
null = walk_data.grf_landmarks('FP2.ForY', 'FP1.ForY', threshold=3.0)
cycles = walk_data.split_at('right', num_samples=20)

axes = walk_data.plot_gait_cycles('FP2.ForY', 'Right.Ankle.PlantarFlexion.Angle')
axes = walk_data.gait_cycle_stats.hist()

sensors, controls = utils.load_sensors_and_controls()
solver = SimpleControlSolver(cycles.iloc[:400], sensors, controls, cycles.iloc[400:])
gain_inclusion_matrix = np.zeros((len(controls), len(sensors))).astype(bool)
for i, row in enumerate(gain_inclusion_matrix):
    row[2 * i:2 * i + 2] = True
result = solver.solve(gain_inclusion_matrix=gain_inclusion_matrix)
fig, axes = utils.plot_joint_isolated_gains(sensors, controls, result[0], result[3])

np.set_printoptions(precision=0)
print(result[0].mean(axis=0))
print(result[0].std(axis=0))

Image('tons-hip-id.png')

sensors = ['Right.Hip.Flexion.Angle', 'Right.Hip.Flexion.Rate']
controls = ['Right.Hip.Flexion.Moment']
solver = SimpleControlSolver(cycles.iloc[:400], sensors, controls, cycles.iloc[400:])
result = solver.solve()

fig, axes = plt.subplots(3, 1)
axes[0].plot(result[1])
axes[0].set_ylabel('m*')
axes[1].plot(result[0][:, 0, 0])
axes[1].set_ylabel('kp')
axes[2].plot(result[0][:, 0, 1])
axes[2].set_ylabel('kd')

axes = solver.plot_estimated_vs_measure_controls(result[-1], result[2])
plt.xlim((0, 500))

!git rev-parse HEAD

!git --git-dir=/home/moorepants/src/GaitAnalysisToolKit/.git --work-tree=/home/moorepants/src/GaitAnalysisToolKit rev-parse HEAD

%install_ext http://raw.github.com/jrjohansson/version_information/master/version_information.py

%load_ext version_information

%version_information numpy, scipy, pandas, matplotlib, tables, oct2py, dtk, gaitanalysis

!conda list

!pip freeze