예제 #1
0
파일: Utrack.py 프로젝트: ernesst/Utrack
def leave(gpx):
    global info_display
    filename = str(round(time.time() * 1000))
    os.system('clear')
    print('\nGPX file Created : ' + filename + ".gpx")
    file = open("/home/phablet/Downloads/" + filename + ".gpx", "w+")
    file.write(gpx.to_xml())
    file.close()
    gpx_file = "/home/phablet/Downloads/" + filename + ".gpx"
    shutil.chown(gpx_file, user="******", group="phablet")
    gpx = gpxpy.parse(open(gpx_file))
    indentation = '   '
    info_display = ""
    length_2d = gpx.length_2d()
    length_3d = gpx.length_3d()
    info_display += "\n%sLength 2D: %s" % (indentation, format_long_length(length_2d))
    info_display += "\n%sLength 3D: %s" % (indentation, format_long_length(length_3d))
    moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data()
    info_display += "\n%sMoving time: %s" %(indentation, format_time(moving_time))
    info_display += "\n%sStopped time: %s" %(indentation, format_time(stopped_time))
    info_display += "\n%sMax speed: %s" % (indentation, format_speed(max_speed))
    info_display += "\n%sAvg speed: %s" % (indentation, format_speed(moving_distance / moving_time) if moving_time > 0 else "?")
    uphill, downhill = gpx.get_uphill_downhill()
    info_display += "\n%sTotal uphill: %s" % (indentation, format_short_length(uphill))
    info_display += "\n%sTotal downhill: %s" % (indentation, format_short_length(downhill))
    info_display += "\n\n\n"
    print(info_display)
    if args.activity:
        newlocation="/home/phablet/.local/share/activitytracker.cwayne18/{}".format(filename + ".gpx")
        copyfile(gpx_file, newlocation)
        shutil.chown(newlocation, user="******", group="phablet")
        add_run(gpx,filename,"", newlocation)
    p.kill()
    sys.exit()
예제 #2
0
def add_run(gpx, name,act_type,filename,polyline):
    conn = sqlite3.connect('%s/activities.db' % filebase)
    cursor = conn.cursor()
    cursor.execute("""CREATE TABLE if not exists activities
                  (id INTEGER PRIMARY KEY AUTOINCREMENT,name text, act_date text, distance text,
                   speed text, act_type text,filename text,polyline text)""")
    sql = "INSERT INTO activities VALUES (?,?,?,?,?,?,?,?)"
    start_time, end_time = gpx.get_time_bounds()
    l2d='{:.3f}'.format(gpx.length_2d() / 1000.)
    moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data()
    print(max_speed)
    #print('%sStopped distance: %sm' % stopped_distance)
    maxspeed = 'Max speed: {:.2f}km/h'.format(max_speed * 60. ** 2 / 1000. if max_speed else 0)
    duration = '{:.2f}'.format(gpx.get_duration() / 60)

    print("-------------------------")
    print(name)
    print(start_time)
    print(l2d)
    print(maxspeed)
    print("-------------------------")
    try:
        cursor.execute(sql, [None, name,start_time,l2d,duration,act_type,filename,polyline])
        conn.commit()
    except sqlite3.Error as er:
        print("-------------______---_____---___----____--____---___-----")
        print(er)
    conn.close()
예제 #3
0
    def publish_stat(self, client, device, tracker, gpx):
        time_data = self.get_time_bounds(gpx)
        move_data = gpx.get_moving_data()

        move_time = (time_data.end_time - time_data.start_time).total_seconds()
        avg_speed = (move_data.moving_distance /
                     move_time) if move_time != 0 else 0

        self.load_counters()

        if device not in self.counters:
            self.counters[device] = {'odo': 0, 'engine_time': 0}

        self.counters[device]['odo'] = self.counters[device][
            'odo'] + move_data.moving_distance / 1000
        self.counters[device]['engine_time'] = self.counters[device][
            'engine_time'] + move_time / 3600.0

        self.store_counters()

        stat = {
            '_type': 'stat',
            'move_time': move_time,
            'avg_speed': avg_speed * 3.6,
            'max_speed': move_data.max_speed * 3.6,
            'distance': move_data.moving_distance / 1000
        }
        stat.update(self.counters[device])
        logging.info("Sendning stat for device:%s %s", device,
                     json.dumps(stat))
        client.publish('owntracks/%s/%s/stat' % (device, tracker),
                       json.dumps(stat),
                       retain=True)
        pass
