Click here to view the embedded video.

But the minimum interval is 30 seconds, making it useless for timelapses of people moving about. Also the quality of the sensor and the lens is not as good as my dSLR. With gTimelapse I can control the interval to anything I like. gTimelapse is rather new so there’s a bit of fiddling involved, to be able to build it under ubuntu 9.10 you need these packages:

sudo apt-get install build-essential libgphoto2-2-dev libwxbase2.8-dev libwxgtk2.8-dev

From then on it is pretty straight forward, connect your camera (make sure it is in PTP mode) also ubuntu nowadays mounts it automagically, gTimelapse doesn’t like that. So unmount the camera using the filemanager and start gTimelapse. Depending on your camera you get all kinds of settings you can fiddle with. (side note I discovered that if you first start gTimelapse and than attach the camera none of the settings appear, but the application still works). Once you’re happy you can press start and sit back.

Creating a movie is still a lot more complicated I’m afraid. I still haven’t found a decent movie editor for linux. Kino is nice but only supports DV camera’s as far as I can tell, dragging something non-DV gives an eternal Kino Import progress bar kdenlive looks promising, but it kept freezing so I gave up on it for the moment. To just get a short movie I threw mencoder at them:

mencoder -nosound -ovc lavc -lavcopts vcodec=mpeg4:mbd=2:mv0:trell:v4mv:cbp:last_pred=3:predia=2:dia=2:vmax_b_frames=2:vb_strategy=1:precmp=2:cmp=2:subcmp=2:preme=2:qns=2 -o test5.avi -mf type=jpeg:fps=5 mf://@files.txt

Where files.txt was a list of the filenames of all the images I wanted to include. This resulted in this movie:

Click here to view the embedded video.

This means it possible to create timelapse movies with linux, but postprocessing is still difficult. The next timelapse project I’ll probably shoot with linux and edit on my mac

To visualize these tracks I used Processing, ‘an open source programming language and environment for people who want to program images, animation, and interactions.’  There are lots of plugins to read different data formats, an interesting one for this project is the gpx library. The plan was to render the tracks of each person in a different color, tracks which happened at the same time should be drawn at the same time. This way you can see which people are at the same time at the same location. Each track would fade out in time, leaving a thin line for past tracks.

To do this on a track-basis however turned out to be quite difficult for my limited knowledge of Processing and the time I had available. So instead of using the gpx module I created a flat table with all locations sorted by time. Each row of the table contains lon,lat,color-id,time. The program iterates through all 42000+ rows and draws the locations as a dot. The size of the dot depends on how ‘old’ the point is. The last 200 points are drawn with a diminishing size, creating the worm-like effect in the animation. Note that it doesn’t take into account the actual time between points, just if it is next in line.

A few tweaks were added: Holland in unprojected lat-lon looks odd to dutch people, so I implemented a simple projection library to reproject the points to a semi-RD (dutch projection). Also I wanted to dynamically zoom to the action (not everything was happening in Amsterdam). I did this by calculating the minimum and maximum X and Y for the last 200 points. I wanted the location of our office building to be in view all the time, to provide a point of reference.

The source code can be found here if you are really interested. There are three files: Table.pde as written by Ben Fry for his book Visualizing Data, Soprojection.pde, written by Steven Fruijtier at my request and Drawing.pde is hacked together by me. This is a very crude and brute-force approach to render a series of tracks, so please use it with care. Since it needs to recalculate each point for each frame it tends to become slower as it advances through the table.

Click here to view the embedded video.

• Geoserver 2.0 (SNAPSHOT downloaded 8 december 10.19UTC)
• Mapserver 5.6.0 (MS4W Base installer v3.0 Beta 7 + MapServer 5.6.0 release Upgrade)
• Deegree 2.3rc1 (Apache Tomcat 5.5.28)

To find out what the problem exactly was I’ve done some testing. I’ve taken a GeoTiff and configured all three the WCS applications to serve it. Gdalinfo gives us the following information, basically it is a GeoTIFF in epsg:3035 with a native resolution of 100m/pixel.

My test sequence was:

