def reassign_spatial_geometry(instance):
    coords = list(instance.geometry.coords)
    if type(coords[0]) == float:
        coords = [coords]
    else:
        while (type(coords[0][0]) != float):
            coords = coords[0]
        coords = [list(x) for x in coords]
    for point in coords:
        if point[0] >= -180 and point[0] <= 180:
            return
    while coords[0][0] < -180:
        for point in coords:
            point[0] += 360
    while coords[0][0] > 180:
        for point in coords:
            point[0] -= 360
    geometry = []
    for point in coords:
        latlng = [point[0], point[1]]
        geometry.append(tuple(latlng))
    if len(geometry) > 1:
        if geometry[0] == geometry[-1]:
            instance.geometry = dumps(Polygon(geometry))
        else:
            instance.geometry = dumps(LineString(geometry))
    else:
        instance.geometry = dumps(Point(geometry))

def set_spatial_ranking(geometry):
    """Given that we have a spatial query in ogc:Filter we check the type of geometry 
    and set the ranking variables"""
    
    if util.ranking_enabled:
        if geometry.type in ['Polygon', 'Envelope']:
            util.ranking_pass = True
            util.ranking_query_geometry = geometry.wkt
        elif geometry.type in ['LineString', 'Point']:
            from shapely.geometry.base import BaseGeometry
            from shapely.geometry import box
            from shapely.wkt import loads,dumps
            ls = loads(geometry.wkt)
            b = ls.bounds
            if geometry.type == 'LineString':
                tmp_box = box(b[0],b[1],b[2],b[3])
                tmp_wkt = dumps(tmp_box)
                if tmp_box.area > 0:
                    util.ranking_pass = True
                    util.ranking_query_geometry = tmp_wkt
            elif geometry.type == 'Point':
                tmp_box = box((float(b[0])-1.0),(float(b[1])-1.0),(float(b[2])+1.0),(float(b[3])+1.0))
                tmp_wkt = dumps(tmp_box)
                util.ranking_pass = True
                util.ranking_query_geometry = tmp_wkt

def get_coordinates_dump(data):
    if 'coordinates' in data and type(data['coordinates']) is dict:
        point = data['coordinates']
        if all(key in point for key in ('lat', 'lng')):
            point = Point(float(point['lng']), float(point['lat']))
            return dumps(point)
    elif all(key in data for key in ('latitude', 'longitude')):
        point = Point(float(data['longitude']), float(data['latitude']))
        return dumps(point)

def geojson_validator(value):
    if value:
        try:
            gjson = json.loads(value)
            shape = asShape(gjson)
            wkt.dumps(shape)
        except:
            raise Invalid(_("Invalid GeoJSON"))
    return value

def geojson_validator(value):
    if value:
        try:
            # accept decoded geojson too
            if isinstance(value, basestring):
                value = json.loads(value)
            shape = asShape(value)
            wkt.dumps(shape)
        except Exception:
            raise Invalid(_("Invalid GeoJSON"))
        # must store as JSON
        return json.dumps(value)
    return value

def gj2geom(geojson):

    """
    Convert a GeoJSON geometry into an OGR geometry.
    """

    return ogr.CreateGeometryFromWkt(wkt.dumps(shape(geojson)))

def parse_coordinates(coordinates):
    if coordinates is None or type(coordinates) is not dict:
        return coordinates

    if all(key in coordinates for key in ('lat', 'lng')):
        point = Point(float(coordinates['lng']), float(coordinates['lat']))
        return dumps(point)

def main(opts):
    pattern = loads(open(opts.input, "r").read())
    extent = loads(open(opts.extent, "r").read())

    if not contains.matches(extent.relate(pattern)):
        print "ERROR: pattern must be contained within the extent"
        return

    c = pattern.centroid
    (xs, ys) = extent.boundary.xy
    (minx, maxx, miny, maxy) = (min(xs) - c.x, max(xs) - c.x, min(ys) - c.y, max(ys) - c.y)

    outputFile = open(opts.output, "w")

    geoms = []

    while len(geoms) < opts.number:
        dx = random.uniform(minx, maxx)
        dy = random.uniform(miny, maxy)

        geom = translate(pattern, xoff=dx, yoff=dy)

        if contains.matches(extent.relate(geom)):
            # Check that it is within the extent
            overlap = False
            for g in geoms:
                if intersects.matches(g.relate(geom)):
                    overlap = True
            if overlap == False:
                geoms.append(geom)

    for geom in geoms:
        outputFile.write(dumps(geom) + "\n")
    outputFile.close()