예제 #4
0
def add_run(gpx, name, act_type, filename, polyline):
    conn = sqlite3.connect("%s/activities.db" % filebase)
    cursor = conn.cursor()
    cursor.execute(
        """CREATE TABLE if not exists activities
                  (id INTEGER PRIMARY KEY AUTOINCREMENT,name text, act_date text, distance text, 
                   speed text, act_type text,filename text,polyline text)"""
    )
    sql = "INSERT INTO activities VALUES (?,?,?,?,?,?,?,?)"
    start_time, end_time = gpx.get_time_bounds()
    l2d = "{:.3f}".format(gpx.length_2d() / 1000.0)
    moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data()
    print(max_speed)
    # print('%sStopped distance: %sm' % stopped_distance)
    maxspeed = "Max speed: {:.2f}km/h".format(max_speed * 60.0 ** 2 / 1000.0 if max_speed else 0)
    duration = "Duration: {:.2f}min".format(gpx.get_duration() / 60)

    print("-------------------------")
    print(name)
    print(start_time)
    print(l2d)
    print(maxspeed)
    print("-------------------------")
    try:
        cursor.execute(sql, [None, name, start_time, l2d, duration, act_type, filename, polyline])
        conn.commit()
    except sqlite3.Error as er:
        print(er)
    conn.close()
예제 #5
0
def get_data():
    moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data()
    return moving_distance, moving_time
예제 #6
0
import gpxpy
import gpxpy.gpx
from geopy.distance import vincenty

gpx_file = open('data\CAStd_116.gpx', 'r+')
gpx = gpxpy.parse(gpx_file)
gpx_file.close()

print('time_data/n', gpx.get_moving_data())

gpx_file1 = open('data\CAStd_116_out.gpx', "w")  #打开文件,进行写操作
out = gpxpy.gpx.GPX()


#分割
def splite(start, avg, seg, new_trk):
    i_p = 0
    pre_point = None
    new_seg = gpxpy.gpx.GPXTrackSegment()

    for point in seg.points[start:]:
        i_p += 1
        #访问到segment.points中第几个point
        index = i_p + start
        #判断distance
        if point.time:
            if pre_point:
                newport_ri = (point.latitude, point.longitude)
                distance = vincenty(pre_point, newport_ri).meters
                if distance > avg:
                    # 出口1:查出不合格的distance,将当前new_seg加入
