It has not been a quiet couple of days here in the Laboratory. Lots of gear and glassware about. Goggles, bunsen burners and all that sort of thing. And the report draft was just finished with Nicolas Nova, which occupied many early mornings. We almost spilled an organic, but toxic material on the draft which cause a collective gasp, but it was pulled out of the way, just in time before irrevocable damage was done. We’re writing with ink and pen these days, which feels so much more angelic and respectful, but are, through incidents like this, reminded that such may have nostalgic integrity, but it is also quite delicate and precious.
In the midst of all that was the need to translate a GPS track from GPX format to DXF. This was harder than I thought it would be, at least after poking around the Google. There are some tools that’ll do format conversions and so forth, but they were way more expensive than I thought was reasonable, seeing as we’re not making precious objects. It’s basically a translation of one connected graph format to another.
Okay, so — it was time to think about making our own tools, which took 10 times less time than the original set of Google searches, mostly because of the recently discovered ancient treasure of a Java library our buddy Tom Carden wrote back in the Precambian of the Age of the Network — somewhere’s around 1996 or some such…
This library provides enough functionality to read a GPX track and draw it on screen. The Processing.org DXF library can spit that drawing from the screen out as a saved DXF. So, that basically solves the problem. The DXF files that come out are flat lines that can then be serviced by other software to do other things. (There also exists this Kabeja library for consuming DXF and creating DOM models, which we’ll save for another day.
My lead toward the Carden code was found here on the Processing.org forums, where I found enough of a simple code snippet to get me out and through the chiseled hole in the brick wall I had hit.
Also to note is the small comment in the small simple bit of code that can cobble together many separate GPX files (tracks from a GPS) into one larger one, which can be quite convenient.
Why do I blog this? Mostly for my own recollection and notes as to how things are done. It’s been enough time in the jungle of small, utility challenges that, when on another project inevitably in the future, some small task I need to perform smells familiar — but, why? One gets the feeling — I’ve had to do this before? What project was it? How did I do it? Playing in the geo/map-making/cartography space has all these little formats and translation steps that are a bit zany to wrangle. Jotting a post with a bit of a reminder helps. Te bigger “why do I blog this?” has to do with using real-world GPS tracks as a basis for constructing other things — the input is movement in the world, an effort to figure out how a map might look that inverted the assumptions about static geographies and fluid movement, so that the ground moved and the things that moved became static. *shrug*
import processing.dxf.*;
// Based on Tom Carden's code and GPX library available at
// http://www.processing.org/hacks/hacks:gpx
// Press "R" and your track gets saved as a DXF file which
// you can use in lots of other things..
import tomc.gpx.*;
GPX gpx;
GPXTrack track;
GPXTrackSeg trackSeg;
String trackName;
double minLat, maxLat;
double minLon, maxLon;
double minEle, maxEle;
boolean record = false;
final static int SEPARATOR = 200;
String filename, filepath;
// I collapse lots of individual GPX files into one larger file
// using the free gpsbabel.
// At the command prompt (the GUI editions don't have enough features
// to do this) you'll do something like this:
/************
/Applications/GPSBabel+-1.3.5/gpsbabel -i gpx -f 20090321.gpx
-f 20090401.gpx -f 20090402.gpx -f 20090403.gpx
-x transform,wpt=trk,del
-x radius,distance=5,lat=34.0236,lon=-118.4319,nosort
-x transform,trk=wpt,del
-o gpx -F foo.gpx
The "-x" filters do a couple of things.
The first -x filter turns the tracks into waypoints to work around
an issue that gpsbabel has with the "radius" filter
The second -x filters the output only to points that are within a
5 mile radius of the specified lat/lon, which is useful if you want
to limit the range of data you draw.
The final -x filter turns the waypoints back into tracks, which is what we want
Finally, we output as GPX formatted data and
write the whole thing to the file called foo.gpx.dxf
*************/
void setup()
{
// Yep, hardcoded path to the GPX file we'll process
filepath = "/Users/julian/Desktop/GPS Tracks/foo.gpx";
// We'll use the name of the file for our DXF output, with the ".dxf" extension added
filename = (new File(filepath)).getName();
size(800, 800, P2D);
gpx = new GPX(this);
// you can load a file or a URL evidently..
gpx.parse(filepath);
// Find scope of track file so we can scale our drawing
minLat = 2000; minLon = 2000; minEle = 100000;
maxLon = -1000; maxLat = -1000;
println("track count "+gpx.getTrackCount());
for(int j=0; j < gpx.getTrackCount(); j++) {
track = gpx.getTrack(j);
println("track size "+track.size());
for(int k=0; k<track.size(); k++) {
trackSeg = track.getTrackSeg(k);
println("track seg size "+trackSeg.size());
for (int i = 0; i < trackSeg.size(); i++)
{
GPXPoint pt = trackSeg.getPoint(i);
if (pt.lat < minLat)
{
minLat = pt.lat;
}
if (pt.lon < minLon)
{
minLon = pt.lon;
}
if (pt.ele maxLat)
{
maxLat = pt.lat;
}
if (pt.lon > maxLon)
{
maxLon = pt.lon;
}
if (pt.ele > maxEle)
{
maxEle = pt.ele;
}
}
}
}
println("Lat: " + minLat + " to " + maxLat);
println("Lon: " + minLon + " to " + maxLon);
println("Ele: " + minEle + " to " + maxEle);
}
boolean hasDrawn = false;
void draw()
{
if(record == true) {
beginRaw(DXF, filename+".dxf");
hasDrawn = false;
}
if(hasDrawn == false) {
background(255);
//stroke(#FF0000);
//line(0, SEPARATOR, width, SEPARATOR);
double distance = 0;
for(int j=0; j < gpx.getTrackCount(); j++) {
track = gpx.getTrack(j);
//println("track size "+track.size());
for(int k=0; k<track.size(); k++) {
trackSeg = track.getTrackSeg(k);
//println("track seg size "+trackSeg.size());
GPXPoint prevPt = trackSeg.getPoint(0);
PVector prevPos = GetPosition(prevPt);
for (int i = 1; i < trackSeg.size(); i++)
{
GPXPoint pt = trackSeg.getPoint(i);
// Show track
PVector pos = GetPosition(pt);
stroke(#FF8800);
line(prevPos.x, prevPos.y, pos.x, pos.y);
prevPos = pos;
}
}
}
}
if(record == true) {
endRaw();
record = false; // stop recording to the file
println("done writing "+filename+".dxf");
}
hasDrawn = true;
}
void keyPressed() {
if (key == 'R' || key == 'r') {
record = true;
}
}
PVector GetElevation(int n, GPXPoint pt)
{
return new PVector(
map(n, 0, trackSeg.size(), 10, width - 10),
map((float) pt.ele, (float) minEle, (float) maxEle, SEPARATOR - 10, 10)
);
}
PVector GetPosition(GPXPoint pt)
{
return new PVector(
map((float) pt.lon, (float) minLon, (float) maxLon, 10, width - 10),
map((float) pt.lat, (float) minLat, (float) maxLat, SEPARATOR + 10, height - 10)
);
}