├── README.md
├── fitcsvfileclean.py
└── CyclingDynamics.py


/README.md:
--------------------------------------------------------------------------------
 1 | Cyclingdynamics
 2 | 
 3 | #Requirements
 4 | -Python
 5 |   -Matplotlib
 6 |   -Pandas
 7 |   -Numpy
 8 | -FFMPEG (with path setup)
 9 | -FitSDK
10 | -Java runtime
11 | 
12 | Your fit file MUST have ALL L/R Balance, Pedal Smoothness, Torque Effectiveness and Cycling dynamics (Assioma OR Vector Series currently) to process. They all must be turned on and recorded or else the math used will fail.
13 | 
14 | They must be recorded with the correct fit descriptors and NOT developer fields
15 | 
16 | #instructions
17 | See the youtube video for walkthrough
18 | 
19 | 1) Use the fitsdk java commandline tool FitToCSV-data on your fitfile
20 | 2) place the <filename>-data.csv in this folder
21 | 3) Run fitcsvfileclean.py to delete duplicate entries and interpolate missing data
22 | 4) Run CyclingDynamics.py to decode to "High speed" and create a polar plot animation that is saved as an .mp4 x264 file
23 | 


--------------------------------------------------------------------------------
/fitcsvfileclean.py:
--------------------------------------------------------------------------------
 1 | #this cleans the fittocsv-data converted file when there are duplicate entries
 2 | 
 3 | import matplotlib.pyplot as plt
 4 | import numpy as np
 5 | import pandas as pd
 6 | import os 
 7 |   
 8 | 
 9 | DEBUG = True
10 | SHOW = True
11 | SAVE = not SHOW
12 | 
13 | def log(s):
14 |     if DEBUG:
15 |         print(s)
16 | 
17 | root = os.path.dirname(os.path.realpath(__file__)) # This gets the current local path
18 | root = root + '\\'
19 | log(root)
20 | 
21 | full_root = []
22 | datafiles = []
23 | filename = []
24 | df_name = []
25 | 
26 | for file in os.listdir(root): #Finds the data.csv
27 |     if file.endswith("data.csv"): # Don't change this, I want the _data.csv files
28 |         filename.append(file)
29 |         full_root.append(root + file)
30 |         log(full_root)
31 | 
32 | #This reads all the csv files via Pandas data interperted into a pandas data frame
33 | log("File will be cleaned. If problems press ctrl-c to kill python from the terminal")
34 | if (len(filename) == 1) :
35 |     df=pd.read_csv(full_root[0])
36 |     df.drop_duplicates(subset='record.timestamp[s]',keep='first',inplace=True)
37 |     df.set_index('record.timestamp[s]', inplace=True, drop=True)
38 |     new_index = pd.Index(np.arange(df.index.min(),df.index.max(),1), name="record.timestamp_x[s]")
39 |     df = df.reindex(new_index)
40 |     df = df.interpolate()
41 |     df.to_csv(root + filename[0] + "-clean.csv", sep=',')
42 | else:
43 |     print("Too many files with data.csv ending")
44 | 


