Next time I speak to a non-technical audience about the "GeoWeb", I'm going to lean heavily on Paul Ramsey's clever and informative talk (click through for the PDF).

Glossing over the different architectures of the Internet is the right thing to do for that audience, so long as you don't get them hooked with lots of Web examples (like pages 84-93 of the PDF) and then sell them "Web Services" (like WFS on page 94) that aren't actually of the Web and haven't really been a success at getting data into the public's hands. Don't bait and switch, in other words.

Last week I was NYU's Institute for the Study of the Ancient World to plan our Concordia project, an effort to interlink projects like Pleiades, IRCyr, the ANS database, and APIS, and build a traversable, searchable network of data based on Web architecture. I'll be blogging more about this all through the year -- expect my blog to intersect more with the Mapufacture and FortiusOne blogs if they continue on course. Some may even be interesting to mainstream GIS designers and developers. ESRI's implicit embrace of Web architecture (along with the explicit embrace of Google) was one of the big stories out of Where 2.0, after all.

One thing that cropped up in our sessions was the need of other Ancient World projects to be able to refer to Barrington Atlas features in Pleiades by URIs derived from their atlas labels. Tom came up with a template for these URIs:

http://pleiades.stoa.org/batlas/{label-normalized}-{map}-{grid}

and simple rules for normalization that just so happen to be already implemented in plone.i18n. We've forked (in a friendly way: forking is now cool thanks to git, right?) plone.i18n and removed the Zope utilities and all dependency on the Zope component architecture. The result is pleiades.normalizer, and it reduces Barrington Atlas labels which may contain annotation and non-ASCII characters to ASCII strings suitable for use in the URI template:

>>> from pleiades.normalizer import normalizer

>>> list(normalizer.normalizeN(u'Tetrapyrgia'))
['tetrapyrgia']

>>> list(normalizer.normalizeN(u'Timeles fl. '))
['timeles-fl']

>>> list(normalizer.normalizeN(u'*Tyinda'))
['tyinda']

>>> list(normalizer.normalizeN(u'[Agrai]'))
['agrai']

>>> list(normalizer.normalizeN(u'Kalaba(n)tia'))
['kalabantia']

>>> list(normalizer.normalizeN(u'Tripolis ad Maeandrum/Apollonia ad Maeandrum/Antoniopolis'))
['tripolis-ad-maeandrum', 'apollonia-ad-maeandrum', 'antoniopolis']

>>> list(normalizer.normalizeN(unicode('Ağva', 'utf-8')))
['agva']

>>> list(normalizer.normalizeN(unicode('Çaykenarı', 'utf-8')))
['caykenari']

The algorithm normalizes non-ASCII characters (normal form KD) and discards elements which are not letters or digits:

U+011F -> (g, U+0306) -> g

U+0131, the last character in Çaykenarı, is a bit of a troublemaker. Our ASCII "i" has the diacritical mark relative to its dotless latin cousin, the inverse of the usual situation, and we have to make a special exception for it in the code.

If you're getting started in web development with Python you might find pleiades.normalizer handy, or at least a starting point for your own normalization code. We won't be publishing it to PyPI, but you can get an egg via:

$ easy_install http://atlantides.org/eggcarton/pleiades.normalizer-0.1.tar.gz

A while ago I wrote about cool stuff that could start to happen when Google's AppEngine supported bounding box searches for geo data. Maybe it already does, thanks to GeoHash. I'm looking forward to David Troy's followup. Via Planet Python.

Placebase's Pushpin API provides a format they call "GeoJSON", which should be good except that it has the wrong coordinate order. Easting and northing are swapped and the data is therefore tilted over, which is bad. See for example

http://rest.beta.pushpin.com/states/CA/counties/alameda.js

The sooner this gets fixed, the better for all of us. Anybody got a line to Placebase?

Update (2008-05-24): The Pushpin response is fixed. I'm excited to see GeoJSON catching on like this.

{"features": [{"geometry": {"type": "Point", "coordinates": [[29.975341, -90.226626]]}, "id": 0, "properties": {...}},...]}

<GeometryField encoding="PointFromColumns" x="bg_lat" y="bg_long">

Shapely 1.0.5 now includes a flexible polygonizer documented in section 2.5.1 of the updated manual, and makes it harder to create a particular class of broken geometries.

Hanke wasn't referring just to ESRI silos, but also to the data stuck behind WMS and GetFeatureInfo(), WFS and GetFeature().

Hey, sometimes you can't avoid the OGC's service architecture. OWSLib makes W*S suck less (apologies to Bob Ippolito) while you and I find our way back to the Web from the land of SDI. OWSLib 0.3 adds preliminary support for coverage services, contributed by Dominic Lowe of the British Atmospheric Data Centre, a colleague of Bryan Lawrence.

I'm a big fan of the Debian GIS Project and pleased to see that Shapely is getting some of its attention. Meanwhile, I'm still building GEOS 3.0 from source (with Kai's hexagonit.recipe.cmmi) because Hardy is still at GEOS 2.2.3.

I just want to point out how well Schuyler Erle's implementation of Douglas-Peucker line simplification plays with Shapely.

>>> from shapely.geometry import Point
>>> point = Point(0.0, 0.0)
>>> outline = point.buffer(2.0, quadsegs=32).boundary
>>> coords = list(outline.coords)
>>> from dp import simplify_points
>>> simple_coords = simplify_points(coords, 0.25)
>>> from shapely.geometry import LineString
>>> simple_outline = LineString(simple_coords)
>>> outline.length
12.565109003731115
>>> simple_outline.length
12.245869835682875

The simplify_points function requires a sequence of coordinate tuples. The coords property of a Shapely geometry is an iterator over coordinate tuples, but you can make a sequence from the iterator by using Python's built in list function.

>>> from numpy import asarray
>>> from matplotlib import pylab
>>> a = asarray(outline)
>>> fig = pylab.figure(1, figsize=(5,5), dpi=72)
>>> pylab.show()
>>> pylab.plot(a[:,0], a[:,1])
[<matplotlib.lines.Line2D instance at 0x8ae7d8c>]
>>> b = asarray(simple_outline)
>>> pylab.plot(b[:,0], b[:,1])
[<matplotlib.lines.Line2D instance at 0x90bc86c>]

The original:

And simplified:

The Programming Historian looks great to me. It covers HTML parsing (with Beautiful Soup), regular expressions, Unicode, and link traversing, with more to come.

Via the author, Bill Turkel.