def import_with_fiona(fpath, source):
    """
    Use fiona to import a parcel file.

    Return a list of dict objects containing WKT-formatted geometries in 
    addition to any metadata.
    """
    shapes = []

    try:
        with fiona.drivers():
            data = fiona.open(fpath)
            for obj in data:
                try:
                    shape = scrape_fiona_metadata(obj, source)
                    geom = to_shapely_obj(obj)
                    if geom:
                        shape['geom'] = dumps(geom)
                        shapes.append(shape)
                except Exception as e:
                    _L.warning('error loading shape from fiona. {}'.format(e))
    except Exception as e:
        _L.warning('error importing file. {}'.format(e))

    return shapes

def csv_to_neatline(in_file, out_file):

    """
    Format a CSV file for Neatline.
    """

    reader = csv.DictReader(in_file)

    # Add wkt field to the CSV.
    cols = reader.fieldnames + ['wkt']
    writer = csv.DictWriter(out_file, cols)
    writer.writeheader()

    for row in reader:

        lat = float(row.pop('latitude'))
        lon = float(row.pop('longitude'))

        # Convert degrees -> meters.
        meters = degrees_to_meters(lon, lat)

        # Convert to WKT.
        point = ShapelyPoint(meters)
        row['wkt'] = wkt.dumps(point)

        writer.writerow(row)

 def getGeometryWKT(self):
     """Return WKT representation of geometry"""
     parts = self._getGeometryRaw().split(':')
     j = '{"type": "%s", "coordinates": %s}' % (
         parts[0].strip(), parts[1].strip())
     d = simplejson.loads(j)
     return wkt.dumps(asShape(d))

def procesaLineaInterna(featuresExternas, featuresInternas, featuresCentroide, featureDefn):
	#print "Procedemos a procesar las lineas internas"
	
	centroides = []
	for centroide in featuresCentroide:
		#obtenemos la altura y el rotulo del estilo de cada centroide
		for n in centroide.GetStyleString().split(','):
			if n.startswith('s'):
				altura = float(n.replace('s:', '').replace('g', ''))
			elif n.startswith('t'):
				rotulo = n.split('"')[1]
		punto = centroide.GetGeometryRef()
		x = punto.GetX()
		y = punto.GetY()
		longitudRotulo = len(rotulo)
		factor = 0.15 * (altura * 3.3333)
		desfaseX = longitudRotulo * factor - 0.05
		punto.SetPoint(point = 0, x = x + desfaseX, y = y - 0.20)
		
		centroides.append((rotulo, punto))
	
	featuresProceso = featuresExternas + featuresInternas
	
	outFeature = []
	if len(featuresProceso) > 1:
		geometry_out = None
		for inFeature in featuresProceso:
			geometry_in = inFeature.GetGeometryRef()
			if geometry_out is None:
				geometry_out = geometry_in
				geometry_out = ogr.ForceToMultiLineString(geometry_out)
			else:
				geometry_out = geometry_out.Union(geometry_in) 
		
		lineasInternasShapely = loads(geometry_out.ExportToWkt())
		polygonsShapely = polygonize(lineasInternasShapely)
	
		polygonGeom = []
		for polygon in polygonsShapely:
			polygonGeom.append(ogr.CreateGeometryFromWkt(dumps(polygon)))
		
		for pol in polygonGeom:
			for cen in centroides:
				if pol.Contains(cen[1]):
					feature = ogr.Feature(featureDefn)
					feature.SetGeometry(pol)
					feature.SetField('rotulo', cen[0])
					outFeature.append(feature.Clone())
					feature.Destroy()
	else:
		feature = ogr.Feature(featureDefn)
		geometryPoly = ogr.BuildPolygonFromEdges(ogr.ForceToMultiLineString(featuresProceso[0].GetGeometryRef()), dfTolerance = 0)
		feature.SetGeometry(geometryPoly)
		feature.SetField('rotulo', centroides[0][0])
		outFeature.append(feature.Clone())
		feature.Destroy()
	
	
	return outFeature

    def _get_wkt_from_shape(self, shape):
        if shape.type == POINT:
            # shapely float precision errors break cypher matches!
            wkt = dumps(shape, rounding_precision=8)
        else:
            wkt = shape.wkt

        return wkt

    def test_wkt_locale(self):

        # Test reading and writing
        p = loads('POINT (0.0 0.0)')
        self.assertEqual(p.x, 0.0)
        self.assertEqual(p.y, 0.0)
        wkt = dumps(p)
        self.assertTrue(wkt.startswith('POINT'))
        self.assertFalse(',' in wkt)

