SoFunction
Updated on 2025-04-08

Detailed explanation of examples of Python generating dynamic routing track diagrams

In today's data-driven era, visualization technologies play an increasingly important role in data analysis and decision support. Especially in the fields of transportation, logistics, etc., being able to dynamically display the movement trajectory of vehicles or personnel is of great significance to optimizing path planning and improving efficiency. This article will introduce how to use Python to generate dynamic routing trajectory diagrams to help developers better understand and analyze data.

1. Environmental preparation

Before you start, make sure that the following Python libraries are installed in your environment:

  • Matplotlib: Used to draw charts.
  • Pandas: for data processing.
  • Folium: Used to create interactive maps.

These libraries can be installed via the following command (if not already installed):

pip install matplotlib pandas folium

2. Data preparation

Suppose we have a CSV file that contains a series of geolocation information, including timestamps, longitudes, and latitudes. We will use Pandas to read this file and perform the necessary preprocessing.

import pandas as pd
 
# Read datadata = pd.read_csv('route_data.csv')
 
# View the first few lines of dataprint(())

3. Draw a static roadmap

First, we use the Folium library to draw a static map showing the location points of all records.

import folium
 
# Create a map objectm = (location=[data['latitude'].mean(), data['longitude'].mean()], zoom_start=13)
 
# Add location tagfor index, row in ():
    ([row['latitude'], row['longitude']]).add_to(m)
 
# Show map("static_route_map.html")

4. Dynamic display track

To make the map more vivid, we can use Folium’s PolyLine feature to dynamically show the changes in trajectory. Here we will gradually add segments to the map in chronological order.

from  import TimestampedGeoJson
 
# Prepare timestamp datafeatures = []
for i in range(len(data) - 1):
    feature = {
        "type": "Feature",
        "geometry": {
            "type": "LineString",
            "coordinates": [[[i]['longitude'], [i]['latitude']],
                            [[i+1]['longitude'], [i+1]['latitude']]]
        },
        "properties": {
            "times": [str([i]['timestamp']), str([i+1]['timestamp'])],
            "popup": f"From {i} to {i+1}",
            "style": {"color": "blue", "weight": 5}
        }
    }
    (feature)
 
# Create timestamp GeoJSONgeojson = {"type": "FeatureCollection", "features": features}
 
# Create a map and add a timestamp GeoJSON layerm = (location=[data['latitude'].mean(), data['longitude'].mean()], zoom_start=13)
TimestampedGeoJson(geojson, period="PT1M").add_to(m)
 
# Save the map("dynamic_route_map.html")

Through the above steps, we can not only generate a static roadmap, but also create a map that dynamically displays trajectory changes. This type of visualization tool is very useful for monitoring and analyzing the paths of moving objects, and can help users understand the story behind the data more intuitively.

Method supplement

Generating dynamic routing trajectory maps is very useful in many applications, such as logistics tracking, vehicle navigation, motion data analysis, etc. Below is a sample code that uses Python and Matplotlib libraries to generate dynamic routing trajectories.

Environmental preparation

First, make sure you have installed the required libraries:

pip install matplotlib

Sample code

Suppose we have a CSV file containing timestamps and latitude and longitude coordinates, with the following content:

timestamp,latitude,longitude
1,37.7749,-122.4194
2,37.7750,-122.4195
3,37.7751,-122.4196
4,37.7752,-122.4197
5,37.7753,-122.4198

We will read this file and use Matplotlib to generate a dynamic routing track map.

import pandas as pd
import  as plt
import  as animation
 
# Read datadata = pd.read_csv('')
 
# Extract time and coordinatestimestamps = data['timestamp']
latitudes = data['latitude']
longitudes = data['longitude']
 
# Create a graphical objectfig, ax = ()
 
# Initialize the imageline, = ([], [], 'o-', lw=2)
ax.set_xlim(min(longitudes) - 0.001, max(longitudes) + 0.001)
ax.set_ylim(min(latitudes) - 0.001, max(latitudes) + 0.001)
 
def init():
    line.set_data([], [])
    return line,
 
def update(frame):
    x = longitudes[:frame]
    y = latitudes[:frame]
    line.set_data(x, y)
    return line,
 
# Create animationani = (fig, update, frames=len(timestamps), init_func=init, blit=True, interval=500)
 
# Show graphics('Dynamic Route Trajectory')
('Longitude')
('Latitude')
()

