Django management command to construct a KML map from the Boundary Service

make_maps.py

import logging 
log = logging.getLogger('electioncenter.jobs.make_maps')
import json
from optparse import make_option
import os
import sys
from urllib import urlencode
from urllib2 import urlopen

from django.conf import settings
from django.contrib.humanize.templatetags.humanize import ordinal
from django.core.management.base import BaseCommand, CommandError

from electioncenter.apps.jobs.models import Job
from electioncenter.lib.map import *

class Command(BaseCommand):
    help = 'Generate static KMLs for job page maps.'
    option_list = BaseCommand.option_list + ()

    def get_version(self):
        return '0.1'

    def handle(self, *args, **options):
        aldermen = Job.objects.filter(office='alderman')

        map_makers = {
                'neighborhoods': self.make_neighborhoods,
            }

        for name, maker in map_makers.items():
            for a in aldermen:
                ward = int(a.seat)
                log.info('Making %s map for Ward %i' % (name, ward))
                maker(ward)

    def make_neighborhoods(self, ward_num):
        """
        Make a map that shows all Neighborhoods intersecting the given Ward.
        """
        # Fetch ward
        ward_slug = '%s-ward' % ordinal(ward_num)
        url = '%s/api/1.0/boundary/%s' % (settings.BOUNDARY_SERVICE, ward_slug)
        response = urlopen(url)

        ward = json.loads(response.read())

        # Fetch intersecting neighborhoods
        params = {
                'limit': 100,
                'intersects': ward_slug,
                'sets': 'neighborhoods',
            }
        url = '%s/api/1.0/boundary/?%s' % (settings.BOUNDARY_SERVICE, urlencode(params))
        response = urlopen(url)
        
        neighborhoods = json.loads(response.read())['objects']

        # Begin building KML
        kml = u"""<?xml version="1.0" encoding="UTF-8"?>
            <kml xmlns="http://www.opengis.net/kml/2.2">
            <Document>
            """

        # Add ward style
        kml += render_style('Ward', line_width=4, line_color='ff000000', poly_color='00000000')

        # Add neighborhood styles
        n_count = len(neighborhoods)
        indices = range(n_count)
        step = 1.0 / n_count
        poly_colors = [hsv_to_kml_hex(i * step, 1.0, 1.0) for i in indices]

        for i in indices:
            kml += render_style('Neighborhood-%i' % i, line_width=0, poly_color='aa%s' % poly_colors[i]) 

        # Add ward shape
        kml += render_boundary(ward)
        
        # Add neighborhood shapes
        for i, n in enumerate(neighborhoods):
            kml += render_boundary(n, override_style='Neighborhood-%i' % i)

        # Close out KML
        kml += u"""</Document>
            </kml>"""

        # TODO - TEMP
        with open('kmltest/ward-%i.kml' % ward_num, 'w') as f:
            f.write(kml)

map.py

from colorsys import hsv_to_rgb
import json
import logging 
log = logging.getLogger('electioncenter.lib.kml')
import struct

from django.contrib.gis.geos import GEOSGeometry

def hsv_to_kml_hex(h, s, v):
    """
    Convert an HSV color to a BGR hex string.

    Uses struct hex conversion trick from:
    http://stackoverflow.com/questions/4296249/how-do-i-convert-a-hex-triplet-to-an-rgb-tuple-and-back
    """
    rgb = hsv_to_rgb(h, s, v)
    rgb = map(lambda x: int(x * 255), rgb)
    hex = struct.pack('BBB', *rgb).encode('hex') 
    return hex

def geojson_to_kml(geojson):
    """
    Convert a geojson string to a KML string.
    """
    return GEOSGeometry(geojson).kml

def render_style(style_id, line_width=1.0, line_color='ff000000', poly_color='ff00ff00'):
    """
    Render a KML style element with optional or default parameters.
    """
    return u"""
        <Style id="%s">
            <LineStyle>
                <width>%.1f</width>
                <color>%s</color>
            </LineStyle>
            <PolyStyle>
                <color>%s</color>
            </PolyStyle>
        </Style>""" % (style_id, line_width, line_color, poly_color)


def render_placemark(name, style, shape):
    """
    Render a KML placemark element with specified values.
    """
    return u"""
        <Placemark>
            <name>%s</name>
            <styleUrl>#%s</styleUrl>
            %s
        </Placemark>""" % (name, style, shape)

def render_boundary(boundary, override_style=None):
    """
    Render a de-jsonified boundary object returned from the boundary service.
    """
    return render_placemark(
        boundary['name'],
        override_style if override_style else boundary['kind'],
        geojson_to_kml(json.dumps(boundary['simple_shape'])))