def internal_multipart_to_singlepart( vector: Union[str, ogr.DataSource], out_path: Optional[str] = None, copy_attributes: bool = False, overwrite: bool = True, add_index: bool = True, process_layer: int = -1, verbose: int = 1, ) -> str: type_check(vector, [str, ogr.DataSource], "vector") type_check(out_path, [str], "out_path", allow_none=True) type_check(overwrite, [bool], "overwrite") type_check(add_index, [bool], "add_index") type_check(process_layer, [int], "process_layer") type_check(verbose, [int], "verbose") vector_list, path_list = ready_io_vector(vector, out_path, overwrite=overwrite) ref = open_vector(vector_list[0]) out_name = path_list[0] driver = ogr.GetDriverByName(path_to_driver_vector(out_name)) metadata = internal_vector_to_metadata(ref) remove_if_overwrite(out_name, overwrite) destination = driver.CreateDataSource(out_name) for index, layer_meta in enumerate(metadata["layers"]): if process_layer != -1 and index != process_layer: continue if verbose == 1: layer_name = layer_meta["layer_name"] print(f"Splitting layer: {layer_name}") target_unknown = False if layer_meta["geom_type_ogr"] == 4: # MultiPoint target_type = 1 # Point elif layer_meta["geom_type_ogr"] == 5: # MultiLineString target_type = 2 # LineString elif layer_meta["geom_type_ogr"] == 6: # MultiPolygon target_type = 3 # Polygon elif layer_meta["geom_type_ogr"] == 1004: # MultiPoint (z) target_type = 1001 # Point (z) elif layer_meta["geom_type_ogr"] == 1005: # MultiLineString (z) target_type = 1002 # LineString (z) elif layer_meta["geom_type_ogr"] == 1006: # MultiPolygon (z) target_type = 1003 # Polygon (z) elif layer_meta["geom_type_ogr"] == 2004: # MultiPoint (m) target_type = 2001 # Point (m) elif layer_meta["geom_type_ogr"] == 2005: # MultiLineString (m) target_type = 2002 # LineString (m) elif layer_meta["geom_type_ogr"] == 2006: # MultiPolygon (m) target_type = 2003 # Polygon (m) elif layer_meta["geom_type_ogr"] == 3004: # MultiPoint (zm) target_type = 3001 # Point (m) elif layer_meta["geom_type_ogr"] == 3005: # MultiLineString (zm) target_type = 3002 # LineString (m) elif layer_meta["geom_type_ogr"] == 3006: # MultiPolygon (zm) target_type = 3003 # Polygon (m) else: target_unknown = True target_type = layer_meta["geom_type_ogr"] destination_layer = destination.CreateLayer( layer_meta["layer_name"], layer_meta["projection_osr"], target_type ) layer_defn = destination_layer.GetLayerDefn() field_count = layer_meta["field_count"] original_target = ref.GetLayerByIndex(index) feature_count = original_target.GetFeatureCount() if copy_attributes: first_feature = original_target.GetNextFeature() original_target.ResetReading() if verbose == 1: print("Creating attribute fields") for field_id in range(field_count): field_defn = first_feature.GetFieldDefnRef(field_id) fname = field_defn.GetName() ftype = field_defn.GetTypeName() fwidth = field_defn.GetWidth() fprecision = field_defn.GetPrecision() if ftype == "String" or ftype == "Date": fielddefn = ogr.FieldDefn(fname, ogr.OFTString) fielddefn.SetWidth(fwidth) elif ftype == "Real": fielddefn = ogr.FieldDefn(fname, ogr.OFTReal) fielddefn.SetWidth(fwidth) fielddefn.SetPrecision(fprecision) else: fielddefn = ogr.FieldDefn(fname, ogr.OFTInteger) destination_layer.CreateField(fielddefn) for _ in range(feature_count): feature = original_target.GetNextFeature() geom = feature.GetGeometryRef() if target_unknown: out_feat = ogr.Feature(layer_defn) out_feat.SetGeometry(geom) if copy_attributes: for field_id in range(field_count): values = feature.GetField(field_id) out_feat.SetField(field_id, values) destination_layer.CreateFeature(out_feat) for geom_part in geom: out_feat = ogr.Feature(layer_defn) out_feat.SetGeometry(geom_part) if copy_attributes: for field_id in range(field_count): values = feature.GetField(field_id) out_feat.SetField(field_id, values) destination_layer.CreateFeature(out_feat) if verbose == 1: progress(_, feature_count - 1, "Splitting.") if add_index: vector_add_index(destination) return out_name
def ogr_index_10(): ds = ogr.GetDriverByName('ESRI Shapefile').CreateDataSource( 'tmp/ogr_index_10.shp') lyr = ds.CreateLayer('ogr_index_10') lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger)) lyr.CreateField(ogr.FieldDefn('realfield', ogr.OFTReal)) lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString)) feat = ogr.Feature(lyr.GetLayerDefn()) feat.SetField(0, 1) feat.SetField(1, 1) feat.SetField(2, "foo") lyr.CreateFeature(feat) feat = None ds.ExecuteSQL('create index on ogr_index_10 using intfield') ds.ExecuteSQL('create index on ogr_index_10 using realfield') lyr.SetAttributeFilter('intfield IN (1)') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('intfield = 1') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('intfield IN (2)') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is not None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('intfield IN (1.0)') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('intfield = 1.0') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('intfield IN (1.1)') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is not None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter("intfield IN ('1')") lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('realfield IN (1.0)') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('realfield = 1.0') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('realfield IN (1.1)') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is not None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('realfield IN (1)') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('realfield = 1') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter('realfield IN (2)') lyr.ResetReading() feat = lyr.GetNextFeature() if feat is not None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter("realfield IN ('1')") lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter("strfield IN ('foo')") lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter("strfield = 'foo'") lyr.ResetReading() feat = lyr.GetNextFeature() if feat is None: gdaltest.post_reason('failed') return 'fail' lyr.SetAttributeFilter("strfield IN ('bar')") lyr.ResetReading() feat = lyr.GetNextFeature() if feat is not None: gdaltest.post_reason('failed') return 'fail' ds = None return 'success'
def testFidSupport(self): # We do not use @unittest.expectedFailure since the test might actually succeed # on Linux 64bit with GDAL 1.11, where "long" is 64 bit... # GDAL 2.0 is guaranteed to properly support it on all platforms version_num = int(gdal.VersionInfo('VERSION_NUM')) if version_num < GDAL_COMPUTE_VERSION(2, 0, 0): return tmpfile = os.path.join(self.basetestpath, 'testFidSupport.sqlite') ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile) lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid']) lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString)) lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger)) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(12) f.SetField(0, 'foo') f.SetField(1, 123) lyr.CreateFeature(f) f = None ds = None vl = QgsVectorLayer('{}'.format(tmpfile), 'test', 'ogr') self.assertEqual(len(vl.fields()), 3) got = [(f.attribute('fid'), f.attribute('strfield'), f.attribute('intfield')) for f in vl.getFeatures()] self.assertEqual(got, [(12, 'foo', 123)]) got = [(f.attribute('fid'), f.attribute('strfield')) for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression( "strfield = 'foo'"))] self.assertEqual(got, [(12, 'foo')]) got = [(f.attribute('fid'), f.attribute('strfield')) for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression( "fid = 12"))] self.assertEqual(got, [(12, 'foo')]) result = [ f['strfield'] for f in vl.dataProvider().getFeatures(QgsFeatureRequest( ).setSubsetOfAttributes(['strfield'], vl.dataProvider().fields())) ] self.assertEqual(result, ['foo']) result = [ f['fid'] for f in vl.dataProvider().getFeatures(QgsFeatureRequest( ).setSubsetOfAttributes(['fid'], vl.dataProvider().fields())) ] self.assertEqual(result, [12]) # Test that when the 'fid' field is not set, regular insertion is done f = QgsFeature() f.setFields(vl.fields()) f.setAttributes([None, 'automatic_id']) (res, out_f) = vl.dataProvider().addFeatures([f]) self.assertEqual(out_f[0].id(), 13) self.assertEqual(out_f[0].attribute('fid'), 13) self.assertEqual(out_f[0].attribute('strfield'), 'automatic_id') # Test that when the 'fid' field is set, it is really used to set the id f = QgsFeature() f.setFields(vl.fields()) f.setAttributes([9876543210, 'bar']) (res, out_f) = vl.dataProvider().addFeatures([f]) self.assertEqual(out_f[0].id(), 9876543210) self.assertEqual(out_f[0].attribute('fid'), 9876543210) self.assertEqual(out_f[0].attribute('strfield'), 'bar') got = [(f.attribute('fid'), f.attribute('strfield')) for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression( "fid = 9876543210"))] self.assertEqual(got, [(9876543210, 'bar')]) self.assertTrue(vl.dataProvider().changeAttributeValues( {9876543210: { 1: 'baz' }})) got = [(f.attribute('fid'), f.attribute('strfield')) for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression( "fid = 9876543210"))] self.assertEqual(got, [(9876543210, 'baz')]) self.assertTrue(vl.dataProvider().changeAttributeValues( {9876543210: { 0: 9876543210, 1: 'baw' }})) got = [(f.attribute('fid'), f.attribute('strfield')) for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression( "fid = 9876543210"))] self.assertEqual(got, [(9876543210, 'baw')]) # Not allowed: changing the fid regular field self.assertTrue(vl.dataProvider().changeAttributeValues( {9876543210: { 0: 12, 1: 'baw' }})) got = [(f.attribute('fid'), f.attribute('strfield')) for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression( "fid = 9876543210"))] self.assertEqual(got, [(9876543210, 'baw')]) # Cannot delete fid self.assertFalse(vl.dataProvider().deleteAttributes([0])) # Delete first "genuine" attribute self.assertTrue(vl.dataProvider().deleteAttributes([1])) got = [(f.attribute('fid'), f.attribute('intfield')) for f in vl.dataProvider().getFeatures( QgsFeatureRequest().setFilterExpression("fid = 12"))] self.assertEqual(got, [(12, 123)])
def export_feature_class(filegdb, featureclass, output_dir, output_epsg, retained_fields, attribute_filter, spatial_filter): log = Logger('Export FC') log.info('Exporting geodatabase feature class {}'.format(featureclass)) # Get the input layer in_driver = ogr.GetDriverByName("OpenFileGDB") in_datasource = in_driver.Open(filegdb, 0) in_layer = in_datasource.GetLayer(featureclass) inSpatialRef = in_layer.GetSpatialRef() if attribute_filter: log.info('Export attribute filter: {}'.format(attribute_filter)) in_layer.SetAttributeFilter(attribute_filter) if spatial_filter: log.info('Export spatial filter area: {}'.format(spatial_filter.area)) in_layer.SetSpatialFilter( ogr.CreateGeometryFromJson(json.dumps(mapping(spatial_filter)))) safe_makedirs(output_dir) # Create the output layer out_shapefile = os.path.join(output_dir, featureclass + '.shp') out_driver = ogr.GetDriverByName("ESRI Shapefile") outSpatialRef, transform = get_transform_from_epsg(inSpatialRef, output_epsg) # Remove output shapefile if it already exists if os.path.exists(out_shapefile): out_driver.DeleteDataSource(out_shapefile) # Create the output shapefile out_datasource = out_driver.CreateDataSource(out_shapefile) out_layer = out_datasource.CreateLayer(featureclass, outSpatialRef, geom_type=in_layer.GetGeomType()) # Add input Layer Fields to the output Layer if it is the one we want in_layer_def = in_layer.GetLayerDefn() for i in range(0, in_layer_def.GetFieldCount()): field_def = in_layer_def.GetFieldDefn(i) field_name = field_def.GetName() if retained_fields and field_name not in retained_fields: continue fieldTypeCode = field_def.GetType() if field_name.lower() == 'nhdplusid' and fieldTypeCode == ogr.OFTReal: field_def.SetWidth(32) field_def.SetPrecision(0) out_layer.CreateField(field_def) # Get the output Layer's Feature Definition out_layer_def = out_layer.GetLayerDefn() # Add features to the ouput Layer progbar = ProgressBar(in_layer.GetFeatureCount(), 50, "Adding features to output layer") counter = 0 for in_feature in in_layer: counter += 1 progbar.update(counter) # Create output Feature out_feature = ogr.Feature(out_layer_def) geom = in_feature.GetGeometryRef() geom.Transform(transform) # Add field values from input Layer for i in range(0, out_layer_def.GetFieldCount()): field_def = out_layer_def.GetFieldDefn(i) field_name = field_def.GetName() if retained_fields and field_name not in retained_fields: continue out_feature.SetField( out_layer_def.GetFieldDefn(i).GetNameRef(), in_feature.GetField(i)) # Set geometry as centroid out_feature.SetGeometry(geom) # Add new feature to output Layer out_layer.CreateFeature(out_feature) out_feature = None progbar.finish() # Save and close DataSources in_datasource = None out_datasource = None return out_shapefile
def test_check_geometries(self): """DelineateIt: Check that we can reasonably repair geometries.""" from natcap.invest.delineateit import delineateit srs = osr.SpatialReference() srs.ImportFromEPSG(32731) # WGS84/UTM zone 31s projection_wkt = srs.ExportToWkt() dem_matrix = numpy.array( [[0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0]], dtype=numpy.int8) dem_raster_path = os.path.join(self.workspace_dir, 'dem.tif') # byte datatype pygeoprocessing.numpy_array_to_raster(dem_matrix, 255, (2, -2), (2, -2), projection_wkt, dem_raster_path) # empty geometry invalid_geometry = ogr.CreateGeometryFromWkt('POLYGON EMPTY') self.assertTrue(invalid_geometry.IsEmpty()) # point outside of the DEM bbox invalid_point = ogr.CreateGeometryFromWkt('POINT (-100 -100)') # line intersects the DEM but is not contained by it valid_line = ogr.CreateGeometryFromWkt( 'LINESTRING (-100 100, 100 -100)') # invalid polygon coult fixed by buffering by 0 invalid_bowtie_polygon = ogr.CreateGeometryFromWkt( 'POLYGON ((2 -2, 6 -2, 2 -6, 6 -6, 2 -2))') self.assertFalse(invalid_bowtie_polygon.IsValid()) # Bowtie polygon with vertex in the middle, could be fixed # by buffering by 0 invalid_alt_bowtie_polygon = ogr.CreateGeometryFromWkt( 'POLYGON ((2 -2, 6 -2, 4 -4, 6 -6, 2 -6, 4 -4, 2 -2))') self.assertFalse(invalid_alt_bowtie_polygon.IsValid()) # invalid polygon could be fixed by closing rings invalid_open_ring_polygon = ogr.CreateGeometryFromWkt( 'POLYGON ((2 -2, 6 -2, 6 -6, 2 -6))') self.assertFalse(invalid_open_ring_polygon.IsValid()) gpkg_driver = gdal.GetDriverByName('GPKG') outflow_vector_path = os.path.join(self.workspace_dir, 'vector.gpkg') outflow_vector = gpkg_driver.Create(outflow_vector_path, 0, 0, 0, gdal.GDT_Unknown) outflow_layer = outflow_vector.CreateLayer('outflow_layer', srs, ogr.wkbUnknown) outflow_layer.CreateField(ogr.FieldDefn('geom_id', ogr.OFTInteger)) outflow_layer.StartTransaction() for index, geometry in enumerate( (invalid_geometry, invalid_point, valid_line, invalid_bowtie_polygon, invalid_alt_bowtie_polygon, invalid_open_ring_polygon)): if geometry is None: self.fail('Geometry could not be created') outflow_feature = ogr.Feature(outflow_layer.GetLayerDefn()) outflow_feature.SetField('geom_id', index) outflow_feature.SetGeometry(geometry) outflow_layer.CreateFeature(outflow_feature) outflow_layer.CommitTransaction() self.assertEqual(outflow_layer.GetFeatureCount(), 6) outflow_layer = None outflow_vector = None target_vector_path = os.path.join(self.workspace_dir, 'checked_geometries.gpkg') with self.assertRaises(ValueError) as cm: delineateit.check_geometries(outflow_vector_path, dem_raster_path, target_vector_path, skip_invalid_geometry=False) self.assertTrue('is invalid' in str(cm.exception)) delineateit.check_geometries(outflow_vector_path, dem_raster_path, target_vector_path, skip_invalid_geometry=True) # I only expect to see 1 feature in the output layer, as there's only 1 # valid geometry. expected_geom_areas = { 2: 0, } target_vector = gdal.OpenEx(target_vector_path, gdal.OF_VECTOR) target_layer = target_vector.GetLayer() self.assertEqual(target_layer.GetFeatureCount(), len(expected_geom_areas)) for feature in target_layer: geom = feature.GetGeometryRef() self.assertAlmostEqual( geom.Area(), expected_geom_areas[feature.GetField('geom_id')]) target_layer = None target_vector = None
def processAlgorithm(self, parameters, context, feedback): raster_layer = self.parameterAsRasterLayer(parameters, self.INPUT_DEM, context) target_crs = raster_layer.crs() rasterPath = raster_layer.source() source = self.parameterAsSource(parameters, self.BOUNDARY_LAYER, context) if source is None: raise QgsProcessingException(self.invalidSourceError(parameters, self.BOUNDARY_LAYER)) step = self.parameterAsDouble(parameters, self.STEP, context) percentage = self.parameterAsBool(parameters, self.USE_PERCENTAGE, context) outputPath = self.parameterAsString(parameters, self.OUTPUT_DIRECTORY, context) rasterDS = gdal.Open(rasterPath, gdal.GA_ReadOnly) geoTransform = rasterDS.GetGeoTransform() rasterBand = rasterDS.GetRasterBand(1) noData = rasterBand.GetNoDataValue() cellXSize = abs(geoTransform[1]) cellYSize = abs(geoTransform[5]) rasterXSize = rasterDS.RasterXSize rasterYSize = rasterDS.RasterYSize rasterBBox = QgsRectangle(geoTransform[0], geoTransform[3] - cellYSize * rasterYSize, geoTransform[0] + cellXSize * rasterXSize, geoTransform[3]) rasterGeom = QgsGeometry.fromRect(rasterBBox) crs = osr.SpatialReference() crs.ImportFromProj4(str(target_crs.toProj4())) memVectorDriver = ogr.GetDriverByName('Memory') memRasterDriver = gdal.GetDriverByName('MEM') features = source.getFeatures(QgsFeatureRequest().setDestinationCrs(target_crs, context.transformContext())) total = 100.0 / source.featureCount() if source.featureCount() else 0 for current, f in enumerate(features): if not f.hasGeometry(): continue if feedback.isCanceled(): break geom = f.geometry() intersectedGeom = rasterGeom.intersection(geom) if intersectedGeom.isEmpty(): feedback.pushInfo( self.tr('Feature {0} does not intersect raster or ' 'entirely located in NODATA area').format(f.id())) continue fName = os.path.join( outputPath, 'hystogram_%s_%s.csv' % (source.sourceName(), f.id())) ogrGeom = ogr.CreateGeometryFromWkt(intersectedGeom.asWkt()) bbox = intersectedGeom.boundingBox() xMin = bbox.xMinimum() xMax = bbox.xMaximum() yMin = bbox.yMinimum() yMax = bbox.yMaximum() (startColumn, startRow) = raster.mapToPixel(xMin, yMax, geoTransform) (endColumn, endRow) = raster.mapToPixel(xMax, yMin, geoTransform) width = endColumn - startColumn height = endRow - startRow srcOffset = (startColumn, startRow, width, height) srcArray = rasterBand.ReadAsArray(*srcOffset) if srcOffset[2] == 0 or srcOffset[3] == 0: feedback.pushInfo( self.tr('Feature {0} is smaller than raster ' 'cell size').format(f.id())) continue newGeoTransform = ( geoTransform[0] + srcOffset[0] * geoTransform[1], geoTransform[1], 0.0, geoTransform[3] + srcOffset[1] * geoTransform[5], 0.0, geoTransform[5] ) memVDS = memVectorDriver.CreateDataSource('out') memLayer = memVDS.CreateLayer('poly', crs, ogr.wkbPolygon) ft = ogr.Feature(memLayer.GetLayerDefn()) ft.SetGeometry(ogrGeom) memLayer.CreateFeature(ft) ft.Destroy() rasterizedDS = memRasterDriver.Create('', srcOffset[2], srcOffset[3], 1, gdal.GDT_Byte) rasterizedDS.SetGeoTransform(newGeoTransform) gdal.RasterizeLayer(rasterizedDS, [1], memLayer, burn_values=[1]) rasterizedArray = rasterizedDS.ReadAsArray() srcArray = numpy.nan_to_num(srcArray) masked = numpy.ma.MaskedArray(srcArray, mask=numpy.logical_or(srcArray == noData, numpy.logical_not(rasterizedArray))) self.calculateHypsometry(f.id(), fName, feedback, masked, cellXSize, cellYSize, percentage, step) memVDS = None rasterizedDS = None feedback.setProgress(int(current * total)) rasterDS = None return {self.OUTPUT_DIRECTORY: outputPath}
def excel_to_shp(data_path, excel_name, vec_file, lng_col_num, lat_col_num): # 支持文件中文路径 gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO") # 支持文件中文字段 gdal.SetConfigOption("SHAPE_ENCODING", "GB2312") # 注册所有的驱动 ogr.RegisterAll() # 获取ESRI ShapeFile文件驱动 driver = ogr.GetDriverByName("ESRI ShapeFile") # 切换到数据路径下 os.chdir(data_path) # 判断该路径下是否存在该文件名的shp文件 if os.path.exists(vec_file): # 存在,删除该shp文件 driver.DeleteDataSource(vec_file) # 创建shp文件 out_ds = driver.CreateDataSource(vec_file) # 判断文件是否创建成功 if out_ds is None: # 提示创建文件失败 print("创建文件失败!") # 跳出当前函数 return # 创建空间参考对象 spatial_ref = osr.SpatialReference() # 导入投影信息 spatial_ref.ImportFromEPSG(4326) # 获取shp文件名称,并将其赋值给图层 layer_name = os.path.splitext(vec_file)[0] # 创建输出的图层 out_layer = out_ds.CreateLayer(layer_name, spatial_ref, ogr.wkbPoint) # 获取excel的表头及数据 cols, data = read_excel(excel_name, "Sheet1") # 获取表头的个数 cols_count = len(cols) # 遍历多有的表头并创建属性字段 for i_col in range(cols_count): # 定义字段的名称 field_name = cols[i_col] # 字段定义 field_def = ogr.FieldDefn(field_name, ogr.OFTString) # 定义字段的长度 field_def.SetWidth(100) # 将字段定义添加到图层中 out_layer.CreateField(field_def) # 获取输出图层定义 out_layer_def = out_layer.GetLayerDefn() # 获取数据的行数 rows_count = len(data) # 遍历所有的数据并写入的字段中 for i_row in range(rows_count): # 获取经度 lng = float(data[i_row][lng_col_num - 1]) # 获取纬度 lat = float(data[i_row][lat_col_num - 1]) # 创建点要素对象 feature_point = ogr.Feature(out_layer_def) for i_col in range(cols_count): # 获取字段名 field_name = cols[i_col] # 获取每个字段对应的值 field_value = data[i_row][i_col] # 给字段赋值 feature_point.SetField(field_name, field_value) # 定义要素为点对象 geom_point = ogr.Geometry(ogr.wkbPoint) # 添加点的坐标值 geom_point.AddPoint(lng, lat) # 设置点的几何信息 feature_point.SetGeometry(geom_point) # 创建要素点 out_layer.CreateFeature(feature_point) # 销毁数据源 out_ds.Destroy() # 提示数据转换成功 print("Excel 转点成功!")
def feature_to_pipes_shp(self, layer, id_nr, pipe): """ Add features to a shapefile. Args: (shapefile layer) layer: A shapefile layer. (dict) queryset: A Django queryset that will be used for getting the values of the fields. Returns: (shapefile layer) layer: A shapefile layer. """ # Get values id_nr = id_nr start_x = pipe.get("Beginpunt x", ' ') start_y = pipe.get("Beginpunt y", ' ') end_x = pipe.get("Eindpunt x", ' ') end_y = pipe.get("Eindpunt y", ' ') AAA = pipe.get("AAA", ' ') AAB = pipe.get("AAB", ' ') AAD = pipe.get("AAD", ' ') AAE = ", ".join(pipe["AAE"]) AAF = pipe.get("AAF", ' ') AAG = ", ".join(pipe["AAG"]) AAJ = pipe.get("AAJ", ' ') AAK = pipe.get("AAK", ' ') AAL = pipe.get("AAL", ' ') AAM = pipe.get("AAM", ' ') AAN = pipe.get("AAN", ' ') AAO = pipe.get("AAO", ' ') AAP = pipe.get("AAP", ' ') AAQ = pipe.get("AAQ", ' ') ABA = pipe.get("ABA", ' ') ABB = pipe.get("ABB", ' ') ABC = pipe.get("ABC", ' ') ABE = pipe.get("ABE", ' ') ABF = pipe.get("ABF", ' ') ABH = pipe.get("ABH", ' ') ABI = pipe.get("ABI", ' ') ABJ = pipe.get("ABJ", ' ') ABK = pipe.get("ABK", ' ') ABL = pipe.get("ABL", ' ') ABM = pipe.get("ABM", ' ') ABP = pipe.get("ABP", ' ') ABQ = pipe.get("ABQ", ' ') ABS = pipe.get("ABS", ' ') ACA = pipe.get("ACA", ' ') ACB = pipe.get("ACB", ' ') ACC = pipe.get("ACC", ' ') ACD = pipe.get("ACD", ' ') ACG = pipe.get("ACG", ' ') ACJ = pipe.get("ACJ", ' ') ACK = pipe.get("ACK", ' ') ACM = pipe.get("ACM", ' ') ACN = pipe.get("ACN", ' ') ADA = pipe.get("ADA", ' ') ADB = pipe.get("ADB", ' ') ADC = pipe.get("ADC", ' ') AXA = pipe.get("AXA", ' ') AXB = pipe.get("AXB", ' ') AXF = pipe.get("AXF", ' ') AXG = pipe.get("AXG", ' ') AXH = pipe.get("AXH", ' ') herstelmaatregel = pipe["Herstelmaatregel"] # herstelmaatregel = HERSTELMAATREGEL_DEFAULT opmerking = pipe["Opmerking"] artrigger = pipe.get("Trigger", '') ZC = pipe["ZC"] # Set values feature = ogr.Feature(layer.GetLayerDefn()) wkt = "LINESTRING({} {}, {} {})".format(start_x, start_y, end_x, end_y) line = ogr.CreateGeometryFromWkt(wkt) feature.SetGeometry(line) feature.SetField("ID", str(id_nr)) feature.SetField("AAA", str(AAA)) feature.SetField("AAB", str(AAB)) feature.SetField("AAD", str(AAD)) feature.SetField("AAE", str(AAE)) feature.SetField("AAF", str(AAF)) feature.SetField("AAG", str(AAG)) feature.SetField("AAJ", str(AAJ)) feature.SetField("AAK", str(AAK)) feature.SetField("AAL", str(AAL)) feature.SetField("AAM", str(AAM)) feature.SetField("AAN", str(AAN)) feature.SetField("AAO", str(AAO)) feature.SetField("AAP", str(AAP)) feature.SetField("AAQ", str(AAQ)) feature.SetField("ABA", str(ABA)) feature.SetField("ABB", str(ABB)) feature.SetField("ABC", str(ABC)) feature.SetField("ABE", str(ABE)) feature.SetField("ABF", str(ABF)) feature.SetField("ABH", str(ABH)) feature.SetField("ABI", str(ABI)) feature.SetField("ABJ", str(ABJ)) feature.SetField("ABK", str(ABK)) feature.SetField("ABL", str(ABL)) feature.SetField("ABM", str(ABM)) feature.SetField("ABP", str(ABP)) feature.SetField("ABQ", str(ABQ)) feature.SetField("ABS", str(ABS)) feature.SetField("ACA", str(ACA)) feature.SetField("ACB", str(ACB)) feature.SetField("ACC", str(ACC)) feature.SetField("ACD", str(ACD)) feature.SetField("ACG", str(ACG)) feature.SetField("ACJ", str(ACJ)) feature.SetField("ACK", str(ACK)) feature.SetField("ACM", str(ACM)) feature.SetField("ACN", str(ACN)) feature.SetField("ADA", str(ADA)) feature.SetField("ADB", str(ADB)) feature.SetField("ADC", str(ADC)) feature.SetField("AXA", str(AXA)) feature.SetField("AXB", str(AXB)) feature.SetField("AXF", str(AXF)) feature.SetField("AXG", str(AXG)) feature.SetField("AXH", str(AXH)) feature.SetField("Herstelmaa", str(herstelmaatregel)) feature.SetField("Opmerking", str(opmerking)) feature.SetField('Trigger', str(artrigger)) feature.SetField("ZC", str(ZC)) layer.CreateFeature(feature) feature = None return layer
def difference(f1,f2): outputFileName = 'difference_' + f1 driver = ogr.GetDriverByName("ESRI Shapefile") f1 = driver.Open(f1,0) layer1 = f1.GetLayer() feature1 = layer1.GetNextFeature() if f1 is None: print "Could not open file ", f1 sys.exit(1) f2 = driver.Open(f2,0) layer2 = f2.GetLayer() # feature2 = layer2.GetNextFeature() if f2 is None: print "Could not open file ", f2 ### Create output file ### if os.path.exists(outputFileName): os.remove(outputFileName) try: output = driver.CreateDataSource(outputFileName) except: print 'Could not create output datasource ', outputFileName sys.exit(1) newLayer = output.CreateLayer('SymmetricDifference',geom_type=ogr.wkbPolygon,srs=layer1.GetSpatialRef()) if newLayer is None: print "Could not create output layer" sys.exit(1) newLayerDef = newLayer.GetLayerDefn() ############################## featureID = 0 while feature1: layer2.ResetReading() geom1 = feature1.GetGeometryRef() feature2 = layer2.GetNextFeature() while feature2: geom2 = feature2.GetGeometryRef() if geom1.Overlaps(geom2) == 1: newgeom = geom1.Difference(geom2) newFeature = ogr.Feature(newLayerDef) newFeature.SetGeometry(newgeom) newFeature.SetFID(featureID) newLayer.CreateFeature(newFeature) featureID += 1 newFeature.Destroy() else: newFeature1 = ogr.Feature(newLayerDef) newFeature1.SetGeometry(geom1) newFeature1.SetFID(featureID) newLayer.CreateFeature(newFeature1) featureID += 1 newFeature2 = ogr.Feature(newLayerDef) newFeature2.SetGeometry(geom2) newFeature2.SetFID(featureID) newLayer.CreateFeature(newfeature2) featureID += 1 newFeature1.Destroy() newFeature2.Destroy() feature2.Destroy() feature2 = layer2.GetNextFeature() feature1.Destroy() feature1 = layer1.GetNextFeature() f1.Destroy() f2.Destroy()
ring.AddPoint_2D(s_maxx, s_maxy) ring.AddPoint_2D(s_minx, s_maxy) ring.AddPoint_2D(s_minx, s_miny) filt_geom = ogr.Geometry(ogr.wkbPolygon) filt_geom.AddGeometry(ring) ############################################################################# # Process all features in input layer. in_feat = in_layer.GetNextFeature() while in_feat is not None: geom = in_feat.GetGeometryRef() if geom.Intersect(filt_geom) != 0: out_feat = ogr.Feature(feature_def=shp_layer.GetLayerDefn()) out_feat.SetFrom(in_feat) shp_layer.CreateFeature(out_feat) out_feat.Destroy() in_feat.Destroy() in_feat = in_layer.GetNextFeature() ############################################################################# # Cleanup shp_ds.Destroy() in_ds.Destroy()
def exportATL08(input_icesat_h5file, out_vec_file, out_vec_lyr, vec_frmt='GPKG'): """ A function to import a ATL08 ICESAT2 hdf5. * input_icesat_file * out_vec_file * out_vec_lyr * vec_frmt """ if os.path.exists(out_vec_file): vecDS = gdal.OpenEx(out_vec_file, gdal.GA_Update) else: outdriver = ogr.GetDriverByName(vec_frmt) vecDS = outdriver.CreateDataSource(out_vec_file) if vecDS is None: raise Exception("Could not open or create '{}'".format(out_vec_file)) srs = osr.SpatialReference() srs.ImportFromEPSG(4326) laser_beams = ['gt1l', 'gt1r', 'gt2l', 'gt2r', 'gt3l', 'gt3r'] flds_dict = dict() # General flds_dict['segment_id'] = ogr.OFTInteger flds_dict['segment_id_beg'] = ogr.OFTInteger flds_dict['segment_id_end'] = ogr.OFTInteger flds_dict['latitude'] = ogr.OFTReal flds_dict['longitude'] = ogr.OFTReal flds_dict['solar_azimuth'] = ogr.OFTReal flds_dict['solar_elevation'] = ogr.OFTReal flds_dict['delta_time'] = ogr.OFTReal flds_dict['delta_time_beg'] = ogr.OFTReal flds_dict['delta_time_end'] = ogr.OFTReal flds_dict['night_flag'] = ogr.OFTInteger flds_dict['dem_h'] = ogr.OFTReal flds_dict['dem_flag'] = ogr.OFTInteger flds_dict['dem_removal_flag'] = ogr.OFTInteger flds_dict['h_dif_ref'] = ogr.OFTReal flds_dict['terrain_flg'] = ogr.OFTInteger flds_dict['segment_landcover'] = ogr.OFTInteger flds_dict['segment_watermask'] = ogr.OFTInteger flds_dict['segment_snowcover'] = ogr.OFTInteger flds_dict['urban_flag'] = ogr.OFTInteger flds_dict['cloud_flag_asr'] = ogr.OFTInteger flds_dict['surf_type'] = ogr.OFTInteger flds_dict['snr'] = ogr.OFTReal # Terrain flds_dict['h_te_mean'] = ogr.OFTReal flds_dict['h_te_median'] = ogr.OFTReal flds_dict['h_te_min'] = ogr.OFTReal flds_dict['h_te_max'] = ogr.OFTReal flds_dict['h_te_mode'] = ogr.OFTReal flds_dict['h_te_skew'] = ogr.OFTReal flds_dict['n_te_photons'] = ogr.OFTInteger flds_dict['h_te_interp'] = ogr.OFTReal flds_dict['h_te_std'] = ogr.OFTReal flds_dict['h_te_uncertainty'] = ogr.OFTReal flds_dict['terrain_slope'] = ogr.OFTReal flds_dict['h_te_best_fit'] = ogr.OFTReal # Canopy flds_dict['canopy_h_metrics_abs_p25'] = ogr.OFTReal flds_dict['canopy_h_metrics_abs_p50'] = ogr.OFTReal flds_dict['canopy_h_metrics_abs_p60'] = ogr.OFTReal flds_dict['canopy_h_metrics_abs_p70'] = ogr.OFTReal flds_dict['canopy_h_metrics_abs_p75'] = ogr.OFTReal flds_dict['canopy_h_metrics_abs_p80'] = ogr.OFTReal flds_dict['canopy_h_metrics_abs_p85'] = ogr.OFTReal flds_dict['canopy_h_metrics_abs_p90'] = ogr.OFTReal flds_dict['canopy_h_metrics_abs_p95'] = ogr.OFTReal flds_dict['canopy_h_metrics_p25'] = ogr.OFTReal flds_dict['canopy_h_metrics_p50'] = ogr.OFTReal flds_dict['canopy_h_metrics_p60'] = ogr.OFTReal flds_dict['canopy_h_metrics_p70'] = ogr.OFTReal flds_dict['canopy_h_metrics_p75'] = ogr.OFTReal flds_dict['canopy_h_metrics_p80'] = ogr.OFTReal flds_dict['canopy_h_metrics_p85'] = ogr.OFTReal flds_dict['canopy_h_metrics_p90'] = ogr.OFTReal flds_dict['canopy_h_metrics_p95'] = ogr.OFTReal flds_dict['h_canopy_abs'] = ogr.OFTReal flds_dict['h_canopy'] = ogr.OFTReal flds_dict['h_mean_canopy_abs'] = ogr.OFTReal flds_dict['h_mean_canopy'] = ogr.OFTReal flds_dict['h_dif_canopy'] = ogr.OFTReal flds_dict['h_min_canopy_abs'] = ogr.OFTReal flds_dict['h_min_canopy'] = ogr.OFTReal flds_dict['h_max_canopy_abs'] = ogr.OFTReal flds_dict['h_max_canopy'] = ogr.OFTReal flds_dict['h_canopy_uncertainty'] = ogr.OFTReal flds_dict['canopy_openness'] = ogr.OFTReal flds_dict['toc_roughness'] = ogr.OFTReal flds_dict['h_canopy_quad'] = ogr.OFTReal flds_dict['n_ca_photons'] = ogr.OFTInteger flds_dict['n_toc_photons'] = ogr.OFTInteger flds_dict['centroid_height'] = ogr.OFTReal flds_dict['canopy_rh_conf'] = ogr.OFTInteger flds_dict['canopy_flag'] = ogr.OFTInteger flds_dict['landsat_flag'] = ogr.OFTInteger flds_dict['landsat_perc'] = ogr.OFTReal print("Processing Input File: {}".format(input_icesat_h5file)) fH5 = h5py.File(input_icesat_h5file) for beam_name in laser_beams: print("\tProcessing Beam: {}".format(beam_name)) lyr_name = '{}_{}'.format(out_vec_lyr, beam_name) out_lyr_obj = vecDS.CreateLayer(lyr_name, srs, geom_type=ogr.wkbPoint, options=['OVERWRITE=YES']) if out_lyr_obj is None: raise Exception("Could not create layer: '{}'".format(lyr_name)) feat_defn = out_lyr_obj.GetLayerDefn() col_exists = False for fld_name in flds_dict: #print(fld_name) for i in range( feat_defn.GetFieldCount() ): if feat_defn.GetFieldDefn(i).GetName().lower() == fld_name.lower(): col_exists = True break if not col_exists: field_defn = ogr.FieldDefn( fld_name, flds_dict[fld_name] ) if out_lyr_obj.CreateField ( field_defn ) != 0: raise Exception("Creating '{}' field failed; becareful with case.".format(fld_name)) lsr_beam_pth = '{}/land_segments'.format(beam_name) cnpy_info_pth = '{}/land_segments/canopy'.format(beam_name) trn_info_pth = '{}/land_segments/terrain'.format(beam_name) land_segs_dir = fH5[lsr_beam_pth] cnpy_info_dir = fH5[cnpy_info_pth] trn_info_dir = fH5[trn_info_pth] # General segment_id = land_segs_dir['segment_id'] segment_id_beg = land_segs_dir['segment_id_beg'] segment_id_end = land_segs_dir['segment_id_end'] latitude = land_segs_dir['latitude'] longitude = land_segs_dir['longitude'] solar_azimuth = land_segs_dir['solar_azimuth'] solar_elevation = land_segs_dir['solar_elevation'] delta_time = land_segs_dir['delta_time'] delta_time_beg = land_segs_dir['delta_time_beg'] delta_time_end = land_segs_dir['delta_time_end'] night_flag = land_segs_dir['night_flag'] dem_h = land_segs_dir['dem_h'] dem_flag = land_segs_dir['dem_flag'] dem_removal_flag = land_segs_dir['dem_removal_flag'] h_dif_ref = land_segs_dir['h_dif_ref'] terrain_flg = land_segs_dir['terrain_flg'] segment_landcover = land_segs_dir['segment_landcover'] segment_watermask = land_segs_dir['segment_watermask'] segment_snowcover = land_segs_dir['segment_snowcover'] urban_flag = land_segs_dir['urban_flag'] last_seg_extend = land_segs_dir['last_seg_extend'] cloud_flag_asr = land_segs_dir['cloud_flag_asr'] snr = land_segs_dir['snr'] # Terrain h_te_mean = trn_info_dir['h_te_mean'] h_te_median = trn_info_dir['h_te_median'] h_te_min = trn_info_dir['h_te_min'] h_te_max = trn_info_dir['h_te_max'] h_te_mode = trn_info_dir['h_te_mode'] h_te_skew = trn_info_dir['h_te_skew'] n_te_photons = trn_info_dir['n_te_photons'] h_te_interp = trn_info_dir['h_te_interp'] h_te_std = trn_info_dir['h_te_std'] h_te_uncertainty = trn_info_dir['h_te_uncertainty'] terrain_slope = trn_info_dir['terrain_slope'] h_te_best_fit = trn_info_dir['h_te_best_fit'] # Canopy canopy_h_metrics_abs = cnpy_info_dir['canopy_h_metrics_abs'] canopy_h_metrics = cnpy_info_dir['canopy_h_metrics'] h_canopy_abs = cnpy_info_dir['h_canopy_abs'] h_canopy = cnpy_info_dir['h_canopy'] h_mean_canopy_abs = cnpy_info_dir['h_mean_canopy_abs'] h_mean_canopy = cnpy_info_dir['h_mean_canopy'] h_dif_canopy = cnpy_info_dir['h_dif_canopy'] h_min_canopy_abs = cnpy_info_dir['h_min_canopy_abs'] h_min_canopy = cnpy_info_dir['h_min_canopy'] h_max_canopy_abs = cnpy_info_dir['h_max_canopy_abs'] h_max_canopy = cnpy_info_dir['h_max_canopy'] h_canopy_uncertainty = cnpy_info_dir['h_canopy_uncertainty'] canopy_openness = cnpy_info_dir['canopy_openness'] toc_roughness = cnpy_info_dir['toc_roughness'] h_canopy_quad = cnpy_info_dir['h_canopy_quad'] n_ca_photons = cnpy_info_dir['n_ca_photons'] n_toc_photons = cnpy_info_dir['n_toc_photons'] centroid_height = cnpy_info_dir['centroid_height'] canopy_rh_conf = cnpy_info_dir['canopy_rh_conf'] canopy_flag = cnpy_info_dir['canopy_flag'] landsat_flag = cnpy_info_dir['landsat_flag'] landsat_perc = cnpy_info_dir['landsat_perc'] open_transaction = False n_feats = latitude.shape[0] for i in range(n_feats): if not open_transaction: out_lyr_obj.StartTransaction() open_transaction = True out_feat = ogr.Feature(feat_defn) pt = ogr.Geometry(ogr.wkbPoint) pt.AddPoint(float(longitude[i]), float(latitude[i])) out_feat.SetGeometry(pt) # General out_feat.SetField('segment_id', int(segment_id[i])) out_feat.SetField('segment_id_beg', int(segment_id_beg[i])) out_feat.SetField('segment_id_end', int(segment_id_end[i])) out_feat.SetField('latitude', float(latitude[i])) out_feat.SetField('longitude', float(longitude[i])) out_feat.SetField('solar_azimuth', float(solar_azimuth[i])) out_feat.SetField('solar_elevation', float(solar_elevation[i])) out_feat.SetField('delta_time', float(delta_time[i])) out_feat.SetField('delta_time_beg', float(delta_time_beg[i])) out_feat.SetField('delta_time_end', float(delta_time_end[i])) out_feat.SetField('night_flag', int(night_flag[i])) out_feat.SetField('dem_h', float(dem_h[i])) out_feat.SetField('dem_flag', int(dem_flag[i])) out_feat.SetField('dem_removal_flag', int(dem_removal_flag[i])) out_feat.SetField('h_dif_ref', float(h_dif_ref[i])) out_feat.SetField('terrain_flg', int(terrain_flg[i])) out_feat.SetField('segment_landcover', int(segment_landcover[i])) out_feat.SetField('segment_watermask', int(segment_watermask[i])) out_feat.SetField('segment_snowcover', int(segment_snowcover[i])) out_feat.SetField('urban_flag', int(urban_flag[i])) out_feat.SetField('cloud_flag_asr', int(cloud_flag_asr[i])) out_feat.SetField('snr', float(snr[i])) # Terrain out_feat.SetField('h_te_mean', float(h_te_mean[i])) out_feat.SetField('h_te_median', float(h_te_median[i])) out_feat.SetField('h_te_min', float(h_te_min[i])) out_feat.SetField('h_te_max', float(h_te_max[i])) out_feat.SetField('h_te_mode', float(h_te_mode[i])) out_feat.SetField('h_te_skew', float(h_te_skew[i])) out_feat.SetField('n_te_photons', int(n_te_photons[i])) out_feat.SetField('h_te_interp', float(h_te_interp[i])) out_feat.SetField('h_te_std', float(h_te_std[i])) out_feat.SetField('h_te_uncertainty', float(h_te_uncertainty[i])) out_feat.SetField('terrain_slope', float(terrain_slope[i])) out_feat.SetField('h_te_best_fit', float(h_te_best_fit[i])) # Canopy out_feat.SetField('canopy_h_metrics_abs_p25', float(canopy_h_metrics_abs[i][0])) out_feat.SetField('canopy_h_metrics_abs_p50', float(canopy_h_metrics_abs[i][1])) out_feat.SetField('canopy_h_metrics_abs_p60', float(canopy_h_metrics_abs[i][2])) out_feat.SetField('canopy_h_metrics_abs_p70', float(canopy_h_metrics_abs[i][3])) out_feat.SetField('canopy_h_metrics_abs_p75', float(canopy_h_metrics_abs[i][4])) out_feat.SetField('canopy_h_metrics_abs_p80', float(canopy_h_metrics_abs[i][5])) out_feat.SetField('canopy_h_metrics_abs_p85', float(canopy_h_metrics_abs[i][6])) out_feat.SetField('canopy_h_metrics_abs_p90', float(canopy_h_metrics_abs[i][7])) out_feat.SetField('canopy_h_metrics_abs_p95', float(canopy_h_metrics_abs[i][8])) out_feat.SetField('canopy_h_metrics_p25', float(canopy_h_metrics[i][0])) out_feat.SetField('canopy_h_metrics_p50', float(canopy_h_metrics[i][1])) out_feat.SetField('canopy_h_metrics_p60', float(canopy_h_metrics[i][2])) out_feat.SetField('canopy_h_metrics_p70', float(canopy_h_metrics[i][3])) out_feat.SetField('canopy_h_metrics_p75', float(canopy_h_metrics[i][4])) out_feat.SetField('canopy_h_metrics_p80', float(canopy_h_metrics[i][5])) out_feat.SetField('canopy_h_metrics_p85', float(canopy_h_metrics[i][6])) out_feat.SetField('canopy_h_metrics_p90', float(canopy_h_metrics[i][7])) out_feat.SetField('canopy_h_metrics_p95', float(canopy_h_metrics[i][8])) out_feat.SetField('h_canopy_abs', float(h_canopy_abs[i])) out_feat.SetField('h_canopy', float(h_canopy[i])) out_feat.SetField('h_mean_canopy_abs', float(h_mean_canopy_abs[i])) out_feat.SetField('h_mean_canopy', float(h_mean_canopy[i])) out_feat.SetField('h_dif_canopy', float(h_dif_canopy[i])) out_feat.SetField('h_min_canopy_abs', float(h_min_canopy_abs[i])) out_feat.SetField('h_min_canopy', float(h_min_canopy[i])) out_feat.SetField('h_max_canopy_abs', float(h_max_canopy_abs[i])) out_feat.SetField('h_max_canopy', float(h_max_canopy[i])) out_feat.SetField('h_canopy_uncertainty', float(h_canopy_uncertainty[i])) out_feat.SetField('canopy_openness', float(canopy_openness[i])) out_feat.SetField('toc_roughness', float(toc_roughness[i])) out_feat.SetField('h_canopy_quad', float(h_canopy_quad[i])) out_feat.SetField('n_ca_photons', int(n_ca_photons[i])) out_feat.SetField('n_toc_photons', int(n_toc_photons[i])) out_feat.SetField('centroid_height', float(centroid_height[i])) out_feat.SetField('canopy_rh_conf', int(canopy_rh_conf[i])) out_feat.SetField('canopy_flag', int(canopy_flag[i])) out_feat.SetField('landsat_flag', int(landsat_flag[i])) out_feat.SetField('landsat_perc', float(landsat_perc[i])) out_lyr_obj.CreateFeature(out_feat) out_feat = None if ((i % 20000) == 0) and open_transaction: out_lyr_obj.CommitTransaction() open_transaction = False if open_transaction: out_lyr_obj.CommitTransaction() open_transaction = False out_lyr_obj.SyncToDisk() fH5 = None vecDS = None
def ogr_dxf_18(): ds = ogr.GetDriverByName('DXF').CreateDataSource( 'tmp/dxf_18.dxf', ['HEADER=data/header_extended.dxf']) lyr = ds.CreateLayer('entities') # Write a feature with a predefined LTYPE in the header. dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly( ogr.CreateGeometryFromWkt('LINESTRING(0 0,25 25)')) dst_feat.SetField('Linetype', 'DASHED') dst_feat.SetStyleString('PEN(c:#ffff00,w:2g,p:"12.0g 6.0g")') lyr.CreateFeature(dst_feat) dst_feat.Destroy() # Write a feature with a named linetype but that isn't predefined in the header. dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly( ogr.CreateGeometryFromWkt('LINESTRING(5 5,30 30)')) dst_feat.SetField('Linetype', 'DOTTED') dst_feat.SetStyleString('PEN(c:#ffff00,w:2g,p:"0.0g 4.0g")') lyr.CreateFeature(dst_feat) dst_feat.Destroy() # Write a feature without a linetype name - it will be created. dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly( ogr.CreateGeometryFromWkt('LINESTRING(5 5,40 30)')) dst_feat.SetStyleString('PEN(c:#ffff00,w:2g,p:"3.0g 4.0g")') lyr.CreateFeature(dst_feat) dst_feat.Destroy() ds = None # Reopen and check contents. ds = ogr.Open('tmp/dxf_18.dxf') lyr = ds.GetLayer(0) # Check first feature. feat = lyr.GetNextFeature() if feat.GetField('Linetype') != 'DASHED': gdaltest.post_reason('Got wrong linetype. (1)') return 'fail' if feat.GetStyleString( ) != 'PEN(c:#ffff00,w:2g,p:"12.6999999999999993g 6.3499999999999996g")': print(feat.GetStyleString()) gdaltest.post_reason("got wrong style string (1)") return 'fail' if ogrtest.check_feature_geometry(feat, 'LINESTRING (0 0,25 25)'): return 'fail' # Check second feature. feat = lyr.GetNextFeature() if feat.GetField('Linetype') != 'DOTTED': gdaltest.post_reason('Got wrong linetype. (2)') return 'fail' if feat.GetStyleString() != 'PEN(c:#ffff00,w:2g,p:"0.0g 4.0g")': print(feat.GetStyleString()) gdaltest.post_reason("got wrong style string (2)") return 'fail' if ogrtest.check_feature_geometry(feat, 'LINESTRING (5 5,30 30)'): return 'fail' # Check third feature. feat = lyr.GetNextFeature() if feat.GetField('Linetype') != 'AutoLineType-1': gdaltest.post_reason('Got wrong linetype. (3)') return 'fail' if feat.GetStyleString() != 'PEN(c:#ffff00,w:2g,p:"3.0g 4.0g")': print(feat.GetStyleString()) gdaltest.post_reason("got wrong style string (3)") return 'fail' if ogrtest.check_feature_geometry(feat, 'LINESTRING (5 5,40 30)'): return 'fail' # Cleanup lyr = None ds = None os.unlink('tmp/dxf_18.dxf') return 'success'
def ogr_dxf_17(): ds = ogr.GetDriverByName('DXF').CreateDataSource( 'tmp/dxf_17.dxf', ['HEADER=data/header_extended.dxf']) blyr = ds.CreateLayer('blocks') lyr = ds.CreateLayer('entities') dst_feat = ogr.Feature(feature_def=blyr.GetLayerDefn()) dst_feat.SetGeometryDirectly( ogr.CreateGeometryFromWkt( 'GEOMETRYCOLLECTION( LINESTRING(0 0,1 1),LINESTRING(1 0,0 1))')) dst_feat.SetField('BlockName', 'XMark') blyr.CreateFeature(dst_feat) dst_feat.Destroy() # Write a block reference feature. dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(200 100)')) dst_feat.SetField('Layer', 'abc') dst_feat.SetField('BlockName', 'XMark') lyr.CreateFeature(dst_feat) dst_feat.Destroy() # Write a block reference feature for a non-existant block. dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(300 50)')) dst_feat.SetField('Layer', 'abc') dst_feat.SetField('BlockName', 'DoesNotExist') lyr.CreateFeature(dst_feat) dst_feat.Destroy() # Write a block reference feature for a template defined block dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(250 200)')) dst_feat.SetField('Layer', 'abc') dst_feat.SetField('BlockName', 'STAR') lyr.CreateFeature(dst_feat) dst_feat.Destroy() # Write a block reference feature with scaling and rotation dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(300 100)')) dst_feat.SetField('BlockName', 'XMark') dst_feat.SetField('BlockAngle', '30') dst_feat.SetFieldDoubleList(lyr.GetLayerDefn().GetFieldIndex('BlockScale'), [4.0, 5.0, 6.0]) lyr.CreateFeature(dst_feat) dst_feat.Destroy() ds = None # Reopen and check contents. ds = ogr.Open('tmp/dxf_17.dxf') lyr = ds.GetLayer(0) # Check first feature. feat = lyr.GetNextFeature() if feat.GetField('SubClasses') != 'AcDbEntity:AcDbBlockReference': gdaltest.post_reason('Got wrong subclasses for feature 1.') return 'fail' if ogrtest.check_feature_geometry( feat, 'GEOMETRYCOLLECTION (LINESTRING (200 100,201 101),LINESTRING (201 100,200 101))' ): print('Feature 1') return 'fail' # Check second feature. feat = lyr.GetNextFeature() if feat.GetField('SubClasses') != 'AcDbEntity:AcDbPoint': gdaltest.post_reason('Got wrong subclasses for feature 2.') return 'fail' if ogrtest.check_feature_geometry(feat, 'POINT (300 50)'): print('Feature 2') return 'fail' # Check third feature. feat = lyr.GetNextFeature() if feat.GetField('SubClasses') != 'AcDbEntity:AcDbBlockReference': gdaltest.post_reason('Got wrong subclasses for feature 3.') return 'fail' if ogrtest.check_feature_geometry( feat, 'GEOMETRYCOLLECTION (LINESTRING (249.971852502328943 201.04145741382942 0,250.619244948763452 198.930395088499495 0),LINESTRING (250.619244948763452 198.930395088499495 0,249.042985079183779 200.47850746040811 0),LINESTRING (249.042985079183779 200.47850746040811 0,251.04145741382942 200.365917469723854 0),LINESTRING (251.04145741382942 200.365917469723854 0,249.52149253959189 198.95854258617058 0),LINESTRING (249.52149253959189 198.95854258617058 0,249.943705004657858 201.013309916158363 0))' ): print('Feature 3') return 'fail' # Check fourth feature (scaled and rotated) feat = lyr.GetNextFeature() if feat.GetField('SubClasses') != 'AcDbEntity:AcDbBlockReference': gdaltest.post_reason('Got wrong subclasses for feature 4.') return 'fail' if ogrtest.check_feature_geometry( feat, 'GEOMETRYCOLLECTION (LINESTRING (300 100,300.964101615137736 106.330127018922198),LINESTRING (303.464101615137736 102.0,297.5 104.330127018922198))' ): print('Feature 4') return 'fail' # Cleanup lyr = None ds = None os.unlink('tmp/dxf_17.dxf') return 'success'
def ogr_dxf_15(): ds = ogr.GetDriverByName('DXF').CreateDataSource('tmp/dxf_14.dxf', ['FIRST_ENTITY=80']) lyr = ds.CreateLayer('entities') dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly( ogr.CreateGeometryFromWkt('LINESTRING(10 12, 60 65)')) dst_feat.SetField('Layer', 'abc') lyr.CreateFeature(dst_feat) dst_feat.Destroy() dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn()) dst_feat.SetGeometryDirectly( ogr.CreateGeometryFromWkt('POLYGON((0 0,100 0,100 100,0 0))')) lyr.CreateFeature(dst_feat) dst_feat.Destroy() lyr = None ds = None # Read back. ds = ogr.Open('tmp/dxf_14.dxf') lyr = ds.GetLayer(0) # Check first feature feat = lyr.GetNextFeature() if ogrtest.check_feature_geometry(feat, 'LINESTRING(10 12, 60 65)'): print(feat.GetGeometryRef().ExportToWkt()) return 'fail' if feat.GetGeometryRef().GetGeometryType() == ogr.wkbLineString25D: gdaltest.post_reason('not linestring 2D') return 'fail' if feat.GetField('Layer') != 'abc': gdaltest.post_reason('Did not get expected layer, abc.') return 'fail' feat.Destroy() # Check second point. feat = lyr.GetNextFeature() if ogrtest.check_feature_geometry(feat, 'POLYGON((0 0,100 0,100 100,0 0))'): print(feat.GetGeometryRef().ExportToWkt()) return 'fail' if feat.GetGeometryRef().GetGeometryType() == ogr.wkbPolygon25D: gdaltest.post_reason('not keeping polygon 2D') return 'fail' if feat.GetField('Layer') != '0': print(feat.GetField('Layer')) gdaltest.post_reason('Did not get expected layer, 0.') return 'fail' feat.Destroy() lyr = None ds.Destroy() ds = None # Check the DXF file itself to try and ensure that the layer # is defined essentially as we expect. We assume the only thing # that will be different is the layer name is 'abc' instead of '0' # and the entity id. outdxf = open('tmp/dxf_14.dxf').read() start_1 = outdxf.find(' 0\nLAYER') start_2 = outdxf.find(' 0\nLAYER', start_1 + 10) txt_1 = outdxf[start_1:start_2] txt_2 = outdxf[start_2:start_2 + len(txt_1) + 2] abc_off = txt_2.find('abc\n') if txt_2[16:abc_off] + '0' + txt_2[abc_off + 3:] != txt_1[16:]: print(txt_2[abc_off] + '0' + txt_2[abc_off + 3:]) print(txt_1) gdaltest.post_reason('Layer abc does not seem to match layer 0.') return 'fail' # Check that $HANDSEED was set as expected. start_seed = outdxf.find('$HANDSEED') handseed = outdxf[start_seed + 10 + 4:start_seed + 10 + 4 + 8] if handseed != '00000053': gdaltest.post_reason('Did not get expected HANDSEED, got %s.' % handseed) return 'fail' os.unlink('tmp/dxf_14.dxf') return 'success'
def db2Feat(self, parent, table, results, columns, geom=""): #Execute the export process #Create driver drv = ogr.GetDriverByName(self.getDriverName()) if drv is None: raise Exception("{0} driver not available.".format( self.getDriverName())) #Create data source self._ds = drv.CreateDataSource(self._targetFile) if self._ds is None: raise Exception("Creation of output file failed.") #Create layer if geom != "": pgGeomType, srid = geometryType(table, geom) geomType = wkbTypes[pgGeomType] else: geomType = ogr.wkbNone lyr = self._ds.CreateLayer(self.getLayerName(), None, geomType) if lyr is None: raise Exception("Layer creation failed") #Create fields for c in columns: #SQLAlchemy string values are in unicode so decoding is required in order to use in OGR encodedFieldName = c.encode('utf-8') field_defn = self.createField(table, encodedFieldName) if lyr.CreateField(field_defn) != 0: raise Exception("Creating %s field failed" % (c)) #Add Geometry column to list for referencing in the result set if geom != "": columns.append(geom) featGeom = None #Configure progress dialog initVal = 0 numFeat = results.rowcount progress = QProgressDialog("", "&Cancel", initVal, numFeat, parent) progress.setWindowModality(Qt.WindowModal) lblMsgTemp = "Writing {0} of {1} to file..." #Iterate the result set for r in results: #Progress dialog progress.setValue(initVal) progressMsg = lblMsgTemp.format(str(initVal + 1), str(numFeat)) progress.setLabelText(progressMsg) if progress.wasCanceled(): break #Create OGR Feature feat = ogr.Feature(lyr.GetLayerDefn()) for i in range(len(columns)): colName = columns[i] #Check if its the geometry column in the iteration if colName == geom: if r[i] is not None: featGeom = ogr.CreateGeometryFromWkt(r[i]) else: featGeom = ogr.CreateGeometryFromWkt("") feat.SetGeometry(featGeom) else: fieldValue = r[i] if isinstance(fieldValue, unicode): fieldValue = fieldValue.encode('utf-8') feat.SetField(i, fieldValue) if lyr.CreateFeature(feat) != 0: progress.close() raise Exception("Failed to create feature in %s" % (self._targetFile)) if featGeom is not None: featGeom.Destroy() feat.Destroy() initVal += 1 progress.setValue(numFeat)
def mask_from_geom(geom, rds, band_num=1, epsg=32760, nodata_value=None, all_touched=False, full_extent=False): """ Return a binary mask to mask off everything outside of geom. Parameters ---------- geom : shapely.geometry Cells inside this geometry will be `False`. Cells outside will be `True` rds : RasterDS The raster dataset to create a mask for. full_extent : bool If `True`, return a mask that's the full extent of `rds`. If `False` (default), return a mask that's the extent of `geom`. Returns ------- numpy boolean array An array with `True` outside `geom` and `False` inside. """ spatial_ref = osr.SpatialReference() spatial_ref.ImportFromEPSG(epsg) mem_drv = ogr.GetDriverByName('Memory') driver = gdal.GetDriverByName('MEM') rb = rds.gdal_ds.GetRasterBand(band_num) rgt = rds.gdal_ds.GetGeoTransform() rsize = (rds.gdal_ds.RasterXSize, rds.gdal_ds.RasterYSize) if nodata_value is not None: nodata_value = float(nodata_value) rb.SetNoDataValue(nodata_value) else: nodata_value = rb.GetNoDataValue() # Point and MultiPoint don't play well with GDALRasterize # convert them into box polygons the size of a raster cell # buff = rgt[1] / 2.0 # if geom.type == "MultiPoint": # geom = MultiPolygon([box(*(pt.buffer(buff).bounds)) # for pt in geom.geoms]) # elif geom.type == 'Point': # geom = box(*(geom.buffer(buff).bounds)) ogr_geom_type = shapely_to_ogr_type(geom.type) if full_extent: geom_bounds = list(rds.raster_extent.bounds) else: geom_bounds = list(geom.bounds) # calculate new pixel coordinates of the feature subset src_offset = bbox_to_pixel_offsets(rgt, geom_bounds, rsize) new_gt = ((rgt[0] + (src_offset[0] * rgt[1])), rgt[1], 0.0, (rgt[3] + (src_offset[1] * rgt[5])), 0.0, rgt[5]) if src_offset[2] <= 0 or src_offset[3] <= 0: # we're off the raster completely, no overlap at all # so there's no need to even bother trying to calculate return None else: # use feature's source extent and read directly from source # fastest option when you have fast disks and well-indexed raster # advantage: each feature uses the smallest raster chunk # disadvantage: lots of disk reads on the source raster #src_array = rb.ReadAsArray(*src_offset) # Create a temporary vector layer in memory mem_ds = mem_drv.CreateDataSource('out') mem_layer = mem_ds.CreateLayer('out', spatial_ref, ogr_geom_type) ogr_feature = ogr.Feature(feature_def=mem_layer.GetLayerDefn()) ogr_geom = ogr.CreateGeometryFromWkt(geom.wkt) ogr_feature.SetGeometryDirectly(ogr_geom) mem_layer.CreateFeature(ogr_feature) # Rasterize it rvds = driver.Create('rvds', src_offset[2], src_offset[3], 1, gdal.GDT_Byte) rvds.SetGeoTransform(new_gt) if all_touched: gdal.RasterizeLayer(rvds, [1], mem_layer, None, None, burn_values=[1], options=['ALL_TOUCHED=True']) else: gdal.RasterizeLayer(rvds, [1], mem_layer, None, None, burn_values=[1], options=['ALL_TOUCHED=False']) rv_array = rvds.ReadAsArray() # Mask the source data array with our current feature # we take the logical_not to flip 0<->1 to get the correct mask effect # we also mask out nodata values explictly # masked = np.ma.MaskedArray( # src_array, # mask=np.logical_or( # src_array == nodata_value, # np.logical_not(rv_array) # ) # ) # return masked # return np.logical_or( src_array == nodata_value, np.logical_not( rv_array ) ) return ~rv_array.astype('bool')
def processAlgorithm(self, progress): """ Based on code by Matthew Perry https://gist.github.com/perrygeo/5667173 """ layer = dataobjects.getObjectFromUri( self.getParameterValue(self.INPUT_VECTOR)) rasterPath = str(self.getParameterValue(self.INPUT_RASTER)) bandNumber = self.getParameterValue(self.RASTER_BAND) columnPrefix = self.getParameterValue(self.COLUMN_PREFIX) useGlobalExtent = self.getParameterValue(self.GLOBAL_EXTENT) rasterDS = gdal.Open(rasterPath, gdal.GA_ReadOnly) geoTransform = rasterDS.GetGeoTransform() rasterBand = rasterDS.GetRasterBand(bandNumber) noData = rasterBand.GetNoDataValue() cellXSize = abs(geoTransform[1]) cellYSize = abs(geoTransform[5]) rasterXSize = rasterDS.RasterXSize rasterYSize = rasterDS.RasterYSize rasterBBox = QgsRectangle(geoTransform[0], geoTransform[3] - cellYSize * rasterYSize, geoTransform[0] + cellXSize * rasterXSize, geoTransform[3]) rasterGeom = QgsGeometry.fromRect(rasterBBox) crs = osr.SpatialReference() crs.ImportFromProj4(str(layer.crs().toProj4())) if useGlobalExtent: xMin = rasterBBox.xMinimum() xMax = rasterBBox.xMaximum() yMin = rasterBBox.yMinimum() yMax = rasterBBox.yMaximum() (startColumn, startRow) = mapToPixel(xMin, yMax, geoTransform) (endColumn, endRow) = mapToPixel(xMax, yMin, geoTransform) width = endColumn - startColumn height = endRow - startRow srcOffset = (startColumn, startRow, width, height) srcArray = rasterBand.ReadAsArray(*srcOffset) srcArray = srcArray * rasterBand.GetScale() + rasterBand.GetOffset( ) newGeoTransform = ( geoTransform[0] + srcOffset[0] * geoTransform[1], geoTransform[1], 0.0, geoTransform[3] + srcOffset[1] * geoTransform[5], 0.0, geoTransform[5], ) memVectorDriver = ogr.GetDriverByName('Memory') memRasterDriver = gdal.GetDriverByName('MEM') fields = layer.fields() (idxMin, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'min', 21, 6) (idxMax, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'max', 21, 6) (idxSum, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'sum', 21, 6) (idxCount, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'count', 21, 6) (idxMean, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'mean', 21, 6) (idxStd, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'std', 21, 6) (idxUnique, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'unique', 21, 6) (idxRange, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'range', 21, 6) (idxVar, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'var', 21, 6) (idxMedian, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'median', 21, 6) if hasSciPy: (idxMode, fields) = vector.findOrCreateField(layer, fields, columnPrefix + 'mode', 21, 6) writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter( fields.toList(), layer.wkbType(), layer.crs()) outFeat = QgsFeature() outFeat.initAttributes(len(fields)) outFeat.setFields(fields) features = vector.features(layer) total = 100.0 / len(features) for current, f in enumerate(features): geom = f.geometry() intersectedGeom = rasterGeom.intersection(geom) ogrGeom = ogr.CreateGeometryFromWkt(intersectedGeom.exportToWkt()) if not useGlobalExtent: bbox = intersectedGeom.boundingBox() xMin = bbox.xMinimum() xMax = bbox.xMaximum() yMin = bbox.yMinimum() yMax = bbox.yMaximum() (startColumn, startRow) = mapToPixel(xMin, yMax, geoTransform) (endColumn, endRow) = mapToPixel(xMax, yMin, geoTransform) width = endColumn - startColumn height = endRow - startRow if width == 0 or height == 0: continue srcOffset = (startColumn, startRow, width, height) srcArray = rasterBand.ReadAsArray(*srcOffset) srcArray = srcArray * rasterBand.GetScale( ) + rasterBand.GetOffset() newGeoTransform = ( geoTransform[0] + srcOffset[0] * geoTransform[1], geoTransform[1], 0.0, geoTransform[3] + srcOffset[1] * geoTransform[5], 0.0, geoTransform[5], ) # Create a temporary vector layer in memory memVDS = memVectorDriver.CreateDataSource('out') memLayer = memVDS.CreateLayer('poly', crs, ogr.wkbPolygon) ft = ogr.Feature(memLayer.GetLayerDefn()) ft.SetGeometry(ogrGeom) memLayer.CreateFeature(ft) ft.Destroy() # Rasterize it rasterizedDS = memRasterDriver.Create('', srcOffset[2], srcOffset[3], 1, gdal.GDT_Byte) rasterizedDS.SetGeoTransform(newGeoTransform) gdal.RasterizeLayer(rasterizedDS, [1], memLayer, burn_values=[1]) rasterizedArray = rasterizedDS.ReadAsArray() srcArray = numpy.nan_to_num(srcArray) masked = numpy.ma.MaskedArray( srcArray, mask=numpy.logical_or(srcArray == noData, numpy.logical_not(rasterizedArray))) outFeat.setGeometry(geom) attrs = f.attributes() v = float(masked.min()) attrs.insert(idxMin, None if numpy.isnan(v) else v) v = float(masked.max()) attrs.insert(idxMax, None if numpy.isnan(v) else v) v = float(masked.sum()) attrs.insert(idxSum, None if numpy.isnan(v) else v) attrs.insert(idxCount, int(masked.count())) v = float(masked.mean()) attrs.insert(idxMean, None if numpy.isnan(v) else v) v = float(masked.std()) attrs.insert(idxStd, None if numpy.isnan(v) else v) attrs.insert(idxUnique, numpy.unique(masked.compressed()).size) v = float(masked.max()) - float(masked.min()) attrs.insert(idxRange, None if numpy.isnan(v) else v) v = float(masked.var()) attrs.insert(idxVar, None if numpy.isnan(v) else v) v = float(numpy.ma.median(masked)) attrs.insert(idxMedian, None if numpy.isnan(v) else v) if hasSciPy: attrs.insert(idxMode, float(mode(masked, axis=None)[0][0])) outFeat.setAttributes(attrs) writer.addFeature(outFeat) memVDS = None rasterizedDS = None progress.setPercentage(int(current * total)) rasterDS = None del writer
idx = [ j for j, x in enumerate(SOIL_ID_List2) if (x == s and LAYER_NO_List[j] == '1') ] #idx = [j for j, x in enumerate(SOIL_ID_List2) if x == s] #for id in idx: # LAYER_NO_List[j] KSATav += float(KSAT_List[idx[0]]) * p / 100 KSATav = KSATav / 2.54 # cm/h to in/h if KSATav < 0.: KSATav = 0.0 print KSATav, 'in in/h' # create a new feature outFeature = ogr.Feature(featureDefn) outFeature.SetGeometry(inFeature.GetGeometryRef()) # Set the field content for field in fields: outFeature.SetField(field, inFeature.GetField(field)) outFeature.SetField('KSAT_IN_HR', KSATav) # add the feature to the output layer outLayer.CreateFeature(outFeature) # destroy the features inFeature.Destroy() outFeature.Destroy() inFeature = inLayer.GetNextFeature() i += 1
def main(): i = 1 output_format = None in_filename = None out_filename = None ovr_level = None while i < len(sys.argv): if sys.argv[i] == "-f": output_format = sys.argv[i + 1] i = i + 1 elif sys.argv[i] == "-ovr": ovr_level = int(sys.argv[i + 1]) i = i + 1 elif sys.argv[i][0] == '-': return Usage() elif in_filename is None: in_filename = sys.argv[i] elif out_filename is None: out_filename = sys.argv[i] else: return Usage() i = i + 1 if out_filename is None: return Usage() if output_format is None: output_format = GetOutputDriverFor(out_filename) src_ds = gdal.Open(in_filename) out_ds = gdal.GetDriverByName(output_format).Create( out_filename, 0, 0, 0, gdal.GDT_Unknown) first_band = src_ds.GetRasterBand(1) main_gt = src_ds.GetGeoTransform() for i in ([ovr_level] if ovr_level is not None else range(1 + first_band.GetOverviewCount())): src_band = first_band if i == 0 else first_band.GetOverview(i - 1) out_lyr = out_ds.CreateLayer('main_image' if i == 0 else ('overview_%d' % i), geom_type=ogr.wkbPolygon, srs=src_ds.GetSpatialRef()) blockxsize, blockysize = src_band.GetBlockSize() nxblocks = (src_band.XSize + blockxsize - 1) // blockxsize nyblocks = (src_band.YSize + blockysize - 1) // blockysize gt = [ main_gt[0], main_gt[1] * first_band.XSize / src_band.XSize, 0, main_gt[3], 0, main_gt[5] * first_band.YSize / src_band.YSize ] for y in range(nyblocks): ymax = gt[3] + y * blockysize * gt[5] ymin = ymax + blockysize * gt[5] for x in range(nxblocks): xmin = gt[0] + x * blockxsize * gt[1] xmax = xmin + blockxsize * gt[1] f = ogr.Feature(out_lyr.GetLayerDefn()) wkt = 'POLYGON((%.18g %.18g,%.18g %.18g,%.18g %.18g,%.18g %.18g,%.18g %.18g))' % ( xmin, ymin, xmin, ymax, xmax, ymax, xmax, ymin, xmin, ymin) f.SetGeometryDirectly(ogr.CreateGeometryFromWkt(wkt)) out_lyr.CreateFeature(f) out_ds = None
) transform = osr.CoordinateTransformation(srcProjection, dstProjection) # Create the dest shapefile, and give it the new projection. driver = ogr.GetDriverByName("ESRI Shapefile") if os.path.exists(shpOutFileName): driver.DeleteDataSource(shpOutFileName) dstFile = driver.CreateDataSource(shpOutFileName) dstLayer = dstFile.CreateLayer("layer", dstProjection) # Copy fields to the layer fieldIndices = range(layerDefn.GetFieldCount()) for fieldIndex in fieldIndices: dstLayer.CreateField(layerDefn.GetFieldDefn(fieldIndex)) # Reproject each feature in turn. for i in range(srcLayer.GetFeatureCount()): feature = srcLayer.GetFeature(i) geometry = feature.GetGeometryRef() newGeometry = geometry.Clone() newGeometry.Transform(transform) newFeature = ogr.Feature(dstLayer.GetLayerDefn()) newFeature.SetGeometry(newGeometry) # Copy field values for fieldIndex in fieldIndices: fieldName = layerDefn.GetFieldDefn(fieldIndex).GetName() fieldValue = feature.GetFieldAsString(fieldName) newFeature.SetField(fieldName, fieldValue) dstLayer.CreateFeature(newFeature) newFeature.Destroy() # All done. srcFile.Destroy() dstFile.Destroy()
def boundary_polygonup(self, path, destination): # ogrsql ''' python process.py --path ../../test/data/boundary-polygon.shp ogr2ogr -f "ESRI Shapefile" ../../test/result.shp ../../test/data/boundary-polygon.shp -dialect sqlite \ -sql "select ST_buffer(Geometry,0.001) from boundary-polygon" ''' from osgeo import ogr ''' ogr_ds = ogr.Open(path) TEST=3 sql = "SELECT upper_polygon.NAME FROM \"boundary-polygon\" current_polygon, \"boundary-polygon\" upper_polygon ON ST_Intersects(ST_PointOnSurface(current_polygon.GEOMETRY), upper_polygon.GEOMETRY)=1 WHERE ADMIN_LVL = '6'" sql = "SELECT current_polygon.NAME AS name_c, upper_polygon.NAME,ST_Intersects(ST_Centroid(current_polygon.GEOMETRY), upper_polygon.GEOMETRY) AS val FROM \"boundary-polygon\" current_polygon, \"boundary-polygon\" upper_polygon ON 1=1 WHERE current_polygon.ADMIN_LVL = '6' AND upper_polygon.ADMIN_LVL = '4' LIMIT 100" sql = "select GEOMETRY, NAME as name from \"boundary-polygon\" WHERE ADMIN_LVL = '6'" layer = ogr_ds.ExecuteSQL(sql,None,'SQLITE') ''' defaultDestination = os.path.dirname(path), "test.shp" driver = ogr.GetDriverByName("ESRI Shapefile") if os.path.isfile(path) == False: raise IOError('file {path} does not exist.'.format(path=path)) quit() dataSource = driver.Open(path, 0) layer = dataSource.GetLayer() #get physical filename for destination #By default in emporary folder temp_destination_folder = '' if destination is None: import tempfile import shutil folder_was_temp = True temp_destination_folder = tempfile.mkdtemp() outShapefile = os.path.join(temp_destination_folder, 'boundary-polygon.shp') else: # Save to a new Shapefile outShapefile = destination outDriver = ogr.GetDriverByName("ESRI Shapefile") # Remove output shapefile if it already exists if os.path.exists(outShapefile): outDriver.DeleteDataSource(outShapefile) # Create the output shapefile outDataSource = outDriver.CreateDataSource(outShapefile) srs = osr.SpatialReference() srs.ImportFromEPSG(4326) outLayer = outDataSource.CreateLayer("test", srs=srs, geom_type=ogr.wkbMultiPolygon, options=["ENCODING=UTF-8"]) # Add input Layer Fields to the output Layer inLayerDefn = layer.GetLayerDefn() for i in range(0, inLayerDefn.GetFieldCount()): fieldDefn = inLayerDefn.GetFieldDefn(i) outLayer.CreateField(fieldDefn) # Add special fields outLayer.CreateField(ogr.FieldDefn('ADMIN_L1', ogr.OFTString)) outLayer.CreateField(ogr.FieldDefn('ADMIN_L2', ogr.OFTString)) outLayer.CreateField(ogr.FieldDefn('ADMIN_L3', ogr.OFTString)) outLayer.CreateField(ogr.FieldDefn('ADMIN_L4', ogr.OFTString)) outLayer.CreateField(ogr.FieldDefn('ADMIN_L5', ogr.OFTString)) outLayer.CreateField(ogr.FieldDefn('ADMIN_L6', ogr.OFTString)) outLayer.CreateField(ogr.FieldDefn('ADMIN_L7', ogr.OFTString)) outLayer.CreateField(ogr.FieldDefn('ADMIN_L8', ogr.OFTString)) outLayer.CreateField(ogr.FieldDefn('ADMIN_L9', ogr.OFTString)) # Get the output Layer's Feature Definition outLayerDefn = outLayer.GetLayerDefn() # Also open source layer several times for search # Apply attribute filter for search upper names dataSource_admlevel1 = driver.Open(path, 0) layer_admlevel1 = dataSource_admlevel1.GetLayer() layer_admlevel1.SetAttributeFilter("ADMIN_LVL = '1'") dataSource_admlevel2 = driver.Open(path, 0) layer_admlevel2 = dataSource_admlevel2.GetLayer() layer_admlevel2.SetAttributeFilter("ADMIN_LVL = '2'") dataSource_admlevel3 = driver.Open(path, 0) layer_admlevel3 = dataSource_admlevel3.GetLayer() layer_admlevel3.SetAttributeFilter("ADMIN_LVL = '3'") dataSource_admlevel4 = driver.Open(path, 0) layer_admlevel4 = dataSource_admlevel4.GetLayer() layer_admlevel4.SetAttributeFilter("ADMIN_LVL = '4'") dataSource_admlevel5 = driver.Open(path, 0) layer_admlevel5 = dataSource_admlevel5.GetLayer() layer_admlevel5.SetAttributeFilter("ADMIN_LVL = '5'") dataSource_admlevel6 = driver.Open(path, 0) layer_admlevel6 = dataSource_admlevel6.GetLayer() layer_admlevel6.SetAttributeFilter("ADMIN_LVL = '6'") dataSource_admlevel7 = driver.Open(path, 0) layer_admlevel7 = dataSource_admlevel7.GetLayer() layer_admlevel7.SetAttributeFilter("ADMIN_LVL = '7'") dataSource_admlevel8 = driver.Open(path, 0) layer_admlevel8 = dataSource_admlevel8.GetLayer() layer_admlevel8.SetAttributeFilter("ADMIN_LVL = '8'") dataSource_admlevel9 = driver.Open(path, 0) layer_admlevel9 = dataSource_admlevel9.GetLayer() layer_admlevel9.SetAttributeFilter("ADMIN_LVL = '9'") # Add features to the ouput Layer bar = progressbar.ProgressBar(widgets=[ ' [', progressbar.Timer(), '] ', progressbar.Bar(), ' (', progressbar.ETA(), ') ', ]) for i in bar(range(0, layer.GetFeatureCount())): #for i in range(0, layer.GetFeatureCount()): # Get the input Feature inFeature = layer.GetFeature(i) geom = inFeature.GetGeometryRef() #Perform a spatial query query_geometry = geom.PointOnSurface().Buffer(0.009) layer_admlevel1.SetSpatialFilter(query_geometry) layer_admlevel2.SetSpatialFilter(query_geometry) layer_admlevel3.SetSpatialFilter(query_geometry) layer_admlevel4.SetSpatialFilter(query_geometry) layer_admlevel5.SetSpatialFilter(query_geometry) layer_admlevel6.SetSpatialFilter(query_geometry) layer_admlevel7.SetSpatialFilter(query_geometry) layer_admlevel8.SetSpatialFilter(query_geometry) layer_admlevel9.SetSpatialFilter(query_geometry) ##according to documentation, it return "all features whose envelope (as returned by OGRGeometry::getEnvelope()) overlaps the envelope of the spatial filter". #may be faster to ..rect #Get name of upper region layer_admlevel1.ResetReading() upFeature_admlevel1 = layer_admlevel1.GetNextFeature() layer_admlevel2.ResetReading() upFeature_admlevel2 = layer_admlevel2.GetNextFeature() layer_admlevel3.ResetReading() upFeature_admlevel3 = layer_admlevel3.GetNextFeature() layer_admlevel4.ResetReading() upFeature_admlevel4 = layer_admlevel4.GetNextFeature() layer_admlevel5.ResetReading() upFeature_admlevel5 = layer_admlevel5.GetNextFeature() layer_admlevel6.ResetReading() upFeature_admlevel6 = layer_admlevel6.GetNextFeature() layer_admlevel7.ResetReading() upFeature_admlevel7 = layer_admlevel7.GetNextFeature() layer_admlevel8.ResetReading() upFeature_admlevel8 = layer_admlevel8.GetNextFeature() layer_admlevel9.ResetReading() upFeature_admlevel9 = layer_admlevel9.GetNextFeature() # Create output Feature outFeature = ogr.Feature(outLayerDefn) # Add field values from input Layer for f in range(0, inLayerDefn.GetFieldCount()): outFeature.SetField( outLayerDefn.GetFieldDefn(f).GetNameRef(), inFeature.GetField(f)) #Add name of upper region current_ADMIN_LVL = inFeature.GetField('ADMIN_LVL') if current_ADMIN_LVL in [ '2', '3', '4', '5', '6', '7', '8', '9', '10' ] and upFeature_admlevel1 is not None: outFeature.SetField('ADMIN_L1', upFeature_admlevel1.GetField('NAME')) if current_ADMIN_LVL in ['3', '4', '5', '6', '7', '8', '9', '10' ] and upFeature_admlevel2 is not None: outFeature.SetField('ADMIN_L2', upFeature_admlevel2.GetField('NAME')) if current_ADMIN_LVL in ['4', '5', '6', '7', '8', '9', '10' ] and upFeature_admlevel3 is not None: outFeature.SetField('ADMIN_L3', upFeature_admlevel3.GetField('NAME')) if current_ADMIN_LVL in ['5', '6', '7', '8', '9', '10' ] and upFeature_admlevel4 is not None: outFeature.SetField('ADMIN_L4', upFeature_admlevel4.GetField('NAME')) if current_ADMIN_LVL in ['6', '7', '8', '9', '10' ] and upFeature_admlevel5 is not None: outFeature.SetField('ADMIN_L5', upFeature_admlevel5.GetField('NAME')) if current_ADMIN_LVL in ['7', '8', '9', '10' ] and upFeature_admlevel6 is not None: outFeature.SetField('ADMIN_L6', upFeature_admlevel6.GetField('NAME')) if current_ADMIN_LVL in ['8', '9', '10' ] and upFeature_admlevel7 is not None: outFeature.SetField('ADMIN_L7', upFeature_admlevel7.GetField('NAME')) if current_ADMIN_LVL in ['9', '10' ] and upFeature_admlevel8 is not None: outFeature.SetField('ADMIN_L8', upFeature_admlevel8.GetField('NAME')) if current_ADMIN_LVL in ['10'] and upFeature_admlevel9 is not None: outFeature.SetField('ADMIN_L9', upFeature_admlevel9.GetField('NAME')) # Set geometry as copy of source outFeature.SetGeometry(geom) #inFeature = None outLayer.CreateFeature(outFeature) outFeature = None upFeature_admlevel1 = None upFeature_admlevel2 = None upFeature_admlevel3 = None upFeature_admlevel4 = None upFeature_admlevel5 = None upFeature_admlevel6 = None upFeature_admlevel7 = None upFeature_admlevel8 = None upFeature_admlevel9 = None # Save and close DataSources inDataSource = None outDataSource = None if destination is None: shutil.move( os.path.join(temp_destination_folder, 'boundary-polygon.shp'), os.path.join(os.path.dirname(path), 'boundary-polygon.shp')) shutil.move( os.path.join(temp_destination_folder, 'boundary-polygon.shx'), os.path.join(os.path.dirname(path), 'boundary-polygon.shx')) shutil.move( os.path.join(temp_destination_folder, 'boundary-polygon.cpg'), os.path.join(os.path.dirname(path), 'boundary-polygon.cpg')) shutil.move( os.path.join(temp_destination_folder, 'boundary-polygon.dbf'), os.path.join(os.path.dirname(path), 'boundary-polygon.dbf')) shutil.move( os.path.join(temp_destination_folder, 'boundary-polygon.prj'), os.path.join(os.path.dirname(path), 'boundary-polygon.prj')) shutil.rmtree(temp_destination_folder)
from osgeo import ogr import os,math driver = ogr.GetDriverByName("ESRI Shapefile") extfile = 'rect_demo.shp' if os.access( extfile, os.F_OK ): driver.DeleteDataSource( extfile ) extent = [400, 1100, 300, 600] newds = driver.CreateDataSource(extfile) layernew = newds.CreateLayer('rect',None,ogr.wkbPolygon) width = math.fabs(extent[1]-extent[0]) height = math.fabs(extent[3]-extent[2]) tw = width/2 th = width/2 extnew = extent[0]+tw wkt = 'POLYGON ((%f %f,%f %f,%f %f,%f %f,%f %f))' % (extent[0],extent[3], extent[1],extent[3], extent[1],extent[2], extent[0],extent[2], extent[0],extent[3]) geom = ogr.CreateGeometryFromWkt(wkt) feat = ogr.Feature(layernew.GetLayerDefn()) feat.SetGeometry(geom) layernew.CreateFeature(feat) newds.Destroy()
def test_point_snapping_multipoint(self): """DelineateIt: test multi-point snapping.""" from natcap.invest.delineateit import delineateit srs = osr.SpatialReference() srs.ImportFromEPSG(32731) # WGS84/UTM zone 31s wkt = srs.ExportToWkt() # need stream layer, points stream_matrix = numpy.array( [[0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0]], dtype=numpy.int8) stream_raster_path = os.path.join(self.workspace_dir, 'streams.tif') # byte datatype pygeoprocessing.numpy_array_to_raster(stream_matrix, 255, (2, -2), (2, -2), wkt, stream_raster_path) source_points_path = os.path.join(self.workspace_dir, 'source_features.gpkg') gpkg_driver = gdal.GetDriverByName('GPKG') points_vector = gpkg_driver.Create(source_points_path, 0, 0, 0, gdal.GDT_Unknown) layer_name = os.path.splitext(os.path.basename(source_points_path))[0] points_layer = points_vector.CreateLayer(layer_name, points_vector.GetSpatialRef(), ogr.wkbUnknown) # Create a bunch of points for the various OGR multipoint types and # make sure that they are all snapped to exactly the same place. points_layer.StartTransaction() for multipoint_type in (ogr.wkbMultiPoint, ogr.wkbMultiPointM, ogr.wkbMultiPointZM, ogr.wkbMultiPoint25D): new_feature = ogr.Feature(points_layer.GetLayerDefn()) new_geom = ogr.Geometry(multipoint_type) component_point = ogr.Geometry(ogr.wkbPoint) component_point.AddPoint(3, -5) new_geom.AddGeometry(component_point) new_feature.SetGeometry(new_geom) points_layer.CreateFeature(new_feature) # Verify point snapping will run if we give it empty multipoints. for point_type in (ogr.wkbPoint, ogr.wkbMultiPoint): new_feature = ogr.Feature(points_layer.GetLayerDefn()) new_geom = ogr.Geometry(point_type) new_feature.SetGeometry(new_geom) points_layer.CreateFeature(new_feature) points_layer.CommitTransaction() snapped_points_path = os.path.join(self.workspace_dir, 'snapped_points.gpkg') snap_distance = 10 # large enough to get multiple streams per point. delineateit.snap_points_to_nearest_stream(source_points_path, (stream_raster_path, 1), snap_distance, snapped_points_path) try: snapped_points_vector = gdal.OpenEx(snapped_points_path, gdal.OF_VECTOR) snapped_points_layer = snapped_points_vector.GetLayer() # All 4 multipoints should have been snapped to the same place and # should all be Point geometries. self.assertEqual(4, snapped_points_layer.GetFeatureCount()) expected_feature = shapely.geometry.Point(5, -5) for feature in snapped_points_layer: shapely_feature = shapely.wkb.loads( feature.GetGeometryRef().ExportToWkb()) self.assertTrue(shapely_feature.equals(expected_feature)) finally: snapped_points_layer = None snapped_points_vector = None
in_dataset = sys.argv[i] elif out_dataset is None: out_dataset = sys.argv[i] else: Usage() i+= 1 if out_dataset is None: Usage() ds = gdal.Open(in_dataset) out_ds = ogr.GetDriverByName('ESRI Shapefile').CreateDataSource(out_dataset) sr = None wkt = ds.GetGCPProjection() if wkt != '': sr = osr.SpatialReference(wkt) out_lyr = out_ds.CreateLayer('gcps', geom_type = ogr.wkbPoint, srs = sr) out_lyr.CreateField(ogr.FieldDefn('Id', ogr.OFTString)) out_lyr.CreateField(ogr.FieldDefn('Info', ogr.OFTString)) out_lyr.CreateField(ogr.FieldDefn('X', ogr.OFTReal)) out_lyr.CreateField(ogr.FieldDefn('Y', ogr.OFTReal)) gcps = ds.GetGCPs() for i in range(len(gcps)): f = ogr.Feature(out_lyr.GetLayerDefn()) f.SetField('Id', gcps[i].Id) f.SetField('Info', gcps[i].Info) f.SetField('X', gcps[i].GCPPixel) f.SetField('Y', gcps[i].GCPLine) f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(%f %f)' % (gcps[i].GCPX, gcps[i].GCPY))) out_lyr.CreateFeature(f)
def testSubsetStringFids(self): """ - tests that feature ids are stable even if a subset string is set - tests that the subset string is correctly set on the ogr layer event when reloading the data source (issue #17122) """ tmpfile = os.path.join(self.basetestpath, 'subsetStringFids.sqlite') ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile) lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid']) lyr.CreateField(ogr.FieldDefn('type', ogr.OFTInteger)) lyr.CreateField(ogr.FieldDefn('value', ogr.OFTInteger)) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(0) f.SetField(0, 1) f.SetField(1, 11) f.SetGeometry(ogr.CreateGeometryFromWkt('Point (0 0)')) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(1) f.SetField(0, 1) f.SetField(1, 12) f.SetGeometry(ogr.CreateGeometryFromWkt('Point (1 1)')) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(2) f.SetField(0, 1) f.SetField(1, 13) f.SetGeometry(ogr.CreateGeometryFromWkt('Point (2 2)')) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(3) f.SetField(0, 2) f.SetField(1, 14) f.SetGeometry(ogr.CreateGeometryFromWkt('Point (3 3)')) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(4) f.SetField(0, 2) f.SetField(1, 15) f.SetGeometry(ogr.CreateGeometryFromWkt('Point (4 4)')) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(5) f.SetField(0, 2) f.SetField(1, 16) f.SetGeometry(ogr.CreateGeometryFromWkt('Point (5 5)')) lyr.CreateFeature(f) f = None ds = None vl = QgsVectorLayer(tmpfile, 'test', 'ogr') self.assertTrue(vl.isValid()) self.assertEqual([f.name() for f in vl.fields()], ['fid', 'type', 'value']) original_fields = vl.fields() vl = QgsVectorLayer(tmpfile + "|subset=type=2", 'test', 'ogr') self.assertTrue(vl.isValid()) def run_checks(): self.assertEqual([f.name() for f in vl.fields()], ['fid', 'type', 'value']) # expression req = QgsFeatureRequest() req.setFilterExpression("value=16") it = vl.getFeatures(req) f = QgsFeature() self.assertTrue(it.nextFeature(f)) self.assertEqual(f.id(), 5) self.assertEqual(f.attributes(), [5, 2, 16]) self.assertEqual([field.name() for field in f.fields()], ['fid', 'type', 'value']) self.assertEqual(f.geometry().asWkt(), 'Point (5 5)') # filter fid req = QgsFeatureRequest() req.setFilterFid(5) it = vl.getFeatures(req) f = QgsFeature() self.assertTrue(it.nextFeature(f)) self.assertEqual(f.id(), 5) self.assertEqual(f.attributes(), [5, 2, 16]) self.assertEqual([field.name() for field in f.fields()], ['fid', 'type', 'value']) self.assertEqual(f.geometry().asWkt(), 'Point (5 5)') # filter fids req = QgsFeatureRequest() req.setFilterFids([5]) it = vl.getFeatures(req) f = QgsFeature() self.assertTrue(it.nextFeature(f)) self.assertEqual(f.id(), 5) self.assertEqual(f.attributes(), [5, 2, 16]) self.assertEqual([field.name() for field in f.fields()], ['fid', 'type', 'value']) self.assertEqual(f.geometry().asWkt(), 'Point (5 5)') # check with subset of attributes req = QgsFeatureRequest() req.setFilterFids([5]) req.setSubsetOfAttributes([2]) it = vl.getFeatures(req) f = QgsFeature() self.assertTrue(it.nextFeature(f)) self.assertEqual(f.id(), 5) self.assertEqual(f.attributes()[2], 16) self.assertEqual([field.name() for field in f.fields()], ['fid', 'type', 'value']) self.assertEqual(f.geometry().asWkt(), 'Point (5 5)') # filter rect and expression req = QgsFeatureRequest() req.setFilterExpression("value=16 or value=14") req.setFilterRect(QgsRectangle(4.5, 4.5, 5.5, 5.5)) it = vl.getFeatures(req) f = QgsFeature() self.assertTrue(it.nextFeature(f)) self.assertEqual(f.id(), 5) self.assertEqual(f.attributes(), [5, 2, 16]) self.assertEqual([field.name() for field in f.fields()], ['fid', 'type', 'value']) self.assertEqual(f.geometry().asWkt(), 'Point (5 5)') # filter rect and fids req = QgsFeatureRequest() req.setFilterFids([3, 5]) req.setFilterRect(QgsRectangle(4.5, 4.5, 5.5, 5.5)) it = vl.getFeatures(req) f = QgsFeature() self.assertTrue(it.nextFeature(f)) self.assertEqual(f.id(), 5) self.assertEqual(f.attributes(), [5, 2, 16]) self.assertEqual([field.name() for field in f.fields()], ['fid', 'type', 'value']) self.assertEqual(f.geometry().asWkt(), 'Point (5 5)') # Ensure that orig_ogc_fid is still retrieved even if attribute subset is passed req = QgsFeatureRequest() req.setSubsetOfAttributes([]) it = vl.getFeatures(req) ids = [] geoms = {} while it.nextFeature(f): ids.append(f.id()) geoms[f.id()] = f.geometry().asWkt() self.assertCountEqual(ids, [3, 4, 5]) self.assertEqual(geoms, { 3: 'Point (3 3)', 4: 'Point (4 4)', 5: 'Point (5 5)' }) run_checks() # Check that subset string is correctly set on reload vl.reload() run_checks()
def save_shapefile_from_polygons(polygons, image_filepath, output_shapefile_filepath, properties_list=None): """ https://gis.stackexchange.com/a/52708/8104 """ if properties_list is not None: assert len(polygons) == len( properties_list ), "polygons and properties_list should have the same length" coor, gt, coor_system = get_coor_in_space(image_filepath) transform_mat = compute_image_to_epsg_mat(coor, gt) # Convert polygons to ogr_polygons ogr_polygons = create_ogr_polygons(polygons, transform_mat) driver = ogr.GetDriverByName('Esri Shapefile') ds = driver.CreateDataSource(output_shapefile_filepath) # create the spatial reference, WGS84 srs = osr.SpatialReference() srs.ImportFromEPSG(4326) layer = ds.CreateLayer('', None, ogr.wkbPolygon) # Add one attribute field_name_list = [] field_type_list = [] if properties_list is not None: for properties in properties_list: for (key, value) in properties.items(): if key not in field_name_list: field_name_list.append(key) field_type_list.append(type(value)) for (name, py_type) in zip(field_name_list, field_type_list): if py_type == int: ogr_type = ogr.OFTInteger elif py_type == float: print("is float") ogr_type = ogr.OFTReal elif py_type == str: ogr_type = ogr.OFTString else: ogr_type = ogr.OFTInteger layer.CreateField(ogr.FieldDefn(name, ogr_type)) defn = layer.GetLayerDefn() for index in range(len(ogr_polygons)): ogr_polygon = ogr_polygons[index] if properties_list is not None: properties = properties_list[index] else: properties = {} # Create a new feature (attribute and geometry) feat = ogr.Feature(defn) for (key, value) in properties.items(): feat.SetField(key, value) # Make a geometry, from Shapely object geom = ogr.CreateGeometryFromWkt(ogr_polygon) feat.SetGeometry(geom) layer.CreateFeature(feat) feat = geom = None # destroy these # Save and close everything ds = layer = feat = geom = None
def testSubsetStringFids(self): """ - tests that feature ids are stable even if a subset string is set - tests that the subset string is correctly set on the ogr layer event when reloading the data source (issue #17122) """ tmpfile = os.path.join(self.basetestpath, 'subsetStringFids.sqlite') ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile) lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid']) lyr.CreateField(ogr.FieldDefn('type', ogr.OFTInteger)) lyr.CreateField(ogr.FieldDefn('value', ogr.OFTInteger)) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(0) f.SetField(0, 1) f.SetField(1, 11) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(1) f.SetField(0, 1) f.SetField(1, 12) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(2) f.SetField(0, 1) f.SetField(1, 13) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(3) f.SetField(0, 2) f.SetField(1, 14) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(4) f.SetField(0, 2) f.SetField(1, 15) lyr.CreateFeature(f) f = ogr.Feature(lyr.GetLayerDefn()) f.SetFID(5) f.SetField(0, 2) f.SetField(1, 16) lyr.CreateFeature(f) f = None ds = None vl = QgsVectorLayer(tmpfile + "|subset=type=2", 'test', 'ogr') self.assertTrue(vl.isValid()) self.assertTrue(vl.fields().at(vl.fields().count() - 1).name() == "orig_ogc_fid") req = QgsFeatureRequest() req.setFilterExpression("value=16") it = vl.getFeatures(req) f = QgsFeature() self.assertTrue(it.nextFeature(f)) self.assertTrue(f.id() == 5) # Ensure that orig_ogc_fid is still retrieved even if attribute subset is passed req = QgsFeatureRequest() req.setSubsetOfAttributes([]) it = vl.getFeatures(req) ids = [] while it.nextFeature(f): ids.append(f.id()) self.assertTrue(len(ids) == 3) self.assertTrue(3 in ids) self.assertTrue(4 in ids) self.assertTrue(5 in ids) # Check that subset string is correctly set on reload vl.reload() self.assertTrue(vl.fields().at(vl.fields().count() - 1).name() == "orig_ogc_fid")
def ogr_rfc35_mitab_2(): ds = ogr.Open('/vsimem/rfc35_test.tab', update=1) lyr = ds.GetLayer(0) if lyr.TestCapability(ogr.OLCReorderFields) != 1: gdaltest.post_reason('fail') return 'fail' feat = ogr.Feature(lyr.GetLayerDefn()) feat.SetField(0, 'foo3') feat.SetField(1, 'bar3_01234') feat.SetField(2, 'baz3_0123456789') feat.SetField(3, 'baw3_012345678901234') lyr.CreateFeature(feat) feat = None if lyr.ReorderField(1, 3) != 0: gdaltest.post_reason('fail') return 'fail' # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) # lyr = ds.GetLayer(0) ret = Check(lyr, ['foo5', 'baz15', 'baw20', 'bar10']) if ret != 'success': gdaltest.post_reason(ret) return ret lyr.ReorderField(3, 1) # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) # lyr = ds.GetLayer(0) ret = Check(lyr, ['foo5', 'bar10', 'baz15', 'baw20']) if ret != 'success': gdaltest.post_reason(ret) return ret lyr.ReorderField(0, 2) # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) # lyr = ds.GetLayer(0) ret = Check(lyr, ['bar10', 'baz15', 'foo5', 'baw20']) if ret != 'success': gdaltest.post_reason(ret) return ret lyr.ReorderField(2, 0) # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) # lyr = ds.GetLayer(0) ret = Check(lyr, ['foo5', 'bar10', 'baz15', 'baw20']) if ret != 'success': gdaltest.post_reason(ret) return ret lyr.ReorderField(0, 1) # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) # lyr = ds.GetLayer(0) ret = Check(lyr, ['bar10', 'foo5', 'baz15', 'baw20']) if ret != 'success': gdaltest.post_reason(ret) return ret lyr.ReorderField(1, 0) # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) # lyr = ds.GetLayer(0) ret = Check(lyr, ['foo5', 'bar10', 'baz15', 'baw20']) if ret != 'success': gdaltest.post_reason(ret) return ret lyr.ReorderFields([3, 2, 1, 0]) # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) # lyr = ds.GetLayer(0) ret = Check(lyr, ['baw20', 'baz15', 'bar10', 'foo5']) if ret != 'success': gdaltest.post_reason(ret) return ret lyr.ReorderFields([3, 2, 1, 0]) # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) # lyr = ds.GetLayer(0) ret = Check(lyr, ['foo5', 'bar10', 'baz15', 'baw20']) if ret != 'success': gdaltest.post_reason(ret) return ret gdal.PushErrorHandler('CPLQuietErrorHandler') ret = lyr.ReorderFields([0, 0, 0, 0]) gdal.PopErrorHandler() if ret == 0: gdaltest.post_reason('fail') return 'fail' # ds = None # ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1) lyr = ds.GetLayer(0) ret = CheckColumnOrder(lyr, ['foo5', 'bar10', 'baz15', 'baw20']) if ret != 'success': gdaltest.post_reason(ret) return ret ret = CheckFeatures(lyr) if ret != 'success': gdaltest.post_reason(ret) return ret return 'success'
def _write_summary_vector(source_aoi_vector_path, target_vector_path, runoff_ret_stats, runoff_ret_vol_stats, flood_volume_stats, damage_per_aoi_stats=None): """Write a vector with summary statistics. This vector will always contain two fields:: * ``'flood_vol'``: The volume of flood (runoff), in m3, per watershed. * ``'rnf_rt_idx'``: Average of runoff retention values per watershed * ``'rnf_rt_m3'``: Sum of runoff retention volumes, in m3, per watershed. If ``damage_per_aoi_stats`` is provided, then these additional columns will be written to the vector:: * ``'aff_bld'``: Potential damage to built infrastructure in $, per watershed. * ``'serv_blt'``: Spatial indicator of the importance of the runoff retention service Args: source_aoi_vector_path (str): The path to a GDAL vector that exists on disk. target_vector_path (str): The path to a vector that will be created. If a file already exists at this path, it will be deleted before the new file is created. This filepath must end with the extension ``.shp``, as the file created will be an ESRI Shapefile. runoff_ret_stats (dict): A dict representing summary statistics of the runoff raster. If provided, it must be a dictionary mapping feature IDs from ``source_aoi_vector_path`` to dicts with ``'count'`` and ``'sum'`` keys. runoff_ret_vol_stats (dict): A dict representing summary statistics of the runoff volume raster. If provided, it must be a dictionary mapping feature IDs from ``source_aoi_vector_path`` to dicts with ``'count'`` and ``'sum'`` keys. flood_volume_stats(dict): A dict mapping feature IDs from ``source_aoi_vector_path`` to float values representing the flood volume over the AOI. damage_per_aoi_stats (dict): A dict mapping feature IDs from ``source_aoi_vector_path`` to float values representing the total damage to built infrastructure in that watershed. Returns: ``None`` """ source_aoi_vector = gdal.OpenEx(source_aoi_vector_path, gdal.OF_VECTOR) source_aoi_layer = source_aoi_vector.GetLayer() source_geom_type = source_aoi_layer.GetGeomType() source_srs_wkt = pygeoprocessing.get_vector_info( source_aoi_vector_path)['projection_wkt'] source_srs = osr.SpatialReference() source_srs.ImportFromWkt(source_srs_wkt) esri_driver = gdal.GetDriverByName('ESRI Shapefile') target_watershed_vector = esri_driver.Create(target_vector_path, 0, 0, 0, gdal.GDT_Unknown) layer_name = os.path.splitext(os.path.basename(target_vector_path))[0] LOGGER.debug("creating layer %s", layer_name) target_watershed_layer = target_watershed_vector.CreateLayer( layer_name, source_srs, source_geom_type) target_fields = ['rnf_rt_idx', 'rnf_rt_m3', 'flood_vol'] if not damage_per_aoi_stats: damage_per_aoi_stats = {} else: target_fields += ['aff_bld', 'serv_blt'] for field_name in target_fields: field_def = ogr.FieldDefn(field_name, ogr.OFTReal) field_def.SetWidth(36) field_def.SetPrecision(11) target_watershed_layer.CreateField(field_def) target_layer_defn = target_watershed_layer.GetLayerDefn() for base_feature in source_aoi_layer: feature_id = base_feature.GetFID() target_feature = ogr.Feature(target_layer_defn) base_geom_ref = base_feature.GetGeometryRef() target_feature.SetGeometry(base_geom_ref.Clone()) base_geom_ref = None if feature_id in runoff_ret_stats: pixel_count = runoff_ret_stats[feature_id]['count'] if pixel_count > 0: mean_value = (runoff_ret_stats[feature_id]['sum'] / float(pixel_count)) target_feature.SetField('rnf_rt_idx', float(mean_value)) if feature_id in runoff_ret_vol_stats: target_feature.SetField( 'rnf_rt_m3', float(runoff_ret_vol_stats[feature_id]['sum'])) if feature_id in damage_per_aoi_stats: pixel_count = runoff_ret_vol_stats[feature_id]['count'] if pixel_count > 0: damage_sum = damage_per_aoi_stats[feature_id] target_feature.SetField('aff_bld', damage_sum) # This is the service_built equation. target_feature.SetField( 'serv_blt', (damage_sum * runoff_ret_vol_stats[feature_id]['sum'])) if feature_id in flood_volume_stats: target_feature.SetField( 'flood_vol', float(flood_volume_stats[feature_id]['sum'])) target_watershed_layer.CreateFeature(target_feature) target_watershed_layer.SyncToDisk() target_watershed_layer = None target_watershed_vector = None
def testGeopackageTwoLayerEdition(self): ''' test https://issues.qgis.org/issues/17034 ''' tmpfile = os.path.join(self.basetestpath, 'testGeopackageTwoLayerEdition.gpkg') ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile) lyr = ds.CreateLayer('layer1', geom_type=ogr.wkbPoint) lyr.CreateField(ogr.FieldDefn('attr', ogr.OFTInteger)) f = ogr.Feature(lyr.GetLayerDefn()) f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 0)')) lyr.CreateFeature(f) f = None lyr = ds.CreateLayer('layer2', geom_type=ogr.wkbPoint) lyr.CreateField(ogr.FieldDefn('attr', ogr.OFTInteger)) f = ogr.Feature(lyr.GetLayerDefn()) f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(1 1)')) lyr.CreateFeature(f) f = None ds = None vl1 = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=layer1", u'layer1', u'ogr') vl2 = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=layer2", u'layer2', u'ogr') # Edit vl1, vl2 multiple times self.assertTrue(vl1.startEditing()) self.assertTrue(vl2.startEditing()) self.assertTrue( vl1.changeGeometry(1, QgsGeometry.fromWkt('Point (2 2)'))) self.assertTrue( vl2.changeGeometry(1, QgsGeometry.fromWkt('Point (3 3)'))) self.assertTrue(vl1.commitChanges()) self.assertTrue(vl2.commitChanges()) self.assertTrue(vl1.startEditing()) self.assertTrue(vl2.startEditing()) self.assertTrue(vl1.changeAttributeValue(1, 1, 100)) self.assertTrue(vl2.changeAttributeValue(1, 1, 101)) self.assertTrue(vl1.commitChanges()) self.assertTrue(vl2.commitChanges()) self.assertTrue(vl1.startEditing()) self.assertTrue(vl2.startEditing()) self.assertTrue( vl1.changeGeometry(1, QgsGeometry.fromWkt('Point (4 4)'))) self.assertTrue( vl2.changeGeometry(1, QgsGeometry.fromWkt('Point (5 5)'))) self.assertTrue(vl1.commitChanges()) self.assertTrue(vl2.commitChanges()) vl1 = None vl2 = None # Check everything is as expected after re-opening vl1 = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=layer1", u'layer1', u'ogr') vl2 = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=layer2", u'layer2', u'ogr') got = [feat for feat in vl1.getFeatures()][0] got_geom = got.geometry() self.assertEqual(got['attr'], 100) reference = QgsGeometry.fromWkt('Point (4 4)') self.assertEqual( got_geom.asWkb(), reference.asWkb(), 'Expected {}, got {}'.format(reference.asWkt(), got_geom.asWkt())) got = [feat for feat in vl2.getFeatures()][0] got_geom = got.geometry() self.assertEqual(got['attr'], 101) reference = QgsGeometry.fromWkt('Point (5 5)') self.assertEqual( got_geom.asWkb(), reference.asWkb(), 'Expected {}, got {}'.format(reference.asWkt(), got_geom.asWkt()))