TIGER/line census data is published by the US Census Bureau and is available for download here. The data describe legal and statistical entities such as towns, counties, and states; landmarks such as churches, hospitals, and cemetaries; and geographical features such as roads, rivers, and railroads. The area, path, or location of each is described in terms of polygons, lines, or points respectively (all in terms of longitude and latitude.)

The primary goal of this experiment is to generate a large body of geo-spatial data by converting the TIGER/line data to RDF and to demonstrate the capabilities of RDF Gateway in transforming, storing, and querying such data. A secondary goal is to make this particular data available to the semantic web community (others have mentioned the desire to see this data available as RDF). For now the conversion scripts are available (plus examples of running queries), but in the future the converted data or a query service (SPARQL?) against the data may be available.

The census data is published for each county. Each county distribution zip file contains a number of fixed-length record text files. The TIGER/line documentation details the layouts of the different files.

The data is relatively static, so I chose to create conversion scripts (using RDFQL, RDF Gateway's dynamic language which is a mix of javascript and a deductive database command/query language) to transform the fixed-length record files into RDF. If the data were more dynamic, I might instead have created a data service (a custom software component to interface a data source with RDF Gateway) to connect to it as a live source.

The conversion process roughly followed these steps (with a few refinement iterations):

• Create an ontology that captured the natural relationships implicit in the TIGER/line data. This meant developing a vocabulary to describe polygons, lines. legal entitites, etc. as well a converting the various hierarchical code schemes into class hierarchies.
• Identify the key properties for each class of object and map into a URI scheme (e.g. counties are uniquely identified by a 2 character state code, followed by a 3 character county code - this turned into a URI like: http://www.census.gov/tiger/2002/fips/ss/ccc)
• Create scripts for each type of record file to transform them into RDF.
• Create additional relationships in the data to speed certain types of queries - somewhat like the RDF equivalent of denormalizing data in the relational world. For example, to find the county that a town belongs to in the raw model, you need to find which polygons specify the area for that town and then find what other entities those polygons are also part of. Due to the single layer model of the census map data, a particular entity could have hundreds or thousands of polygons specifying its area which can lead to a more complex query than you'd like. In this case a property was added - tiger:intersectsArea - that made the relationship at the entity level, rather than the polygon level.

Running the completed scripts on a state such a vermont yields nearly 2 million triples - sufficient data for developing queries. Note that I skipped converting some data - shape nodes for lines, address and zip ranges for roads, alternative names for features, etc. I'll likely add some or all of those at some point.

Source Files

• import.txt - the conversion script
• tiger_vocab.rdf - the base vocabulary
• tiger_features.rdf - the census feature class code as a class hierarchy
• tiger_fipcc.rdf - the fips class codes as a class hierarchy
• tiger_fipad.rdf - the area description codes a class hierarchy
• tiger_fippd.rdf - the place description codes a class hierarchy

Below are some sample queries I developed against the TIGER/line data. All of the queries assume the data has been imported into a table named geo.

Example 1 - Find the polygons that describe the area of Addison county [Try It]

Example 2 - Find up to 100 linear features in Addison County [Try It]

Example 3 - Find all the towns and their respective counties in Vermont [Try It]

Example 4 - Find all of the landmarks [Try It]

Example 5 - Find the smallest rectangle that will hold the town of Addison [Try It]

Example 6 - Find all features within 1 mile of Middlebury College [Try It]

Example 7 - Find the outline of Addison County and display as SVG [Try It]

// this example also demonstrates the templating capabilities of RDFQL
// finding the boundary lines (of all the lines associated with all of the polygons)
// can be pretty expensive - might be better to add a [tiger:boundaryLine] property

var rs = (select ?start_lat ?start_long ?end_lat ?end_long ?min_lat ?max_lat ?min_long ?max_long using geo where 
	{[rdf:type] ?county [http://www.census.gov/tiger/2002/fips/area_description/06]} 
	and {[tiger:name] ?county 'Addison'} 
	and {[tiger:area] ?county ?poly}
	and (
		{[tiger:atLeft] ?line ?poly} and not ({[tiger:atRight] ?line ?poly2} and {[tiger:area] ?county ?poly2})
			or
		{[tiger:atRight] ?line ?poly} and not ({[tiger:atLeft] ?line ?poly2} and {[tiger:area] ?county ?poly2})
	    )
	and {[tiger:start] ?line ?start}
	and {[tiger:lat] ?start ?start_lat}
	and {[tiger:long] ?start ?start_long}
	and {[tiger:end] ?line ?end}
	and {[tiger:lat] ?end ?end_lat}
	and {[tiger:long] ?end ?end_long}
	and (?lat=?start_lat or ?lat=?end_lat)
	and (?long=?start_long or ?long=?end_long)
	and ?max_lat=max(?lat)
	and ?max_long=max(?long)
	and ?min_lat=min(?lat)
	and ?min_long=min(?long)
	);

var minx = rs["min_long"]/1000;
var miny = rs["min_lat"]/1000;
var maxx = rs["max_long"]/1000;
var maxy = rs["max_lat"]/1000;
var width=maxx-minx;
var height=maxy-miny;

response.contentType="image/svg+xml";

%><svg xmlns='http://www.w3.org/2000/svg' width="300" height="300" viewBox="0 0 <%=width%> <%=height%>">
<g style="stroke-width:1">
<%
for (rs.moveFirst();!rs.EOF;rs.MoveNext())
{
	%><line x1="<%=rs[1]/1000 - minx%>" y1="<%=height-(rs[0]/1000 - miny)%>" x2="<%=rs[3]/1000 - minx%>" y2="<%=height-(rs[2]/1000 - miny)%>" style="stroke:black;stroke-linecap:round"/>
<%	
}
%>
</g>
</svg>