1. request the full extent in native resolution
2. request the full extent in a 10th of the resolution
3. request the full extent with the same size as the original data (256×256)
4. request part of the data in native resolution
5. request part of the data in non-native, non-multiple resolution

I’m not going to show all the results here, because that would result in an unhealthy long document

To verify the results I loaded the original GeoTiff in Quantum GIS and highlighted a specific feature to show the possible offset of the different results.

Corine GeoTiff

1  request the full extent in native resolution:

deegree: http://localhost:8080/deegree-wcs1/services?service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&resx=100&resy=100&format=GeoTIFF gives a three band(!) GeoTiff of 262,674 bytes with a shift of around 40m:

Deegree result

MapServer: http://localhost/cgi-bin/mapserver56/mapserv.exe?map=maps/corine.map&service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&resx=100&resy=100&format=GTiff gives a three band(!) GeoTiff of 197,477 bytes without a shift:

Mapserver result

GeoServer: http://localhsot:8081/geoserver/ows?service=WCS&version=1.0.0&request=GetCoverage&coverage=corine_merge_gtiff_proj_121_108&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&resx=100&resy=100&format=GeoTiff gives a single band GeoTiff of 8,848 bytes with a shift of  around 50m:

Geoserver result

Note:

Deegree both shifts the data and returns a multi-band image; Mapserver doesn’t shift the data, but returns a multi-band image; Geoserver shifts the data 1/2 a pixel (50m), but does give a single band image.

2. request the full extent in a 10th of the resolution

deegree: http://localhost:8080/deegree-wcs1/services?service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&resx=10&resy=10&format=GeoTIFF produces a 26,237,726 multi band GeoTiff which shifts the data the other way than the first request:

Deegree result on a tenth of the resolution

Mapserver: http://localhost/cgi-bin/mapserver56/mapserv.exe?map=maps/corine.map&service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&resx=10&resy=10&format=GTiff produces a multi-band GeoTiff of 19,681,941 bytes with no shift.

Geoserver: http://localhost:8081/geoserver/ows?service=WCS&version=1.0.0&request=GetCoverage&coverage=corine_merge_gtiff_proj_121_108&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&resx=10&resy=10&format=GeoTiff gives a single band GeoTiff of 158,802 bytes with a shift of around 50m, though there is a small difference with the previous result.

Note:

Mapserver and Geoserver both produce a bigger result (as expected) with the same location as the previous request. Deegree shifts the data differently than previously and also produces a bigger result.

3. request the full extent with the same size as the original data (256×256)

geoserver: http://localhost:8081/geoserver/ows?service=WCS&version=1.0.0&request=GetCoverage&coverage=corine_merge_gtiff_proj_121_108&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&width=256&height=256&format=GeoTiff produces exactly the same image as in the first request.

mapserver: http://localhost/cgi-bin/mapserver56/mapserv.exe?map=maps/corine.map&service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&width=256&height=256&format=GTiff produces exactly the same image as in the first request.

deegree: http://localhost:8080/deegree-wcs1/services?service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&crs=EPSG:3035&BBOX=3539200,3402400,3564800,3428000&width=256&height=256&format=GeoTIFF produces a slightly smaller image than the first request (262,674 bytes) with no shift!.

Deegree result with width en height

Note:

Since the request is a different way of describing the same data one would expect that you get the same results. Mapserver and Geoserver do so, Deegree does not, somehow using resx and resy in the request results in shifted data.

4. request part of the data in native resolution

deegree: http://localhost:8080/deegree-wcs1/services?service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&resx=100&resy=100&crs=EPSG:3035&BBOX=3550000,3413200,3554000,3417200&format=GeoTIFF has the correct left-top location but the size of the pixels is wrong, producing a shift of the data which increases as you go right/down:

Deegree result for a part request

geoserver: http://localhost:8081/geoserver/ows?service=WCS&request=GetCoverage&format=GeoTiff&version=1.0.0&coverage=geodan:Corine&resx=100&resy=100&crs=EPSG:3035&BBOX=3550000,3413200,3554000,3417200 produces an image with almost exactly the same shift as the first request.
mapserver: http://localhost/cgi-bin/mapserver56/mapserv.exe?map=maps/corine.map&service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&resx=100&resy=100&crs=EPSG:3035&BBOX=3550000,3413200,3554000,3417200&format=GTiff produces an image with almost exactly the same location as the first request.

