#5 Work in progress:

-Plot with gmplot

[ci skip]

Author: FABallemand

README.md

@@ -20,14 +20,6 @@ test_gpx.plot(start_stop=True, elevation_color=True)
 
 ## 📚 References:
 
-### 🖥️ Implementation
-
-#### 🏷️ XML
-- [GPX XML Schema](http://www.topografix.com/GPX/1/1/)
-
-#### 🌏 Map Projection
-- Wikipedia: [Web Mercator projection](https://en.wikipedia.org/wiki/Web_Mercator_projection)
-
 ### 🧭 Other Python GPX Library
 - [gpxpy](https://github.com/tkrajina/gpxpy)
 

ezgpx/gpx/gpx.py

@@ -2,8 +2,12 @@
 from datetime import datetime
 import pandas as pd
 from math import degrees
+
 import matplotlib.pyplot as plt
 
+import webbrowser
+import gmplot
+
 from ..gpx_elements import Gpx
 from ..gpx_parser import Parser
 from ..gpx_writer import Writer
@@ -20,18 +24,41 @@ def __init__(self, file_path: str):
         self.gpx: Gpx = self.parser.gpx
         self.writer: Writer = Writer(self.gpx, precisions=self.parser.precisions, time_format=self.parser.time_format)
 
+    def name(self) -> str:
+        """
+        Return activity name.
+
+        Returns:
+            str: Activity name.
+        """
+        return self.gpx.name()
+
     def nb_points(self) -> int:
         """
-        Compute the number of points in the GPX.
+        Return the number of points in the GPX.
 
         Returns:
             int: Number of points in the GPX.
         """
-        nb_pts = 0
-        for track in self.gpx.tracks:
-            for track_segment in track.trkseg:
-                nb_pts += len(track_segment.trkpt)
-        return nb_pts
+        return self.gpx.nb_points()
+    
+    def bounds(self) -> tuple[float, float, float, float]:
+        """
+        Find minimum and maximum latitude and longitude.
+
+        Returns:
+            tuple[float, float, float, float]: Min latitude, min longitude, max latitude, max longitude
+        """
+        return self.gpx.bounds()
+    
+    def center(self) -> tuple[float, float]:
+        """
+        Return the coordinates of the center point.
+
+        Returns:
+            tuple[float, float]: Latitude and longitude of the center point.
+        """
+        return self.gpx.center()
 
     def distance(self) -> float:
         """
@@ -236,18 +263,18 @@ def simplify(self, tolerance: float = 2):
         epsilon = degrees(tolerance/EARTH_RADIUS)
         self.gpx.simplify(epsilon)
 
-    def plot(
+    def matplotlib_plot(
             self,
             projection: str = None,
             title: str = "Track",
             base_color: str = "#101010",
             start_stop: bool = False,
             elevation_color: bool = False,
-            duration: bool = None,
-            distance: bool = None,
-            ascent: bool = None,
-            pace: bool = None,
-            speed: bool = None,
+            duration: bool = False,
+            distance: bool = False,
+            ascent: bool = False,
+            pace: bool = False,
+            speed: bool = False,
             file_path: str = None):
 
         # Handle projection
@@ -304,4 +331,38 @@ def plot(
             # Check path
             plt.savefig(file_path)
         else:
-            plt.show()
+            plt.show()
+
+    def gmap_plot(
+        self,
+        title: str = None,
+        base_color: str = "#110000",
+        start_stop: str = False,
+        zoom: float = 10.0,
+        file_path: str = None,
+        open: bool = True,
+        scatter: bool = False,
+        plot: bool = True):
+
+        # Convert to dataframe and compute center latitude and longitude
+        test_gpx_df = self.to_dataframe()
+        center_lat, center_lon = self.center()
+
+        # Create plotter
+        map = gmplot.GoogleMapPlotter(center_lat, center_lon, zoom)
+
+        # Plot and save
+        if title is not None:
+            map.text(center_lat, center_lon, self.name(), color="#FFFFFF")
+        if start_stop:
+            map.scatter([self.gpx.tracks[0].trkseg[0].trkpt[0].lat], [self.gpx.tracks[0].trkseg[0].trkpt[0].lon], "#00FF00", size=5, marker=True)
+            map.scatter([self.gpx.tracks[-1].trkseg[-1].trkpt[-1].lat], [self.gpx.tracks[-1].trkseg[-1].trkpt[-1].lat], "#FF0000", size=5, marker=True)
+        if scatter:
+            map.scatter(test_gpx_df["latitude"], test_gpx_df["longitude"], base_color, size=5, marker=False)
+        if plot:
+            map.plot(test_gpx_df["latitude"], test_gpx_df["longitude"], base_color, edge_width=2.5)
+        map.draw(file_path)
+
+        # Open
+        if open:
+            webbrowser.open(file_path)

ezgpx/gpx_elements/gpx.py

@@ -69,6 +69,66 @@ def __init__(
         self.tracks: list[Track] = tracks
         self.extensions: Extensions = extensions
 
+    def name(self) -> str:
+        """
+        Return activity name.
+
+        Returns:
+            str: Activity name.
+        """
+        return self.tracks[0].name
+
+    def nb_points(self) -> int:
+        """
+        Compute the number of points in the GPX.
+
+        Returns:
+            int: Number of points in the GPX.
+        """
+        nb_pts = 0
+        for track in self.tracks:
+            for track_segment in track.trkseg:
+                nb_pts += len(track_segment.trkpt)
+        return nb_pts
+    
+    def bounds(self) -> tuple[float, float, float, float]:
+        """
+        Find minimum and maximum latitude and longitude.
+
+        Returns:
+            tuple[float, float, float, float]: Min latitude, min longitude, max latitude, max longitude
+        """
+        min_lat = self.tracks[0].trkseg[0].trkpt[0].lat
+        min_lon = self.tracks[0].trkseg[0].trkpt[0].lon
+        max_lat = min_lat
+        max_lon = min_lon
+
+        for track in self.tracks:
+            for track_segment in track.trkseg:
+                for track_point in track_segment.trkpt:
+                    if track_point.lat < min_lat:
+                        min_lat = track_point.lat
+                    if track_point.lon < min_lon:
+                        min_lon = track_point.lon
+                    if track_point.lat > max_lat:
+                        max_lat = track_point.lat
+                    if track_point.lon > max_lon:
+                        max_lon = track_point.lon
+        return min_lat, min_lon, max_lat, max_lon
+
+
+    def center(self) -> tuple[float, float]:
+        """
+        Compute the center coordinates of the track.
+
+        Returns:
+            tuple[float, float]: Latitude and longitude of the center point.
+        """
+        min_lat, min_lon, max_lat, max_lon = self.bounds()
+        center_lat = min_lat + (max_lat - min_lat) / 2
+        center_lon = min_lon + (max_lon - min_lon) / 2
+        return center_lat, center_lon
+
     def distance(self) -> float:
         """
         Compute the total distance (meters) of the tracks contained in the Gpx element.

notes.md

@@ -2,12 +2,16 @@
 
 ### 🖥️ Implementation
 
-#### 💾 Python XML Parsing:
+#### 🏷️ XML
+- [GPX XML Schema](http://www.topografix.com/GPX/1/1/)
 - Real Python: [A roadmap to XML Parsers in Python](https://realpython.com/python-xml-parser/#learn-about-xml-parsers-in-pythons-standard-library)
 - [xml.etree.ElementTree — The ElementTree XML API](https://docs.python.org/3/library/xml.etree.elementtree.html)
 - GeeksForGeeks: [Reading and Writing XML Files in Python](https://www.geeksforgeeks.org/reading-and-writing-xml-files-in-python/)
 
-#### 🌏 Map Projection
+#### 🌏 Map Plotting
+- [gmplot](https://github.com/gmplot/gmplot)
+- [OSMPythonTools](https://wiki.openstreetmap.org/wiki/OSMPythonTools)
+- - Towards Data Science: [Loading Data from OpenStreetMap with Python and the Overpass API](https://towardsdatascience.com/loading-data-from-openstreetmap-with-python-and-the-overpass-api-513882a27fd0)
 - Wikipedia: [Web Mercator projection](https://en.wikipedia.org/wiki/Web_Mercator_projection)
 
 #### 🗃️ Creating a Python Library