Table of Contents for

HTML5 Geolocation

The Python Shapefile Library (PSL) was written by Joel Lawhead. It provides read and write capabilities for shapefiles using the Python scripting language. It is designed to be as extensible as it can be when creating a shapefile while still having some validation to ensure a proper file is produced. Take a look at Example 5-2.

# Include the Python Shapefile Library
import shapefile as sf

# Name of the shapefile to create
filename = 'shapefiles/geolocation'

# Create a /point/ shapefile, and turn on autoBalance
sf_w = sf.Writer(sf.POINT)
sf_w.autoBalance = 1

# Add the points
sf_w.point(-90.185278, 38.624722, 212)
sf_w.point(-89.788221, 38.4233, 18)
sf_w.point(-90.123129, 37.992331, 25)

# Create attribute information
sf_w.field('Name', 'C', 20)
sf_w.field('Description', 'C', 80)
sf_w.field('Timestamp', 'D')
sf_w.field('Accuracy', 'N', 4, 0)
sf_w.field('AltitudeAccuracy', 'N', 4, 0)
sf_w.field('Heading', 'N', 9, 6)
sf_w.field('Speed', 'N', 7, 4)

# Add attribute information
sf_w.record('Point 000000', 'This is the first point collected.', \
    '2011-04-06T23:24:12+06:00', 20, 100, None, 0)
sf_w.record('Point 000001', 'This is the second point collected.', \
    '2011-04-07T00:15:37+06:00', 10, 10, 37, 15.6464)
sf_w.record('Point 000002', 'This is the third point collected.', \
    '2011-04-07T11:49:03+06:00', 60, 80, 147, 31.2928)

# Save the file
sf_w.save(filename)

# Create a projection file
prj = open("%s.prj" % filename, 'w')
epsg = 'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137, \
    298.257223563]],PRIMEM["Greenwich",0],UNIT["degree", \
    0.0174532925199433]]'
prj.write(epsg)
prj.close()

The first line of code imports PSL into the working script. After specifying that the shapefile will be a POINT type using the Writer object, the property autoBalance is set to true. This verifies that when a point or a record is added with the script, the opposite is also added (every point has a record and every record has a point). Next, the points are added with the point() method. The point() method takes a latitude, longitude, and optional altitude and measure. In Example 5-2, the latitude, longitude, and altitude of each point is recorded.

Before attribute records can be added to the shapefile, the attributes must be defined using the field() method. The field() method takes a field name, field type, field length, and (for numbers) decimal length. Once defined, the records, one for each point, are created using the record() method. After the records have been added, the shapefile is saved and the three required files (.shp, .shx, and .dbf) are created. Additionally, Example 5-2 creates a .prj file for a more complete shapefile instance.

In most cases, the shapefile holding the geolocation information will already be created when the application needs to add another record. The following code shows a small script that can edit an existing shapefile and add another point to it:

import shapefile as sf
filename = 'shapefiles/geolocation'
sf_e = sf.Editor(shapefile = filename + '.shp')
sf_e.point(-102.125532, 34.223411, 40)
sf_e.record('Point 000004', 'This is an appended point. ', \
'2011-04-10T01:52:22+06:00', 20, 30, 118, 17.21)
sf_e.save(filename)

The code for editing an existing shapefile and adding a point is simple. Updating existing points is a little more complicated, however. The Editor object takes care of inserting and deleting records in the shapefile. The specific record number needs to be obtained by first reading the shapefile and locating the record (also something PSL can do). Then the record should be deleted using the delete() method, and a new record with the corrected information should be added to the shapefile.

The Python Shapefile Library is fairly easy to use, even if you do not know a lot of Python to start with. The only downside to this library is that it does not have the best documentation available. Otherwise, it is a great way to manipulate shapefiles within a web application.

ArcSDE, or simply SDE (Spatial Database Engine), is an Esri product for storing and managing geographic data with other business data within a relational database. It is designed to run with the commercial databases IBM DB2, Informix, Microsoft SQL Server, and Oracle, as well as the open source database PostgreSQL. Starting with ArcGIS 9.2, Esri stopped selling ArcSDE as a stand-alone product and began bundling it with their ArcGIS Desktop and ArcGIS Server products. The latest release of the software at the time of this writing is 10.0. ArcSDE supports various standards, including OGC simple features, the International Organization for Standardization (ISO) spatial types, the OracleSpatial format, the PostGIS format, and the Microsoft spatial format.