Note:

Mapserver and Geoserver shift (or not) the data similar to the first request, Deegree has once again a different shift than any of the previous ones.

5. request part of the data in non-native, non-multiple resolution

deegree: http://localhost:8080/deegree-wcs1/services?service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&resx=30.0&resy=30.0&crs=EPSG:3035&BBOX=3550000,3413200,3554000,3417200&format=GeoTIFF shifts data:

Deegree result for non native, non multiple resolution

geoserver: http://localhost:8081/geoserver/ows?service=WCS&request=GetCoverage&format=GeoTiff&version=1.0.0&coverage=geodan:Corine&resx=30.0&resy=30.0&crs=EPSG:3035&BBOX=3550000,3413200,3554000,3417200 shifts data and adds a black border to the left and top of the result:

Geoserver result for non-native, non-multiple resolution

mapserver: http://localhost/cgi-bin/mapserver56/mapserv.exe?map=maps/corine.map&service=WCS&version=1.0.0&request=GetCoverage&coverage=Corine&resx=30.0&resy=30.0&crs=EPSG:3035&BBOX=3550000,3413200,3554000,3417200&format=GTiff shifts data:

Mapserver result for non-native, non-multiple resolution

Note:

This request was my initial prompt to find out why all WCS applications shift the data in the results. However this is a false conclusion. What’s happening here is that the service has to extract 30m wide pixels from 100m wide source data, since 100 divided by 30 isn’t a whole number it will add the remaining 10m in an adjacent pixel. If you overlay the result and the source data you get a pixel problem, data of source pixel 2 will most likely end up in result pixel b, which is partly over source pixel 1, resulting in a data shift:

Overlapping 100m with 30m

Conclusion:

Geoserver has a bug feature which offsets all the results by half a pixel, this is a known issue with the definition of the location of a pixel. Added to this there’s the no-data border which appears with non-native, non-multiple requests. I presume that will be gone once the pixel issue is resolved. (update: apparently I’ve misunderstood the Geoserver developers; there’s an issue between pixel placement according to standards and real world implementations, where Geoserver adheres to the standard).

Mapserver doesn’t offset the data unless it is physically impossible (non-native, non-multiple resolutions, extents which don’t snap to source data) but produces a multi-band (this was a configuration issue, thanks to FrankW for spotting this – proper config is IMAGEMODE BYTE) geotiff where the source data is single band.

Deegree has a bug which offsets some of the results, but I don’t know what causes it and although it is resolution-related I don’t see a pattern. It also produces a multi-band geotiff instead of a single band.

Configuration files and source data can be found here.

BruTile @ the Surface

Once we got the basics running I tried to edit the XAML to make it look better. This turned out to be harder than expected. The surface has once again its own default designs, which in my opinion are worse than the WPF standard designs. The default look is grey and square. So I wanted to change it to something more akin to our other touchtable applications: white and round. However Paul used a ScatterView component to display the layerlist and the geodan logo. He had read that one can just drop components in a ScatterView, without the need to embed them in ScatterViewItems. This is true, but it is a nightmare for the (non-initiated) designer. What happens is that the grey-square design of the ScatterViewItem is drawn beneath any layout you come up with for your own item. This is a very puzzling behaviour, although not entirely unexpected once you know that the ScatterViewItem exists.

Once I solved this issue I could seriously try to change the layout of the ScatterViewItems. Here however real glitches appeared. We use rounded borders and dropshadows for our items. As you can see below there are (at least) two issues:

Rounded border on the Surface don't work

The dark rectangle in the top of the image is actually a shadow of  a ScatterViewItem which for some reason doesn’t start below it. However this makes it easy to see the first glitch in the rendering. As you can see there is a thin dark line near the edge, which makes a weird square corner at the corner. This shouldn’t be there and when you resize the ScatterViewItem down, the shadow becomes darker (as it should have been in the first place) and the line is not visible anymore. If you don’t use rounded corners on the shadow the line is still there, but harder to notice because it is exactly following the edge of the shadow.

