Example #1
0
def run(shapePath):
    'Load regions from shapefile'
    # Parse shapePath
    shapeName = store.extractFileBaseName(shapePath).decode('utf-8')
    proj4, shapelyGeometries, fieldPacks, fieldDefinitions = geometry_store.load(shapePath)
    # Initialize
    srid = getSRID(proj4)
    featureCount = 0
    # Make tags
    tagTexts = [
        shapeName,
    ]
    tags = model.getTags('\n'.join(tagTexts), addMissing=True)
    # For each geometry,
    for shapelyGeometry, fieldPack in itertools.izip(shapelyGeometries, fieldPacks):
        # Gather properties
        featureProperties = {}
        for fieldValue, (fieldName, fieldType) in itertools.izip(fieldPack, fieldDefinitions):
            if fieldType == osgeo.ogr.OFTString and fieldValue:
                fieldValue = fieldValue.decode('latin-1')
            featureProperties[fieldName] = fieldValue
        # Make feature
        feature = model.Feature()
        feature.owner_id = personID
        feature.geometry = geoalchemy.WKBSpatialElement(buffer(shapelyGeometry.wkb), srid)
        feature.scope = model.scopePublic
        feature.properties = featureProperties
        feature.tags = tags
        Session.add(feature)
        # Increment
        featureCount += 1
    # Commit
    Session.commit()
    # Return
    return '%s: %s' % (shapeName, featureCount)