Code explanation

  • Read data: Use Pandas to read data in CSV files.
  • Extract time and coordinates: Extract timestamps, latitudes, and longitudes from the data.
  • Create a graph object: Create a graph object using Matplotlib.
  • Initialize the image: Set the initial graphics range.
  • Define the initialization function: the init function is used to initialize the image.
  • Define update function: The update function is used to update the image in each frame.
  • Create an animation: Create an animation with FuncAnimation, specifying the number of frames, initializing functions, update functions, and frame intervals.
  • Display Graphics: Displays the generated dynamic routing track diagram.

After running the above code, you will see a dynamic routing track diagram, which will gradually be displayed over time.

Hope this example helps you! If you have any questions or need further explanation, feel free to let me know. Generating dynamic routing trajectory maps in Python can be implemented using a variety of libraries, such as Matplotlib, Plotly, and Folium. These libraries have their own characteristics, and you can choose the right tools according to your specific needs. Below I will introduce how to use these three libraries to generate dynamic routing track maps.

1. Use Matplotlib

Matplotlib is a very popular drawing library suitable for basic 2D graphics drawing. For dynamic displays, you can use FuncAnimation to update the graphics.

Sample code:

import  as plt
from  import FuncAnimation
import numpy as np
 
# Simulate datax_data = []
y_data = []
 
fig, ax = ()
line, = ([], [], lw=2)
 
def init():
    ax.set_xlim(0, 10)
    ax.set_ylim(-5, 5)
    return line,
 
def update(frame):
    x_data.append(frame)
    y_data.append((frame))
    line.set_data(x_data, y_data)
    return line,
 
ani = FuncAnimation(fig, update, frames=(0, 10, 100), init_func=init, blit=True)
()

2. Use Plotly

Plotly is an interactive chart library that supports dynamic updates and interactive operations. It is perfect for making complex dynamic charts.

Sample code:

import plotly.graph_objects as go
import numpy as np
 
# Simulate datax = (0, 10, 100)
y = (x)
 
frames = [(data=[(x=x[:k], y=y[:k])],
                   traces=[0],
                   name=f'frame{k}') for k in range(1, len(x))]
 
fig = (
    data=[(x=x[:1], y=y[:1], mode="lines+markers")],
    layout=(
        title="Dynamic Route",
        updatemenus=[dict(
            type="buttons",
            buttons=[dict(label="Play",
                          method="animate",
                          args=[None, {"frame": {"duration": 100, "redraw": False},
                                      "fromcurrent": True, "transition": {"duration": 0}}]),
                     dict(label="Pause",
                          method="animate",
                          args=[[None], {"frame": {"duration": 0, "redraw": False},
                                        "mode": "immediate", "transition": {"duration": 0}}])
                    ])]
    ),
    frames=frames
)
 
fig.update_layout(xaxis_range=[0, 10], yaxis_range=[-1, 1])
()

3. Use Folium

Folium is a map visualization library based on, suitable for dynamic display of geographic information. It makes it easy to add markers, routes, and more to the map.

Sample code:

import folium
from  import TimestampedGeoJson
 
# Simulate datadata = [
    {"time": "2023-01-01T00:00:00Z", "coordinates": [37.7749, -122.4194]},
    {"time": "2023-01-01T00:01:00Z", "coordinates": [37.7750, -122.4195]},
    {"time": "2023-01-01T00:02:00Z", "coordinates": [37.7751, -122.4196]},
    # Add more points]
 
# Create a mapm = (location=[37.7749, -122.4194], zoom_start=13)
 
# Prepare GeoJSON datageojson_data = {
    "type": "FeatureCollection",
    "features": [
        {
            "type": "Feature",
            "geometry": {
                "type": "Point",
                "coordinates": item["coordinates"]
            },
            "properties": {
                "time": item["time"],
                "icon": "circle",
                "iconstyle": {
                    "fillColor": "blue",
                    "fillOpacity": 0.8,
                    "stroke": "false",
                    "radius": 5
                }
            }
        } for item in data
    ]
}
 
# Add timestamp GeoJSONTimestampedGeoJson(geojson_data, period="PT1M").add_to(m)
 
# Show map("dynamic_route.html")

Summarize

Matplotlib: Suitable for simple 2D graphics, suitable for beginners.

Plotly: Suitable for charts that require interaction and complex animations.

Folium: suitable for dynamic display of geographic information, especially for applications involving maps.

Depending on your specific needs, you can choose the appropriate library to generate dynamic routing track maps. Hope these examples help you!

The above is a detailed explanation of the example of Python generating dynamic routing track maps. For more information about Python dynamic routing track maps, please pay attention to my other related articles!