root/PCL/trunk/PCL-GeoRSS/cartography/data/georss.py

# =============================================================================
# Python Cartographic Library. Copyright (C) 2007 Sean C. Gillies
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation; either version 2 of the License, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
# Place, Suite 330, Boston, MA 02111-1307 USA
#
# Contact email: sgillies@frii.com
# =============================================================================

"""
Read Georeferenced Atom/RSS entries (http://georss.org) as PCL features.
Requires Mark Pilgrim's feedparser (http://www.feedparser.org/).

See PCL-Core/tests/AtomFeatures.txt for usage examples.
"""

try:
    import pkg_resources
    pkg_resources.require('PCL-Core')
    pkg_resources.require('PCL-GeoRSS')
except:
    pass

import feedparser

from cartography.styles import Layer
from cartography.geometry import *
from cartography.data.feature import *
from cartography.proj import SpatialReference
from cartography.data.interfaces import IFeature, IFeatureSource, IFeatureStore

from zope.interface import implements


# Factory for GeoRSS feature sources
def georss_source(file):
    """Return a feature source."""
    # Python files, filenames, or strings
    if hasattr(file, 'read'):
        d = feedparser.parse(file.read())
    else:
        d = feedparser.parse(file)
    try:
        assert d.entries is not None
    except:
        import pdb; pdb.set_trace()
    return GeoRSSFeatureSource(document=d)

# Factory for features
def georss_feature(entry):
    # parse the geometry
    if entry.has_key('point'):
        y, x = [float(v) for v in entry['point'].split()]
        the_geom = Point(x, y)
    elif entry.has_key('line'):
        vals = [float(v) for v in entry['line'].split()]
        points = []
        for i in range(len(vals)/2):
            y, x = vals[2*i:2*i+2]
            points.append(Point(x, y))
        the_geom = LineString(points)
    elif entry.has_key('polygon'):
        vals = [float(v) for v in entry['polygon'].split()]
        points = []
        for i in range(len(vals)/2):
            y, x = vals[2*i:2*i+2]
            points.append(Point(x, y))
        the_geom = Polygon(LinearRing(points))
    elif entry.has_key('box'):
        y0, x0, y1, x1 = [float(v) for v in entry['box'].split()]
        the_geom = BoundingBox(x0, y0, x1, y1)
    else:
        the_geom = None

    return GeoRSSFeature(
        id=entry.id,
        title=entry.title,
        summary=entry.description,
        updated=entry.date,
        the_geom=the_geom
        )

def source_layer(source):
    """Factory for a cartographic Layer."""
    typename = source.document.feed.title
    ds = GeoRSSFeatureStore(sources={typename: source})
    return Layer(ds, typename)


class GeoRSSFeature(Feature):

    """A feature corresponds to an Atom/RSS entry.
    """
    implements(IFeature)

    __typename__ = 'GeoRSSFeature'
    __schema__ = PropertyTypeCollection([
                    StringProperty('id'),
                    StringProperty('title'),
                    StringProperty('summary'),
                    StringProperty('updated'),
                    GeometryProperty('the_geom'),
                    ])
    __srs__ = SpatialReference(epsg=4326)


class GeoRSSFeatureSource:

    """Implements IFeatureSource.

    A Source corresponds to a Atom/RSS feed.
    """
    implements(IFeatureSource)

    def __init__(self, document):
        """Initialize"""
        self.document = document
        self._featuretype = GeoRSSFeature
        #self._bbox = None
        #self._maxfeatures = -1

    def schema(self):
        return self._featuretype.schema()
        
    def iterfeatures(self):
        for entry in self.document.entries:
            yield georss_feature(entry)

    __call__ = iterfeatures
       

class GeoRSSFeatureStore:

    """Implements IFeatureStore.

    A store corresponds to an Atom service document.
    """
    implements(IFeatureStore)

    def __init__(self, sources):
        self.sources = sources.copy()

    def featuretype(self, typename):
        return GeoRSSFeature

    def source(self, typename, maxfeatures=-1):
        return self.sources[typename]

    def count(self, typename):
        """Returns the feature count."""
        return len(self.sources[typename].document.entries)

    def typenames(self):
        """Returns the typenames available in this store."""
        return tuple(self.sources.keys())