Creating polyline-based "heatmap" from GPS tracks?

Question

This winter I am planning to track my downhill skiing/snowboarding using a GPS. Most of my riding will occur at the same resort. I would like to be able to create a sort of "heatmap" that shows the amount of runs that I have made in a given area. As I add more and more GPS traces to my database, my goal would be to see a sort of linear heatmap of the most traveled areas. Given the nature of downhill skiing, you would expect the uphill chairlift lines will be the "hottest" because it will be the only places visited over-and-over again.

Given that 1) my track will not be the same every time and 2) the area covered by following one "run" may be a few hundred feet wide, what might be the best way to analyze this "linear" data to create a sort of heatmap? My thoughts were to buffer the lines, then intersect the polys to get a sort of Venn Diagram thing going. My preference is to use open-source technologies. I've got QGIS and PostGIS loaded and available.

UPDATE: In regards to @blah238's response, I was thinking of something that might be able to "collect" the number of passes ("runs") through an area, and then symbolize by the count. Conceptually, this would be similar to ArcGIS "Collect Events" (but for lines, not points) or Collapse Dual Lines To Centerline (but for multiple line in roughly the same area).

A more visual example of a similar concept might be a traffic-flow map, where highly-congested areas would equate to "highly-traveled" ski runs/areas:

I've read the following questions that may give some ideas, but they don't really address what I am trying to accomplish:

Clustering Trajectories (GPS data of (x,y) points) and Mining the data

Managing error with GPS routes (theoretical framework?)

Answer 1

I've done a bit of work on this in GeoTools/GeoServer by extending the Heatmap Rendering Transformation to support geometries other than points.

It's not finished yet, but you can get the feature branch from my repository on GitHub.

The screenshot is of GPS tracks from when I worked as a pizza delivery driver.

Answer 2

Here is a good tutorial for doing exactly that using MapBox and TileMill:

• A heatmap for all your runs in RunKeeper

Answer 3

here is my simple approach:

1. create a new map in umap: http://umap.openstreetmap.fr/en
2. click Import Data a select all the gpx files you have and upload them into map (you can import all of them at once)
3. enter Edit map settings > Default properties, choose opacity 0.25, weight 10.

The three steps above will take 5 minutes and here is the result:

Answer 4

Here is my approach on QGIS. This was for a set of bus routes, and I wanted to identify which roads had the most density of bus routes passing by.

• Used the Qchainage plugin to convert my lines into points. Tested different scenarios until I produced a lot of points per line (1,500 per line, and lines were about 9kms).
• Applied the heatmap symbology rendering that Qgis has built-in in the style tab. layer properties > style > heatmap
• Play with the radius and the maximum value. Make sure to select the best rendering quality.
• Created a new color ramp (choose continuous) starting from black and any other bright color on the other side.

And voilà.

Answer 5

I realize this is quite an old post, however, I came across it doing similar research. I developed a pretty simple model/work flow that can accomplish just this in ArcGIS (possibly QGIS, but I've not yet implemented it there).

If you have a GPX or TCX file specifically (any point file works though), it can simply be opened up in Excel, then converted to a CSV and brought into ArcGIS. Using the Points to Line tool, you convert the GPS points from the CSV, into trajectories by sorting the points by time (you could also group them using a unique identifier, which in this case might be by the resort, route, or specific date of the event - e.g. Day1, 2, etc). This will create a single polyline layer (unless you group them by the unique ID). You then use the Split Line at Vertices tool which creates line segments between each successive point. From there, you use the Line Density tool which counts the number of lines passing through a cell given a specified cell size and search radius, and outputs a raster. This raster can be symbolized as a heat map.

I have, and continue to implement this frequently, and included a sample result below:

Answer 6

Our use of this involves routing students to their school using PGRouting.

The results of an individual route are at their core a set of nodes (which are turned into lines by optionally joining the related edges).

If you route multiple students to a single school, the output collection of nodes can be then displayed in QGIS using the heatmap renderer, which shows the 'hotspots' of collected routes to the school (see below).

These maps were used to inform areas that should be targeted for further safety infrastructure such as crossings, signals, signs, etc.

Answer 7

Create a graticular gridwork, convert gpsdata to shapefiles, polygonize the lines, extract x,y point data from tables, make a surface density, or heat map using standard practice at this point. You could then merge with linear vector data to get pixel values in a raster display or for further numerical processing.

Answer 8

Most people (including myself) look at a GPX file and think of it as a sequence of positions (points), while it can be perfectly seen as a sequence of line segments instead.

Your problem formulation involves a "heat map" so that you can inspect visually your trajectories, so there is a rather simple way to skip the complex numbercrunching part by delegating it directly to a plotting engine.

When you say "buffer the lines", that would be line thickness. When you say "collect the passes" that would mean plotting over and over with transparent lines, thus "building up" more and more color.

So, I suggest you to plot each trajectory as a single polyline with thickness enough that there is some overlap (it depends on zoom, so you'll want to set the thickness in map distance instead of pixels), and with a fairly low opacity, say, 0.05, in black.

It is important not to plot each segment, because if you do so, their extremities will overlap, doubling their opacity and creating a "dot" of stronger color.

In the end, you'll get a grayscale image upon which you can apply the colormap of your choice.

I would probably do it using Python/Cairo, but Python/Matplotlib would do, and Html/Canvas or Html/SVG (or programmatic SVG) certainly would do.

The end result would depend only on resolution of your output media.

Answer 9

I'm aware that this is quite an old question, but as this post is one of the top search results for this topic, I thought I'd post a link to a workflow for producing polyline heat maps in ArcGIS that answers this question, as there is currently no solution for ArcGIS in this post.

https://luke-webber.github.io/polyline-heatmap/