• Thesis Updates

    Its been a while since my last update on the progress of my thesis, but I suppose it is time for one as the day of my defense draws nigh.  Speaking of which. December 19th, 2011 is the big date and it seems like days are getting shorter is the day comes closer.  That could also be the effects of the sun setting earlier but I’ll save you all form my thoughts on that. (I love the winter)

    So, progress.  Where am I?  Well interestingly enough – and I suspect this was clear to some from the start – the project has slowly deviated from being a study on the visualization of the data to an ongoing conversation about the openness of the data that drives such visualization.  For the aesthetically hungry, yes there is still a technical aspect. (And yes, I’m extremely excited about the 3D OpenStreetMap meetup in Germany, March of 2012!).

    What I’ve found as I’ve been working with the data is that what we perceive to be “released” into the open is, in fact, not actually “open” as someone thinking in terms of open source would define it.  This poses two major problems (in addition to many smaller ones).

    • Integration – There can be little or none.  With data released under restrictive licenses we’re teased with high-quality data but are legally bound not to do anything of consequence with it.  It dooms the geo-savvy developer to perpetually bolt a viewer onto the data rather than to bring anything new to the table.
    • Quality Assurance – Its left up to the governing bodies.  Public input is taken via HTML contact forms.  Are corrections ever made?
    The problem is a spider-web and it entangles just about everything that it touches, or gets even remotely near.  I won't write my entire thesis here, but I'll leave you with a thought that's been sitting with me for a few weeks now, ‘Are we really supposed to wait for “official” data producers to catch up to us?'
  • Testing PostGIS 2.0 in Ubuntu

    With PostgreSQL’s introduction of K-Nearest Neighbor searches in version 9.1, it was only a matter of time until PostGIS implemented GiST idexes for its own data types.  That time has come with its upcoming 2.0 release.  If you’ve got a twitch and want to set it up today, here’s how to get started. (A great many thanks to the manual which got me a large part of the way there)

    Start with a vanilla installation of Ubuntu Server (I’m using version 11.10)

    **EDIT 28 February 2012:** Link to current snapshot updated.

    EDIT 29 February 2012: Added GDAL library dependency.

    First, make sure we have the necessary tools installed

    sudo apt-get install build-essential autoconf libtool gettext libxml2-dev libgeos-dev libgdal1-dev proj subversion

    Install PostgreSQL 9.1

    sudo apt-get install postgresql-9.1 postgresql-server-dev-9.1

    Normally I would want to get the sources directly from the SVN repository, but I was having trouble building from there. There are snapshots available, however, so lets grab that and use it.

    wget http://postgis.refractions.net/download/postgis-2.0.0alpha7SVN.tar.gz
    tar -zxvf postgis-2.0.0alpha7SVN.tar.gz

    Now lets navigate into the folder so we can build and install PostGIS

    cd postgis-2.0.0SVN
    sudo make install

    Congratulations, PostGIS 2.0 is now installed!

    And a quick refresher on setting up a PostGIS database:

    sudo su postgres
    postgres=# create role myuser with createdb superuser login password 'mypassword';
    postgres=# \q
    createdb testdb
    psql -d testdb -f /usr/share/postgresql/9.1/contrib/postgis-2.0/postgis.sql -v ON_ERROR_STOP=1
    psql -d testdb -f /usr/share/postgresql/9.1/contrib/postgis-2.0/spatial_ref_sys.sql -v ON_ERROR_STOP=1
  • Another Iteration of OpenStreetMap Visualization in 3D

    I’ve made some great strides since my last update a day and a half ago.  It turns out that having someone around to re-frame your problem can make the solutions to problems more readily apparent.  I suspect this is how psychiatrists stay in business, I’m just glad it carries over into the world of mathematics

    Rather than going through conforming Delaunay triangulations or by attempting to cut up triangles and create keystones, I’ve gotten another way to do it.  Given a center-line, quads can be created by thinking of the left and right sides as ‘tracing’ along the path of the center, but offset by some distance on either side.  In the case of turns, subtle and sharp angles can be handled in the same way.  By getting the azimuth between the prior point and the next point (we can think of them as i-1 and i+1), a constant distance from i can be maintained by simply getting the positive and negative perpendicular vectors with respect to the azimuth from i-1 to i+1.  It turned out to be a pretty good solution as you can see in the video below.

  • More on OpenStreetMap Data in jME

    So since my deliciously glitched programmer art meets geodata post yesterday I’ve done a fair bit of work on my Thesis project.  After some frustration with Delaunay Triangulations and Conforming Delaunay Triangulations I’ve resigned myself to using GL_LINES as a temporary stopgap measure.  I’ve alotted myself a total of 1 week for the integration of any data coming out of OpenStreetMap into the project and I’m less than 48 hours in.  Hopefully I get the time to come back to this and do the triangulation properly.  Some advice from the make of Mythruna, Paul Speed, on chat tonight looks to be promising and a significantly simpler solution than I had anticipated (aren’t those the best kind?).

    I’ve also added the rendering of railroad tracks this and have begun to build a color schema for the display of data.  Grey is roads and brown is railway.  Public transportation is also linked to blue lines, but New York evidently doesn’t have it annotated as such in the map.

  • OpenStreetMap data in jMonkeyEngine

    I’m working on the integration of different GIS-related services into a single unified application for my masters thesis and have been picking up where I left off on Betaville and its OSM capabilities. (It loads the data, makes some pretty scruffy looking geometry out of it, and can then render it in real-time as well as export it to COLLADA or OBJ)

    Below are a few short videos of me letting off some creative steam while playing with the data.

    Triangulation is done courtesy of Java Topology Suite (JTS), which may be the coolest library ever written… with the exception of jME ;)