Sol Katz, a pioneer in free and open source geospatial software, died in 1999. His family has agreed to allow us to honor him and give credit to other contributors to the community with an annual award in his name.

The first recipient of the Sol Katz Award for Geospatial Free and Open Source Software is Frank Warmerdam. It is unanimously agreed that his geospatial data translators have been the catalysts for the rapid growth of our community. I've benefitted from Frank's software, and also from his generous advice and mentorship. Congratulations, Frank, and thanks for everything!

Yesterday afternoon, post workshop, I went with my brother across the river to visit the Walker Art Center. Among the major works -- the Chuck Close potraits, the Warhols -- was a fun interface to information about the museum's works: the dialog table. This interface consists of museum objects, and avatars for various "Locate", "Describe", etc operations on the objects. These elements are dragged to each other to execute operations.

How are elements selected and translated? This is the fun part. The user stands holding her hand over the dialog table, with illumination from above. The shadow of her hand on the dialog table screen, and its gestures, are captured and processed. A pinching motion creates a hotspot for object selection, and the selected object can be translated with a dragging gesture. Once you get the hang of it, it's quite natural and fun.

The lightning talk session went well. Hobu kept us on time and schedule, and after a succession of modest 9 volt talks Schuyler finally brought some real thunder to close it out. The audience appreciated his proposal for a distributed WMS cache, but it was his old time revival preacher delivery that made the entire session.

After this, Markus Neteler made an excellent case for users to try the new and improved GRASS 6. He asserted that they had cut the codebase by more than half, throwing out cruft while adding a new vector engine and yet more raster processing and analysis tools. The MapServer project has been unwilling to take on rewrites of such an extent, but might want to reconsider after seeing what might be gained.

Get it from http://mapserver.gis.umn.edu/dload.html. I was unhappy and nervous about the 4.4 release because we'd crammed a lot of new features in at the last second. This time we've been more disciplined, and offer many significant and proven improvements. Release manager Daniel Morissette, the "mother" of MapServer, summarizes the changes:

MapServer 4.6.0 has just been released, just in time for MUM3. This new release represents the culmination of over two months of beta releases and six months of development. Highlights of new features include:

• GEOS support
• GML 3.1.0 support from WFS server
• Improved threading support when using various MapScript flavors
• SVG output support
• Several enhancements to Oracle Spatial support (3D data, geodetic queries, getextent and Oracle compound polygons)
• Unix and Windows build improvements
• Can now build PHP/MapScript without the PHP source (PHP regex issues have been resolved)
• Various MapScript bug fixes and improvments (very few API changes)
• Gobs of other bug fixes and improvements.

Denizens of the all-ESRI blogosphere are writing about their tentative forays into open source GIS software. Predictably, the square peg doesn't fit in the round hole, and the result is disappointment. Hopefully, Fee will keep plugging, get beyond the lack of drag and drop, and see the obvious upside of PostGIS.

PostGIS is a great tool, and continues to get better and better as its user base grows in size and sophistication. The developers have clearly chosen to expend more resources on stability and performance than on useability, and it's been a good choice. Fee's problem is that he expects it to be a drop-in replacement for ArcSDE. This is not the objective of PostGIS and I think it would be a pointless waste of resources to try.

The UNC-CH Ancient World Mapping Center brings a GIS perspective to ancient studies, and its maps for students are far better than the maps in my Penguin Classics copy of The Histories. I've downloaded the map of the Roman Empire's Northern Provinces cira 100 A.D., georeferenced it, and loaded it up as a layer available in the ZCO demo. Select the global_mosaic and rve11 layers to produce the following effect (here zoomed into the Aegean Sea):

Combine these maps with the better map interface of PrimaGIS and its support for custom annotations and one could have a rather nice annotated online atlas of the Ancient World.

mapserver-4.6.0-beta3.tar.gz

Should now be possible to compile MapServer's PHP mapscript module without the PHP source.

The April-June 2005 issue of ArcUser contains an article by Hobu on pages 34-36. It's an introduction to Python and GIS, and vector, grid, and raster processing with ogr.py and gdal.py for users of ArcGIS 9 -- which includes Python and makes a small subset of its functionality scriptable. Good writing, too bad he seems to have retired from blogging ;)

I ventured further into the magaine and found myself comparing the agility of ArcGIS and the GDAL/OGR Python modules while reading the tutorial on pages 46-49 ("Creating Accurate Footprints of Registered Aerial Images"). It's a rather involved and round-about manual process requiring an expensive ArcGIS add-on (Spatial Analyst). I'm sure that one could also manage to open a beer bottle using dentistry tools, but not as readily as with a bottle opener. Consider the following Python script:

# Create footprint shapefile
import ogr

driver = ogr.GetDriverByName('ESRI Shapefile')
footprints_shp = driver.CreateDataSource('footprints.shp')
footprints = footprints_shp.CreateLayer('footprints',
                 geom_type=ogr.wkbPolygon)
fd = ogr.FieldDefn('FILENAME', ogr.OFTString)
fd.SetWidth(30)
footprints.CreateField(fd)

# Loop over a number of georeferenced images
import glob
import gdal

files = glob.glob('*.jpg')
for file in files:
    # Get georeferencing and size of imagery
    dataset = gdal.Open(file)
    g = dataset.GetGeoTransform()
    pixels = dataset.RasterXSize
    lines = dataset.RasterYSize
    minx = g[0]
    maxx = minx + pixels * g[1]
    maxy = g[3]
    miny = maxy + lines * g[5]

    # append to the 'footprints' layer
    wkt = 'POLYGON ((%f %f, %f %f, %f %f, %f %f, %f %f))' \
        % (minx, miny, minx, maxy, maxx, maxy, maxx, miny, minx, miny)
    g = ogr.CreateGeometryFromWkt(wkt)
    f = ogr.Feature(feature_def=footprints.GetLayerDefn())
    f.SetField(0, file)
    f.SetGeometryDirectly(g)
    footprints.CreateFeature(f)
    f.Destroy()

# destroy footprints_shp to flush and close
footprints_shp.Destroy()

No fooling about -- directly to the imagery bounds and write a polygon. Simple and straight-forward, the right tool for the job.