Vjylku

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.

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

• A heatmap for all your runs in RunKeeper

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:

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à.

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:

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.

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.

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/

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.