The second annoying glitch I’ve found is the gap between the border and the content. If we zoom in a bit on the layercontrol you can see there is a pixel space between the border and the content:

A gap between border and content

So far I haven’t been able to eliminate the pixel wide gap. It doesn’t look bad in our application right now, but in general it is bad that there is such an uncontrollable gap. So I have the feeling that the Surface people are not a big fan of borders in general and rounded border specifically.

We’re involved in both ESDIN and EGN and we decided to use the latter as a trial for the first. Together with our partners we’ve setup a series of servers to fulfill the needs of the projects. The main standard used is the latest WFS and GML versions, which have the annoying disadvantage that there are few clients available.

To be able to show nicely (as in not an XML file) that everything worked I was asked to build a webclient which would show a map and the data from the EGN service for that area. I figured that this was once again a good reason to look into the latest developments for OpenLayers. I quickly discovered that the released version (2.7) doesn’t support WFS 1.1.0 so I asked on the mailinglist if people already tried to implement it (and if not, pointers how to do so). Luckily people already did the work and created various patches for the support. (thanks tschaub, bartvde and others)

The most important patch is the one which implements protocols for WFS: ticket 1648 and its wfs.patch The main disadvantage of this patch was in my case that it tried to minimise the number of requests to the WFS server (which in general is a good thing). It requests all the features which are within twice the size of the viewport and it doesn’t request new features when you zoom in. However our server is limited to 10 features per request this results in very interesting behavior. For a starter all the 10 feature could be outside your viewport and also very funny is that shown feature might dissappear when you move the page too much (it requests new features in that case and the first 10 might be outside the viewport). A second patch, on ticket 1830, provided a more aggressive feature update: each zoom action triggers a new request and I set the request-boundingbox-ratio to 1, meaning only those feature within the viewport are requested. This means that every action triggers a new request, which is heavy on the server.

However this is just a reference implementation and hopefully for actual implementations they remove the 10 feature limit. For those interested the reference implementation can be found at http://research.geodan.nl/egn

We spend quite some time calibrating, recalibrating and reading documentation from the invite only Microsoft site without any effect. In the end Vista asked us to install an update and to reboot the Surface. When it was rebooted we ran the ‘Surface Shell’ application from the Desktop and suddenly it worked!!

The Surface, or at least our version, comes with a set of code examples. We tried several to see how well it works and found out that especially the Grand Piano demo is a crowd drawer (mainly due to the sound probably). The Piano is a limited set of piano keys in perspective view. ‘Pressing’ a key results in a tone, just like a real piano

Playing piano on a Surface

The sensitivity of the Surface is well balanced. The Surface doesn’t notice fingers which are hovering just above the surface and you don’t need to apply any pressure to get noticed once you touch it. We’ve built our own table using a similar FTIR technique and we had quite some problems getting that balance right. Also the Surface is using 5 camera’s where we used just one as such it’s resolution is better as well.

It has additional logic in the interpretation of the camera feeds. It has three different types of touches it can recognize: finger, blob and tag. From each type it gives a location, an orientation, an id and in case of the tags a value.

Surface information of a finger

The difference between a blob and a finger is the size and shape of the touch, for instance a small square object is seen as a blob and a larger oval object is seen as a finger. Furthermore the earlier white-only bias of the Surface we experienced is now changed to a no-black bias. This gives some interesting results; a black/orange marker on the surface is recognized as a single finger at the tip of the marker;

Fingers come in strange shapes

The Surface feels pretty responsive, but using the Data Visualizer you notice that the position of the touch as interpreted by the Surface lags behind the actual touch. In the demos it is not noticeable but we found a similar lag very annoying on the DiamondTouch. On that table we managed to get rid of the lag and hopefully we can do the same here.

There is the famous demo of the telephone on the Surface, where it gets recognised and you can drag and drop data. We tried it and noticed that it doesn’t like android phones; it just doesn’t see the phone. An (ancient) windows mobile phone however does get recognised for what it is: a blob;

Android on the Surface

Obviously the Surface doesn’t automagically recognize phones or any other object. The table comes with a set of fiducials which you can stick on objects. These fiducials get recognised as tags with a value and using that value you can do fun stuff in your software.