예제 #7
0
def main():
    """Run the main programme."""
    parser = setup_argparser()
    args = parser.parse_args()

    if args.plot_all:
        args.plot_heart_rate = True
        args.plot_speed = True
        args.plot_cadence = True
        args.show_summary = True

    gpx = get_gpx(args.filename, args.quiet)
    (track, data) = parse_gpx(gpx)

    duration = gpx.get_moving_data().moving_time
    distance = gpx.get_moving_data().moving_distance
    average_speed = distance / duration

    butterworth_filter = get_filter(average_speed)
    elevations_filtered = signal.filtfilt(butterworth_filter[0],
                                          butterworth_filter[1],
                                          data["elevations"])
    gradient = np.diff(elevations_filtered)
    zero_crossings = np.where(np.diff(np.sign(gradient)))[0]

    markers = np.insert(zero_crossings, 0, 0)
    markers = np.append(markers, len(data["elevations"]) - 1)

    if not args.quiet:
        print("Calculating metrics")

    metrics = calculate_metrics(markers, data)
    summary = calculate_summary(data, metrics)

    if not args.quiet:
        print("Plotting")
        if args.plot_heart_rate and not data["heart_rates"]:
            print(
                "WARNING: Heart rate plot requested but no heart rate data could be found",
                file=sys.stderr)
        if args.plot_cadence and not data["cadences"]:
            print(
                "WARNING: Cadence plot requested but no cadence data could be found",
                file=sys.stderr)

    # https://www.codecademy.com/articles/seaborn-design-i
    sns.set_style(style="ticks", rc={"grid.linestyle": "--"})
    sns.set_context(rc={"grid.linewidth": 0.3})
    (_blue, orange, green, red, purple, _brown, _magenta, _grey, yellow,
     cyan) = sns.color_palette("deep")

    if args.interactive_plot:
        plt.ion()
    else:
        plt.ioff()

    (fig, (ax_elevation, ax_speed, ax_hr,
           ax_pedaling)) = get_figure(args, data["heart_rates"],
                                      data["cadences"])
    axes = tuple(
        [a for a in (ax_elevation, ax_speed, ax_hr, ax_pedaling) if a])

    plot_elevation(ax_elevation, data["cumulative_distances"],
                   data["elevations"], elevations_filtered, gradient, summary,
                   green, [yellow, orange, red])
    ax_grade = ax_elevation.twinx()
    plot_grades(ax_grade, data["cumulative_distances"], metrics["grades"],
                orange)
    handles_ax_grade, legend_ax_grade = ax_grade.get_legend_handles_labels()
    # https://stackoverflow.com/questions/4700614/how-to-put-the-legend-out-of-the-plot
    ax_grade.legend(handles_ax_grade,
                    legend_ax_grade,
                    loc="upper right",
                    fontsize=_FONT_SIZE)

    if ax_speed:
        plot_speed(ax_speed, data["cumulative_distances"],
                   metrics["speed_averages"], data["speed"], cyan)
    if ax_hr:
        plot_hr(ax_hr, data["cumulative_distances"],
                metrics["heart_rate_averages"], data["heart_rates"], red)
    if ax_pedaling:
        plot_pedaling(ax_pedaling, data["cumulative_distances"],
                      metrics["cadence_percentages"], data["cadences"], purple)

    bottom_axis = axes[-1]
    bottom_axis.xaxis.set_major_formatter(ticker.ScalarFormatter())
    bottom_axis.set_xlabel("Distance (km)", fontsize=_FONT_SIZE)
    fig.align_ylabels(axes)

    if track.name:
        # https://stackoverflow.com/questions/1111317/how-do-i-print-a-python-datetime-in-the-local-timezone
        # assume the gpx time is always UTC
        start_time = track.get_time_bounds().start_time.astimezone(
            get_localzone())
        fig.suptitle("{name} on {date} at {time}".format(
            name=track.name.strip(),
            date=start_time.date(),
            time=start_time.time().strftime("%H:%M")))
        # https://stackoverflow.com/questions/2507726/how-to-display-locale-sensitive-time-format-without-seconds-in-python
        # fig.suptitle("{name} on {date} at {time}".format(name=track.name.strip(),
        #                                                  date=start_time.date().strftime("%x"),
        #                                                  time=start_time.time().strftime("%X")))

    save_figure(fig, args)

    if args.interactive_plot:
        plt.show()
        input("Press any key to quit ...")
        plt.close()

    if args.show_summary:
        print_summary(summary)
예제 #8
0
 file.close()
 gpx_file = filename + ".gpx"
 shutil.chown(gpx_file, user="******", group="phablet")
 gpx = gpxpy.parse(open(gpx_file))
 indentation = '   '
 info_display = ""
 """
 gpx_part may be a track or segment.
 """
 length_2d = gpx.length_2d()
 length_3d = gpx.length_3d()
 info_display += "\n%sLength 2D: %s" % (indentation,
                                        format_long_length(length_2d))
 info_display += "\n%sLength 3D: %s" % (indentation,
                                        format_long_length(length_3d))
 moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data(
 )
 info_display += "\n%sMoving time: %s" % (indentation,
                                          format_time(moving_time))
 info_display += "\n%sStopped time: %s" % (indentation,
                                           format_time(stopped_time))
 info_display += "\n%sMax speed: %s" % (indentation,
                                        format_speed(max_speed))
 info_display += "\n%sAvg speed: %s" % (
     indentation, format_speed(moving_distance /
                               moving_time) if moving_time > 0 else "?")
 uphill, downhill = gpx.get_uphill_downhill()
 info_display += "\n%sTotal uphill: %s" % (indentation,
                                           format_short_length(uphill))
 info_display += "\n%sTotal downhill: %s" % (indentation,
                                             format_short_length(downhill))
 info_display += "\n\n\n"
예제 #9
0
def get_data():
    moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data(
    )
    return moving_distance, moving_time
