def extract_from_fit(file_handler):
activity = Activity(file_handler)
activity.parse()
# Records, in an activity file that represent actual data points in your workout
records = activity.get_records_by_type('session')
out = []
for record in records:
d = {}
# get the list of valid fields on this record
valid_field_names = record.get_valid_field_names()
# Examine only >>> event='session' and trigger='activity_end' <<<
if not ('trigger' in valid_field_names) and (record.get_data('trigger') == 'activity_end'):
continue
for field_name in list(set(INTERESTING_FIELD_NAMES) & set(valid_field_names)):
# Get the data and units for the field
field_data = record.get_data(field_name)
field_units = record.get_units(field_name)
if not field_units:
field_units = None
d[field_name] = {'data': field_data, 'units': field_units}
out.append(d)
return out
def convert(filename):
document = create_document()
element = create_sub_element(document.getroot(), "Activities")
activity = Activity(filename)
activity.parse()
add_activity(element, activity)
return document
def convert(filename):
document = createDocument()
element = createSubElement(document.getroot(), "Activities")
activity = Activity(filename)
activity.parse()
addActivity(element, activity)
return document
def parse_fit_file(file_path):
activity = Activity(file_path)
activity.parse()
# Parse the session data, this contains some aggregate statistics about the workout (e.g. avg/max_speed)
sessions_df = WorkoutFileParser._fit_get_dataframe_by_type(
activity, 'session')
# Parse bike_profile data, contains some information the bike and about the sensors on the bike
bike_profiles_df = WorkoutFileParser._fit_get_dataframe_by_type(
activity, 'bike_profile')
# Parse activity data
activities_df = WorkoutFileParser._fit_get_dataframe_by_type(
activity, 'activity')
# Parse lap data: these are aggregate statistics about segments within the workout
laps_df = WorkoutFileParser._fit_get_dataframe_by_type(activity, 'lap')
# Parse event data: contains the timestamp of certain events (such as stopping and starting)
events_df = WorkoutFileParser._fit_get_dataframe_by_type(
activity, 'event')
# Parse user data: contains information about the athlete
user_df = WorkoutFileParser._fit_get_dataframe_by_type(
activity, 'user_profile')
# Parse body metrics such as weight, percent_fat, ..
body_metrics_df = WorkoutFileParser._fit_get_dataframe_by_type(
activity, 'weight_scale')
# Parse file data: which sensor/device produced this data?
file_data_df = WorkoutFileParser._fit_get_dataframe_by_type(
activity, 'file_id')
# Parse the sample data: certain parameters (distance, heart rate, ...) are measured at certain freqs
sample_df = WorkoutFileParser._fit_get_dataframe_by_type(
activity, 'record')
return {
'sessions': sessions_df,
'bike_profiles': bike_profiles_df,
'activities': activities_df,
'laps': laps_df,
'events': events_df,
'user': user_df,
'body_metrics': body_metrics_df,
'file_data': file_data_df,
'samples': sample_df
}
def main_fit_id(argv):
theids=[]
if os.path.isdir(argv[2]):
fit_files=[os.path.join(argv[1],f) for f in os.listdir(sys.argv[1]) if f.endswith('.fit')]
else:
fit_files=argv[2:]
for filename in fit_files:
sys.stderr.write("Getting ID for .fit file: "+filename+"\n")
activity = Activity(filename)
# TODO: this is the really time consuming one
activity.parse()
session = next(activity.get_records_by_type('session'))
start_time=session.get_data("start_time")
theid=("%04d" % start_time.year)+("%02d" % start_time.month)+("%02d" % start_time.day)+'T'+("%02d" % start_time.hour)+("%02d" % start_time.minute)+("%02d" % start_time.second)
thefilenametimestamp=os.path.getmtime(filename)
theids.append((os.path.normpath(filename),theid))
for theid in theids:
print theid[0] + ' ' + theid[1]
class FitParser(object):
def __init__(self, path, tz_offset=None):
self.path = path
self.tz_offset = tz_offset
self.act = Activity(path)
self.act.parse()
def parseFitRecord(self, r, last_sample):
d = r.as_dict()
try:
lat = semicircles_to_radians(d['position_lat'])
except KeyError:
lat = last_sample.lat
try:
lon = semicircles_to_radians(d['position_long'])
except KeyError:
lon = last_sample.lon
ts = time.mktime(d['timestamp'].timetuple())
if self.tz_offset is None:
self.tz_offset = local_timezone_offset(ts)
ts -= self.tz_offset
return ActSample(ts, lat, lon,
d.get('altitude', last_sample.alt),
d.get('temperature', last_sample.temp),
d.get('distance', last_sample.d),
d.get('speed', last_sample.v),
d.get('heart_rate', last_sample.hr),
d.get('cadence', last_sample.cad),
d.get('power', last_sample.pwr)
)
def samples(self, s=ActSample.empty()):
"""Yield all trackpoints as ActSample objects."""
for r in self.act.get_records_by_type('record'):
s = self.parseFitRecord(r, s)
yield s
def all(self):
"""Yield all .fit records as dicts."""
for d in self.act.get_records_as_dicts():
yield d
def main_fit_id(argv):
theids = []
if os.path.isdir(argv[2]):
fit_files = [
os.path.join(argv[1], f) for f in os.listdir(sys.argv[1])
if f.endswith('.fit')
]
else:
fit_files = argv[2:]
for filename in fit_files:
sys.stderr.write("Getting ID for .fit file: " + filename + "\n")
activity = Activity(filename)
# TODO: this is the really time consuming one
activity.parse()
session = next(activity.get_records_by_type('session'))
start_time = session.get_data("start_time")
theid = ("%04d" % start_time.year) + ("%02d" % start_time.month) + (
"%02d" % start_time.day) + 't' + ("%02d" % start_time.hour) + (
"%02d" % start_time.minute) + ("%02d" % start_time.second)
thefilenametimestamp = os.path.getmtime(filename)
theids.append((os.path.normpath(filename), theid))
for theid in theids:
print theid[0] + ' ' + theid[1]
'C:\\Users\\sean\\Documents\\python-fitparse-master\\tests\\data\\*.fit'
):
time,distance,heartrate,velocity_smooth ,lat,long,altitude,watts,cadence,temp,grade_smooth = [],[],[],[],[],[],[],[],[],[],[]
header, header_dict, header_csv = True, {}, [] #for create header.json
count += 1
print fname
print_hook_func = None
if not quiet:
print_hook_func = print_record
record_number = 0
a = Activity(fname)
a.parse(hook_func=print_hook_func)
if time != []:
min_time = min(time)
for i in range(len(time)):
time[i] = time[i] - min_time
write_zero(csv_dict)
ID = fname[58:-4]
if len(distance) != 0:
distance_max = max(distance) / 1000
else:
distance_max = 0
if len(velocity_smooth) != 0:
speed_everage = sum(velocity_smooth) / float(
localString += ("\n<|\"record number\"-> %d, \"type\"-> \"%s\", \"fields\"->{" % (record_number, rec.type.name))
shortFields = rec.fields[0:99] # for debugging, limits the number of fields per record
for field in shortFields:
localString += "<|\"name\"->\"%s\", \"type\"->\"%s\", \"data\"->\"%s\", \"unit\"->\"%s\"|>," % (field.name, field.type.name, field.data, field.units)
localString = localString[:-1]
localString += "}|>, "
else:
localString+=""
# the program as such starts below
for f in filenames:
#displays a header so you know it has started
if quiet:
print f
else:
print ('##### %s ' % f).ljust(60, '#')
record_number = 0
localString = ""
a = Activity(f)
localString= "{"
a.parse(print_record) # calls the interesting function
localString = localString[:-2]
localString += "\n}"
newpath, tail = os.path.split(f) # parts of the path and filename for the file we're parsing
tail = tail[:-3]
tail+="txt"
outFile = os.path.join(newpath, tail)
file = open(outFile,"w")
file.write(localString)
file.close()
# search_records.py
# crack the record.type
from datetime import datetime
from fitparse import Activity
FileLoc = r'S:\\will\\documents\\OneDrive\\bike\\activities\\will\\'
#fitfilepath = FileLoc + r'2018-06-01-11-13-49.fit' # long ride
fitfilepath = FileLoc + r'2016-07-09-13-52-59.fit' # problems
activity = Activity(fitfilepath)
activity.parse()
records = activity.records
record_types = set()
for record in records:
record_types.add(record.type.name)
fields_by_type = {}
for RType in record_types:
print 'type = %s' % RType
records = activity.get_records_by_type(RType)
RecNum = 0
fields_by_type[RType] = set()
for record in records:
valid_field_names = record.get_valid_field_names()
#print ' name = ',
for name in valid_field_names:
fields_by_type[RType].add(name)
# print name + ', ',
# if 'balance' in name.lower():
# print 'balance found in %s field within %s record type' \
# % (name, RType)
# if RType == 'record':
# print '*',
def convert(filename):
activity = Activity(filename)
activity.parse()
wrapper = ActivityWrapper(activity)
wrapper.process()
return None
def main_fit(argv):
filename=sys.argv[1]
activity = Activity(filename)
activity.parse()
session = next(activity.get_records_by_type('session'))
session_dict={}
start_time=local_date_to_utc(session.get_data("start_time"))
real_start_time=session.get_data("start_time")
session_dict['elapsed-time']=session.get_data("total_elapsed_time")
timer_time=session.get_data("total_timer_time")
session_dict['timer-time']=timer_time
distance=session.get_data("total_distance")
session_dict['distance']=distance
# TODO: possibility do this for very small distances
if distance == 0.0:
# TODO: change to None?
session_dict['pace']=0.0
else:
session_dict['pace']=(1000./(distance/timer_time))/60.
theid=time_to_id(start_time)
session_dict['id']=theid
session_dict['start-time']=theid
end_time=local_date_to_utc(session.get_data("timestamp"))
end_time_id=time_to_id(end_time)
session_dict['end-time']=end_time_id
session_dict['laps']={}
session_dict['laps']['start-time']=[]
session_dict['laps']['start-timestamp']=[]
session_dict['laps']['end-time']=[]
session_dict['laps']['end-timestamp']=[]
session_dict['laps']['timer-time']=[]
session_dict['laps']['distance']=[]
session_dict['laps']['pace']=[]
session_dict['laps']['maximum-speed']=[]
session_dict['laps']['average-heart-rate']=[]
session_dict['laps']['maximum-heart-rate']=[]
session_dict['laps']['trigger-method']=[]
session_dict['laps']['trackpoints']=[]
session_dict['lap start times']=[]
session_dict['lap end times']=[]
session_dict['lap start distances']=[]
session_dict['lap end distances']=[]
for lap in activity.get_records_by_type('lap'):
session_dict['laps']['start-time'].append(str(local_date_to_utc(lap.get_data("start_time"))))
start_time=lap.get_data("start_time")
session_dict['laps']['end-time'].append(str(local_date_to_utc(lap.get_data("timestamp"))))
end_time=lap.get_data("timestamp")
timer_time=lap.get_data("total_timer_time")
session_dict['laps']['timer-time'].append(timer_time)
distance=lap.get_data("total_distance")
session_dict['laps']['distance'].append(distance)
if distance == 0.0 or distance == None or timer_time == None:
# TODO: change to None?
session_dict['laps']['pace'].append(0.)
else:
session_dict['laps']['pace'].append((1000./(distance/timer_time))/60.)
session_dict['laps']['maximum-speed'].append(lap.get_data("max_speed")) # opt
session_dict['laps']['average-heart-rate'].append(lap.get_data("avg_heart_rate")) #opt
session_dict['laps']['maximum-heart-rate'].append(lap.get_data("max_heart_rate")) #opt
session_dict['laps']['trigger-method'].append(LAP_TRIGGER_MAP.get(lap.get_data("lap_trigger"), "Manual"))
first_track_point=True
for trackpoint in activity.get_records_by_type('record'):
tts = trackpoint.get_data("timestamp")
if tts >= start_time and tts <= end_time:
if first_track_point==True:
session_dict['lap start times'].append((trackpoint.get_data("timestamp")-real_start_time).seconds)
session_dict['lap start distances'].append(trackpoint.get_data("distance"))
first_track_point=False
session_dict['laps']['trackpoints'].append({})
session_dict['laps']['trackpoints'][-1]['timestamp']=str(local_date_to_utc(trackpoint.get_data("timestamp")))
session_dict['laps']['trackpoints'][-1]['elapsed-time']=(trackpoint.get_data("timestamp")-real_start_time).seconds
session_dict['laps']['trackpoints'][-1]['latitude-position']=trackpoint.get_data("position_lat")
session_dict['laps']['trackpoints'][-1]['longitude-position']=trackpoint.get_data("position_long")
session_dict['laps']['trackpoints'][-1]['distance']=trackpoint.get_data("distance")
session_dict['laps']['trackpoints'][-1]['altitude']=trackpoint.get_data("altitude")
session_dict['laps']['trackpoints'][-1]['speed']=trackpoint.get_data("speed")
session_dict['laps']['trackpoints'][-1]['heart rate']=trackpoint.get_data("heart_rate")
# TODO: make sure this works out OK, get last valid position
if session_dict['laps']['trackpoints'][-1]['latitude-position'] == None:
session_dict['laps']['trackpoints'][-1]['latitude']=None
else:
session_dict['laps']['trackpoints'][-1]['latitude']=str(semicircle_to_degrees(session_dict['laps']['trackpoints'][-1]['latitude-position']))
if session_dict['laps']['trackpoints'][-1]['longitude-position'] == None:
session_dict['laps']['trackpoints'][-1]['longitude']=None
else:
session_dict['laps']['trackpoints'][-1]['longitude']=str(semicircle_to_degrees(session_dict['laps']['trackpoints'][-1]['longitude-position']))
# add first and last
session_dict['lap end times'].append(session_dict['laps']['trackpoints'][-1]['elapsed-time'])
session_dict['lap end times'].append(session_dict['laps']['trackpoints'][-1]['distance'])
# update things from laps
session_dict['start-latitude']=session_dict['laps']['trackpoints'][0]['latitude']
session_dict['start-longitude']=session_dict['laps']['trackpoints'][0]['longitude']
session_dict['end-latitude']=session_dict['laps']['trackpoints'][-1]['latitude']
session_dict['end-longitude']=session_dict['laps']['trackpoints'][-1]['longitude']
return session_dict
record_number = 0
a = Activity(fpath)
fxpath = "%s.gpx" %(fpath)
name=basename(fpath)
fdate=datetime.strptime(name, "%Y-%m-%d-%H-%M-%S.fit")
start_date_activity = ""
if fdate is not None:
start_date_activity = datetime.strftime(fdate,"%Y-%m-%sT%H:%M:%SZ")
#begin the GPX File !!!
if not os.path.exists(fxpath):
open(fxpath, 'w').close()
with open(fxpath, 'rt+') as f:
print ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
print ("<gpx creator=\"jpmena\"")
print (" xmlns:gpxtrx=\"http://www.garmin.com/xmlschemas/GpxExtensions/v3\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"")
print (" xmlns:gpxtpx=\"http://www.garmin.com/xmlschemas/TrackPointExtension/v1\"")
print (" xmlns:gpxx=\"http://www.garmin.com/xmlschemas/WaypointExtension/v1\" xmlns:nmea=\"http://trekbuddy.net/2009/01/gpx/nmea\">")
print ("<metadata>")
print ("<time>%s</time>" %(start_date_activity))
print ("</metadata>")
print ("<trk>")
print ("<name>%s</name>" %(name))
print ("<trkseg>")
map(affiche_trkpoinnt, a.parse(hook_func=print_hook_func))
print()
print ("</trkseg>")
print ("</trk>")
print ("</gpx>")
#ends the GPX File !!!!
fit_id_list = []
try:
direct = open(com_path+"direct_table.csv","rb")
for fit_id in csv.reader(direct):
fit_id_list += [fit_id[0]]
direct.close()
except:
pass
ID = fname[38:-4]#depend on your com_path
if ID not in fit_id_list:
print fname+" Start parsing!!"
time_start = times.time()
a = Activity(fname)
a.parse(hook_func=print_record)
#check None value
for data in csv_dict:
if(csv_dict[data] < csv_dict["time"]):
list = eval(data)
list += [-1]
csv_dict[data] += 1
missing_count[data]+=1
if time != []:
min_time = min(time)
for i in range(len(time)):
time[i] = time[i] - min_time
if len(distance) != 0:
def get_records(f):
filename = '%s/%s' % (fit_files_path, f)
activity = Activity(filename)
activity.parse()
records = activity.get_records_by_type('record')
return records
def get_records(f):
filename = '%s/%s' % (fit_files_path, f)
activity = Activity(filename)
activity.parse()
records = activity.get_records_by_type('record')
return records
def main_fit(argv):
filename = sys.argv[1]
activity = Activity(filename)
activity.parse()
session = next(activity.get_records_by_type('session'))
session_dict = {}
start_time = local_date_to_utc(session.get_data("start_time"))
real_start_time = session.get_data("start_time")
session_dict['elapsed-time'] = session.get_data("total_elapsed_time")
timer_time = session.get_data("total_timer_time")
session_dict['timer-time'] = timer_time
distance = session.get_data("total_distance")
session_dict['distance'] = distance
# TODO: possibility do this for very small distances
if distance == 0.0:
# TODO: change to None?
session_dict['pace'] = 0.0
else:
session_dict['pace'] = (1000. / (distance / timer_time)) / 60.
theid = time_to_id(start_time)
session_dict['id'] = theid
session_dict['start-time'] = theid
end_time = local_date_to_utc(session.get_data("timestamp"))
end_time_id = time_to_id(end_time)
session_dict['end-time'] = end_time_id
session_dict['laps'] = {}
session_dict['laps']['start-time'] = []
session_dict['laps']['start-timestamp'] = []
session_dict['laps']['end-time'] = []
session_dict['laps']['end-timestamp'] = []
session_dict['laps']['timer-time'] = []
session_dict['laps']['distance'] = []
session_dict['laps']['pace'] = []
session_dict['laps']['maximum-speed'] = []
session_dict['laps']['average-heart-rate'] = []
session_dict['laps']['maximum-heart-rate'] = []
session_dict['laps']['trigger-method'] = []
session_dict['laps']['trackpoints'] = []
session_dict['lap start times'] = []
session_dict['lap end times'] = []
session_dict['lap start distances'] = []
session_dict['lap end distances'] = []
for lap in activity.get_records_by_type('lap'):
session_dict['laps']['start-time'].append(
str(local_date_to_utc(lap.get_data("start_time"))))
start_time = lap.get_data("start_time")
session_dict['laps']['end-time'].append(
str(local_date_to_utc(lap.get_data("timestamp"))))
end_time = lap.get_data("timestamp")
timer_time = lap.get_data("total_timer_time")
session_dict['laps']['timer-time'].append(timer_time)
distance = lap.get_data("total_distance")
session_dict['laps']['distance'].append(distance)
if distance == 0.0 or distance == None or timer_time == None:
# TODO: change to None?
session_dict['laps']['pace'].append(0.)
else:
session_dict['laps']['pace'].append(
(1000. / (distance / timer_time)) / 60.)
session_dict['laps']['maximum-speed'].append(
lap.get_data("max_speed")) # opt
session_dict['laps']['average-heart-rate'].append(
lap.get_data("avg_heart_rate")) #opt
session_dict['laps']['maximum-heart-rate'].append(
lap.get_data("max_heart_rate")) #opt
session_dict['laps']['trigger-method'].append(
LAP_TRIGGER_MAP.get(lap.get_data("lap_trigger"), "Manual"))
first_track_point = True
for trackpoint in activity.get_records_by_type('record'):
tts = trackpoint.get_data("timestamp")
if tts >= start_time and tts <= end_time:
if first_track_point == True:
session_dict['lap start times'].append(
(trackpoint.get_data("timestamp") -
real_start_time).seconds)
session_dict['lap start distances'].append(
trackpoint.get_data("distance"))
first_track_point = False
session_dict['laps']['trackpoints'].append({})
session_dict['laps']['trackpoints'][-1]['timestamp'] = str(
local_date_to_utc(trackpoint.get_data("timestamp")))
session_dict['laps']['trackpoints'][-1]['elapsed-time'] = (
trackpoint.get_data("timestamp") - real_start_time).seconds
session_dict['laps']['trackpoints'][-1][
'latitude-position'] = trackpoint.get_data("position_lat")
session_dict['laps']['trackpoints'][-1][
'longitude-position'] = trackpoint.get_data(
"position_long")
session_dict['laps']['trackpoints'][-1][
'distance'] = trackpoint.get_data("distance")
session_dict['laps']['trackpoints'][-1][
'altitude'] = trackpoint.get_data("altitude")
session_dict['laps']['trackpoints'][-1][
'speed'] = trackpoint.get_data("speed")
session_dict['laps']['trackpoints'][-1][
'heart rate'] = trackpoint.get_data("heart_rate")
# TODO: make sure this works out OK, get last valid position
if session_dict['laps']['trackpoints'][-1][
'latitude-position'] == None:
session_dict['laps']['trackpoints'][-1]['latitude'] = None
else:
session_dict['laps']['trackpoints'][-1]['latitude'] = str(
semicircle_to_degrees(
session_dict['laps']['trackpoints'][-1]
['latitude-position']))
if session_dict['laps']['trackpoints'][-1][
'longitude-position'] == None:
session_dict['laps']['trackpoints'][-1]['longitude'] = None
else:
session_dict['laps']['trackpoints'][-1]['longitude'] = str(
semicircle_to_degrees(
session_dict['laps']['trackpoints'][-1]
['longitude-position']))
# add first and last
session_dict['lap end times'].append(
session_dict['laps']['trackpoints'][-1]['elapsed-time'])
session_dict['lap end times'].append(
session_dict['laps']['trackpoints'][-1]['distance'])
# update things from laps
session_dict['start-latitude'] = session_dict['laps']['trackpoints'][0][
'latitude']
session_dict['start-longitude'] = session_dict['laps']['trackpoints'][0][
'longitude']
session_dict['end-latitude'] = session_dict['laps']['trackpoints'][-1][
'latitude']
session_dict['end-longitude'] = session_dict['laps']['trackpoints'][-1][
'longitude']
return session_dict
fit_id_list = []
try:
direct = open(com_path + "direct_table.csv", "rb")
for fit_id in csv.reader(direct):
fit_id_list += [fit_id[0]]
direct.close()
except:
pass
ID = fname[38:-4] #depend on your com_path
if ID not in fit_id_list:
print fname + " Start parsing!!"
time_start = times.time()
a = Activity(fname)
a.parse(hook_func=print_record)
#check None value
for data in csv_dict:
if (csv_dict[data] < csv_dict["time"]):
list = eval(data)
list += [-1]
csv_dict[data] += 1
missing_count[data] += 1
if time != []:
min_time = min(time)
for i in range(len(time)):
time[i] = time[i] - min_time
if len(distance) != 0:
startTime = field.data
if "total_distance" in field.name:
global totalDistance
totalDistance = field.data
totalDistance *= 0.0006213711922373
if "avg_speed" in field.name:
global avgSpeed
avgSpeed = field.data
avgSpeed *= 2.236936292054
if "total_elapsed_time" in field.name:
global totalElapsedTime
totalElapsedTime = field.data
totalElapsedTime /= 3600
for f in filenames:
if quiet:
print f
else:
print ('File = %s ' % f)
print_hook_func = None
if not quiet:
print_hook_func = print_record
record_number = 0
a = Activity(f)
a.parse(hook_func=print_hook_func)
if startTime is not None:
f1.write("%s,%s,%s,%s\n" % (startTime,totalDistance,avgSpeed,totalElapsedTime))
print ("%s,%s,%s,%s\n" % (startTime,totalDistance,avgSpeed,totalElapsedTime))
#!/usr/bin/env python
# Sample usage of python-fitparse to parse an activity and
# print its data records.
from __future__ import print_function
from fitparse import Activity
import re
from collections import OrderedDict
activity = Activity("tests/data/sample-activity.fit")
activity.parse()
# Records of type 'record' (I know, confusing) are the entries in an
# activity file that represent actual data points in your workout.
records = activity.get_records_by_type('record')
current_record_number = 0
dic =OrderedDict.fromkeys(["timestamp","position_lat","position_long","distance","altitude","speed","heart_rate","temperature"])
counter =0
for value in dic.keys():
if counter != 0:
print(';',sep='',end='')
print(value,sep='',end='')
counter+=1
print()
for record in records:
# Print record number
current_record_number += 1
#print (" Record #%d " % current_record_number).center(40, '-')
def convert(filename):
activity = Activity(filename)
activity.parse()
wrapper = ActivityWrapper(activity)
wrapper.process()
return None