Update

I discovered that while it doesn’t respond to hovering fingers, it does notice hovering areas the size of a hand. Which is slightly annoying since in normal use you easily have your hand hovering just above the surface while one or more fingers touch it. It might be possible to filter this unwanted behavior in real applications, because the hand shows up as a blob instead of a finger.

We were supposed to have two normal and one developer edition but it wasn’t very clear which one was which so we picked one and carried it to our office. This turned out to quite tricky, this thing is heavy and doesn’t have any clear handles. In the end we carried it by holding the projection-surface …

Once setup we had to fiddle a bit to get the powercable connected and find the proper (two) powerswitches. Once it booted it prompted us an EULA we had to accept. However the Surface is designed to be a standalone machine completely controlled by touch but before the touch was working we had to accept the EULA, which was only accessible by touch … hm

You need to accept to start touch, and you need touch to accept

So we had to plug in a mouse, but apparently we hadn’t chosen the developer edition since no usb ports where visible. The manual explained that we need to open up the side of the table to access the ports. After two screws and a bit of force we managed to open up the side and it gave us full access to all normal PC ports.

The surface insides

It asked us to create an admin account and once it was setup it gave us the choice to login as that admin or as TableUser, since we had no clue what the password for TableUser was, we logged in as admin.  After a bit we were shown a fresh Vista desktop with a few shortcuts. The most obvious for us was the calibration tool. We calibrated our table and started a touch application. It failed to run complaining that the filtergraph was not found at the location specified. We neither had knew what a filtergraph was, nor what the location specified was.  This got us stuck for quite a while, the manuals didn’t help and the online site with information was only accessible by invitation and due to some miscommunication(?) we were not (yet) invited.

Digging into things like registries, hidden folders and binary blobs we finally discovered that there are two versions of the calibration tool. One which does a background-light calibration and one which does a per camera calibration. We had run both, but we failed to notice that the latter had to run 5 times (5 cameras in the surface). Once we had done so the different surface programs ran without errors and without effect.

Pretty annoyed we banged our fist on the table and that seemed to have effect. It turned out that putting a lot of force on the table gave results, indicating a calibration issue. Having no idea how to finetune the calibration we started to experiment with different ways of touching. The current consensus is that it is designed for ubergeeks who never see the sun and are pure white; touching the Surface with a finger doesn’t give a result, wrapping the finger in white tissue suddenly does …

The 'attract' application

Hopefully we will figure out soon how to tweak the calibration and otherwise we need to buy a set of white surgical gloves to hand out to users

Still I’m very much excited by the prospect of creating beautiful GIS applications and so far I’ve had enthousiast reactions from developers as well.

For EduGIS we figured that it might be easier and more scalable to serve all tiles from S3, using the bandwidth and storage space of amazon, instead of buying more servers and bandwidth ourselves. Already we use tilecache in a test setup and the initial idea was to replace the diskcache for an AWSS3 cache. This was we could tap into the vast storage space of amazon, however, since every request had to be forwarded to S3 and back, the bandwidth-load was doubled. So instead of hosting the TileCache on our server we moved the TileCache instance to a virtual computer on Amazons EC2 platform.

To do this, I picked a sample machine-image of a small, headless, ubuntu 8.10 setup. Installed tilecache (apt-get install tilecache ) and changed it to use mod_python instead of the default cgi in apache. Since this means that the machine-image is changed, you need to bundle it into a new machine image and register it with amazon. this way you can easily create multiple instances, also if you powerdown your machine it gets destroyed so you loose all your changes.

So once I mastered the art of cloud-herding I pointed our test environment to TileCache in the cloud to see if it would work at all and how quick the bill would increase. After a few days and some seedings I noticed that the AWSS3 backend uses a simple dump in a single folder backend. This quickly produces insane amounts of files and it becomes impossible to have a quick look at the status of your cache with tools like S3fox. So I wrote a patch for the AWSS3 cache module to store the tiles in a TMS style folder structure.

Now all we need to do is to create a tilecache.cfg with all 200+ layers we have and start seeding.