Example #2
0
def run(shapePath):
    'Load regions from shapefile'
    # Parse shapePath
    shapeName = store.extractFileBaseName(shapePath)
    countryAlpha3, administrativeLevel = re.match(r'(.*)_adm(\d+)', shapeName).groups()
    countryAlpha3 = countryAlpha3.upper()
    administrativeLevel = int(administrativeLevel)
    # Load
    try:
        countryName = countryPackByAlpha3[countryAlpha3][0].decode('utf-8')
    except KeyError:
        return '%s: Unable to match country code' % shapeName
    proj4, shapelyGeometries, fieldPacks, fieldDefinitions = geometry_store.load(shapePath)
    # Initialize
    srid = getSRID(proj4)
    featureCount = 0
    # Make tags
    tagTexts = [
        countryName + (u' Administrative Level %s' % administrativeLevel if administrativeLevel > 0 else ''),
    ]
    tags = model.getTags('\n'.join(tagTexts), addMissing=True)
    # For each geometry,
    for shapelyGeometry, fieldPack in itertools.izip(shapelyGeometries, fieldPacks):
        # Gather properties
        featureProperties = {}
        for fieldValue, (fieldName, fieldType) in itertools.izip(fieldPack, fieldDefinitions):
            if fieldType == osgeo.ogr.OFTString and fieldValue:
                fieldValue = fieldValue.decode('latin-1')
            featureProperties[fieldName] = fieldValue
        if administrativeLevel > 0:
            featureName = featureProperties['NAME_%s' % administrativeLevel]
        else:
            featureName = featureProperties['NAME_ENGLI']
        featureProperties['Name'] = featureName
        # Make feature
        feature = model.Feature()
        feature.owner_id = personID
        feature.geometry = geoalchemy.WKBSpatialElement(buffer(shapelyGeometry.wkb), srid)
        feature.scope = model.scopePublic
        feature.properties = featureProperties
        feature.tags = tags
        Session.add(feature)
        # Increment
        featureCount += 1
    # Commit
    Session.commit()
    # Return
    return '%s: %s' % (shapeName, featureCount)
    def test(self):
        'Run tests'

        print 'Save and load a SHP file without attributes'
        path = self.getPath('.shp')
        geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries)
        result = geometry_store.load(path)
        self.assertEqual(result[0].strip(), geometry_store.proj4LL)
        self.assertEqual(len(result[1]), len(shapelyGeometries))

        print 'Save and load a SHP file with attributes'
        path = self.getPath('.shp')
        geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, fieldPacks, fieldDefinitions)
        result = geometry_store.load(path)
        self.assertEqual(len(result[2]), len(fieldPacks))
        for shapelyGeometry, fieldPack in itertools.izip(result[1], result[2]):
            print
            for fieldValue, (fieldName, fieldType) in itertools.izip(fieldPack, result[3]):
                print '%s = %s' % (fieldName, fieldValue)
            print shapelyGeometry

        print 'Save a SHP file with attributes with different targetProj4'
        path = self.getPath('.shp')
        geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, fieldPacks, fieldDefinitions, targetProj4=geometry_store.proj4SM)
        result = geometry_store.load(path)
        self.assertNotEqual(result[0].strip(), geometry_store.proj4LL)

        print 'Load a SHP file with attributes with different targetProj4'
        path = self.getPath('.shp')
        geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, fieldPacks, fieldDefinitions)
        result = geometry_store.load(path, targetProj4=geometry_store.proj4SM)
        self.assertNotEqual(result[0].strip(), geometry_store.proj4LL)

        print 'Save and load a ZIP file without attributes using save'
        path = self.getPath('.shp.zip')
        geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries)
        result = geometry_store.load(path)
        self.assertEqual(result[0].strip(), geometry_store.proj4LL)
        self.assertEqual(len(result[1]), len(shapelyGeometries))

        print 'Save and load a ZIP file with attributes using save'
        path = self.getPath('.shp.zip')
        geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, fieldPacks, fieldDefinitions)
        result = geometry_store.load(path)
        self.assertEqual(len(result[2]), len(fieldPacks))

        print 'Test saving and loading ZIP files of point coordinates'
        path = self.getPath('.shp.zip')
        geometry_store.save_points(path, geometry_store.proj4LL, [(0, 0)], fieldPacks, fieldDefinitions)
        result = geometry_store.load_points(path)
        self.assertEqual(result[1], [(0, 0)])

        print 'Test get_transform_point'
        transform_point0 = geometry_store.get_transform_point(geometry_store.proj4LL, geometry_store.proj4LL)
        transform_point1 = geometry_store.get_transform_point(geometry_store.proj4LL, geometry_store.proj4SM)
        self.assertNotEqual(transform_point0(0, 0), transform_point1(0, 0))

        print 'Test get_transform_geometry'
        transform_geometry = geometry_store.get_transform_geometry(geometry_store.proj4LL, geometry_store.proj4SM)
        self.assertEqual(type(transform_geometry(geometry.Point(0, 0))), type(geometry.Point(0, 0)))
        self.assertEqual(type(transform_geometry(ogr.CreateGeometryFromWkt('POINT (0 0)'))), type(ogr.CreateGeometryFromWkt('POINT (0 0)')))

        print 'Test get_coordinateTransformation'
        geometry_store.get_coordinateTransformation(geometry_store.proj4LL, geometry_store.proj4SM)

        print 'Test get_spatialReference'
        geometry_store.get_spatialReference(geometry_store.proj4LL)
        with self.assertRaises(geometry_store.GeometryError):
            geometry_store.get_spatialReference('')

        print 'Test get_geometryType'
        geometry_store.get_geometryType(shapelyGeometries)

        print 'Test save() when a fieldPack has fewer fields than definitions'
        with self.assertRaises(geometry_store.GeometryError):
            path = self.getPath('.shp')
            geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, [x[1:] for x in fieldPacks], fieldDefinitions)

        print 'Test save() when a fieldPack has more fields than definitions'
        with self.assertRaises(geometry_store.GeometryError):
            path = self.getPath('.shp')
            geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, [x * 2 for x in fieldPacks], fieldDefinitions)

        print 'Test save() when the driverName is unrecognized'
        with self.assertRaises(geometry_store.GeometryError):
            path = self.getPath('.shp')
            geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, driverName='')

        print 'Test load() when format is unrecognized'
        with self.assertRaises(geometry_store.GeometryError):
            path = self.getPath('')
            geometry_store.load(path)