Esempio n. 1
0
def add_attributevalue(request, shapefile_id, feature_id):
  userid = request.user
  
  feature = feature_id
  shapefile = Shapefile.objects.get(id=shapefile_id)
  
  # 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()  
  
  if request.method == "POST":
     print 'Adding value'     
     form = AddAttributeValueForm(request.POST)
     if form.is_valid():
     	 newattribute = request.POST['attribute']    
         newvalue = request.POST['attribute_value']
         print newvalue
         print newattribute
         attributeval = AttributeValue(feature_id=feature, attribute_id=newattribute, value=newvalue)
  #  attributeval.value = newvalue
         attributeval.save()
               
      
  return render(request, "add_attributevalue.html",  
                  {'shapefile' : shapefile_id,
                   'attributes': attributes1,
                   'feature': feature_id,
		   'full_name': request.user.username})
Esempio n. 2
0
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(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
Esempio n. 5
0
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 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