--------------------------------------------------------------------------------
/CyclingDynamics.py:
--------------------------------------------------------------------------------
  1 | from scipy import signal
  2 | import matplotlib.pyplot as plt
  3 | import numpy as np
  4 | import pandas as pd
  5 | import csv
  6 | import os
  7 | import math
  8 | from matplotlib import animation
  9 | 
 10 | # from basic_units import radians, degrees, cos
 11 | 
 12 | DEBUG = True
 13 | SHOW = True
 14 | SAVE = not SHOW
 15 | 
 16 | 
 17 | def log(s):
 18 |     if DEBUG:
 19 |         print(s)
 20 | 
 21 | # with open('file.csv', 'rb') as csvfile:
 22 | root = os.path.dirname(os.path.realpath(__file__)) # This gets the current local path
 23 | root = root + '\\'
 24 | # log(root)
 25 | full_root = []
 26 | datafiles = []
 27 | filename = []
 28 | df_name = []
 29 | 
 30 | data = []
 31 | 
 32 | for file in os.listdir(root): #Finds the data.csv
 33 |     if file.endswith("-clean.csv"): # Don't change this, I want the _data.csv files
 34 |         filename.append(file)
 35 |         full_root.append(root + file)
 36 | 
 37 | log(full_root)
 38 | begin = False
 39 | 
 40 | #select which file that ends in -clean.csv
 41 | df = pd.read_csv(full_root[0], sep =',')
 42 | # print(df)
 43 | 
 44 | raw_timestamp = df['record.timestamp_x[s]']
 45 | raw_left_right_balance = df['record.left_right_balance']
 46 | raw_cadence = df['record.cadence[rpm]']
 47 | raw_accumulated_power = df['record.accumulated_power[watts]']
 48 | raw_power = df['record.power[watts]']
 49 | raw_left_power_phase = df['record.left_power_phase[degrees]']
 50 | raw_left_power_phase_peak = df['record.right_power_phase_peak[degrees]']
 51 | raw_right_power_phase = df['record.right_power_phase[degrees]']
 52 | raw_right_power_phase_peak = df['record.right_power_phase_peak[degrees]']
 53 | raw_left_torque_effectiveness = df['record.left_torque_effectiveness[percent]']
 54 | raw_right_torque_effectiveness = df['record.right_torque_effectiveness[percent]']
 55 | raw_left_pedal_smoothness = df['record.left_pedal_smoothness[percent]']
 56 | raw_right_pedal_smoothness = df['record.right_pedal_smoothness[percent]']
 57 | 
 58 | left_power_phase_start = []
 59 | left_power_phase_end = []
 60 | 
 61 | for x in range(len(raw_left_power_phase)):
 62 |     try:
 63 |         txt = raw_left_power_phase[x]
 64 |         y = txt.split("|")
 65 |         left_power_phase_start.append(float(y[0]))
 66 |         left_power_phase_end.append(float(y[1]))
 67 |     except:
 68 |         left_power_phase_start.append(0)
 69 |         left_power_phase_end.append(0)
 70 | 
 71 | left_power_phase_peak_start = []
 72 | left_power_phase_peak_end = []
 73 | 
 74 | for x in range(len(raw_left_power_phase_peak)):
 75 |     try:
 76 |         txt = raw_left_power_phase_peak[x]
 77 |         y = txt.split("|")
 78 |         left_power_phase_peak_start.append(float(y[0]))
 79 |         left_power_phase_peak_end.append(float(y[1]))
 80 |     except:
 81 |         left_power_phase_peak_start.append(0)
 82 |         left_power_phase_peak_end.append(0)
 83 | 
 84 | 
 85 | right_power_phase_start = []
 86 | right_power_phase_end = []
 87 | 
 88 | for x in range(len(raw_right_power_phase)):
 89 |     try:
 90 |         txt = raw_right_power_phase[x]
 91 |         y = txt.split("|")
 92 |         right_power_phase_start.append(float(y[0]))
 93 |         right_power_phase_end.append(float(y[1]))
 94 |     except:
 95 |         right_power_phase_start.append(0)
 96 |         right_power_phase_end.append(0)
 97 | 
 98 | log("length raw_right_power_phase, length right_power_phase_start, length right_power_phase_end")
 99 | log(len(raw_right_power_phase))
