def getMapForm(shapefile):
""" Devuelve un form. Subclase Form para editar las features del shapefile.
El formulario tendrá un solo campo, 'geometría', que permite al usuario editar
La geometría del feature.
"""
geometryField = utils.calc_geometry_field(shapefile.geom_type)
geometryType = utils.calcGeometryFieldType(shapefile.geom_type)
if geometryType == "Point":
adminType = PointAdmin
elif geometryType == "LineString":
adminType = LineStringAdmin
elif geometryType == "Polygon":
adminType = PolygonAdmin
elif geometryType == "MultiPoint":
adminType = MultiPointAdmin
elif geometryType == "MultiLineString":
adminType = MultiLineStringAdmin
elif geometryType == "MultiPolygon":
adminType = MultiPolygonAdmin
elif geometryType == "GeometryCollection":
adminType = GeometryCollectionAdmin
adminInstance = adminType(Feature, admin.site)
field = Feature._meta.get_field(geometryField)
widgetType = adminInstance.get_map_widget(field)
# Defina un formulario que encapsule el campo de edición deseado.
class MapForm(forms.Form):
geometry = forms.CharField(widget=widgetType(), label="")
return MapForm
def editFeature(request, shapefile_id, feature_id=None):
""" Permite al usuario añadir o editar una feature del shapefile.
el campo 'feature_id' será None if we are adding a new feature.
"""
shapefile = Shapefile.objects.get(id=shapefile_id)
if request.method == "POST" and "delete" in request.POST:
# User clicked on the "Delete" button -> show "Delete Feature" page.
return HttpResponseRedirect("/deleteFeature/" + shapefile_id + "/" +
feature_id)
geometryField = utils.calc_geometry_field(shapefile.geom_type)
formType = shapefileEditor.getMapForm(shapefile)
if feature_id == None:
# Annadiendo una nueva feature.
feature = Feature(shapefile=shapefile)
attributes = []
else:
# Editando una feature.
feature = Feature.objects.get(id=feature_id)
# Toma los atributos para esta feature.
attributes = []
for attrValue in feature.attributevalue_set.all():
attributes.append([attrValue.attribute.name, attrValue.value])
attributes.sort()
# Muestra el formulario
if request.method == "GET":
wkt = getattr(feature, geometryField)
form = formType({'geometry': wkt})
return render_to_response("editFeature.html", {
'shapefile': shapefile,
'form': form,
'attributes': attributes
})
elif request.method == "POST":
form = formType(request.POST)
try:
if form.is_valid():
wkt = form.cleaned_data['geometry']
setattr(feature, geometryField, wkt)
feature.save()
# Devuelve al usuario a la pagina de seleccion de features.
return HttpResponseRedirect("/edit/" + shapefile_id)
except ValueError:
pass
return render_to_response("editFeature.html", {
'shapefile': shapefile,
'form': form,
'attributes': attributes
})
def edit_feature(request, shapefile_id, feature_id=None):
if request.method == "POST" and "delete" in request.POST:
return HttpResponseRedirect("/delete_feature/" + shapefile_id + "/" +
feature_id)
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except ShapeFile.DoesNotExist:
return HttpResponseNotFound()
if feature_id == None:
feature = Feature(shapefile=shapefile)
else:
try:
feature = Feature.objects.get(id=feature_id)
except Feature.DoesNotExist:
return HttpResponseNotFound()
attributes = []
for attr_value in feature.attributevalue_set.all():
attributes.append([attr_value.attribute.name, attr_value.value])
attributes.sort()
if request.method == "GET":
form = MyForm()
return render(request, "template.html", {'form': form})
elif request.method == "POST":
form = MyForm(request.POST)
if form.is_valid():
# Extract and save the form's contents here...
return HttpResponseRedirect("/somewhere/else")
return render(request, "template.html", {'form': form})
geometry_field = utils.calc_geometry_field(shapefile.geom_type)
form_class = utils.get_map_form(shapefile)
if request.method == "GET":
wkt = getattr(feature, geometry_field)
form = form_class({'geometry': wkt})
return render(request, "edit_feature.html", {
'shapefile': shapefile,
'form': form,
'attributes': attributes
})
elif request.method == "POST":
form = form_class(request.POST)
try:
if form.is_valid():
wkt = form.cleaned_data['geometry']
setattr(feature, geometry_field, wkt)
feature.save()
return HttpResponseRedirect("/edit/" + shapefile_id)
except ValueError:
pass
return render(request, "edit_feature.html", {
'shapefile': shapefile,
'form': form,
'attributes': attributes
})
def edit_feature(request, shapefile_id, feature_id=None):
if request.method == "POST" and "delete" in request.POST:
return HttpResponseRedirect("/delete_feature/" +
shapefile_id+"/"+feature_id)
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except ShapeFile.DoesNotExist:
return HttpResponseNotFound()
if feature_id == None:
feature = Feature(shapefile=shapefile)
else:
try:
feature = Feature.objects.get(id=feature_id)
except Feature.DoesNotExist:
return HttpResponseNotFound()
attributes = []
for attr_value in feature.attributevalue_set.all():
attributes.append([attr_value.attribute.name,
attr_value.value])
attributes.sort()
geometry_field = \
utils.calc_geometry_field(shapefile.geom_type)
form_class = utils.get_map_form(shapefile)
if request.method == "GET":
wkt = getattr(feature, geometry_field)
form = form_class({'geometry' : wkt})
return render(request, "edit_feature.html",
{'shapefile' : shapefile,
'form' : form,
'attributes' : attributes})
elif request.method == "POST":
form = form_class(request.POST)
try:
if form.is_valid():
wkt = form.cleaned_data['geometry']
setattr(feature, geometry_field, wkt)
feature.save()
return HttpResponseRedirect("/edit/" +
shapefile_id)
except ValueError:
pass
return render(request, "edit_feature.html",
{'shapefile' : shapefile,
'form' : form,
'attributes' : attributes})
def export_data(shapefile):
dst_dir = tempfile.mkdtemp()
dst_file = os.path.join(dst_dir, shapefile.filename)
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromWkt(shapefile.srs_wkt)
driver = ogr.GetDriverByName("ESRI Shapefile")
datasource = driver.CreateDataSource(dst_file)
layer = datasource.CreateLayer(shapefile.filename, dst_spatial_ref)
for attr in shapefile.attribute_set.all():
field = ogr.FieldDefn(attr.name, attr.type)
field.SetWidth(attr.width)
field.SetPrecision(attr.precision)
layer.CreateField(field)
src_spatial_ref = osr.SpatialReference()
src_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(src_spatial_ref,
dst_spatial_ref)
geom_field = utils.calc_geometry_field(shapefile.geom_type)
for feature in shapefile.feature_set.all():
geometry = getattr(feature, geom_field)
geometry = utils.unwrap_geos_geometry(geometry)
dst_geometry = ogr.CreateGeometryFromWkt(geometry.wkt)
dst_geometry.Transform(coord_transform)
dst_feature = ogr.Feature(layer.GetLayerDefn())
dst_feature.SetGeometry(dst_geometry)
for attr_value in feature.attributevalue_set.all():
utils.set_ogr_feature_attribute(attr_value.attribute,
attr_value.value, dst_feature)
layer.CreateFeature(dst_feature)
layer = None
datasource = None
temp = tempfile.TemporaryFile()
zip = zipfile.ZipFile(temp, 'w', zipfile.ZIP_DEFLATED)
shapefile_name = os.path.splitext(shapefile.filename)[0]
for fName in os.listdir(dst_dir):
zip.write(os.path.join(dst_dir, fName), fName)
zip.close()
shutil.rmtree(dst_dir)
temp.flush()
temp.seek(0)
response = FileResponse(temp)
response['Content-type'] = "application/zip"
response[
'Content-Disposition'] = "attachment; filename=" + shapefile_name + ".zip"
return response
def tile(request, version, shapefile_id, zoom, x, y):
try:
# Parse and check our parameters.
if version != "1.0":
raise Http404
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except Shapefile.DoesNotExist:
raise Http404
zoom = int(zoom)
x = int(x)
y = int(y)
if zoom < 0 or zoom > MAX_ZOOM_LEVEL:
raise Http404
xExtent = _unitsPerPixel(zoom) * TILE_WIDTH
yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT
minLong = x * xExtent - 180.0
minLat = y * yExtent - 90.0
maxLong = minLong + xExtent
maxLat = minLat + yExtent
if (minLong < -180 or maxLong > 180 or minLat < -90 or maxLat > 90):
raise Http404
# Set up the map.
map = mapnik.Map(TILE_WIDTH, TILE_HEIGHT, "+proj=longlat +datum=WGS84")
map.background = mapnik.Color("#7391ad")
# Define the base layer.
dbSettings = settings.DATABASES['default']
datasource = \
mapnik.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
table='tms_basemap',
srid=4326,
geometry_field="geometry",
geometry_table='tms_basemap')
baseLayer = mapnik.Layer("baseLayer")
baseLayer.datasource = datasource
baseLayer.styles.append("baseLayerStyle")
rule = mapnik.Rule()
rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color("#b5d19c")))
rule.symbols.append(mapnik.LineSymbolizer(mapnik.Color("#404040"),
0.2))
style = mapnik.Style()
style.rules.append(rule)
map.append_style("baseLayerStyle", style)
map.layers.append(baseLayer)
# Define the feature layer.
geometry_field = utils.calc_geometry_field(shapefile.geom_type)
query = '(select ' + geometry_field \
+ ' from "shared_feature" where' \
+ ' shapefile_id=' + str(shapefile.id) + ') as geom'
datasource = \
mapnik.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
table=query,
srid=4326,
geometry_field=geometry_field,
geometry_table='shared_feature')
featureLayer = mapnik.Layer("featureLayer")
featureLayer.datasource = datasource
featureLayer.styles.append("featureLayerStyle")
rule = mapnik.Rule()
if shapefile.geom_type in ["Point", "MultiPoint"]:
rule.symbols.append(mapnik.PointSymbolizer())
elif shapefile.geom_type in ["LineString", "MultiLineString"]:
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5))
elif shapefile.geom_type in ["Polygon", "MultiPolygon"]:
rule.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color("#f7edee")))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5))
style = mapnik.Style()
style.rules.append(rule)
map.append_style("featureLayerStyle", style)
map.layers.append(featureLayer)
# Finally, render the map tile.
map.zoom_to_box(mapnik.Box2d(minLong, minLat, maxLong, maxLat))
image = mapnik.Image(TILE_WIDTH, TILE_HEIGHT)
mapnik.render(map, image)
imageData = image.tostring('png')
return HttpResponse(imageData, content_type="image/png")
except:
traceback.print_exc()
return HttpResponse("Error")
def import_data(request, shapefile, character_encoding):
#return "More to come..."
fd,fname = tempfile.mkstemp(suffix=".zip")
# tempfile.mkstemp() returns both a file descriptor and a filename, we call
# os.close(fd) to close the file descriptor. This allows us to reopen the
# file using open() and write to it in the normal way.
os.close(fd)
f = open(fname, "wb")
for chunk in shapefile.chunks():
f.write(chunk)
f.close()
# Use the Python standard library's zipfile module to check the
# contents of the uploaded ZIP archive, and return a suitable error message
# if something is wrong
if not zipfile.is_zipfile(fname):
os.remove(fname)
return "Not a valid zip archive."
zip = zipfile.ZipFile(fname)
required_suffixes = [".shp", ".shx", ".dbf", ".prj"]
has_suffix = {}
for suffix in required_suffixes:
has_suffix[suffix] = False
for info in zip.infolist():
extension = os.path.splitext(info.filename)[1].lower()
if extension in required_suffixes:
has_suffix[extension] = True
for suffix in required_suffixes:
if not has_suffix[suffix]:
zip.close()
# Delete the temporary file before returning
# an error message, so that we don't leave temporary files lying around
os.remove(fname)
return "Archive missing required "+suffix+" file."
# When it's known that the uploaded file is a valid ZIP archive containing
# the files that make up a shapefile, extract these files and store them
# into a temporary directory
shapefile_name = None
dst_dir = tempfile.mkdtemp()
for info in zip.infolist():
if info.filename.endswith(".shp"):
shapefile_name = info.filename
dst_file = os.path.join(dst_dir, info.filename)
f = open(dst_file, "wb")
f.write(zip.read(info.filename))
f.close()
zip.close()
# Open the shapefile
try:
datasource = ogr.Open(os.path.join(dst_dir, shapefile_name))
layer = datasource.GetLayer(0)
shapefileOK = True
except:
traceback.print_exc()
shapefileOK = False
# if something goes wrong - clean up our temporary files and return a
# suitable error message.
if not shapefileOK:
os.remove(fname)
shutil.rmtree(dst_dir)
return "Not a valid shapefile."
# If the shapefile was opened sucessfully - read the data out
# of it. Create the Shapefile object to represent this imported shapefile.
# Get the spatial reference from the shapefile's layer, and then store
# the shapefile's name, spatial reference, and encoding into a Shapefile
# object. The geom_type field is supposed to hold the name of the geometry
# type that this shapefile holds but can't get the name of the geometry
# directly using OGR. Need to implement our own version of
# OGRGeometryTypeToName(). See utils.py module in shared app directory
src_spatial_ref = layer.GetSpatialRef()
geometry_type = layer.GetLayerDefn().GetGeomType()
geometry_name = utils.ogr_type_to_geometry_name(geometry_type)
curr_user = request.user
shapefile = Shapefile(filename=shapefile_name,
srs_wkt=src_spatial_ref.ExportToWkt(),
geom_type=geometry_name,
encoding=character_encoding,
owner=curr_user)
shapefile.save()
# Create Attribute objects describing the shapefile's attributes
# Save the Attribute objects into a database and create a
# separate list of these attributes in a variable named attributes.
# Needed for import the attribute values for each feature.
attributes = []
layer_def = layer.GetLayerDefn()
for i in range(layer_def.GetFieldCount()):
field_def = layer_def.GetFieldDefn(i)
attr = Attribute(
shapefile=shapefile,
name=field_def.GetName(),
type=field_def.GetType(),
width=field_def.GetWidth(),
precision=field_def.GetPrecision())
attr.save()
attributes.append(attr)
# Extract the shapefile's features and store them as Feature objects
# in the database. Because the shapefile's features can be in any spatial
# reference, we need to transform them into our internal spatial reference
# system (EPSG 4326, unprojected latitude, and longitude values) before we
# can store them. To do this, use an OGR CoordinateTransformation() object.
# GEOS geometry object caan be stored into the Feature object.
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(src_spatial_ref,
dst_spatial_ref)
for i in range(layer.GetFeatureCount()):
src_feature = layer.GetFeature(i)
# src_name = src_feature.name;
src_geometry = src_feature.GetGeometryRef()
src_geometry.Transform(coord_transform)
geometry = GEOSGeometry(src_geometry.ExportToWkt())
# See wrap geometry in utils: it distinguish polygons and multipoligon,
# linestring and multilinestrings
geometry = utils.wrap_geos_geometry(geometry)
# Can't simply use the geometry name to identify the field because
# sometimes have to wrap up geometries. See utils.py.
geometry_field = utils.calc_geometry_field(geometry_name)
# Store the feature's geometry into a Feature object within the database
# Note: Use keyword arguments (**args) to create the Feature object.
# This lets to store the geometry into the correct field of the Feature
# object with a minimum of fuss.
args = {}
args['shapefile'] = shapefile
args[geometry_field] = geometry
feature = Feature(**args)
feature.save()
for attr in attributes:
success,result = utils.getOGRFeatureAttribute(
attr,
src_feature,
character_encoding)
if not success:
os.remove(fname)
shutil.rmtree(dst_dir)
shapefile.delete()
return result
attr_value = AttributeValue(
feature=feature,
attribute=attr,
value=result)
attr_value.save()
os.remove(fname)
shutil.rmtree(dst_dir)
return None
def import_data(shapefile, character_encoding):
# Save the uploaded file into a temporary file on disk.
fd,fname = tempfile.mkstemp(suffix=".zip")
os.close(fd)
f = open(fname, "wb")
for chunk in shapefile.chunks():
f.write(chunk)
f.close()
# Check that the uploaded file is a zip archive.
if not zipfile.is_zipfile(fname):
os.remove(fname)
return "Not a valid zip archive."
zip = zipfile.ZipFile(fname)
# Check that the zip archive contains the required parts of a shapefile.
required_suffixes = [".shp", ".shx", ".dbf", ".prj"]
has_suffix = {}
for suffix in required_suffixes:
has_suffix[suffix] = False
for info in zip.infolist():
extension = os.path.splitext(info.filename)[1].lower()
if extension in required_suffixes:
has_suffix[extension] = True
for suffix in required_suffixes:
if not has_suffix[suffix]:
zip.close()
os.remove(fname)
return "Archive mising required " + suffix + " file."
# Extract the contents of the zip archive.
shapefile_name = None
dst_dir = tempfile.mkdtemp()
for info in zip.infolist():
if info.filename.endswith(".shp"):
shapefile_name = info.filename
dst_file = os.path.join(dst_dir, info.filename)
f = open(dst_file, "wb")
f.write(zip.read(info.filename))
f.close()
zip.close()
# Open the shapefile.
try:
datasource = ogr.Open(os.path.join(dst_dir,
shapefile_name))
layer = datasource.GetLayer(0)
shapefile_ok = True
except:
traceback.print_exc()
shapefile_ok = False
if not shapefile_ok:
os.remove(fname)
shutil.rmtree(dst_dir)
return "Not a valid shapefile."
# Create our Shapefile object to represent the imported shapefile.
src_spatial_ref = layer.GetSpatialRef()
geometry_type = layer.GetLayerDefn().GetGeomType()
geometry_name = utils.ogr_type_to_geometry_name(geometry_type)
shapefile = Shapefile(filename=shapefile_name,
srs_wkt=src_spatial_ref.ExportToWkt(),
geom_type=geometry_name,
encoding=character_encoding)
shapefile.save()
# Store the shapefile's attribute definitions into the database.
attributes = []
layer_def = layer.GetLayerDefn()
for i in range(layer_def.GetFieldCount()):
field_def = layer_def.GetFieldDefn(i)
attr = Attribute(shapefile=shapefile,
name=field_def.GetName(),
type=field_def.GetType(),
width=field_def.GetWidth(),
precision=field_def.GetPrecision())
attr.save()
attributes.append(attr)
# Set up a coordinate transformation to convert from the shapefile's
# coordinate system into EPSG 4326 (unprojected lat/long coordinates).
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(src_spatial_ref,
dst_spatial_ref)
# Process each feature in turn.
for i in range(layer.GetFeatureCount()):
src_feature = layer.GetFeature(i)
# Transform this feature's geometry into EPSG 4326.
src_geometry = src_feature.GetGeometryRef()
src_geometry.Transform(coord_transform)
geometry = GEOSGeometry(src_geometry.ExportToWkt())
# If necessary, wrap this geometry so that all features have the same
# geometry type.
geometry = utils.wrap_geos_geometry(geometry)
# Calculate the field in the Feature object which will hold the
# imported feature.
geometry_field = utils.calc_geometry_field(geometry_name)
# Create a new Feature object to hold this feature's geometry.
args = {}
args['shapefile'] = shapefile
args[geometry_field] = geometry
feature = Feature(**args)
feature.save()
# Store the feature's attribute values into the database.
for attr in attributes:
success,result = utils.get_ogr_feature_attribute(
attr, src_feature,
character_encoding)
if not success:
os.remove(fname)
shutil.rmtree(dst_dir)
shapefile.delete()
return result
attr_value = AttributeValue(feature=feature,
attribute=attr,
value=result)
attr_value.save()
# Finally, clean up.
os.remove(fname)
shutil.rmtree(dst_dir)
return None
def import_data(shapefile):
# Copia el archivo zip en un archivo temporal
fd,fname = tempfile.mkstemp(suffix=".zip")
os.close(fd)
f = open(fname, "wb")
for chunk in shapefile.chunks():
f.write(chunk)
f.close()
# Se abre el zip y se chequea su contenido.
if not zipfile.is_zipfile(fname):
os.remove(fname)
return "No es un archivo zip válido."
zip = zipfile.ZipFile(fname)
#Diferenciacion de los archivos requeridos segun el formato del archivo de entrada
es_shp = False
for info in zip.infolist():
extension = os.path.splitext(info.filename)[1].lower()
if extension == '.shp':
es_shp = True
#Sie s un shp, se aplica una comprobación de que todos los archivos necearios estén en el zip
if es_shp:
required_suffixes = [".shp", ".shx", ".dbf", ".prj"]
hasSuffix = {}
for suffix in required_suffixes:
hasSuffix[suffix] = False
for info in zip.infolist():
extension = os.path.splitext(info.filename)[1].lower()
if extension in required_suffixes:
hasSuffix[extension] = True
else:
print "Archivo extraño: " + info.filename
for suffix in required_suffixes:
if not hasSuffix[suffix]:
zip.close()
os.remove(fname)
return "No se encuentra el archivo " + suffix + " requerido"
else:
zip.close()
# Descomprime el zip en un directorio temporal.
# Se toma el nombre del archivo principal.
zip = zipfile.ZipFile(fname)
shapefileName = None
dirname = tempfile.mkdtemp()
for info in zip.infolist():
if info.filename.endswith(".shp") and es_shp:
shapefileName = info.filename
if not es_shp:
shapefileName = info.filename
dst_file = os.path.join(dirname, info.filename)
f = open(dst_file, "wb")
f.write(zip.read(info.filename))
f.close()
zip.close()
# Intenta abrir el archivo
try:
datasource = ogr.Open(os.path.join(dirname, shapefileName))
layer = datasource.GetLayer(0)
shapefileOK = True
except:
traceback.print_exc()
shapefileOK = False
if not shapefileOK:
os.remove(fname)
shutil.rmtree(dirname)
return "No es un archivo válido."
# Importar los datos del shapefile abierto.
feature1 = layer.GetFeature(0)
tipo_geometria = feature1.geometry().GetGeometryType()
feature1.Destroy()
#geometryType = layer.GetLayerDefn().GetGeomType()
geometryName = ogr.GeometryTypeToName(tipo_geometria)
geometryName = geometryName.replace(" ", "")
src_spatial_ref = layer.GetSpatialRef()
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromEPSG(4326) #Aqui se define que sistema de coordenadas se le asigna en la BD
shapefile = Shapefile(filename=shapefileName,
srs_wkt=src_spatial_ref.ExportToWkt(),
geom_type=geometryName)
shapefile.save()
attributes = []
layerDef = layer.GetLayerDefn()
for i in range(layerDef.GetFieldCount()):
fieldDef = layerDef.GetFieldDefn(i)
attr = Attribute(shapefile=shapefile,
name=fieldDef.GetName(),
type=fieldDef.GetType(),
width=fieldDef.GetWidth(),
precision=fieldDef.GetPrecision())
attr.save()
attributes.append(attr)
#layerDef.Destroy()
coordTransform = osr.CoordinateTransformation(src_spatial_ref,
dst_spatial_ref)
for i in range(layer.GetFeatureCount()):
srcFeature = layer.GetFeature(i)
srcGeometry = srcFeature.GetGeometryRef()
srcGeometry.Transform(coordTransform)
geometry = GEOSGeometry(srcGeometry.ExportToWkt())
geometry = utils.wrap_geos_geometry(geometry)
geometryField = utils.calc_geometry_field(geometryName)
args = {}
args['shapefile'] = shapefile
args[geometryField] = geometry
feature = Feature(**args)
feature.save()
for attr in attributes:
success,result = utils.get_ogr_feature_attribute(attr, srcFeature)
#if not success:
#os.remove(fname)
#print dirname
#shutil.rmtree(dirname)
#shapefile.delete()
#return result
if success:
attrValue = AttributeValue(feature=feature, attribute=attr, value=result)
attrValue.save()
# Finalmente, limpiarlo todo.
datasource.Destroy()
os.remove(fname)
print dirname
shutil.rmtree(dirname)
return None # Exito.
def export_data(shapefile, dst_spatial_ref, driver, extension):
shapefile.filename = os.path.splitext(shapefile.filename)[0] + str(extension)
# Crea el shapefile.
dst_dir = tempfile.mkdtemp()
dst_file = str(os.path.join(dst_dir, shapefile.filename))
#dst_spatial_ref = osr.SpatialReference() #Comentado porque recibe el src de la template
#dst_spatial_ref.ImportFromEPSG(dst_epsg)
#dst_spatial_ref.ImportFromWkt(shapefile.srs_wkt)
#driver = ogr.GetDriverByName("ESRI Shapefile") #Comentado porque recibe el driver de la template
datasource = driver.CreateDataSource(dst_file)
layer = datasource.CreateLayer(str(shapefile.filename), dst_spatial_ref)
# Define los atributos del shapefile.
for attr in shapefile.attribute_set.all():
field = ogr.FieldDefn(str(attr.name), attr.type)
field.SetWidth(attr.width)
field.SetPrecision(attr.precision)
layer.CreateField(field)
# Crea el sistema de coodenadas.
src_spatial_ref = osr.SpatialReference()
src_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(
src_spatial_ref, dst_spatial_ref)
# Calcula que campo de geometria contiene la geometria del shapefile's.
geom_field = utils.calc_geometry_field(shapefile.geom_type)
# Exporta las features.
for feature in shapefile.feature_set.all():
geometry = getattr(feature, geom_field)
geometry = utils.unwrap_geos_geometry(geometry)
dst_geometry = ogr.CreateGeometryFromWkt(geometry.wkt)
dst_geometry.Transform(coord_transform)
dst_feature = ogr.Feature(layer.GetLayerDefn())
dst_feature.SetGeometry(dst_geometry)
for attr_value in feature.attributevalue_set.all():
utils.set_ogr_feature_attribute(
attr_value.attribute,
attr_value.value,
dst_feature)
layer.CreateFeature(dst_feature)
layer = None
datasource = None
# Compreime el shapefile como archivo ZIP.
temp = tempfile.TemporaryFile()
zip = zipfile.ZipFile(temp, 'w', zipfile.ZIP_DEFLATED)
shapefile_name = os.path.splitext(shapefile.filename)[0]
for fName in os.listdir(dst_dir):
zip.write(os.path.join(dst_dir, fName), fName)
zip.close()
shutil.rmtree(dst_dir)
# Devuelve el archivo ZIP.
temp.flush()
temp.seek(0)
response = FileResponse(temp)
response['Content-type'] = "application/zip"
response['Content-Disposition'] = \
"attachment; filename=" + shapefile_name + ".zip"
return response
def export_data(shapefile):
# return "More to come..."
# Create a temporary directory to hold the shapefile's contents
dst_dir = tempfile.mkdtemp()
dst_file = str(os.path.join(dst_dir, shapefile.filename))
# Create a spatial reference for the shapefile to use, and
# set up the shapefile's datasource and layer
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromWkt(shapefile.srs_wkt)
driver = ogr.GetDriverByName("ESRI Shapefile")
datasource = driver.CreateDataSource(dst_file)
layer = datasource.CreateLayer(str(shapefile.filename),
dst_spatial_ref)
# Define the various fields which will hold the shapefile's attributes.
# Django makes iterating over the shapefile's attributes
for attr in shapefile.attribute_set.all():
field = ogr.FieldDefn(str(attr.name), attr.type)
field.SetWidth(attr.width)
field.SetPrecision(attr.precision)
layer.CreateField(field)
# To transform the shapefile's features from the spatial reference
# used internally (EPSG 4326) into the shapefile's own spatial reference.
# First, need to set up an osr.CoordinateTransformation object to do the transformation
src_spatial_ref = osr.SpatialReference()
src_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(
src_spatial_ref, dst_spatial_ref)
# Determine which geometry field in the Feature object holds the feature's geometry data
geom_field = \
utils.calc_geometry_field(shapefile.geom_type)
# Exporting the shapefile's features
for feature in shapefile.feature_set.all():
geometry = getattr(feature, geom_field)
# Need to unwrap the geometry so that features that have only one Polygon
# or LineString in their geometries are saved as Polygons and LineStrings
# rather than MultiPolygons and MultiLineStrings.
# See utils.py function for unwrapping
geometry = utils.unwrap_geos_geometry(geometry)
# Convert feature's geometry back into an OGR geometry again,
# transform it into the shapefile's own spatial reference system,
# and create an OGR feature using that geometry:
dst_geometry = ogr.CreateGeometryFromWkt(geometry.wkt)
dst_geometry.Transform(coord_transform)
dst_feature = ogr.Feature(layer.GetLayerDefn())
dst_feature.SetGeometry(dst_geometry)
# Save the attribute values associated with each feature by
# storing the string value into the OGR attribute field. See utils.py
for attr_value in feature.attributevalue_set.all():
utils.set_ogr_feature_attribute(
attr_value.attribute,
attr_value.value,
dst_feature,
shapefile.encoding)
# Add the feature to the layer and call the Destroy() method to
# save the feature (and then the layer) into the shapefile
layer.CreateFeature(dst_feature)
dst_feature.Destroy()
datasource.Destroy()
# Compress exported data into an OGR shapefile into a ZIP archive
# Note: a temporary file, named temp, is used to store the ZIP
# archive's contents. It'll be returned to the user's web browser
# once the export process has finished
temp = tempfile.TemporaryFile()
zip = zipfile.ZipFile(temp, 'w', zipfile.ZIP_DEFLATED)
shapefile_base = os.path.splitext(dst_file)[0]
shapefile_name = os.path.splitext(shapefile.filename)[0]
for fName in os.listdir(dst_dir):
zip.write(os.path.join(dst_dir, fName), fName)
zip.close()
# Deleting the shapefile that was created earlier
shutil.rmtree(dst_dir)
# Send the ZIP archive to the user's web browser so that it can be
# downloaded onto the user's computer. To do this: create an
# HttpResponse object which includes a Django FileWrapper object
# to attach the ZIP archive to the HTTP response
f = FileWrapper(temp)
response = HttpResponse(f, content_type="application/zip")
response['Content-Disposition'] = \
"attachment; filename=" + shapefile_name + ".zip"
response['Content-Length'] = temp.tell()
temp.seek(0)
return response
def export_data(shapefile):
# Create the shapefile.
dst_dir = tempfile.mkdtemp()
dst_file = os.path.join(dst_dir, shapefile.filename)
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromWkt(shapefile.srs_wkt)
driver = ogr.GetDriverByName("ESRI Shapefile")
datasource = driver.CreateDataSource(dst_file)
layer = datasource.CreateLayer(shapefile.filename,
dst_spatial_ref)
# Define the shapefile's attributes.
for attr in shapefile.attribute_set.all():
field = ogr.FieldDefn(attr.name, attr.type)
field.SetWidth(attr.width)
field.SetPrecision(attr.precision)
layer.CreateField(field)
# Create our coordinate transformation.
src_spatial_ref = osr.SpatialReference()
src_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(
src_spatial_ref, dst_spatial_ref)
# Calculate which geometry field holds the shapefile's geometry.
geom_field = utils.calc_geometry_field(shapefile.geom_type)
# Export the shapefile's features.
for feature in shapefile.feature_set.all():
geometry = getattr(feature, geom_field)
geometry = utils.unwrap_geos_geometry(geometry)
dst_geometry = ogr.CreateGeometryFromWkt(geometry.wkt)
dst_geometry.Transform(coord_transform)
dst_feature = ogr.Feature(layer.GetLayerDefn())
dst_feature.SetGeometry(dst_geometry)
for attr_value in feature.attributevalue_set.all():
utils.set_ogr_feature_attribute(
attr_value.attribute,
attr_value.value,
dst_feature)
layer.CreateFeature(dst_feature)
layer = None
datasource = None
# Compress the shapefile as a ZIP archive.
temp = tempfile.TemporaryFile()
zip = zipfile.ZipFile(temp, 'w', zipfile.ZIP_DEFLATED)
shapefile_name = os.path.splitext(shapefile.filename)[0]
for fName in os.listdir(dst_dir):
zip.write(os.path.join(dst_dir, fName), fName)
zip.close()
shutil.rmtree(dst_dir)
# Return the ZIP archive back to the caller.
temp.flush()
temp.seek(0)
response = FileResponse(temp)
response['Content-type'] = "application/zip"
response['Content-Disposition'] = \
"attachment; filename=" + shapefile_name + ".zip"
return response
def export_data(shapefile):
# Create a temporary directory to hold our shapefile.
dst_dir = tempfile.mkdtemp()
dst_file = str(os.path.join(dst_dir, shapefile.filename))
# Create the shapefile and its associated spatial reference.
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromWkt(shapefile.srs_wkt)
driver = ogr.GetDriverByName("ESRI Shapefile")
datasource = driver.CreateDataSource(dst_file)
layer = datasource.CreateLayer(str(shapefile.filename),
dst_spatial_ref)
# Define the various fields which will hold the shapefile's attributes.
for attr in shapefile.attribute_set.all():
field = ogr.FieldDefn(str(attr.name), attr.type)
field.SetWidth(attr.width)
field.SetPrecision(attr.precision)
layer.CreateField(field)
# Setup a coordinate transformation to convert from our internal spatial
# reference system to the shapefile's original SRS.
src_spatial_ref = osr.SpatialReference()
src_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(src_spatial_ref,
dst_spatial_ref)
# See which field in the Feature object holds the feature's geometry.
geom_field = utils.calc_geometry_field(shapefile.geom_type)
# Start exporting the shapefile's contents.
for feature in shapefile.feature_set.all():
geometry = getattr(feature, geom_field)
# If necessary, unwrap the geometry again.
geometry = utils.unwrap_geos_geometry(geometry)
# Convert the geometry into an OGR geometry object, and transform it
# into the shapefile's original spatial reference system.
dst_geometry = ogr.CreateGeometryFromWkt(geometry.wkt)
dst_geometry.Transform(coord_transform)
dst_feature = ogr.Feature(layer.GetLayerDefn())
dst_feature.SetGeometry(dst_geometry)
# Save the feature's attributes into the shapefile.
for attr_value in feature.attributevalue_set.all():
utils.set_ogr_feature_attribute(attr_value.attribute,
attr_value.value,
dst_feature,
shapefile.encoding)
# Finally, save the feature into the shapefile.
layer.CreateFeature(dst_feature)
dst_feature.Destroy()
# Close the shapefile.
datasource.Destroy()
# Compress the shapefile into a ZIP archive.
temp = tempfile.TemporaryFile()
zip = zipfile.ZipFile(temp, "w", zipfile.ZIP_DEFLATED)
shapefile_base = os.path.splitext(dst_file)[0]
shapefile_name = os.path.splitext(shapefile.filename)[0]
for fName in os.listdir(dst_dir):
zip.write(os.path.join(dst_dir, fName), fName)
zip.close()
# Delete the shapefile directory.
shutil.rmtree(dst_dir)
# Finally, wrap the compressed ZIP archive in a FileWrapper so it can be
# sent back to the user's web browser.
f = FileWrapper(temp)
response = HttpResponse(f, content_type="application/zip")
response['Content-Disposition'] = \
"attachment; filename=" + shapefile_name + ".zip"
response['Content-Length'] = temp.tell()
temp.seek(0)
return response
def tile(request, version, shapefile_id, zoom, x, y):
try:
if version != "1.0":
raise Http404
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except Shapefile.DoesNotExist:
raise Http404
zoom = int(zoom)
x = int(x)
y = int(y)
if zoom < 0 or zoom > MAX_ZOOM_LEVEL:
raise Http404
xExtent = _unitsPerPixel(zoom) * TILE_WIDTH
yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT
minLong = x * xExtent - 180.0
minLat = y * yExtent - 90.0
maxLong = minLong + xExtent
maxLat = minLat + yExtent
if (minLong < -180 or maxLong > 180 or
minLat < -90 or maxLat > 90):
print "Map extent out of bounds:",minLong,minLat,maxLong,maxLat
raise Http404
#######################################################
map = mapnik.Map(TILE_WIDTH, TILE_HEIGHT,
str("+proj=longlat +datum=WGS84"))
map.background = mapnik.Color(str("#7391ad"))
dbSettings = settings.DATABASES['default']
datasource = mapnik.PostGIS(user=str(dbSettings['USER']),password=str(dbSettings['PASSWORD']),
dbname=str(dbSettings['NAME']),table='tms_basemap', srid=4326,
geometry_field="geometry", geometry_table='tms_basemap',
port=5433)
baseLayer = mapnik.Layer(str("baseLayer"))
baseLayer.datasource = datasource
baseLayer.styles.append(str("baseLayerStyle"))
rule = mapnik.Rule()
rule.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color(str("#b5d19c"))))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color(str("#404040")), 0.2))
style = mapnik.Style()
style.rules.append(rule)
map.append_style(str("baseLayerStyle"), style) ####
map.layers.append(baseLayer)
geometry_field = \
utils.calc_geometry_field(shapefile.geom_type)
query = '(SELECT ' + geometry_field \
+ ' FROM "shared_feature" WHERE' \
+ ' shapefile_id = ' + str(shapefile.id) + ') as geom'
print query
print dbSettings['USER'],dbSettings['PASSWORD'],dbSettings['NAME'],query,geometry_field
datasource = \
mapnik.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
port=dbSettings['PORT'],
srid=4326,
table=query,
geometry_field=geometry_field,
geometry_table='shared_feature',
)
featureLayer = mapnik.Layer(str("featureLayer"))
featureLayer.datasource = datasource
featureLayer.styles.append(str("featureLayerStyle"))
rule = mapnik.Rule()
if shapefile.geom_type in ["Point", "MultiPoint"]:
rule.symbols.append(mapnik.PointSymbolizer())
elif shapefile.geom_type in ["LineString", "MultiLineString"]:
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5))
elif shapefile.geom_type in ["Polygon", "MultiPolygon"]:
rule.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color(str("#f7edee"))))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color(str("#000000")), 0.5))
style = mapnik.Style()
style.rules.append(rule)
map.append_style(str("featureLayerStyle"), style)
map.layers.append(featureLayer)
map.zoom_to_box(mapnik.Box2d(minLong, minLat, maxLong, maxLat))
image = mapnik.Image(TILE_WIDTH, TILE_HEIGHT)
mapnik.render(map, image)
imageData = image.tostring(str('png'))
print imageData
return HttpResponse(imageData, content_type="image/png")
except:
traceback.print_exc()
return HttpResponse("Error")
def tile(request, version, shapefile_id, zoom, x, y):
try:
if version != "1.0":
raise Http404
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except Shapefile.DoesNotExist:
raise Http404
zoom = int(zoom)
x = int(x)
y = int(y)
if zoom < 0 or zoom > MAX_ZOOM_LEVEL:
raise Http404
# Convert the supplied x and y parameters into the minimum and maximum latitude and longitude values covered by the tile. This requires us to use the _unitsPerPixel() function defined earlier to calculate the amount of the Earth's surface covered by the tile for the current zoom level
xExtent = _unitsPerPixel(zoom) * TILE_WIDTH
yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT
minLong = x * xExtent - 180.0
minLat = y * yExtent - 90.0
maxLong = minLong + xExtent
maxLat = minLat + yExtent
if (minLong < -180 or maxLong > 180 or
minLat < -90 or maxLat > 90):
raise Http404
# Create mapnik.Map object
map = mapnik2.Map(TILE_WIDTH, TILE_HEIGHT,
"+proj=longlat +datum=WGS84")
map.background = mapnik2.Color("#8aa3ec")
# Define the layer which draws the base map by setting up a mapnik.PostGIS datasource for the layer
dbSettings = settings.DATABASES['default']
datasource = \
mapnik2.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
table='tms_basemap',
srid=4326,
geometry_field="geometry",
geometry_table='tms_basemap')
# Create the baselayer itself
baseLayer = mapnik2.Layer("baseLayer")
baseLayer.datasource = datasource
baseLayer.styles.append("baseLayerStyle")
# Set up the layer's style. In this case, we'll use a single rule with two symbolizers: a PolygonSymbolizer which draws the interior of the base map's polygons, and a LineSymbolizer to draw the polygon outlines
#labelStyle = mapnik2.Style()
rule = mapnik2.Rule()
#symbol = mapnik2.TextSymbolizer(mapnik2.Expression("[name]"),"DejaVu Sans Book", 12, mapnik2.Color("#000000"))
#rule.symbols.append(symbol)
#labelStyle.rules.append(rule)
# rule = mapnik2.Rule()
rule.symbols.append(
mapnik2.PolygonSymbolizer(mapnik2.Color("#f0e9e6")))
rule.symbols.append(
mapnik2.LineSymbolizer(mapnik2.Color("#807878"), 0.2))
style = mapnik2.Style()
style.rules.append(rule)
# Add the base layer and its style to the map
map.append_style("baseLayerStyle", style)
map.layers.append(baseLayer)
# Add another layer to draw the shapefile's features onto the map.
# Once again, set up a mapnik.PostGIS datasource for the new layer
geometryField = utils.calc_geometry_field(shapefile.geom_type)
#print geometryField
if geometryField=='geom_point':
query = '(select geom_point from shared_feature where shapefile_id=' + str(shapefile.id) + ') as geom'
else:
query = '(select ' + geometryField \
+ ' from "shared_feature" where' \
+ ' shapefile_id=' + str(shapefile.id) + ') as geom'
print query
datasource = \
mapnik2.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
table=query,
srid=4326,
geometry_table='shared_feature',
geometry_field=geometryField)
print datasource
# Create the new layer itself
featureLayer = mapnik2.Layer("featureLayer")
featureLayer.datasource = datasource
featureLayer.styles.append("featureLayerStyle")
# Define the styles used by the feature layer
rule = mapnik2.Rule()
if shapefile.geom_type in ["Point", "MultiPoint"]:
rule.symbols.append(mapnik2.PointSymbolizer())
elif shapefile.geom_type in ["LineString", "MultiLineString"]:
rule.symbols.append(
mapnik2.LineSymbolizer(mapnik2.Color("#404040"), 0.5))
elif shapefile.geom_type in ["Polygon", "MultiPolygon"]:
rule.symbols.append(
mapnik2.PolygonSymbolizer(mapnik2.Color("#f7edee")))
rule.symbols.append(
mapnik2.LineSymbolizer(mapnik2.Color("#000000"), 0.5))
style = mapnik2.Style()
style.rules.append(rule)
# Add new feature layer to the map
map.append_style("featureLayerStyle", style)
map.layers.append(featureLayer)
# Rendering the map tile. Create a mapnik.Image object, convert it into raw image data in PNG format, and return that data back to the caller using an HttpResponse object
map.zoom_to_box(mapnik2.Box2d(minLong, minLat,
maxLong, maxLat))
image = mapnik2.Image(TILE_WIDTH, TILE_HEIGHT)
mapnik2.render(map, image)
imageData = image.tostring('png')
return HttpResponse(imageData, mimetype="image/png")
# Error-catching
except:
traceback.print_exc()
return HttpResponse("Error")
def import_data(shapefile):
# Extract the uploaded shapefile.
fd, fname = tempfile.mkstemp(suffix=".zip")
os.close(fd)
f = open(fname, "wb")
for chunk in shapefile.chunks():
f.write(chunk)
f.close()
if not zipfile.is_zipfile(fname):
os.remove(fname)
return "Not a valid zip archive."
zip = zipfile.ZipFile(fname)
required_suffixes = [".shp", ".shx", ".dbf", ".prj"]
has_suffix = {}
for suffix in required_suffixes:
has_suffix[suffix] = False
for info in zip.infolist():
suffix = os.path.splitext(info.filename)[1].lower()
if suffix in required_suffixes:
has_suffix[suffix] = True
for suffix in required_suffixes:
if not has_suffix[suffix]:
zip.close()
os.remove(fname)
return "Archive missing required " + suffix + " file."
shapefile_name = None
dir_name = tempfile.mkdtemp()
for info in zip.infolist():
if info.filename.endswith(".shp"):
shapefile_name = info.filename
dst_file = os.path.join(dir_name, info.filename)
f = open(dst_file, "wb")
f.write(zip.read(info.filename))
f.close()
zip.close()
# Open the shapefile.
try:
datasource = ogr.Open(os.path.join(dir_name, shapefile_name))
layer = datasource.GetLayer(0)
shapefile_ok = True
except:
traceback.print_exc()
shapefile_ok = False
if not shapefile_ok:
os.remove(fname)
shutil.rmtree(dir_name)
return "Not a valid shapefile."
# Save Shapefile object to database.
src_spatial_ref = layer.GetSpatialRef()
geom_type = layer.GetLayerDefn().GetGeomType()
geom_name = ogr.GeometryTypeToName(geom_type)
shapefile = Shapefile(filename=shapefile_name,
srs_wkt=src_spatial_ref.ExportToWkt(),
geom_type=geom_name)
shapefile.save()
# Define the shapefile's attributes.
attributes = []
layer_def = layer.GetLayerDefn()
for i in range(layer_def.GetFieldCount()):
field_def = layer_def.GetFieldDefn(i)
attr = Attribute(shapefile=shapefile,
name=field_def.GetName(),
type=field_def.GetType(),
width=field_def.GetWidth(),
precision=field_def.GetPrecision())
attr.save()
attributes.append(attr)
# Save the Shapefile's features and attributes to disk.
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(src_spatial_ref,
dst_spatial_ref)
for i in range(layer.GetFeatureCount()):
src_feature = layer.GetFeature(i)
src_geometry = src_feature.GetGeometryRef()
src_geometry.Transform(coord_transform)
geometry = GEOSGeometry(src_geometry.ExportToWkt())
geometry = utils.wrap_geos_geometry(geometry)
geom_field = utils.calc_geometry_field(geom_name)
fields = {}
fields['shapefile'] = shapefile
fields[geom_field] = geometry
feature = Feature(**fields)
feature.save()
for attr in attributes:
success, result = utils.get_ogr_feature_attribute(
attr, src_feature)
if not success:
os.remove(fname)
shutil.rmtree(dir_name)
shapefile.delete()
return result
attr_value = AttributeValue(feature=feature,
attribute=attr,
value=result)
attr_value.save()
os.remove(fname)
shutil.rmtree(dir_name)
return None
def import_data(shapefile):
# Extract the uploaded shapefile.
fd,fname = tempfile.mkstemp(suffix=".zip")
os.close(fd)
f = open(fname, "wb")
for chunk in shapefile.chunks():
f.write(chunk)
f.close()
if not zipfile.is_zipfile(fname):
os.remove(fname)
return "Not a valid zip archive."
zip = zipfile.ZipFile(fname)
required_suffixes = [".shp", ".shx", ".dbf", ".prj"]
has_suffix = {}
for suffix in required_suffixes:
has_suffix[suffix] = False
for info in zip.infolist():
suffix = os.path.splitext(info.filename)[1].lower()
if suffix in required_suffixes:
has_suffix[suffix] = True
for suffix in required_suffixes:
if not has_suffix[suffix]:
zip.close()
os.remove(fname)
return "Archive missing required " + suffix + " file."
shapefile_name = None
dir_name = tempfile.mkdtemp()
for info in zip.infolist():
if info.filename.endswith(".shp"):
shapefile_name = info.filename
dst_file = os.path.join(dir_name, info.filename)
f = open(dst_file, "wb")
f.write(zip.read(info.filename))
f.close()
zip.close()
# Open the shapefile.
try:
datasource = ogr.Open(os.path.join(dir_name, shapefile_name))
layer = datasource.GetLayer(0)
shapefile_ok = True
except:
traceback.print_exc()
shapefile_ok = False
if not shapefile_ok:
os.remove(fname)
shutil.rmtree(dir_name)
return "Not a valid shapefile."
# Save Shapefile object to database.
src_spatial_ref = layer.GetSpatialRef()
geom_type = layer.GetLayerDefn().GetGeomType()
geom_name = ogr.GeometryTypeToName(geom_type)
shapefile = Shapefile(filename=shapefile_name,
srs_wkt=src_spatial_ref.ExportToWkt(),
geom_type=geom_name)
shapefile.save()
# Define the shapefile's attributes.
attributes = []
layer_def = layer.GetLayerDefn()
for i in range(layer_def.GetFieldCount()):
field_def = layer_def.GetFieldDefn(i)
attr = Attribute(shapefile=shapefile,
name=field_def.GetName(),
type=field_def.GetType(),
width=field_def.GetWidth(),
precision=field_def.GetPrecision())
attr.save()
attributes.append(attr)
# Save the Shapefile's features and attributes to disk.
dst_spatial_ref = osr.SpatialReference()
dst_spatial_ref.ImportFromEPSG(4326)
coord_transform = osr.CoordinateTransformation(
src_spatial_ref,
dst_spatial_ref)
for i in range(layer.GetFeatureCount()):
src_feature = layer.GetFeature(i)
src_geometry = src_feature.GetGeometryRef()
src_geometry.Transform(coord_transform)
geometry = GEOSGeometry(src_geometry.ExportToWkt())
geometry = utils.wrap_geos_geometry(geometry)
geom_field = utils.calc_geometry_field(geom_name)
fields = {}
fields['shapefile'] = shapefile
fields[geom_field] = geometry
feature = Feature(**fields)
feature.save()
for attr in attributes:
success,result = utils.get_ogr_feature_attribute(
attr, src_feature)
if not success:
os.remove(fname)
shutil.rmtree(dir_name)
shapefile.delete()
return result
attr_value = AttributeValue(feature=feature,
attribute=attr,
value=result)
attr_value.save()
os.remove(fname)
shutil.rmtree(dir_name)
return None
def tile(request, version, shapefile_id, zoom, x, y):
try:
# Parse and check our parameters.
if version != "1.0":
raise Http404
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except Shapefile.DoesNotExist:
raise Http404
zoom = int(zoom)
x = int(x)
y = int(y)
if zoom < 0 or zoom > MAX_ZOOM_LEVEL:
raise Http404
xExtent = _unitsPerPixel(zoom) * TILE_WIDTH
yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT
minLong = x * xExtent - 180.0
minLat = y * yExtent - 90.0
maxLong = minLong + xExtent
maxLat = minLat + yExtent
if (minLong < -180 or maxLong > 180 or
minLat < -90 or maxLat > 90):
raise Http404
# Set up the map.
map = mapnik.Map(TILE_WIDTH, TILE_HEIGHT,
"+proj=longlat +datum=WGS84")
map.background = mapnik.Color("#7391ad")
# Define the base layer.
dbSettings = settings.DATABASES['default']
datasource = \
mapnik.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
table='tms_basemap',
srid=4326,
geometry_field="geometry",
geometry_table='tms_basemap')
baseLayer = mapnik.Layer("baseLayer")
baseLayer.datasource = datasource
baseLayer.styles.append("baseLayerStyle")
rule = mapnik.Rule()
rule.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color("#b5d19c")))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#404040"), 0.2))
style = mapnik.Style()
style.rules.append(rule)
map.append_style("baseLayerStyle", style)
map.layers.append(baseLayer)
# Define the feature layer.
geometry_field = utils.calc_geometry_field(shapefile.geom_type)
query = '(select ' + geometry_field \
+ ' from "shared_feature" where' \
+ ' shapefile_id=' + str(shapefile.id) + ') as geom'
datasource = \
mapnik.PostGIS(user=dbSettings['USER'],
password=dbSettings['PASSWORD'],
dbname=dbSettings['NAME'],
table=query,
srid=4326,
geometry_field=geometry_field,
geometry_table='shared_feature')
featureLayer = mapnik.Layer("featureLayer")
featureLayer.datasource = datasource
featureLayer.styles.append("featureLayerStyle")
rule = mapnik.Rule()
if shapefile.geom_type in ["Point", "MultiPoint"]:
rule.symbols.append(mapnik.PointSymbolizer())
elif shapefile.geom_type in ["LineString", "MultiLineString"]:
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5))
elif shapefile.geom_type in ["Polygon", "MultiPolygon"]:
rule.symbols.append(
mapnik.PolygonSymbolizer(mapnik.Color("#f7edee")))
rule.symbols.append(
mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5))
style = mapnik.Style()
style.rules.append(rule)
map.append_style("featureLayerStyle", style)
map.layers.append(featureLayer)
# Finally, render the map tile.
map.zoom_to_box(mapnik.Box2d(minLong, minLat,
maxLong, maxLat))
image = mapnik.Image(TILE_WIDTH, TILE_HEIGHT)
mapnik.render(map, image)
imageData = image.tostring('png')
return HttpResponse(imageData, content_type="image/png")
except:
traceback.print_exc()
return HttpResponse("Error")
def edit_feature(request, shapefile_id, feature_id=None, attributevalue=None):
userid = request.user
if request.method == "POST" and "delete" in request.POST:
return HttpResponseRedirect("/editor/delete_feature/" +
shapefile_id+"/"+feature_id)
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except ShapeFile.DoesNotExist:
return HttpResponseNotFound()
if request.method == "POST" and "attributevalue" in request.POST:
print attributevalue
return HttpResponseRedirect("/editor/edit_attributevalue/" +
shapefile_id+"/"+attributevalue)
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except ShapeFile.DoesNotExist:
return HttpResponseNotFound()
if request.method == "POST" and "addattributevalue" in request.POST:
print feature_id
return HttpResponseRedirect("/editor/add_attributevalue/" +
str(shapefile_id)+"/"+str(feature_id))
try:
shapefile = Shapefile.objects.get(id=shapefile_id)
except ShapeFile.DoesNotExist:
return HttpResponseNotFound()
# Create a new Feature object if the feature_id is not specified,
# but fail if an invalid feature ID was specified.
if feature_id == None:
feature = Feature(shapefile=shapefile)
else:
try:
feature = Feature.objects.get(id=feature_id)
except Feature.DoesNotExist:
return HttpResponseNotFound()
# Store attributes and attributes' values in an array
attributes = []
for attr_value in feature.attributevalue_set.all():
attributes.append([attr_value.attribute.name,
attr_value.value,
attr_value.id])
attributes.sort()
# get all attributes for shapefile
q = []
q = Feature.objects.raw('SELECT * from shared_attribute where shapefile_id=%s', [shapefile_id])
all_attr = []
for p in q:
all_attr.append(p.id)
# get only attributes that have values
q1 = []
set_attr = []
q1 = Feature.objects.raw('SELECT * from shared_attributevalue where feature_id=%s', [feature_id])
for p in q1:
set_attr.append(p.attribute_id)
attributes1 = []
attr1 = []
for n in all_attr:
if n not in set_attr:
#print n
attr = Attribute.objects.get(id=n)
attr1.append(attr.name)
attr1.append(attr.id)
attributes1.append(attr1)
attr1=[]
attributes1.sort()
print attributes1
geometry_field = \
utils.calc_geometry_field(shapefile.geom_type)
form_class = utils.get_map_form(shapefile)
if request.method == "GET":
wkt = getattr(feature, geometry_field)
form = form_class({'geometry' : wkt})
return render(request, "edit_feature.html",
{'shapefile' : shapefile,
'form' : form,
'feature': feature_id,
'attributes' : attributes,
'available': attributes1,
'full_name': request.user.username})
elif request.method == "POST":
form = form_class(request.POST)
try:
if form.is_valid():
wkt = form.cleaned_data['geometry']
setattr(feature, geometry_field, wkt)
feature.save()
return HttpResponseRedirect("/editor/edit_feature/" +
str(shapefile_id)+"/"+str(feature.id))
except ValueError:
pass
return render(request, "edit_feature.html",
{'shapefile' : shapefile,
'form' : form,
'feature': feature_id,
'attributes' : attributes,
'available': attributes1,
'full_name': request.user.username})