def ogr_wkbwkt_test_geometrycollection_wkb_recursion(): import struct wkb_repeat = struct.pack('B' * 9, 0, 0, 0, 0, 7, 0, 0, 0, 1 ) wkb_end = struct.pack('B' * 9, 0, 0, 0, 0, 7, 0, 0, 0, 0 ) wkb = struct.pack('B' * 0) for i in range(31): wkb = wkb + wkb_repeat wkb = wkb + wkb_end geom = ogr.CreateGeometryFromWkb(wkb) if geom is None: gdaltest.post_reason('expected a geometry') return 'fail' wkb = struct.pack('B' * 0) for i in range(32): wkb = wkb + wkb_repeat wkb = wkb + wkb_end gdal.PushErrorHandler('CPLQuietErrorHandler') geom = ogr.CreateGeometryFromWkb(wkb) gdal.PopErrorHandler() if geom is not None: gdaltest.post_reason('expected None') return 'fail' return 'success'
def way(self, w): if len(w.tags) == 0: return if w.is_closed() and closed_way_is_polygon( w.tags): # this will be handled in area() return try: # NOTE: it is possible this is actually a MultiLineString # in the case where a LineString is clipped by the clipping geom, # or the way is self-intersecting # but GDAL and QGIS seem to handle it OK. linestring = None for theme in self.mapping.themes: if theme.matches(GeomType.LINE, w.tags): if not linestring: wkb = fab.create_linestring(w) if self.clipping_geom: sg = loads(bytes.fromhex(wkb)) if not self.prepared_clipping_geom.intersects(sg): return if not self.prepared_clipping_geom.contains_properly( sg): sg = self.clipping_geom.intersection(sg) linestring = ogr.CreateGeometryFromWkb(dumps(sg)) else: linestring = create_geom(wkb) for output in self.outputs: output.write(w.id, theme.name, GeomType.LINE, linestring, w.tags) except RuntimeError: print("Incomplete way: {0}".format(w.id))
def netgeometry(key, data): if 'Wkb' in data: geom = ogr.CreateGeometryFromWkb(data['Wkb']) elif 'Wkt' in data: geom = ogr.CreateGeometryFromWkt(data['Wkt']) elif type( key[0]).__name__ == 'tuple': # edge keys are packed tuples geom = ogr.Geometry(ogr.wkbLineString) _from, _to = key[0], key[1] try: geom.SetPoint(0, *_from) geom.SetPoint(1, *_to) except TypeError: # assume user used tuple of int and choked ogr _ffrom = [float(x) for x in _from] _fto = [float(x) for x in _to] geom.SetPoint(0, *_ffrom) geom.SetPoint(1, *_fto) else: geom = ogr.Geometry(ogr.wkbPoint) try: geom.SetPoint(0, *key) except TypeError: # assume user used tuple of int and choked ogr fkey = [float(x) for x in key] geom.SetPoint(0, *fkey) return geom
def save(polygones, name, epsg): driver = ogr.GetDriverByName('Esri Shapefile') ds = driver.CreateDataSource(name) srs = ogr.osr.SpatialReference() srs.ImportFromEPSG(epsg) geom = polygones[(0, 0)] # (0, 0) object is presented always if geom.geom_type == 'Polygon': geom_type = ogr.wkbPolygon elif geom.geom_type == 'LineString': geom_type = ogr.wkbLineString else: raise NotImplementedError("Unknown geometry type %s" % (geom.geom_type, )) layer = ds.CreateLayer('', srs, geom_type) layer.CreateField(ogr.FieldDefn('col', ogr.OFTInteger)) layer.CreateField(ogr.FieldDefn('row', ogr.OFTInteger)) defn = layer.GetLayerDefn() for (col, row), poly in polygones.items(): feat = ogr.Feature(defn) feat.SetField('col', col) feat.SetField('row', row) geom = ogr.CreateGeometryFromWkb(poly.wkb) feat.SetGeometry(geom) layer.CreateFeature(feat) feat = geom = None ds = layer = feat = geom = None
def area(self, a): if len(a.tags) == 0: return if not closed_way_is_polygon(a.tags): return osm_id = a.orig_id() if a.from_way() else -a.orig_id() try: multipolygon = None for theme in self.mapping.themes: if theme.matches(GeomType.POLYGON, a.tags): if not multipolygon: wkb = fab.create_multipolygon(a) if self.clipping_geom: sg = loads(bytes.fromhex(wkb)) if not self.prepared_clipping_geom.intersects(sg): return if not self.prepared_clipping_geom.contains_properly( sg): sg = self.clipping_geom.intersection(sg) multipolygon = ogr.CreateGeometryFromWkb(dumps(sg)) else: multipolygon = create_geom(wkb) for output in self.outputs: output.write(osm_id, theme.name, GeomType.POLYGON, multipolygon, a.tags) except RuntimeError: print('Invalid area: {0}'.format(a.orig_id()))
def ogr_db2_hack_3(): if ogr.SetGenerate_DB2_V72_BYTE_ORDER(1) != 0: return 'skip' wkt = 'MULTIPOLYGON (((10.00121344 2.99853145,10.00121344 1.99853145,11.00121343 1.99853148,11.00121343 2.99853148)),((10.00121344 2.99853145,10.00121344 3.99853145,9.00121345 3.99853143,9.00121345 2.99853143)))' geom = ogr.CreateGeometryFromWkt(wkt) wkb = geom.ExportToWkb() geom.Destroy() # Check primary byte order value. if wkb.decode('latin1')[0] != '0' and wkb.decode('latin1')[0] != '1': gdaltest.post_reason('corrupt primary geometry byte order') return 'fail' # Check component geometry byte order if wkb.decode('latin1')[9] != '0' and wkb.decode('latin1')[9] != '1': gdaltest.post_reason('corrupt sub-geometry byte order') return 'fail' geom = ogr.CreateGeometryFromWkb(wkb) if geom.ExportToWkt() != wkt: gdaltest.post_reason( 'Convertion to/from DB2 format seems to have corrupted geometry.') return 'fail' geom.Destroy() ogr.SetGenerate_DB2_V72_BYTE_ORDER(0) return 'success'
def save_shapefile(self, path, name, geom_wkb_dict, gtype=ogr.wkbMultiPolygon): """ Save a collection of geometries to a shapefile in [path]. :param geom_wkb_dict: dict (key, value) = (identifier, wkb (binary string))""" os.popen("mkdir -p {}".format(path)) # Now convert it to a shapefile with OGR driver = ogr.GetDriverByName('Esri Shapefile') ds = driver.CreateDataSource(os.path.join(path, '{}.shp'.format(name))) layer = ds.CreateLayer('', None, gtype) # Add one attribute layer.CreateField(ogr.FieldDefn('id', ogr.OFTInteger)) defn = layer.GetLayerDefn() for key, wkb in geom_wkb_dict.iteritems(): # Create a new feature (attribute and geometry) feat = ogr.Feature(defn) feat.SetField('id', 123) # Make a geometry, from Shapely object geom = ogr.CreateGeometryFromWkb(wkb) feat.SetGeometry(geom) layer.CreateFeature(feat) feat = geom = None # destroy these # Save and close everything ds = layer = feat = geom = None
def write_polylines(poly, out_file): """Write polyline shapefile to file path. :param poly: input polyline :type poly: shapely polyline object :param out_file: file path to restore polyline :type out_file: str """ driver = ogr.GetDriverByName("Esri Shapefile") ds = driver.CreateDataSource(out_file) layer = ds.CreateLayer("", None, ogr.wkbLineString) # Add one attribute layer.CreateField(ogr.FieldDefn("id", ogr.OFTInteger)) defn = layer.GetLayerDefn() # Create a new feature (attribute and geometry) feat = ogr.Feature(defn) feat.SetField("id", 1) # Make a geometry, from Shapely object geom = ogr.CreateGeometryFromWkb(poly.wkb) feat.SetGeometry(geom) layer.CreateFeature(feat) # Save and close everything ds = layer = feat = geom = None
def clip(in_lyr, clip_lyr=None, clip_feat=None, outName=None): import ogr import os if clip_lyr is None and clip_feat is None: print('No clip layer or clip feature defined. Exiting') return out_ds = ogr.GetDriverByName('Memory').CreateDataSource('mem') out_lyr = out_ds.CreateLayer('') clipper = ogr.GetDriverByName('Memory').CreateDataSource('mem') clipper_lyr = clipper.CreateLayer('') defn = clipper_lyr.GetLayerDefn() out_feat = ogr.Feature(defn) if clip_feat is None: clip_feat = clip_lyr.GetNextFeature() clip_geom = clip_feat.geometry().Clone() clip_geom_Wkb = ogr.CreateGeometryFromWkb(clip_geom.ExportToWkb()) out_feat.SetGeometry(clip_geom_Wkb) clipper_lyr.CreateFeature(out_feat) ogr.Layer.Clip(in_lyr, clipper_lyr, out_lyr) if outName is not None: write_vector(out_ds, outName, srs=get_srs_vec(in_lyr)) return out_ds
def makeValidByOGR(gdf, verbose=False): '''Returns a copy of the geodataframe (or list thereof) passed through ogr MakeValid Requires geopandas, shapely, ogr ''' unlist = False if type(gdf) != list: gdf = [gdf] unlist = True ret = [] for i, g in enumerate(gdf): if verbose: t_start = time.time() gb = g.copy(deep=True) indb_invalid = ~gb.geometry.is_valid gb.geometry.loc[indb_invalid] = [ shapely.wkb.loads( ogr.CreateGeometryFromWkb(g.to_wkb()).MakeValid(). RemoveLowerDimensionSubGeoms().ExportToWkb()) for g in gb.geometry.loc[indb_invalid] ] ret.append(gb) if verbose: print( f'GDF at index {i} corrected {sum(indb_invalid)} invalid geometries in {time.strftime("%H:%M:%S",time.gmtime(time.time()-t_start))}' ) if unlist: ret = ret[0] return ret
def get_geometry(self, row): x, y = self.geo_vals(row) if self.type == 'point': geometry = ogr.Geometry(ogr.wkbPoint) geometry.SetPoint_2D(0, x, y) elif self.geo_col_names[0].lower() == 'geometry': geometry = ogr.CreateGeometryFromWkt(x) elif self.geo_col_names[0] == 'wkt': geometry = ogr.CreateGeometryFromWkt(x) elif self.geo_col_names[0] == 'wkb': geometry = ogr.CreateGeometryFromWkb(x) else: raise Exception("Didn't find geometry column") if geometry: if not geometry.TransformTo(self.srs): raise Exception("Failed to transform Geometry") else: raise Exception("Didn't get a geometry object for name {}".format( self.geo_col_names[0])) return geometry
def convert_polygons_2_shp(shape_polygon, shape_file, template_file=None): template_handle = rasterio.open(template_file) metadata = template_handle.meta.copy() metadata.update(compress='lzw') driver = ogr.GetDriverByName('Esri Shapefile') ds = driver.CreateDataSource(shape_file) if shape_polygon.type == 'MultiPolygon': layer = ds.CreateLayer('', None, ogr.wkbMultiPolygon) elif shape_polygon.type == 'Polygon': layer = ds.CreateLayer('', None, ogr.wkbPolygon) else: raise IOError('Shape type not implemented yet') defn = layer.GetLayerDefn() feat = ogr.Feature(defn) # Make a geometry, from Shapely object geom = ogr.CreateGeometryFromWkb(shape_polygon.wkb) feat.SetGeometry(geom) layer.CreateFeature(feat) feat = geom = None # destroy these # Save and close everything ds = layer = feat = geom = None
def _postproc_feature(feature, kept_features, srs_transform=None, roi=None, allow_outlying=False, clip_outlying=False): if isinstance(feature["geometry"], dict): assert feature["geometry"]["type"] in ["Polygon", "MultiPolygon"], \ f"unhandled raw geometry type: {feature['geometry']['type']}" if feature["geometry"]["type"] == "Polygon": coords = feature["geometry"]["coordinates"] assert isinstance(coords, list), "unexpected poly coords type" assert len(coords) == 1, "unexpected coords embedding; should be list-of-list-of-points w/ unique ring" assert all([isinstance(c, list) and len(c) == 2 for c in coords[0]]) and len(coords[0]) >= 4, \ "unexpected poly coord format" poly = shapely.geometry.Polygon(coords[0]) if srs_transform is not None: ogr_geometry = ogr.CreateGeometryFromWkb(poly.wkb) ogr_geometry.Transform(srs_transform) poly = shapely.wkt.loads(ogr_geometry.ExportToWkt()) feature["geometry"] = poly feature["type"] = "Polygon" elif feature["geometry"]["type"] == "MultiPolygon": multipoly = shapely.geometry.shape(feature["geometry"]) assert multipoly.is_valid, "found invalid input multipolygon" if srs_transform is not None: ogr_geometry = ogr.CreateGeometryFromWkb(multipoly.wkb) ogr_geometry.Transform(srs_transform) multipoly = shapely.wkt.loads(ogr_geometry.ExportToWkt()) feature["geometry"] = multipoly feature["type"] = "MultiPolygon" assert isinstance(feature["geometry"], (shapely.geometry.polygon.Polygon, shapely.geometry.multipolygon.MultiPolygon)) bounds = feature["geometry"].bounds feature["tl"] = bounds[0:2] feature["br"] = bounds[2:4] feature["clipped"] = False feature["centroid"] = feature["geometry"].centroid if roi is None: kept_features.append(feature) else: if (allow_outlying and roi.intersects(feature["geometry"])) or \ (not allow_outlying and roi.contains(feature["geometry"])): if clip_outlying: if not roi.contains(feature["geometry"]): feature["clipped"] = True feature["geometry"] = roi.intersection(feature["geometry"]) assert feature["geometry"].type in ["Polygon", "MultiPolygon"], \ f"unhandled intersection geometry type: {feature['geometry'].type}" feature["type"] = feature["geometry"].type kept_features.append(feature)
def readGeometry(self, geometry): self.list = [] wkb = geometry.asWkb() geom = ogr.CreateGeometryFromWkb(wkb) geomCount = geom.GetPointCount() for pointIdx in range(geomCount): point = geom.GetPoint(pointIdx) self.addPoint(point)
def __call__(self, geom): try: geom2 = self.geom0.intersection(geom) except: import pdb; pdb.set_trace() if geom2 is None: import pdb; pdb.set_trace() geomx = ogr.CreateGeometryFromWkb(geom2.wkb) return geomx
def max_range_linemerge_io(input_filename, input_layername, output_drivername, output_filename, output_layername, merge_attribute, max_range, group_by: Union[str, Iterable] = None): # input in_ds = ogr.Open(input_filename) in_layer = in_ds.GetLayerByName(input_layername) geometry_groups = dict() value_groups = dict() if group_by: groups = tuple(distinct(in_layer, group_by)) else: groups = tuple('DUMMY_GROUP_9876543210') print(f'groups: {groups}') for group in groups: geometry_groups[group] = [] value_groups[group] = [] for feat in in_layer: ogr_geom = feat.GetGeometryRef() wkb_geom = ogr_geom.ExportToWkb() feat_group = tuple( [feat[group_by_field] for group_by_field in group_by]) geometry_groups[feat_group].append(wkb.loads(wkb_geom)) value_groups[feat_group].append(feat[merge_attribute]) # output out_driver = ogr.GetDriverByName(output_drivername) out_ds = out_driver.CreateDataSource(output_filename) srs = in_layer.GetSpatialRef() out_layer = out_ds.CreateLayer(output_layername, srs=srs, geom_type=ogr.wkbLineString) merge_field_defn = ogr.FieldDefn(merge_attribute, ogr.OFTReal) out_layer.CreateField(merge_field_defn) if group_by: for field in in_layer.schema: if field.name in group_by: out_layer.CreateField(field) # write results to output out_layer_defn = out_layer.GetLayerDefn() for group in groups: for geom, val in max_range_linemerge(geometry_groups[group], value_groups[group], max_range): out_feat = ogr.Feature(out_layer_defn) out_geom = ogr.CreateGeometryFromWkb(geom.wkb) out_feat.SetGeometry(out_geom) out_feat[merge_attribute] = val if group_by: for i, group_by_fieldname in enumerate(group_by): out_feat[group_by_fieldname] = group[i] out_layer.CreateFeature(out_feat) out_feat = None
def _create_base_map(self, ): ''' Deal with different types way to define the AOI, if none is specified, then the image bound is used. ''' if self.aoi is not None: if os.path.exists(self.aoi): try: g = gdal.Open(self.aoi) subprocess.call([ 'gdaltindex', '-f', 'GeoJSON', self.toa_dir + '/AOI.json', self.aoi ]) except: try: g = ogr.Open(self.aoi) except: raise IOError( 'AOI file cannot be opened by gdal, please check it or transform into format can be opened by gdal' ) else: try: g = ogr.CreateGeometryFromJson(aoi) except: try: g = ogr.CreateGeometryFromGML(aoi) except: try: g = ogr.CreateGeometryFromWkt(aoi) except: try: g = ogr.CreateGeometryFromWkb(aoi) except: raise IOError( 'The AOI has to be one of GeoJSON, GML, Wkt or Wkb.' ) gjson_str = '''{"type":"FeatureCollection","features":[{"type":"Feature","properties":{},"geometry":%s}]}''' % g.ExportToJson( ) with open(self.toa_dir + '/AOI.json', 'wb') as f: f.write(gjson_str) if not os.path.exists(self.toa_dir + '/AOI.json'): subprocess.call([ 'gdaltindex', '-f', 'GeoJSON', self.toa_dir + '/AOI.json', self.toa_bands[0] ]) self.logger.warning( 'AOI is not created and full band extend is used') self.aoi = self.toa_dir + '/AOI.json' else: self.aoi = self.toa_dir + '/AOI.json' if self.pixel_res is None: self.pixel_res = abs( gdal.Open(self.toa_bands[0]).GetGeoTransform()[1]) self.psf_xstd = 260 / self.pixel_res self.psf_ystd = 340 / self.pixel_res
def coords_to_geovector(coords, epsg, path_export): """ Exports coordinates to a Point shapefile. Parameters ---------- coords : list-like of list-likes List or tuple of (x, y) coordinates to export. epsg : int EPSG code of the coordinate reference system of the coordinates. path_export : str Path with .shp extension where the shapefile should be saved. Returns ------- None. """ # TODO: This should be replaced by a geodataframe creation, but no use cases # yet... all_coords = [] for c in coords: pt = ogr.Geometry(type=ogr.wkbPoint) pt.AddPoint_2D(c[1], c[0]) all_coords.append(pt) # Write the shapefile driver = ogr.GetDriverByName('ESRI Shapefile') datasource = driver.CreateDataSource(path_export) srs = osr.SpatialReference() srs.ImportFromEPSG(epsg) layer = datasource.CreateLayer("Coords", srs, ogr.wkbPoint) defn = layer.GetLayerDefn() idField = ogr.FieldDefn('id', ogr.OFTInteger) layer.CreateField(idField) for i, p in enumerate(all_coords): # Create a new feature (attribute and geometry) feat = ogr.Feature(defn) feat.SetField('id', int(i)) # Make a geometry geom = ogr.CreateGeometryFromWkb(p.ExportToWkb()) feat.SetGeometry(geom) layer.CreateFeature(feat) feat = geom = None # destroy these # Save and close everything datasource = layer = feat = geom = None
def process( self, args, writeback=False ): """ get dataset handle and geolocation metadata """ # open image file image = self.openImageFile( args.image_pathname ) data = image[ 'band' ].ReadAsArray() # create output shapefile centroids = self.createOutputFile( args.out_pathname, image ) # generate threshold image idx = data > args.threshold mask = np.zeros_like( data ) mask[ idx ] = 1 # grab kernel and apply open operation kernel = cv2.getStructuringElement( cv2.MORPH_RECT, (5,5) ) mask_open = cv2.morphologyEx( mask, cv2.MORPH_OPEN, kernel, iterations=args.iterations ) # writeback if writeback: data[ np.where ( mask_open == 1 ) ] = 0 plt.imshow( data, cmap='Greys' ) plt.show() # label blob map labels = label( mask_open ) for idx in range( 1, np.amax( labels ) + 1 ): # find location of blob with current label coords = np.where( labels == idx ) if len ( coords[ 0 ] ) < self._maxBlobSize: # create shapely point object img_x = np.mean( coords[ 1 ] ) img_y = np.mean( coords[ 0 ] ) # compute geo coordinates geo_x = ( img_x * image[ 'transform' ][ 1 ] ) + image[ 'transform' ][ 0 ] geo_y = ( img_y * image[ 'transform' ][ 5 ] ) + image[ 'transform' ][ 3 ] # create new feature (attribute and geometry) feature = ogr.Feature( centroids[ 'defn' ] ) feature.SetField( 'id', idx ) # create geometry from shapely object geom = ogr.CreateGeometryFromWkb( Point( geo_x, geo_y ).to_wkb() ) feature.SetGeometry(geom) centroids[ 'layer' ].CreateFeature( feature ) return
def transform_geometry(geom, src_epsg=4326, dst_epsg=3395): """Transform a single wkb geometry :param geom: wkb geom :param src_epsg: EPSG code for the source geometry :param dst_epsg: EPSG code for the destination geometry """ ogr_geom = ogr.CreateGeometryFromWkb(geom) ogr_transformation = create_transform(src_epsg, dst_epsg) ogr_geom.Transform(ogr_transformation) return ogr_geom.ExportToWkb()
def fromGeometry(geometry): instance = QgsPolylineV2() wkb = geometry.asWkb() geom = ogr.CreateGeometryFromWkb(wkb) geomCount = geom.GetPointCount() for pointIdx in range(geomCount): point = geom.GetPoint(pointIdx) instance.addPoint(point) return instance
def nodes_to_shapefile(nodes, dims, gt, epsg, outpath): # Create point objects to write to shapefile if 'id' not in nodes.keys(): ids = list(range(0, len(nodes['idx']))) else: ids = nodes['id'] all_nodes = [] for node in nodes['idx']: pt = ogr.Geometry(type=ogr.wkbPoint) xy = np.unravel_index(node, dims) ll = gu.xy_to_coords(xy[1] + .5, xy[0] + .5, gt, inputEPSG=epsg, outputEPSG=epsg)[0] pt.AddPoint_2D(ll[1], ll[0]) all_nodes.append(pt) # Write the shapefile driver = ogr.GetDriverByName('ESRI Shapefile') datasource = driver.CreateDataSource(outpath) srs = osr.SpatialReference() srs.ImportFromEPSG(epsg) layer = datasource.CreateLayer("Nodes", srs, ogr.wkbPoint) defn = layer.GetLayerDefn() idField = ogr.FieldDefn('id', ogr.OFTInteger) connField = ogr.FieldDefn('conn', ogr.OFTString) layer.CreateField(idField) layer.CreateField(connField) for p, i in zip(all_nodes, ids): # Create a new feature (attribute and geometry) feat = ogr.Feature(defn) feat.SetField('id', int(i)) fieldstr = str(nodes['conn'][nodes['id'].index(i)]) fieldstr = fieldstr[1:-1] feat.SetField('conn', fieldstr) # Make a geometry geom = ogr.CreateGeometryFromWkb(p.ExportToWkb()) feat.SetGeometry(geom) layer.CreateFeature(feat) feat = geom = None # destroy these # Save and close everything datasource = layer = feat = geom = None
def reproject_vector(in_vector, target_srs, out_fp='mem', driver="MEMORY"): ''' Reproject a vector file from one projection to another :param in_vector: string or ogr.DataSource - path to source ds or ds :param target_srs: osr.SpatialReference - SRS to project to :param out_fp: optional, str - output filepath :param driver: ogr.Driver - driver to be used for output :return: ogr.DataSource if driver is MEMORY or None and file written to disk ''' import ogr, osr # open file to reproject if isinstance(in_vector, str): in_vector = ogr.Open(in_vector) in_layer = in_vector.GetLayer() # set spatial reference and transformation in_srs = in_layer.GetSpatialRef() if isinstance(target_srs, int): target_srs = create_srs(target_srs) transform = osr.CoordinateTransformation(in_srs, target_srs) # create layer to copy information into driver = ogr.GetDriverByName(driver) out_ds = driver.CreateDataSource(out_fp) # checks which geometry type we're looking at automatically layer.GetLayerDefn().GetGeomType() out_layer = out_ds.CreateLayer('', target_srs, in_layer.GetLayerDefn().GetGeomType()) in_feat = in_layer.GetFeature(0) # create same fields as in input for i in range(in_feat.GetFieldCount()): out_layer.CreateField(in_feat.GetFieldDefnRef(i)) # apply transformation for i, in_feat in enumerate(in_layer): transformed = in_feat.GetGeometryRef() transformed.Transform(transform) geom = ogr.CreateGeometryFromWkb(transformed.ExportToWkb()) defn = out_layer.GetLayerDefn() out_feat = ogr.Feature(defn) out_feat.SetGeometry(geom) # write information to fields for i in range(in_feat.GetFieldCount()): value = in_feat.GetField(i) out_feat.SetField(i, value) out_layer.CreateFeature(out_feat) out_feat = None if driver.GetDescription() == 'Memory': return out_ds del out_ds
def write_vector(in_data, out_fp, driver="ESRI Shapefile", srs=None): import ogr out_ds = create_vector(out_fp, driver) if out_ds is None: print("Could not create file. Check if file exists and is in use.") return if srs is not None: if isinstance(srs, int): srs = create_srs(srs) else: srs = get_srs_vec(in_data) # create layer, layer definition if isinstance(in_data, ogr.DataSource): in_lyr = in_data.GetLayer() else: in_lyr = in_data geomType = in_lyr.GetGeomType() # or in_data.GetLayerDefn().GetGeomType() out_lyr = out_ds.CreateLayer('', srs, geomType) # create/copy fiels from input in_feat = in_lyr.GetFeature(0) for i in range(in_feat.GetFieldCount()): out_lyr.CreateField(in_feat.GetFieldDefnRef(i)) defn = out_lyr.GetLayerDefn() for i in range(in_lyr.GetFeatureCount()): in_feat = in_lyr.GetFeature(i) out_feat = ogr.Feature(defn) for i in range(in_feat.GetFieldCount()): value = in_feat.GetField(i) out_feat.SetField(i, value) geometry = in_feat.geometry().Clone() featureWkb = geometry.ExportToWkb() geometry = ogr.CreateGeometryFromWkb(featureWkb) out_feat.SetGeometry(geometry) out_lyr.CreateFeature(out_feat) #experimental change: #for feature in in_lyr: # attribs = feature.items() # out_feat = ogr.Feature(defn) # for i, value in enumerate(attribs.values()): # out_feat.SetField(i, value) # geometry = in_feat.geometry().Clone() # featureWkb = geometry.ExportToWkb() # geometry = ogr.CreateGeometryFromWkb(featureWkb) # out_feat.SetGeometry(geometry) # out_lyr.CreateFeature(out_feat) out_feat = geometry = None # destroy stuff out_ds = out_lyr = out_feat = geometry = None # Save and close
def addPolygon(simplePolygon, dst_layer, index): featureDefn = dst_layer.GetLayerDefn() polygon = ogr.CreateGeometryFromWkb(simplePolygon) dst_feat = ogr.Feature(featureDefn) dst_feat.SetGeometry(polygon) geom = dst_feat.GetGeometryRef() dst_feat.SetField('id', index) dst_feat.SetField('area', geom.Area()) dst_layer.CreateFeature(dst_feat) dst_layer.SyncToDisk()
def append_poly(feat, props, srs_transform=None): if feat.is_empty: return elif feat.type == "Polygon": if srs_transform is not None: ogr_geometry = ogr.CreateGeometryFromWkb(feat.wkb) ogr_geometry.Transform(srs_transform) feat = shapely.wkt.loads(ogr_geometry.ExportToWkt()) output_features.append((geojson.Feature(geometry=feat, properties=props), feat)) elif feat.type == "MultiPolygon" or feat.type == "GeometryCollection": for f in feat: append_poly(f, props)
def snapToDtm(self): player = self.edit3d_pointlayerbox.currentLayer() llayer = self.edit3d_linelayerbox.currentLayer() rlayer = self.edit3d_dtmlayerbox.currentLayer() llayer.startEditing() points = list(player.getFeatures()) pointid = self.edit3d_currPointId.value() if points: point = points[pointid] pointGeom = point.geometry() if pointGeom.asMultiPoint(): pointGeom = pointGeom.asMultiPoint()[0] else: pointGeom = pointGeom.asPoint() pid, feat = closestpoint(llayer, QgsGeometry.fromPoint(pointGeom)) linegeom = feat.geometry().asWkb().data() olinegeom = ogr.CreateGeometryFromWkb(linegeom) dx = rlayer.rasterUnitsPerPixelX() dy = rlayer.rasterUnitsPerPixelY() xpos = pointGeom.x() ypos = pointGeom.y() # assume pixel = center xll = rlayer.extent().xMinimum() + 0.5 * dx yll = rlayer.extent().yMinimum() + 0.5 * dy xoffs = (pointGeom.x() - xll) % dx yoffs = (pointGeom.y() - yll) % dy dtm_val_ll = rlayer.dataProvider().identify( QgsPoint(xpos - dx / 2, ypos - dy / 2), QgsRaster.IdentifyFormatValue).results()[1] dtm_val_ur = rlayer.dataProvider().identify( QgsPoint(xpos + dx / 2, ypos + dy / 2), QgsRaster.IdentifyFormatValue).results()[1] dtm_val_lr = rlayer.dataProvider().identify( QgsPoint(xpos + dx / 2, ypos - dy / 2), QgsRaster.IdentifyFormatValue).results()[1] dtm_val_ul = rlayer.dataProvider().identify( QgsPoint(xpos - dx / 2, ypos + dy / 2), QgsRaster.IdentifyFormatValue).results()[1] a00 = dtm_val_ll a10 = dtm_val_lr - dtm_val_ll a01 = dtm_val_ul - dtm_val_ll a11 = dtm_val_ur + dtm_val_ll - (dtm_val_lr + dtm_val_ul) dtm_bilinear = a00 + a10 * xoffs + a01 * yoffs + a11 * xoffs * yoffs x, y = olinegeom.GetPoint_2D(pid) olinegeom.SetPoint(pid, x, y, dtm_bilinear) llayer.beginEditCommand("Snap point height to DTM") updatedGeom = QgsGeometry() updatedGeom.fromWkb(olinegeom.ExportToWkb()) llayer.dataProvider().changeGeometryValues( {feat.id(): updatedGeom}) llayer.endEditCommand() # refresh vertex editor self.showProblemPoint()
def linkshp_exp(self): try: # 입력파일 검증 if os.path.exists(self._cc._LINK_SHP_FILE_PATH) == False: print(self._cc._LINK_SHP_FILE_PATH + ' 파일이 없습니다.') return -1 self._logger.info("load link shp") link_shp = gpd.read_file(self._cc._LINK_SHP_FILE_PATH) link_shp.crs = {'init': 'epsg:4326'} self._logger.info("load link_dust info") dust_link = pd.read_csv(self._cc._DUST_LINK_TXT_FILE_PATH, sep=',', engine='python', usecols=['LINK_ID', 'CAI_VAL', 'CMID' ]) #'UV', 'PM10', 'PM2_5', 'CAI', self._logger.info("load all") link_shp['LINK_ID'] = link_shp['LINK_ID'].astype(np.int64) link_dust_line = pd.merge(link_shp, dust_link, how='inner', on='LINK_ID') self._logger.info("make link shape by ogr") drv = ogr.GetDriverByName('ESRI Shapefile') ds = drv.CreateDataSource(self._cc._DUST_LINK_LINE_FILE_PATH) lyr = ds.CreateLayer('myshp', geom_type=ogr.wkbLineString) fieldDef = ogr.FieldDefn('LINK_ID', ogr.OFTInteger64) lyr.CreateField(fieldDef) fieldDef = ogr.FieldDefn('CAI_VAL', ogr.OFTInteger) lyr.CreateField(fieldDef) fieldDef = ogr.FieldDefn('CMID', ogr.OFTString) lyr.CreateField(fieldDef) for index, item in link_dust_line.iterrows(): feat = ogr.Feature(lyr.GetLayerDefn()) feat.SetField('LINK_ID', item['LINK_ID']) feat.SetField('CAI_VAL', item['CAI_VAL']) feat.SetField('CMID', item['CMID']) #pt = ogr.CreateGeometryFromWkt(item['geometry']) line = ogr.CreateGeometryFromWkb(item['geometry'].to_wkb()) feat.SetGeometry(line) lyr.CreateFeature(feat) feat = None self._logger.info("complete to make link shape by ogr") except KeyboardInterrupt: print('\n\rquit')
def project(geom, from_epsg=900913, to_epsg=4326): # source: http://hackmap.blogspot.com/2008/03/ogr-python-projection.html to_srs = ogr.osr.SpatialReference() to_srs.ImportFromEPSG(to_epsg) from_srs = ogr.osr.SpatialReference() from_srs.ImportFromEPSG(from_epsg) ogr_geom = ogr.CreateGeometryFromWkb(geom.wkb) ogr_geom.AssignSpatialReference(from_srs) ogr_geom.TransformTo(to_srs) return loads(ogr_geom.ExportToWkb())
def meshlines_to_shapefile(lines, EPSG, outpath, nameid=None): """ Given meshlines (output by RivMesh), ouput a shapefile. """ # Create line objects to write to shapefile all_lines = [] for l in lines: line = ogr.Geometry(type=ogr.wkbLineString) line.AddPoint_2D(l[0][0], l[0][1]) line.AddPoint_2D(l[1][0], l[1][1]) all_lines.append(line) # Write the shapefile driver = ogr.GetDriverByName('ESRI Shapefile') datasource = driver.CreateDataSource(outpath) srs = osr.SpatialReference() srs.ImportFromEPSG(EPSG) layer = datasource.CreateLayer("meshlines", srs, ogr.wkbLineString) defn = layer.GetLayerDefn() idField = ogr.FieldDefn('id', ogr.OFTInteger) layer.CreateField(idField) if nameid is not None: nameField = ogr.FieldDefn('River_Name', ogr.OFTString) layer.CreateField(nameField) for i, p in enumerate(all_lines): # Create a new feature (attribute and geometry) feat = ogr.Feature(defn) feat.SetField('id', int(i)) # Set upstream and downstream node attributes if nameid is not None: fieldstr = str(nameid) feat.SetField('River_Name', fieldstr) # Make a geometry geom = ogr.CreateGeometryFromWkb(p.ExportToWkb()) feat.SetGeometry(geom) layer.CreateFeature(feat) feat = geom = None # destroy these # Save and close everything datasource = layer = feat = geom = None