예제 #10
0
파일: test15.py 프로젝트: swjmy/gpx_project
import gpxpy
import gpxpy.gpx
from geopy.distance import vincenty


gpx_file=open('data\CAStd_116.gpx','r+')
gpx=gpxpy.parse(gpx_file)
gpx_file.close()

print('time_data/n',gpx.get_moving_data())

gpx_file1=open('data\CAStd_116_out.gpx', "w") #打开文件,进行写操作
out=gpxpy.gpx.GPX()




#分割
def splite(start,avg,seg,new_trk):
    i_p=0
    pre_point=None
    new_seg=gpxpy.gpx.GPXTrackSegment()

    for point in seg.points[start:]:
        i_p+=1
        #访问到segment.points中第几个point
        index = i_p+start
        #判断distance
        if point.time:
            if pre_point:
                newport_ri = (point.latitude, point.longitude)
예제 #11
0
def getalldata(filepath):
    gpx_file = open(filepath, 'r')
    gpx = gpxpy.parse(gpx_file)
    moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data(
    )
    dist_pace_calc = 0
    dist_split_calc = 0
    split_distance = 0
    split_pace = []
    split_dist = []
    graph_distance = 0
    graph_speed = []
    graph_dist = []
    all_pace = []
    all_elev = []
    all_points_x = []
    all_points_y = []
    dist_bw_pts = []
    all_hr = []
    def_origin = 1
    # Get all x,y points and speed
    for track in gpx.tracks:
        for segment in track.segments:
            for point_no, point in enumerate(segment.points):
                pointxy = to_xy((point.latitude, point.longitude), r,
                                math.sin(math.radians(point.longitude)))
                if def_origin:
                    origin = pointxy
                    origin_latlong = point
                    prev_point_graph = origin_latlong
                    prev_point_split = origin_latlong
                    start_point = point
                    def_origin = 0
                else:
                    end_point = point
                    dist_from_prev = gpxpy.geo.distance(
                        segment.points[point_no - 1].latitude,
                        segment.points[point_no - 1].longitude,
                        segment.points[point_no - 1].elevation,
                        point.latitude,
                        point.longitude,
                        point.elevation,
                        haversine=True)
                    dist_bw_pts.append(dist_from_prev)
                    dist_pace_calc = dist_pace_calc + dist_from_prev
                    dist_split_calc = dist_split_calc + dist_from_prev
                    time_diff = get_time_diff(segment.points[point_no - 1],
                                              point, 's')
                    all_pace.append(mydiv(time_diff, dist_from_prev))
                    all_elev.append(point.elevation)
                    all_points_x.append(pointxy[0] - origin[0])
                    all_points_y.append(pointxy[1] - origin[1])
                    if dist_pace_calc > DIST_BETWEEN_PACE:
                        graph_distance = graph_distance + dist_pace_calc
                        time_diff = get_time_diff(prev_point_graph, point, 's')
                        m_per_s = mydiv(dist_pace_calc, time_diff)
                        graph_speed.append(m_per_s)
                        graph_dist.append(graph_distance)
                        dist_pace_calc = 0
                        prev_point_graph = point
                    if dist_split_calc > SPLIT_DIST_M:
                        split_distance = split_distance + dist_split_calc
                        time_diff = get_time_diff(prev_point_split, point,
                                                  'min')
                        min_per_selected_split = mydiv(
                            time_diff, (dist_split_calc / M_IN_KM))
                        split_pace.append(min_per_selected_split)
                        split_dist.append(split_distance)
                        dist_split_calc = 0
                        prev_point_split = point
                    for ext in point.extensions:
                        for child in ext:
                            if 'hr' in child.tag:
                                all_hr.append(int(child.text))

    total_time = (
        moving_time + stopped_time
    ) / SECONDS_IN_MINUTE  #get_time_diff(start_point, end_point, 'min')
    ret_dict = {
        'all_pace': all_pace,
        'all_elev': all_elev,
        'all_hr': all_hr,
        'all_dist': dist_bw_pts,
        'graph_speed': graph_speed,
        'graph_dist': graph_dist,
        'split_pace': split_pace,
        'split_dist': split_dist,
        'all_x': all_points_x,
        'all_y': all_points_y,
        'total_time': total_time,
        'moving_dist': moving_distance,
        'moving_time': moving_time
    }
    return ret_dict