def write_regions(filename, regions, duprange, lossrange):
    out = util.open_stream(filename, 'w')
    print >>out, '\t'.join(map(str, duprange + lossrange))
    for cv, region in regions.iteritems():
        coords = None; area = None
        if isinstance(region, geometry.Polygon):                                              # non-degenerate
            coords = list(region.exterior.coords)
            area = region.area
        elif isinstance(region, geometry.LineString) or isinstance(region, geometry.Point):   # degenerate
            coords = list(region.coords)
            area = region.area
        else:
            raise Exception("count vector (%s) has invalid region (%s)" % (cv, dumps(region)))

        coords = dumps(region)
        toks = (cv, coords, area)
        print >>out, '\t'.join(map(str, toks))
    out.close()

    def handle(self, *args, **options):


        CENSUS_BLOCK_2010 = pickle.load(open(BOUNDARY_DATA + "census.p", 'rb')) 

        NEIGHBORHOOD = pickle.load(open(BOUNDARY_DATA + "community.p",'rb'))
        NEIGHBORHOOD_INDEX = create_spatial_index(NEIGHBORHOOD)
        aggregate_results = {}            
        for i, (aggregate_id, aggregate_shape) in \
                enumerate(CENSUS_BLOCK_2010.iteritems(), 1):

            # print out a nice message to know how it's going
            if i % 1000 == 0:
                print >> sys.stderr, 'Aggregating %i of %i' % \
                    (i, len(CENSUS_BLOCK_2010))
        

            if not CensusBlocks.objects.filter(census_id=aggregate_id,
                                               building_subtype="All").exists():
                print >> sys.stderr, "Updating census_id: %s" %(aggregate_id)
                neighborhood_count = 0
                for j,item_2010 in enumerate(NEIGHBORHOOD_INDEX.intersection(aggregate_shape.bounds,
                                                                      objects=True)):

                    # get the element id
                    raw_id = item_2010.object


                    # get the shape from the shape dictionary
                    raw_shape = NEIGHBORHOOD[raw_id]

                    # calculate the intersection of the polygons
                    intersection = aggregate_shape.intersection(raw_shape)

                    # calculate the fraction of the area of the aggregate shape that
                    # is in the raw shape
                    frac_raw = float(intersection.area) / aggregate_shape.area

                    # fix rawid in those two cases for mckliney and ohare
                    raw_id = raw_id.title()
                    if raw_id == 'Mckinley Park':
                        raw_id = 'McKinley Park'
                    elif raw_id == 'Ohare':
                        raw_id = "O'hare"
                    # if there is any area above tolerance, then add it up
                    if neighborhood_count == 0:
                        neighborhood, created = Neighborhoods.objects.get_or_create(name = raw_id)

                        census_block, created = CensusBlocks.objects.get_or_create(census_id=aggregate_id,
                                                                         building_type="Residential",
                                                                         building_subtype="All",
                                                                         neighborhood = neighborhood,
                                                                         shape = wkt.dumps(aggregate_shape))
     
                        neighborhood_count += 1
                    else:
                        continue

def write_wkt(filepath, shply_geom):
    """

    :param filepath: output path for new javascript file
    :param shply_geom: shapely geometry features
    :return:
    """
    with open(filepath, "w") as f:
        # create a javascript variable called ply_data used in html
        # Shapely dumps geometry out to WKT
        f.write("var ply_data = '" + dumps(shply_geom) + "'")

def insert(cursor, feature, tablename, srid):
    """
    Insert a "feature" as a row in PostGIS
    """
    fields = ", ".join([field for field in feature["properties"].keys()])
    values = ", ".join(["'%s'" % unicode(field) for field in feature["properties"].values()])
    sql = """
    INSERT INTO %s (%s, geom)
    VALUES (%s, ST_GeomFromText('%s', %s))
    """ % (tablename, fields, values, dumps(get_geom(feature)), srid)
    cursor.execute(sql)

def getMaintenanceData(
    start_date,
    end_date,
    token,
    sz_roads,
    ):
    errors=[]
    filters = []
    filters.append({'columnName': 'transaction_date',
                   'operator': 'GreaterEqualThan', 'value': start_date})
    filters.append({'columnName': 'transaction_date',
                   'operator': 'LessEqualThan', 'value': end_date})

    mc_cost = getTable(
        token=token,
        table='mc_cost',
        columns=[
            'cost_group',
            'activity',
            'fault',
            'cost_amount',
            ],
        filters=filters,
        szRoads=sz_roads,
        getGeometry=True
        )

    mc_cost.getData()

    if mc_cost.error is True:
        errors.append('mc_cost: ' + mc_cost.message)

    data = []

    for row in mc_cost.data:
        line = loads(row['values'][4])
        #length = line.length

        #sections = int(math.ceil(length / 200))
        #sections_pc = 1 / (sections + 1)
        #section = 1
        #while (section <= sections):
        point = line.interpolate(0.5, True)
        data.append([
            row['values'][0],
            row['values'][1],
            row['values'][2],
            row['values'][3],
            dumps(point, rounding_precision=0),
            ])
        #  section = section + 1

    return {'data': data, 'errors': errors}

def parse_area(area):
    if area is None:
        return area

    points = map(get_lng_lat_pair, area)

    if len(points) == 2:
        polygon = box(points[0][0], points[0][1], points[1][0], points[1][1])
    else:
        polygon = Polygon(points)

    return dumps(polygon)