100 | log(len(right_power_phase_start))
101 | log(len(right_power_phase_end))
102 | 
103 | right_power_phase_peak_start = []
104 | right_power_phase_peak_end = []
105 | 
106 | for x in range(len(raw_right_power_phase_peak)):
107 |     try:
108 |         txt = raw_right_power_phase_peak[x]
109 |         y = txt.split("|")
110 |         right_power_phase_peak_start.append(float(y[0]))
111 |         right_power_phase_peak_end.append(float(y[1]))
112 |     except:
113 |         right_power_phase_peak_start.append(0)
114 |         right_power_phase_peak_end.append(0)
115 | 
116 | log("length raw_right_power_phase_peak, length right_power_phase_peak_start, length right_power_phase_end")
117 | log(len(raw_right_power_phase_peak))
118 | log(len(right_power_phase_peak_start))
119 | log(len(right_power_phase_peak_end))
120 | 
121 | true_left_right_balance = (raw_left_right_balance-128) 
122 | left_power = (true_left_right_balance/100)*raw_power
123 | right_power = raw_power - left_power
124 | rev_time = 1/(raw_cadence/60)
125 | 
126 | log("length true_left_right_balance, length left_power, length right_power, length rev_time")
127 | log(len(true_left_right_balance))
128 | log(len(left_power))
129 | log(len(right_power))
130 | log(len(rev_time))
131 | 
132 | 
133 | 
134 | left_phase_start_time = left_power_phase_start*rev_time/360
135 | left_phase_peak_start_time = left_power_phase_peak_start*rev_time/360
136 | left_phase_peak_end_time = left_power_phase_peak_end*rev_time/360
137 | left_phase_end_time = left_power_phase_end*rev_time/360
138 | left_torque_peak_time = (left_phase_peak_start_time + left_phase_peak_end_time)/2
139 | 
140 | right_phase_start_time = right_power_phase_start*rev_time/360
141 | right_phase_peak_start_time = right_power_phase_peak_start*rev_time/360
142 | right_phase_peak_end_time = right_power_phase_peak_end*rev_time/360
143 | right_phase_end_time = right_power_phase_end*rev_time/360
144 | right_torque_peak_time = (right_phase_peak_start_time + right_phase_peak_end_time)/2
145 | 
146 | 
147 | log("length left_phase_start_time, length left_phase_peak_start_time, length left_torque_peak_time, length left_phase_peak_end_time, length left_torque_peak_time")
148 | log(len(left_phase_start_time))
149 | log(len(left_phase_peak_start_time))
150 | log(len(left_torque_peak_time))
151 | log(len(left_phase_peak_end_time))
152 | log(len(left_torque_peak_time))
153 | 
154 | left_torque_trough_time = []
155 | for i in range(len(left_phase_start_time)):
156 |         try:
157 |                 if(left_phase_start_time[i]<left_phase_end_time[i]):
158 |                         left_torque_trough_time.append((rev_time[i]+left_phase_start_time[i]+left_phase_end_time[i])/2)
159 | 
160 |                 else:
161 |                         left_torque_trough_time.append((left_phase_start_time[i]+left_phase_end_time[i])/2)
162 |         except:
163 |                 left_torque_trough_time.append(0)
164 | log("length left_torque_trough_time")
165 | log(len(left_torque_trough_time))
166 | 
167 | right_torque_trough_time = []
168 | for i in range(len(right_phase_start_time)):
169 |         try:
170 |                 if(right_phase_start_time[i]<right_phase_end_time[i]):
171 |                         right_torque_trough_time.append((rev_time[i]+right_phase_start_time[i]+right_phase_end_time[i])/2)
172 |                 else:
173 |                         right_torque_trough_time.append((right_phase_start_time[i]+right_phase_end_time[i])/2)
174 |         except:
175 |                 right_torque_trough_time.append(0)
176 | 
177 | 
178 | left_torque_peak_angle = []
179 | for i in range(len(left_power_phase_peak_start)):
180 |         try:
181 |                 left_torque_peak_angle.append((left_power_phase_peak_start[i]+left_power_phase_peak_end[i])/2)
182 |         except:
183 |                 left_torque_peak_angle.append(0)
184 | 
185 | right_torque_peak_angle = []
186 | for i in range(len(right_power_phase_peak_start)):
187 |         try:
188 |                 right_torque_peak_angle.append((right_power_phase_peak_start[i]+right_power_phase_peak_end[i])/2)
189 |         except:
190 |                 right_torque_peak_angle.append(0)
191 | 
192 | left_torque_trough_angle = []
193 | for i in range(len(left_power_phase_start)):
194 |         try:
195 |                 if(left_power_phase_start[i]<left_power_phase_end[i]):
196 |                         left_torque_trough_angle.append((360+left_power_phase_start[i]+left_power_phase_end[i])/2)
197 | 
198 |                 else:
199 |                         left_torque_trough_angle.append((left_power_phase_start[i]+left_power_phase_end[i])/2)
200 |         except:
201 |                 left_torque_trough_angle.append(0)
202 | 
203 | right_torque_trough_angle = []
204 | for i in range(len(right_power_phase_start)):
205 |         try:
206 |                 if(right_power_phase_start[i]<right_power_phase_end[i]):
207 |                         right_torque_trough_angle.append((360+right_power_phase_start[i]+right_power_phase_end[i])/2)
208 | 
209 |                 else:
210 |                         right_torque_trough_angle.append((right_power_phase_start[i]+right_power_phase_end[i])/2)
211 |         except:
212 |                 right_torque_trough_angle.append(0)
213 | 
214 | 
215 | 
216 | # for i in range(len(left_phase_start_time)):
217 | #         try:
218 | #                 if(left_power_phase_start[i]<left_power_phase_end[i]):
219 | #                         left_torque_trough_angle.append((360+left_power_phase_start[i]+left_power_phase_end[i])/2)
220 | #                 else:
221 | #                         left_torque_trough_angle.append((left_power_phase_start[i]+left_power_phase_end[i])/2)
222 | #         except:
223 | #                 left_torque_trough_angle.append(0)
224 | 
225 | # right_torque_trough_angle = []
226 | # for i in range(len(right_phase_start_time)):
227 | #         try:
228 | #                 if(right_power_phase_start[i]<right_power_phase_end[i]):
229 | #                         right_torque_trough_angle.append((360+right_power_phase_start[i]+right_power_phase_end[i])/2)
230 | #                 else:
231 | #                         right_torque_trough_angle.append((right_power_phase_start[i]+right_power_phase_end[i])/2)
232 | #         except:
233 | #                 right_torque_trough_angle.append(0)
234 | 
235 | log("length right_torque_trough_time")
236 | log(len(right_torque_trough_time))
237 | 
238 | left_torque = left_power/((raw_cadence/60)*2*3.141592)
239 | right_torque = right_power/((raw_cadence/60)*2*3.141592)
240 | left_peak_torque = left_torque/(raw_left_pedal_smoothness/100)
241 | right_peak_torque = right_torque/(raw_right_pedal_smoothness/100)
242 | 
243 | # print(left_power[50],right_power[50],left_torque[50],right_torque[50])
244 | # print(raw_left_pedal_smoothness[50],raw_right_pedal_smoothness[50],left_peak_torque[50],right_peak_torque[50])
245 | 
246 | left_phase_start_torque = 0
247 | left_phase_end_torque = 0
248 | right_phase_start_torque = 0
249 | right_phase_end_torque = 0
250 | left_phase_peak_start_torque = left_peak_torque/2
251 | left_phase_peak_end_torque = left_peak_torque/2
252 | right_phase_peak_start_torque = right_peak_torque/2
253 | right_phase_peak_end_torque = right_peak_torque/2
254 | 
255 | left_torque_trough = []
256 | right_torque_trough = []
257 | 
258 | for i in range(len(left_phase_start_time)):
259 |         try:
260 |                 if(left_phase_start_time[i]<left_phase_end_time[i]):
261 |                         a = (0.5*left_phase_peak_start_torque[i]*(left_phase_peak_start_time[i]-left_phase_start_time[i]))
262 |                         b = (0.5*(left_peak_torque[i]-left_phase_peak_start_torque[i])*(left_torque_peak_time[i]-left_phase_peak_start_time[i]))
263 |                         c = ((left_phase_peak_start_torque[i])*(left_torque_peak_time[i]-left_phase_peak_start_time[i]))
264 |                         d = (0.5*(left_peak_torque[i]-left_phase_peak_end_torque[i])*(left_phase_peak_end_time[i]-left_torque_peak_time[i]))
265 |                         e = ((left_phase_peak_end_torque[i])*(left_phase_peak_end_time[i]-left_torque_peak_time[i]))
266 |                         f = (0.5*left_phase_peak_end_torque[i]*(left_phase_end_time[i]-left_phase_peak_end_time[i]))
267 |                         area_top = a+b+c+d+e+f
268 |                         area_btm = area_top*(1-raw_left_torque_effectiveness[i]/100)
269 |                         left_torque_neg_peak = -area_btm/(left_phase_start_time[i]+rev_time[i]-left_phase_end_time[i])
270 |                         left_torque_trough.append(left_torque_neg_peak)
271 |                         if (i == 48):
272 |                                 print(a,b,c,d,e,f)
273 |                                 print(raw_left_torque_effectiveness[i],area_top,area_btm, left_peak_torque[i], left_torque_neg_peak)
274 |                 else:
275 |                         a = (0.5*left_phase_peak_start_torque[i]*(left_phase_peak_start_time[i]-left_phase_start_time[i]+rev_time[i]))
276 |                         b = (0.5*(left_peak_torque[i]-left_phase_peak_start_torque[i])*(left_torque_peak_time[i]-left_phase_peak_start_time[i]))
277 |                         c = ((left_phase_peak_start_torque[i])*(left_torque_peak_time[i]-left_phase_peak_start_time[i]))
278 |                         d = (0.5*(left_peak_torque[i]-left_phase_peak_end_torque[i])*(left_phase_peak_end_time[i]-left_torque_peak_time[i]))
279 |                         e = ((left_phase_peak_end_torque[i])*(left_phase_peak_end_time[i]-left_torque_peak_time[i]))
280 |                         f = (0.5*left_phase_peak_end_torque[i]*(left_phase_end_time[i]-left_phase_peak_end_time[i]))
281 |                         area_top = a+b+c+d+e+f
282 |                         area_btm = area_top*(1-raw_left_torque_effectiveness[i]/100)
283 |                         left_torque_neg_peak = -area_btm/(left_phase_start_time[i] - left_phase_end_time[i])
284 |                         left_torque_trough.append(left_torque_neg_peak)
285 |                         if (i == 47):
286 |                                 print(a,b,c,d,e,f)
287 |                                 print(raw_left_torque_effectiveness[i],area_top,area_btm,left_peak_torque[i], left_torque_neg_peak)
288 |         except:
289 |                 print(i)
290 |                 left_torque_trough.append(0)
291 | 
292 | for i in range(len(right_phase_start_time)):
293 |         try:
294 |                 if(right_phase_start_time[i]<right_phase_end_time[i]):
295 |                         a = (0.5*right_phase_peak_start_torque[i]*(right_phase_peak_start_time[i]-right_phase_start_time[i]))
296 |                         b = (0.5*(right_peak_torque[i]-right_phase_peak_start_torque[i])*(right_torque_peak_time[i]-right_phase_peak_start_time[i]))
297 |                         c = ((right_phase_peak_start_torque[i])*(right_torque_peak_time[i]-right_phase_peak_start_time[i]))
298 |                         d = (0.5*(right_peak_torque[i]-right_phase_peak_end_torque[i])*(right_phase_peak_end_time[i]-right_torque_peak_time[i]))
299 |                         e = ((right_phase_peak_end_torque[i])*(right_phase_peak_end_time[i]-right_torque_peak_time[i]))
300 |                         f = (0.5*right_phase_peak_end_torque[i]*(right_phase_end_time[i]-right_phase_peak_end_time[i]))
301 |                         area_top = a+b+c+d+e+f
302 |                         area_btm = area_top*(1-raw_right_torque_effectiveness[i]/100)
303 |                         right_torque_neg_peak = -area_btm/(right_phase_start_time[i]+rev_time[i]-right_phase_end_time[i])
304 |                         right_torque_trough.append(right_torque_neg_peak)
305 |                         # if (i == 48):
306 |                         #         print(a,b,c,d,e,f)
307 |                         #         print(raw_right_torque_effectiveness[i],area_top,area_btm, right_peak_torque[i], right_torque_neg_peak)
308 |                 else:
309 |                         a = (0.5*right_phase_peak_start_torque[i]*(right_phase_peak_start_time[i]-right_phase_start_time[i]+rev_time[i]))
310 |                         b = (0.5*(right_peak_torque[i]-right_phase_peak_start_torque[i])*(right_torque_peak_time[i]-right_phase_peak_start_time[i]))
311 |                         c = ((right_phase_peak_start_torque[i])*(right_torque_peak_time[i]-right_phase_peak_start_time[i]))
312 |                         d = (0.5*(right_peak_torque[i]-right_phase_peak_end_torque[i])*(right_phase_peak_end_time[i]-right_torque_peak_time[i]))
313 |                         e = ((right_phase_peak_end_torque[i])*(right_phase_peak_end_time[i]-right_torque_peak_time[i]))
314 |                         f = (0.5*right_phase_peak_end_torque[i]*(right_phase_end_time[i]-right_phase_peak_end_time[i]))
315 |                         area_top = a+b+c+d+e+f
316 |                         area_btm = area_top*(1-raw_right_torque_effectiveness[i]/100)
317 |                         right_torque_neg_peak = -area_btm/(right_phase_start_time[i] - right_phase_end_time[i])
318 |                         right_torque_trough.append(right_torque_neg_peak)
319 |                         # if (i == 47):
320 |                         #         print(a,b,c,d,e,f)
321 |                         #         print(raw_right_torque_effectiveness[i],area_top,area_btm,right_peak_torque[i], right_torque_neg_peak)
322 |         except:
323 |                 print(i)
324 |                 right_torque_trough.append(0)
325 | 
326 | # First set up the figure, the axis, and the plot element we want to animate
327 | fig = plt.figure()
328 | # ax = plt.axes(xlim=(0, 1), ylim=(-15, 90))
329 | ax = plt.subplot(111, polar=True)
330 | ax.set_theta_direction(-1)
331 | ax.set_theta_zero_location("N")
332 | # ax.set_rmax(100)
333 | ax.set_rlim(-40,120)
334 | DPI = fig.get_dpi()
335 | fig.set_size_inches(1920.0/float(DPI),1080.0/float(DPI))
336 | plt.xlabel('Angle (s)')
337 | plt.ylabel('Torque N-M')
338 | 
339 | 
340 | plotlays, plotcols = [2], ["blue","red"]
341 | lines = []
342 | for index in range(2):
343 |     lobj = ax.plot([],[],lw=2,color=plotcols[index])[0]
344 |     lines.append(lobj)
345 | 
346 | 
347 | # initialization function: plot the background of each frame
348 | def init():
349 |     for line in lines:
350 |         line.set_data([],[])
351 |     return lines
352 | 
353 | xl,xla,yl = [],[],[]
354 | xr,xra,yr = [],[],[]
355 | 
356 | 
357 | # animation function.  This is called sequentially
358 | def animate(i):
359 |         if(left_phase_start_time[i]<left_phase_end_time[i]):
360 |                 xl = [left_phase_start_time[i],left_phase_peak_start_time[i],left_torque_peak_time[i],left_phase_peak_end_time[i],left_phase_end_time[i],left_torque_trough_time[i],(left_phase_start_time[i]+rev_time[i])]
361 |                 xla = [left_power_phase_start[i],left_power_phase_peak_start[i],left_torque_peak_angle[i],left_power_phase_peak_end[i],left_power_phase_end[i],left_torque_trough_angle[i],(left_power_phase_start[i]+360)]
362 |                 xla_radians = []
363 |                 for z in range(len(xla)):
364 |                         xla_radians.append(xla[z]*3.141592/180)
365 |                 yl = [left_phase_start_torque,left_phase_peak_start_torque[i],left_peak_torque[i],left_phase_peak_end_torque[i],left_phase_end_torque,left_torque_trough[i],left_phase_start_torque]
366 | 
367 |         else:
368 |                 xl = [(left_phase_start_time[i]-rev_time[i]),left_phase_peak_start_time[i],left_torque_peak_time[i],left_phase_peak_end_time[i],left_phase_end_time[i],left_torque_trough_time[i],(left_phase_start_time[i])]
369 |                 xla = [(left_power_phase_start[i]-360),left_power_phase_peak_start[i],left_torque_peak_angle[i],left_power_phase_peak_end[i],left_power_phase_end[i],left_torque_trough_angle[i],(left_power_phase_start[i])]
370 |                 xla_radians = []
371 |                 for z in range(len(xla)):
372 |                         xla_radians.append(xla[z]*3.141592/180)
373 |                 yl = [left_phase_start_torque,left_phase_peak_start_torque[i],left_peak_torque[i],left_phase_peak_end_torque[i],left_phase_end_torque,left_torque_trough[i],left_phase_start_torque]
374 | 
375 |         if(right_phase_start_time[i]<right_phase_end_time[i]):
376 |                 xr = [right_phase_start_time[i],right_phase_peak_start_time[i],right_torque_peak_time[i],right_phase_peak_end_time[i],right_phase_end_time[i],right_torque_trough_time[i],(right_phase_start_time[i]+rev_time[i])]
377 |                 xra = [right_power_phase_start[i],right_power_phase_peak_start[i],right_torque_peak_angle[i],right_power_phase_peak_end[i],right_power_phase_end[i],right_torque_trough_angle[i],(right_power_phase_start[i]+360)]
378 |                 xra_radians = []
379 |                 for z in range(len(xra)):
380 |                         xra_radians.append(xra[z]*3.141592/180)
381 |                 yr = [right_phase_start_torque,right_phase_peak_start_torque[i],right_peak_torque[i],right_phase_peak_end_torque[i],right_phase_end_torque,right_torque_trough[i],right_phase_start_torque]
382 | 
383 |         else:
384 |                 xr = [(right_phase_start_time[i]-rev_time[i]),right_phase_peak_start_time[i],right_torque_peak_time[i],right_phase_peak_end_time[i],right_phase_end_time[i],right_torque_trough_time[i],(right_phase_start_time[i])]
385 |                 xra = [(right_power_phase_start[i]-360),right_power_phase_peak_start[i],right_torque_peak_angle[i],right_power_phase_peak_end[i],right_power_phase_end[i],right_torque_trough_angle[i],(right_power_phase_start[i])]
386 |                 xra_radians = []
387 |                 for z in range(len(xra)):
388 |                         xra_radians.append(xra[z]*3.141592/180)
389 |                 yr = [right_phase_start_torque,right_phase_peak_start_torque[i],right_peak_torque[i],right_phase_peak_end_torque[i],right_phase_end_torque,right_torque_trough[i],right_phase_start_torque]
390 | 
391 | 
392 | 
393 |         xlist = [xla_radians, xra_radians]
394 |         ylist = [yl, yr]
395 | 
396 |             #for index in range(0,1):
397 |         for lnum,line in enumerate(lines):
398 |                 line.set_data(xlist[lnum], ylist[lnum]) # set data for each line separately. 
399 |         # line.set_data(x, y)
400 |         return lines
401 | 
402 | # call the animator.  blit=True means only re-draw the parts that have changed.
403 | anim = animation.FuncAnimation(fig, animate, init_func=init,
404 |                                frames=len(left_phase_start_time), interval=100, blit=True)
405 | 
406 | anim.save('basic_animation.mp4', fps=30, extra_args=['-vcodec', 'libx264'])
407 | 
408 | plt.show()
409 | 
410 | # for i in range(len(left_phase_start_time)):
411 | #         if(left_phase_start_time[i]<left_phase_end_time[i]):
412 | #                 x = [left_phase_start_time[i],left_phase_peak_start_time[i],left_torque_peak_time[i],left_phase_peak_end_time[i],left_phase_end_time[i],left_torque_trough_time[i],(left_phase_start_time[i]+rev_time[i])]
413 | #                 xla = [left_power_phase_start[i],left_power_phase_peak_start[i],left_torque_peak_angle[i],left_power_phase_peak_end[i],left_power_phase_end[i],left_torque_trough_angle[i],(left_power_phase_start[i]+360)]
414 | #                 xla_radians = []
415 | #                 for z in range(len(xla)):
416 | #                         xla_radians.append(xla[z]*3.141592/180)
417 | #                 # xla = 3.1415*xla/180
418 | #                 y = [left_phase_start_torque,left_phase_peak_start_torque[i],left_peak_torque[i],left_phase_peak_end_torque[i],left_phase_end_torque,left_torque_trough[i],left_phase_start_torque]
419 | #                 plt.figure(1)
420 | #                 ax = plt.subplot(111, polar=True)
421 | #                 ax.set_theta_zero_location("N")
422 | #                 ax.set_rlim(-40,120)
423 | #                 plt.plot(xla_radians,y, color='blue',linewidth=3)
424 | #                 print(xla)
425 | #                 print(y)
426 | #                 plt.show()
427 | #                 # input("Press Enter to continue...")
428 | #         else:
429 | #                 x = [(left_phase_start_time[i]-rev_time[i]),left_phase_peak_start_time[i],left_torque_peak_time[i],left_phase_peak_end_time[i],left_phase_end_time[i],left_torque_trough_time[i],(left_phase_start_time[i])]
430 | #                 xla = [(left_power_phase_start[i]-360),left_power_phase_peak_start[i],left_torque_peak_angle[i],left_power_phase_peak_end[i],left_power_phase_end[i],left_torque_trough_angle[i],(left_power_phase_start[i])]
431 | #                 xla_radians = []
432 | #                 for z in range(len(xla)):
433 | #                         xla_radians.append(xla[z]*3.141592/180)
434 | #                 y = [left_phase_start_torque,left_phase_peak_start_torque[i],left_peak_torque[i],left_phase_peak_end_torque[i],left_phase_end_torque,left_torque_trough[i],left_phase_start_torque]
435 | #                 plt.figure(1)
436 | #                 ax = plt.subplot(111, polar=True)
437 | #                 ax.set_theta_zero_location("N")
438 | #                 ax.set_rlim(-40,120)
439 | #                 plt.plot(xla_radians,y, color='blue',linewidth=3)
440 | #                 print(xla)
441 | #                 print(y)
442 | #                 plt.show()
443 | #                 # input("Press Enter to continue...")
444 | 
445 | 


--------------------------------------------------------------------------------