PostGIS adds spatial functionality to the PostgreSQL relational database. It was developed by Refractions Research as an open source project and is released under the GNU General Public License. The first stable version (1.0) of the software was released in 2005. The current version of the software (as of this writing) is 1.5.2. PostGIS, which acts like ArcSDE or OracleSpatial, follows the OGC Simple Feature specification, though it has not been certified compliant by the OGC.

The following should give you some idea of PostGIS functionality using SQL:

SELECT loc.the_geom
FROM
geolocations loc INNER JOIN 
(SELECT the_geom
FROM
 (SELECT the_geom, ST_Area(the_geom) AS area
  FROM parks) p
WHERE
 area > 10000) park ON ST_Intersects(loc.the_geom, park.the_geom)

This query finds all geolocations that are located within city parks with an area greater than 10,000 feet. To do this, it first pulls the parks polygons and calculates their areas using the PostGIS function ST_Area(). It then finds the parks with an area larger than 10,000 feet. Finally, it finds the geolocations located within the parks using the ST_Intersects() function. The results of this query is the geometry associated with each geolocation found within a city park with an area greater than 10,000 feet.

MySQL is the world’s most popular open source database, in use by some of the most heavily visited websites like Google, Wikipedia, YouTube, and Facebook. Instead of requiring additional software on top of itself, MySQL implements a subset of the OGC SQL with Geometry Types specification directly into its database. It has taken MySQL several releases since it first introduced spatial capabilities to get to the place where other spatial databases like PostGIS and OracleSpatial currently are.

The OGC naming conventions were not implemented in MySQL until version 5.6. Unfortunately, as of the time of this writing, the current generally available community release of MySQL is 5.5.11, which has differences in naming. For example, MySQL 5.6 would utilize the exact same SQL statement as the example in PostGIS. The MySQL 5.5 version of this code would look like the following:

SELECT loc.the_geom
FROM
geolocations loc INNER JOIN 
(SELECT the_geom
FROM
 (SELECT the_geom, Area(the_geom) AS area
  FROM parks) p
WHERE
 area > 10000) park ON Intersects(loc.the_geom, park.the_geom)

As you can see, they are very similar in nature to one another, and anyone with some SQL and spatial database experience could figure out MySQL’s version of things. Once MySQL 5.6 becomes generally available, MySQL will have caught up with its competitors, making it very attractive solution for spatial data management considering its popularity as a relational database.

To conclude the discussion on spatial data management with relational databases, Example 5-3 creates the structure our geolocations would need to match the examples in KML or Python Shapefile Library.

CREATE DATABASE geolocations;

USE geolocations;

CREATE TABLE positions (
pos_id           INT            NOT NULL AUTO_INCREMENT PRIMARY KEY,
the_geom         POINT          NOT NULL,
altitude         DECIMAL(8, 2)  NOT NULL,
accuracy         DECIMAL(4, 0)  NOT NULL,
altitudeAccuracy DECIMAL(4, 0)  NULL,
heading          DECIMAL(9, 6)  NULL,
speed            DECIMAL(7, 4)  NULL,
timestamp        DATETIME       NOT NULL,
name             VARCHAR(20)    NOT NULL,
description      VARCHAR(80)    NULL
);

This example creates a new database called geolocations, and then creates a table called positions that holds all of the attribute data that can be collected from the W3C Geolocation API. The SQL script to insert a new position record into our database would look like this:

INSERT INTO positions (
the_geom, 
altitude, 
accuracy, 
altitudeAccuracy, 
heading, 
speed, 
timestamp, 
name,
description
) VALUES (
GeomFromText('POINT(-89.788221 38.4233)'),
18,
10,
10,
37,
15.6464,
'2011-04-07 00:15:37',
'Point 000001', 
'This is the second point collected.'
);

This SQL statement adds a point with the OGC Well-Known Text (WKT) format using the GeomFromText() function. This SQL would be executed from a server-side script with values passed to it from the client after a location had been retrieved. The table creation and insertion would be almost the same in any relational database.