def test_polygonize_4():
src_ds = gdal.Open('data/polygonize_in.grd')
src_band = src_ds.GetRasterBand(1)
# Create a memory OGR datasource to put results in.
mem_drv = ogr.GetDriverByName('Memory')
mem_ds = mem_drv.CreateDataSource('out')
mem_layer = mem_ds.CreateLayer('poly', None, ogr.wkbPolygon)
fd = ogr.FieldDefn('DN', ogr.OFTInteger)
mem_layer.CreateField(fd)
# run the algorithm.
result = gdal.Polygonize(src_band, None, mem_layer, 0, ["8CONNECTED=8"])
assert result == 0, 'Polygonize failed'
# Confirm we get the set of expected features in the output layer.
expected_feature_number = 16
assert mem_layer.GetFeatureCount() == expected_feature_number
expect = [
107, 123, 132, 115, 132, 115, 140, 148, 123, 140, 132, 156, 100, 101,
102, 103
]
tr = ogrtest.check_features_against_list(mem_layer, 'DN', expect)
assert tr
def mask2json(mask):
memdrv = gdal.GetDriverByName('MEM')
src_ds = memdrv.Create('', mask.shape[1], mask.shape[0], 1)
geom = [0.0, 1.0, 0.0, 0.0, 0.0, 1.0]
src_ds.SetGeoTransform(geom)
band = src_ds.GetRasterBand(1)
band.WriteArray(mask)
dst_layername = "results"
drv = ogr.GetDriverByName("geojson")
dst_ds = drv.CreateDataSource('results.json')
dst_layer = dst_ds.CreateLayer(dst_layername, srs=None)
fieldName = 'class_id'
fd = ogr.FieldDefn(fieldName, ogr.OFTInteger)
dst_layer.CreateField(fd)
dst_field = 0
gdal.Polygonize(band, None, dst_layer, dst_field, [], callback=None)
dst_ds.Destroy()
logging.info(f'results.json已保存')
with open('results.json', 'r') as f:
res = f.read()
res = json.loads(res)
features = res.get('features')
res['features'] = list(map(adjust_json, features))
logging.info(res)
return json.dumps(res, ensure_ascii=False)
def raster2shp(classifiy_raster, output_dir, bkg_value=0):
ds = gdal.Open(classifiy_raster, gdal.GA_ReadOnly)
srcband = ds.GetRasterBand(1)
maskband = srcband.GetMaskBand()
out_shp = os.path.join(output_dir, f'{Path(classifiy_raster).stem}.shp')
drv = ogr.GetDriverByName('ESRI Shapefile')
dst_ds = drv.CreateDataSource(out_shp)
dst_srs = osr.SpatialReference()
dst_srs.ImportFromWkt(ds.GetProjection())
dst_layername = 'out'
dst_layer = dst_ds.CreateLayer(dst_layername, srs=dst_srs)
dst_fieldname = 'Category'
fd = ogr.FieldDefn(dst_fieldname, ogr.OFTInteger)
dst_layer.CreateField(fd)
dst_field = 0
options = []
# 参数：输入栅格图像波段、掩码图像波段、矢量化后的矢量图层、需要将值写入属性字段的索引,比如Category索引为0、算法选项、进度条回调函数、进度条参数
gdal.Polygonize(srcband, maskband, dst_layer, dst_field, options)
ds = None
# Remove backgroud value from converted shapefile
pFeaturelayer = dst_ds.GetLayer(0)
strFilter = f"Category = '{bkg_value}'"
pFeaturelayer.SetAttributeFilter(strFilter)
for pFeature in pFeaturelayer:
pFeatureFID = pFeature.GetFID()
pFeaturelayer.DeleteFeature(int(pFeatureFID))
def polygonize(M, georef):
"""
Polygonize a mask.
Args:
M: a numpy 'mask' array.
georef: GDAL style georeference of mask.
Returns:
OGR datasource, OGR layer
"""
# TODO: supply srs
# polygonize an input Mask (bool or uint8 -todo, add more types)
dst_fieldname = 'DN'
# create a GDAL memory raster
mem_driver = gdal.GetDriverByName("MEM")
mask_ds = mem_driver.Create("dummy", int(M.shape[1]), int(M.shape[0]), 1,
gdal.GDT_Byte)
mask_ds.SetGeoTransform(georef)
mask_ds.GetRasterBand(1).WriteArray(M) # write zeros to output
# Ok - so now polygonize that - use the mask as ehem... mask...
m_drv = ogr.GetDriverByName("Memory")
ds = m_drv.CreateDataSource("dummy")
lyr = ds.CreateLayer("polys", None, ogr.wkbPolygon)
fd = ogr.FieldDefn(dst_fieldname, ogr.OFTInteger)
lyr.CreateField(fd)
dst_field = 0
gdal.Polygonize(mask_ds.GetRasterBand(1), mask_ds.GetRasterBand(1), lyr,
dst_field)
lyr.ResetReading()
return ds, lyr
def polygonize(img, shp_path):
# mapping between gdal type and ogr field type
type_mapping = {
gdal.GDT_Byte: ogr.OFTInteger,
gdal.GDT_UInt16: ogr.OFTInteger,
gdal.GDT_Int16: ogr.OFTInteger,
gdal.GDT_UInt32: ogr.OFTInteger,
gdal.GDT_Int32: ogr.OFTInteger,
gdal.GDT_Float32: ogr.OFTReal,
gdal.GDT_Float64: ogr.OFTReal,
gdal.GDT_CInt16: ogr.OFTInteger,
gdal.GDT_CInt32: ogr.OFTInteger,
gdal.GDT_CFloat32: ogr.OFTReal,
gdal.GDT_CFloat64: ogr.OFTReal,
}
tif = os.path.split(img)[1]
# print("reading {}...".format(tif))
ds = gdal.Open(img)
prj = ds.GetProjection()
srcband = ds.GetRasterBand(1)
# create shapefile datasource from geotiff file
shp = os.path.split(shp_path)[1]
print("creating {}...".format(shp))
dst_layername = "Shape"
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(shp_path)
srs = osr.SpatialReference(wkt=prj)
dst_layer = dst_ds.CreateLayer(dst_layername, srs=srs)
raster_field = ogr.FieldDefn("level", type_mapping[srcband.DataType])
dst_layer.CreateField(raster_field)
gdal.Polygonize(srcband, srcband, dst_layer, 0, [], callback=None)
def createGeoJSONFromRaster(geoJsonFileName,
array2d,
geom,
proj,
layerName="BuildingID",
fieldName="BuildingID"):
memdrv = gdal.GetDriverByName('MEM')
src_ds = memdrv.Create('', array2d.shape[1], array2d.shape[0], 1)
src_ds.SetGeoTransform(geom)
src_ds.SetProjection(proj)
band = src_ds.GetRasterBand(1)
band.WriteArray(array2d)
dst_layername = "BuildingID"
drv = ogr.GetDriverByName("geojson")
dst_ds = drv.CreateDataSource(geoJsonFileName)
dst_layer = dst_ds.CreateLayer(layerName, srs=None)
fd = ogr.FieldDefn(fieldName, ogr.OFTInteger)
dst_layer.CreateField(fd)
dst_field = 1
gdal.Polygonize(band, None, dst_layer, dst_field, [], callback=None)
return
def polygonize(shapepath, file, rasterpath):
srcarray,projection,geotrans, shape = GetRasterDataSource(file, rasterpath)
print "Start polygonizing.."
start = time.time()
srcarray[srcarray > 1] = 0 #we are interested in the class 1, we put everything else to 0
drv = gdal.GetDriverByName('MEM')
srs = osr.SpatialReference()
srs.ImportFromWkt(projection)
src_ds = drv.Create('', shape[1], shape[0], 1, gdal.GDT_UInt16)
src_ds.SetGeoTransform(geotrans)
src_ds.SetProjection(projection)
# gdal_array.BandWriteArray(src_ds.GetRasterBand(1), srcarray.T)
gdal_array.BandWriteArray(src_ds.GetRasterBand(1), srcarray)
srcband = src_ds.GetRasterBand(1)
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(shapepath + file + ".shp")
dst_layer = dst_ds.CreateLayer(shapepath + file, srs = srs)
new_field = ogr.FieldDefn("type", ogr.OFTInteger)
dst_layer.CreateField(new_field)
new_field = None
new_field = ogr.FieldDefn("area", ogr.OFTReal)
# new_field.SetWidth(32)
# new_field.SetPrecision(2) #added line to set precision (for floating point)
dst_layer.CreateField(new_field)
gdal.Polygonize(srcband, srcband, dst_layer, 0, [], callback = None )
print "Number of features detected: ", dst_layer.GetFeatureCount()
for feature in dst_layer:
geom = feature.GetGeometryRef()
area = geom.GetArea()
feature.SetField("area", area)
dst_layer.SetFeature(feature)
# Filter per size
if (geom.GetArea() < 1) or (geom.GetArea() > 100):
dst_layer.DeleteFeature(feature.GetFID())
dst_layer.SyncToDisk()
dst_ds.ExecuteSQL("REPACK " + file)
print "Number of features after deleting: ", dst_layer.GetFeatureCount()
dst_ds = None
print "*---------------------------*"
print "Shapefile correctly saved in: " + shapepath
end = time.time()
print "Time for polygonizing: "
print (end-start)
def boundary(self, file_name, array):
src_ds = gdal.Open(file_name + '_BDR.tif')
srcband = src_ds.GetRasterBand(1)
data = srcband.ReadAsArray()
data = data > 0
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(file_name + ".shp")
dst_layer = dst_ds.CreateLayer(file_name, srs=None)
gdal.Polygonize(srcband, data, dst_layer, -1, [], callback=None)
def rast2vect(self, rasterTexture, legend):
"convert raster to vector"
gdal.AllRegister()
options = []
# open the image
rasterTexture = str(rasterTexture)
srcRaster = gdal.Open(rasterTexture, GA_ReadOnly)
srcband = srcRaster.GetRasterBand(1)
spatialReference = osr.SpatialReference()
spatialReference.ImportFromWkt(srcRaster.GetProjectionRef())
# Create output file.
pathSource = os.path.dirname(rasterTexture)
fileName = os.path.splitext(os.path.basename(rasterTexture))[0]
driver = ogr.GetDriverByName('ESRI Shapefile')
dstPath = os.path.join(pathSource, fileName + ".shp")
dstFile = driver.CreateDataSource(dstPath)
if os.path.exists(dstPath) == False:
#Find or create destination layer.
dstLayer = dstFile.CreateLayer("layer", spatialReference)
#Create texture int code field from raster value
fieldDef = ogr.FieldDefn("code", ogr.OFTInteger)
dstLayer.CreateField(fieldDef)
dst_field = 0
#Polygonize
prog_func = gdal.TermProgress
result = gdal.Polygonize(srcband,
None,
dstLayer,
dst_field,
options,
callback=prog_func)
#Create texture label field
fieldLabel = ogr.FieldDefn('label_txt', ogr.OFTString)
fieldLabel.SetWidth(50)
dstLayer.CreateField(fieldLabel)
#fieldLabel = 1
codeList = [line.split("=") for line in legend[1:-1]]
codeDict = {int(v[0]): v[1] for (v) in codeList}
for i in range(dstLayer.GetFeatureCount()):
feature = dstLayer.GetFeature(i)
code = feature.GetField("code")
iIndex = feature.GetFieldIndex("label_txt")
feature.SetField(iIndex, str(codeDict[code]))
dstLayer.SetFeature(feature)
feature.Destroy()
dstFile.Destroy()
return dstPath
else:
self.textEdit.append(
"""<b>There is a file with the same output name.
Vector texture file will not be created. Only the raster texture
file will be processed file.<\b>""")
return 'None'
def raster2polygon(inRaster, outPoly):
src_ds = gdal.Open(inRaster)
srcband = src_ds.GetRasterBand(1)
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(outPoly + ".shp")
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
# create the layer
dst_layer = dst_ds.CreateLayer(outPoly, srs)
gdal.Polygonize(srcband, srcband, dst_layer, -1, [], callback=None)
def create_shp_from_mask(shp_fname, mask_fname):
# Create a shapefile from the mask that was just created
# Initialize the information for the shapefile
driver = ogr.GetDriverByName("ESRI Shapefile")
shape_file = driver.CreateDataSource(shp_fname + ".shp")
layer = shape_file.CreateLayer(shp_fname, srs=None)
# Open the mask and polygonize it into the specified shape file
mask = gdal.Open(mask_fname)
mask_band = mask.GetRasterBand(1)
gdal.Polygonize(mask_band, mask_band, layer, -1, [], callback=None)
def netcdf2boundary_mask(ncFile, geographic):
### Extract metadata
meta = nc2meta(ncFile)
cols = meta['cols']
rows = meta['rows']
proj = osr.SpatialReference()
proj.ImportFromEPSG(meta['epsg'])
geoTrans = \
(meta['minX'], meta['pixelSize'], 0, meta['maxY'], 0, -meta['pixelSize'])
### Reading time series
dataset = nc.Dataset(ncFile, 'r')
image = dataset.variables['image'][:]
dataset.close()
### Save in memory
data = image[0, :, :] / image[0, :, :]
image = None
gdalDriver = gdal.GetDriverByName('Mem')
outRaster = gdalDriver.Create('out', rows, cols, 1, gdal.GDT_Byte)
outRaster.SetGeoTransform(geoTrans)
outRaster.SetProjection(proj.ExportToWkt())
outBand = outRaster.GetRasterBand(1)
outBand.WriteArray(data)
inBand = None
data = None
### Polygonize the raster image
inBand = outRaster.GetRasterBand(1)
ogrDriver = ogr.GetDriverByName('Memory')
outVector = ogrDriver.CreateDataSource('out')
outLayer = outVector.CreateLayer('boundary', srs=proj)
fieldDefinition = ogr.FieldDefn('ID', ogr.OFTInteger)
outLayer.CreateField(fieldDefinition)
gdal.Polygonize(inBand, inBand, outLayer, 0, [], None)
outRaster = None
### Extract geometry from layer
inSpatialRef = outLayer.GetSpatialRef()
multipolygon = ogr.Geometry(ogr.wkbMultiPolygon)
for outFeature in outLayer:
geometry = outFeature.GetGeometryRef()
multipolygon.AddGeometry(geometry)
outFeature = None
outLayer = None
### Convert geometry from projected to geographic coordinates (if requested)
if geographic == True:
(multipolygon, outSpatialRef) = \
geometry_proj2geo(multipolygon, inSpatialRef)
return (multipolygon, outSpatialRef)
else:
return (multipolygon, inSpatialRef)
def geotiff2boundary_ext(inGeotiff, maskFile, geographic):
# Extract metadata
(spatialRef, gt, shape, pixel) = raster_meta(inGeotiff)
epsg = int(spatialRef.GetAttrValue('AUTHORITY', 1))
(data, colFirst, rowsFirst, geoTrans, proj) = \
geotiff2boundary_mask(inGeotiff, epsg, None)
(rows, cols) = data.shape
# Save in mask file (if defined)
if maskFile is not None:
gdalDriver = gdal.GetDriverByName('GTiff')
outRaster = gdalDriver.Create(maskFile, rows, cols, 1, gdal.GDT_Byte)
outRaster.SetGeoTransform(geoTrans)
outRaster.SetProjection(proj.ExportToWkt())
outBand = outRaster.GetRasterBand(1)
outBand.WriteArray(data)
outRaster = None
# Save in memory
gdalDriver = gdal.GetDriverByName('Mem')
outRaster = gdalDriver.Create('out', rows, cols, 1, gdal.GDT_Byte)
outRaster.SetGeoTransform(geoTrans)
outRaster.SetProjection(proj.ExportToWkt())
outBand = outRaster.GetRasterBand(1)
outBand.WriteArray(data)
data = None
# Polygonize the raster image
inBand = outRaster.GetRasterBand(1)
ogrDriver = ogr.GetDriverByName('Memory')
outVector = ogrDriver.CreateDataSource('out')
outLayer = outVector.CreateLayer('boundary', srs=proj)
fieldDefinition = ogr.FieldDefn('ID', ogr.OFTInteger)
outLayer.CreateField(fieldDefinition)
gdal.Polygonize(inBand, inBand, outLayer, 0, [], None)
outRaster = None
# Extract geometry from layer
inSpatialRef = outLayer.GetSpatialRef()
multipolygon = ogr.Geometry(ogr.wkbMultiPolygon)
for outFeature in outLayer:
geometry = outFeature.GetGeometryRef()
multipolygon.AddGeometry(geometry)
outFeature = None
outLayer = None
# Convert geometry from projected to geographic coordinates (if requested)
if geographic == True:
(multipolygon, outSpatialRef) = \
geometry_proj2geo(multipolygon, inSpatialRef)
return (multipolygon, outSpatialRef)
else:
return (multipolygon, inSpatialRef)
def polygonize_1(is_int_polygonize=True):
src_ds = gdal.Open('data/polygonize_in.grd')
src_band = src_ds.GetRasterBand(1)
# Create a memory OGR datasource to put results in.
mem_drv = ogr.GetDriverByName('Memory')
mem_ds = mem_drv.CreateDataSource('out')
mem_layer = mem_ds.CreateLayer('poly', None, ogr.wkbPolygon)
fd = ogr.FieldDefn('DN', ogr.OFTInteger)
mem_layer.CreateField(fd)
# run the algorithm.
if is_int_polygonize:
result = gdal.Polygonize(src_band, src_band.GetMaskBand(), mem_layer,
0)
else:
result = gdal.FPolygonize(src_band, src_band.GetMaskBand(), mem_layer,
0)
if result != 0:
gdaltest.post_reason('Polygonize failed')
return 'fail'
# Confirm we get the set of expected features in the output layer.
expected_feature_number = 13
if mem_layer.GetFeatureCount() != expected_feature_number:
gdaltest.post_reason(
'GetFeatureCount() returned %d instead of %d' %
(mem_layer.GetFeatureCount(), expected_feature_number))
return 'fail'
expect = [107, 123, 115, 115, 140, 148, 123, 140, 156, 100, 101, 102, 103]
tr = ogrtest.check_features_against_list(mem_layer, 'DN', expect)
# check at least one geometry.
if tr:
mem_layer.SetAttributeFilter('dn = 156')
feat_read = mem_layer.GetNextFeature()
if ogrtest.check_feature_geometry(
feat_read,
'POLYGON ((440720 3751200,440720 3751020,440900 3751020,440900 3751200,440720 3751200),(440780 3751140,440840 3751140,440840 3751080,440780 3751080,440780 3751140))'
) != 0:
tr = 0
feat_read.Destroy()
if tr:
return 'success'
else:
return 'fail'
def vectorize_labels_file_io(labeled_file,
out_ds,
out_layer,
out_format,
out_dsco=[],
out_lco=[],
id_attribute='bspot_id',
quiet=False):
# This method does exactly the same as could be done with gdal_polygonize.py
src_ds = gdal.Open(labeled_file)
src_band = src_ds.GetRasterBand(1)
# Create a memory OGR datasource to put results in.
try:
gdal.PushErrorHandler('CPLQuietErrorHandler')
dst_ds = ogr.Open(out_ds, update=1)
gdal.PopErrorHandler()
except:
dst_ds = None
if not dst_ds:
dst_drv = ogr.GetDriverByName(out_format)
dst_ds = dst_drv.CreateDataSource(out_ds, options=out_dsco)
srs = src_ds.GetSpatialRef()
dst_layer = dst_ds.CreateLayer(out_layer,
geom_type=ogr.wkbPolygon,
srs=srs,
options=out_lco)
fd = ogr.FieldDefn(id_attribute, ogr.OFTInteger)
dst_layer.CreateField(fd)
# Use 8-connectedness
options = ['8CONNECTED=8']
# run the algorithm.
if quiet:
progress_callback = None
else:
progress_callback = gdal.TermProgress_nocb
result = gdal.Polygonize(src_band,
src_band.GetMaskBand(),
dst_layer,
0,
options,
callback=progress_callback)
src_band = None
src_ds = None
dst_ds = None
def image_segmentation(image,
scale_param=10,
min_area=9,
max_area=None,
output=None,
of='ESRI Shapefile',
overwrite=True):
# type: (str, int, int, int, str, str, bool) -> np.array
"""
Use the Felsenszwalb algorithm for image segmentation. \n
Original publication here: http://vision.stanford.edu/teaching/cs231b_spring1415/papers/IJCV2004_FelzenszwalbHuttenlocher.pdf \n
Implementation here: https://scikit-image.org/docs/0.14.x/api/skimage.segmentation.html#skimage.segmentation.felzenszwalb
:param image: Input image
:param scale_param: The number of produced segments as well as their size can only be controlled indirectly through this
parameter. Higher values result in larger clusters.
:param min_area: Minimum segment size (in pixels)
:param max_area: Maximum segment size (in pixels)
:param output: Output name in case segments shall be exported
:param of: Output format according to OGR driver standard
:param overwrite: Overwrite output file, if it already exists
:return:
"""
img = io.imread(image)
# img = exposure.equalize_hist(image)
if get_raster_properties(image, dictionary=True)['bandnum'] > 1:
segments = felzenszwalb(img,
multichannel=True,
scale=scale_param,
min_size=min_area)
else:
segments = felzenszwalb(img,
multichannel=False,
scale=scale_param,
min_size=min_area)
if max_area:
segments = remove_large_areas(segments, max_area)
if output:
from basic_functions.vector_tools import create_ds, close_rings
temp = output.replace(os.path.splitext(output)[-1], '__TEMP.tif')
export_image(temp, segments, image)
ds = gdal.Open(temp)
data_band = ds.GetRasterBand(1)
sr = osr.SpatialReference()
sr.ImportFromEPSG(get_epsg(image))
out_ds, out_lyr = create_ds(output, of, ogr.wkbPolygon, sr, overwrite)
gdal.Polygonize(data_band, None, out_lyr, -1, [], callback=None)
out_lyr = None
out_ds = None
ds = None
close_rings(output)
return segments
def polygonalize_raster(raster_path, target_vector_path):
"""Polygonalize `raster_path` to `target_vector_path` gpkg."""
raster = gdal.OpenEx(raster_path, gdal.OF_RASTER)
band = raster.GetRasterBand(1)
gpkg_driver = ogr.GetDriverByName('gpkg')
vector = gpkg_driver.CreateDataSource(target_vector_path)
layer_name = os.path.basename(os.path.splitext(target_vector_path)[0])
raster_srs = osr.SpatialReference(raster.GetProjection())
target_layer = vector.CreateLayer(layer_name, raster_srs, ogr.wkbPolygon)
target_layer.CreateField(ogr.FieldDefn('pix_val', ogr.OFTInteger))
rasterize_callback = pygeoprocessing._make_logger_callback(
"polygonalizing %.1f%% complete")
gdal.Polygonize(band, None, target_layer, 0, callback=rasterize_callback)
def vectorize_tiff(main_path, shp_name, ds_tiff):
band = ds_tiff.GetRasterBand(1)
dst_ds_shp = driver_shp.CreateDataSource((main_path+"/" + shp_name + ".shp"))
srs = osr.SpatialReference()
srs.ImportFromWkt(ds_tiff.GetProjectionRef())
dst_layer = dst_ds_shp.CreateLayer(shp_name, geom_type=ogr.wkbPolygon, srs=srs)
newField = ogr.FieldDefn('value', ogr.OFTInteger)
dst_layer.CreateField(newField)
gdal.Polygonize(band, None, dst_layer, 0, [], callback=None)
dst_ds_shp.Destroy()
band = None
ds_tiff = None
dst_ds_shp = None
def dissolve_polygon(raster, shp):
"""
Needs work.
:param raster: use karst_raster or any soil raster. We just need the GT object
:param shp: shp file to be dissolved
:return: raster object of dissolved shp file.
"""
gt = raster.gt()
x_min = gt[0]
y_max = gt[3]
x_res = raster.data.RasterXSize
y_res = raster.data.RasterYSize
x_max = x_min + gt[1] * x_res
y_min = y_max + gt[5] * y_res
pixel_width = gt[1]
if not os.path.exists('temp_shapefiles'):
os.mkdir('temp_shapefiles')
out_file = "temp_shapefiles//karst_flat.shp"
target_ds = gdal.GetDriverByName('MEM').Create('', x_res, y_res, 1, gdal.GDT_Byte)
target_ds.SetGeoTransform((x_min, pixel_width, 0, y_min, 0, pixel_width))
band = target_ds.GetRasterBand(1)
band.SetNoDataValue(0)
band.FlushCache()
gdal.RasterizeLayer(target_ds, [1], shp.lyr, options=["ATTRIBUTE=Gridcode"])
driver = ogr.GetDriverByName("ESRI Shapefile")
out_ds = driver.CreateDataSource(out_file)
srs = osr.SpatialReference()
srs.ImportFromProj4(shp.prj4)
out_lyr = out_ds.CreateLayer(out_file, srs=srs)
fd = ogr.FieldDefn("DN", ogr.OFTInteger)
out_lyr.CreateField(fd)
gdal.Polygonize(band, band, out_lyr, -1, [])
multi = ogr.Geometry(ogr.wkbMultiPolygon)
for feat in out_lyr:
if feat.geometry():
feat.geometry().CloseRings() # this copies the first point to the end
wkt = feat.geometry().ExportToWkt()
multi.AddGeometryDirectly(ogr.CreateGeometryFromWkt(wkt))
out_lyr.DeleteFeature(feat.GetFID())
union = multi.UnionCascaded()
out_feat = ogr.Feature(out_lyr.GetLayerDefn())
out_feat.SetGeometry(union)
out_lyr.CreateFeature(out_feat)
flat = dbShp(path=out_file)
target_ds = None
return flat
def Raster_to_Polygon(input_file, output_file):
gdal.UseExceptions()
src_ds = gdal.Open(input_file)
if src_ds is None:
raise Exception('Unable to open {}'.format(src_filename))
srcband = src_ds.GetRasterBand(1)
srd = srcband.GetMaskBand()
dst_layername = output_file
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(dst_layername + ".shp")
dst_layer = dst_ds.CreateLayer(dst_layername, srs=None)
gdal.Polygonize(srcband, srd, dst_layer, -1, [], callback=None)
def make_shp(imgname):
STATIC_FOLDER = '/app/app/static/'
app.config['STATIC_FOLDER'] = STATIC_FOLDER
origname = STATIC_FOLDER + imgname + '.tif'
alignedname = STATIC_FOLDER + imgname + '_blackalign.png'
alignedname_tif = STATIC_FOLDER + imgname + '_blackalign.tif'
zipname = STATIC_FOLDER + imgname + '.zip'
ziplist = [
STATIC_FOLDER + imgname + '_shape.dbf',
STATIC_FOLDER + imgname + '_shape.prj',
STATIC_FOLDER + imgname + '_shape.shp',
STATIC_FOLDER + imgname + '_shape.shx'
]
source = gdal.Open(origname)
srcbnd = np.array(source.GetRasterBand(1).ReadAsArray())
alignments = gdal.Open(alignedname)
alignband = np.array(alignments.GetRasterBand(1).ReadAsArray())
dst_ds = gdal.GetDriverByName('GTiff').Create(alignedname_tif,
srcbnd.shape[1],
srcbnd.shape[0],
3,
gdal.GDT_Byte,
options=[
'PHOTOMETRIC=RGB',
'PROFILE=GeoTIFF',
])
gdalnumeric.CopyDatasetInfo(source, dst_ds)
dst_ds.GetRasterBand(1).WriteArray(alignband)
dst_ds.FlushCache()
src_ds = dst_ds
proj = osr.SpatialReference(wkt=src_ds.GetProjection())
dst_layername = imgname + "_shape"
srcband = src_ds.GetRasterBand(1)
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(STATIC_FOLDER + dst_layername + ".shp")
dst_layer = dst_ds.CreateLayer(dst_layername,
proj,
geom_type=ogr.wkbMultiLineString)
gdal.Polygonize(srcband, None, dst_layer, -1, [], callback=None)
dst_ds.FlushCache()
with ZipFile(zipname, 'w') as zip:
for file in ziplist:
zip.write(file)
def polygonize_stats(geo_files):
for geo_file in geo_files:
for raster in geo_file['rasters']:
grid = gdal.Open(raster['stat_grid'])
band = grid.GetRasterBand(1)
driver = ogr.GetDriverByName('ESRI Shapefile')
if os.path.exists(raster['stat_shp']):
driver.DeleteDataSource(raster['stat_shp'])
outshp = driver.CreateDataSource(raster['stat_shp'])
ref = osr.SpatialReference()
ref.ImportFromEPSG(4326)
outlr = outshp.CreateLayer('poly', srs = ref)
outlr.CreateField(ogr.FieldDefn('sig', ogr.OFTInteger))
gdal.Polygonize(band, None, outlr, 0, [], callback=None)
def raster2shp(rasterfile,
vectorshp,
layername=None,
fieldname=None,
band_num=1,
mask='default'):
"""Convert raster to ESRI shapefile"""
FileClass.remove_files(vectorshp)
FileClass.check_file_exists(rasterfile)
# this allows GDAL to throw Python Exceptions
gdal.UseExceptions()
src_ds = gdal.Open(rasterfile)
if src_ds is None:
print('Unable to open %s' % rasterfile)
sys.exit(1)
try:
srcband = src_ds.GetRasterBand(band_num)
except RuntimeError as e:
# for example, try GetRasterBand(10)
print('Band ( %i ) not found, %s' % (band_num, e))
sys.exit(1)
if mask == 'default':
maskband = srcband.GetMaskBand()
elif mask is None or mask.upper() == 'NONE':
maskband = None
else:
mask_ds = gdal.Open(mask)
maskband = mask_ds.GetRasterBand(1)
# create output datasource
if layername is None:
layername = FileClass.get_core_name_without_suffix(rasterfile)
drv = ogr_GetDriverByName(str('ESRI Shapefile'))
dst_ds = drv.CreateDataSource(vectorshp)
srs = None
if src_ds.GetProjection() != '':
srs = osr_SpatialReference()
srs.ImportFromWkt(src_ds.GetProjection())
dst_layer = dst_ds.CreateLayer(str(layername), srs=srs)
if fieldname is None:
fieldname = layername.upper()
fd = ogr_FieldDefn(str(fieldname), OFTInteger)
dst_layer.CreateField(fd)
dst_field = 0
result = gdal.Polygonize(srcband,
maskband,
dst_layer,
dst_field, ['8CONNECTED=8'],
callback=None)
return result
def raster_polygonize(mask_temp_mp, shp_temp_mp):
src_ds = gdal.Open(mask_temp_mp)
srcband = src_ds.GetRasterBand(1)
dst_layername = shp_temp_mp
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(dst_layername + ".shp")
dst_layer = dst_ds.CreateLayer(dst_layername, srs=None)
fd = ogr.FieldDefn("DN", ogr.OFTInteger)
dst_layer.CreateField(fd)
dst_field = dst_layer.GetLayerDefn().GetFieldIndex("DN")
gdal.Polygonize(srcband, None, dst_layer, 0, [], callback=None)
del src_ds, dst_ds, dst_layer, dst_field
return dst_layername
def binary_raster_to_vector(binary_raster_path,
output_vector_path,
driver="ESRI Shapefile"):
""" Convert a binary raster to a vector """
# Open the binary tile as read-only and get the driver GDAL is using to access the data
binary_tile_fh = gdal.Open(binary_raster_path, gdal.GA_ReadOnly)
input_raster_driver = binary_tile_fh.GetDriver()
# Pull Metadata associated with the binary tile so we can create the output raster later
raster_geotransform = binary_tile_fh.GetGeoTransform()
raster_projection = binary_tile_fh.GetProjection()
cols = binary_tile_fh.RasterXSize # Get the number of columns
rows = binary_tile_fh.RasterYSize # Get the number of rows
binary_tile = binary_tile_fh.GetRasterBand(1) # Get the raster band
binary_nodata = binary_tile.GetNoDataValue(
) # Get the NoData value so we can set our mask
# Create the spatial ref for the output vector
osr_ref = osr.SpatialReference()
osr_ref.ImportFromWkt(raster_projection)
# Create a memory OGR datasource to put results in.
vect_driver = ogr.GetDriverByName(driver)
vect_datasrc = vect_driver.CreateDataSource(output_vector_path)
# Create the layer
vect_layer = vect_datasrc.CreateLayer('poly', osr_ref, ogr.wkbPolygon)
# Create a field
fd = ogr.FieldDefn('value', ogr.OFTInteger)
vect_layer.CreateField(fd)
# run the algorithm.
logger.info(" Runing Polygonize()...")
logger.info(" converting raster to vector...")
result = gdal.Polygonize(binary_tile, binary_tile.GetMaskBand(),
vect_layer, 0)
logger.info(" done.")
# Clean up
logger.info(" cleaning up and closing out of datasources...")
vect_layer = None
vect_datasrc = None
binary_tile = None
binary_tile_fh = None
logger.info(" done.")
return output_vector_path
def RasterToVector(tiffile,shpfile,maskfile = None):
dataset = gdal.Open(tiffile)
porj = dataset.GetProjection()
srcband = dataset.GetRasterBand(1)
srcband.SetNoDataValue(0)
driver = ogr.GetDriverByName("ESRI Shapefile")
if os.path.exists(shpfile):
driver.DeleteDataSource(shpfile)
outDatasource = driver.CreateDataSource(shpfile)
srs = osr.SpatialReference()
srs.ImportFromWkt(porj)
outLayer = outDatasource.CreateLayer("polygonized", srs = srs)
oFieldID = ogr.FieldDefn('DN',ogr.OFTInteger)
outLayer.CreateField(oFieldID, 1)
gdal.Polygonize( srcband, srcband, outLayer,0 , [], callback=None )
outDatasource.Destroy()
def geojson_from_preds(file_name,
preds,
layer_name="features",
field_name="features"):
dset = gdal.Open(preds)
band = dset.GetRasterBand(1)
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(file_name)
dst_layer = dst_ds.CreateLayer(layer_name, srs=None)
fd = ogr.FieldDefn(field_name, ogr.OFTInteger)
dst_layer.CreateField(fd)
dst_field = 1
gdal.Polygonize(band, None, dst_layer, dst_field, [], callback=None)
def polygonize(raster_path, band, out_shp_path, epsg):
# mapping between gdal type and ogr field type
type_mapping = {
gdal.GDT_Byte: ogr.OFTInteger,
gdal.GDT_UInt16: ogr.OFTInteger,
gdal.GDT_Int16: ogr.OFTInteger,
gdal.GDT_UInt32: ogr.OFTInteger,
gdal.GDT_Int32: ogr.OFTInteger,
gdal.GDT_Float32: ogr.OFTReal,
gdal.GDT_Float64: ogr.OFTReal,
gdal.GDT_CInt16: ogr.OFTInteger,
gdal.GDT_CInt32: ogr.OFTInteger,
gdal.GDT_CFloat32: ogr.OFTReal,
gdal.GDT_CFloat64: ogr.OFTReal
}
src_ds = gdal.Open(raster_path)
src_band = src_ds.GetRasterBand(band)
driver = ogr.GetDriverByName("ESRI Shapefile")
if os.path.exists(out_shp_path):
driver.DeleteDataSource(out_shp_path)
outDataSource = driver.CreateDataSource(out_shp_path)
out_spatial_ref = osr.SpatialReference()
out_spatial_ref.ImportFromEPSG(epsg)
outLayer = outDataSource.CreateLayer("polygonized",
out_spatial_ref,
geom_type=ogr.wkbPolygon)
raster_field = ogr.FieldDefn('id', type_mapping[src_band.DataType])
outLayer.CreateField(raster_field)
progbar = ProgressBar(100, 50, "Polygonizing raster")
def poly_progress(progress, msg, data):
# double dfProgress, char const * pszMessage=None, void * pData=None
progbar.update(int(progress * 100))
gdal.Polygonize(src_band,
src_ds.GetRasterBand(band),
outLayer,
0, [],
callback=poly_progress)
progbar.finish()
outDataSource.Destroy()
src_ds = None
def create_slope_poly(folder, fn_dem, fn_sl_water):
fn_sl_poly = folder + DemToTopoUtills.add_file_name_marker_shp(fn_dem, DemToTopoConsts.SLOPE_POLY_EXT)
# print(fn_sl_poly)
dn_sl = gdal.Open(fn_sl_water)
band_input = dn_sl.GetRasterBand(1)
# create the spatial reference, WGS84
source_srs = osr.SpatialReference()
source_srs.ImportFromEPSG(4326)
driver_file = ogr.GetDriverByName("ESRI Shapefile")
driver_mem = ogr.GetDriverByName('Memory')
if os.path.exists(fn_sl_poly):
driver_file.DeleteDataSource(fn_sl_poly)
out_datasource_file = driver_file.CreateDataSource(fn_sl_poly)
out_layer_file = out_datasource_file.CreateLayer("polygonized", source_srs, geom_type=ogr.wkbPolygon)
out_datasource_mem = driver_mem.CreateDataSource('out')
out_layer_mem = out_datasource_mem.CreateLayer("polygonized1", source_srs)
gdal.Polygonize(band_input, band_input, out_layer_mem, -1, [], callback=None)
for feat in out_layer_mem:
# For each feature, get the geometry
geom = feat.GetGeometryRef()
area = geom.GetArea()
if area > 0.0000009:
out_layer_file.CreateFeature(feat)
out_datasource_file = None
out_datasource_mem = None
dn_sl = None
fn_sl_poly_prj = folder + DemToTopoUtills.add_file_name_marker_prj(fn_dem, DemToTopoConsts.SLOPE_POLY_EXT)
spatial_ref = osr.SpatialReference()
spatial_ref.ImportFromEPSG(4326)
spatial_ref.MorphToESRI()
file = open(fn_sl_poly_prj, 'w')
file.write(spatial_ref.ExportToWkt())
file.close()
file = None
DemToTopoUtills.print_dot()
return fn_sl_poly
def vectorize_labels_file(labeled_file, id_attribute='bspot_id'):
"""Vectorize bluespot id raster
Parameters
----------
labeled_file : str
Path to GDAL supported file with bluespot ids (labels)
id_attribute : str
Attribute name to write bluespot id to
Yields
-------
feature : dict
Geojson formatted feature
"""
src_ds = gdal.Open(labeled_file)
src_band = src_ds.GetRasterBand(1)
# Create a memory OGR datasource to put results in.
mem_drv = ogr.GetDriverByName('Memory')
mem_ds = mem_drv.CreateDataSource('out')
mem_layer = mem_ds.CreateLayer('poly', None, ogr.wkbPolygon)
fd = ogr.FieldDefn(id_attribute, ogr.OFTInteger)
mem_layer.CreateField(fd)
# Use 8-connectedness
options = ['8CONNECTED=8']
# run the algorithm.
result = gdal.Polygonize(src_band, src_band.GetMaskBand(), mem_layer, 0,
options)
if result != 0:
raise Exception('Vectorization failed')
feat_read = mem_layer.GetNextFeature()
while feat_read:
yield json.loads(feat_read.ExportToJson())
feat_read.Destroy()
feat_read = mem_layer.GetNextFeature()
# Without these this code crashes in Python3
del fd
del src_ds
del mem_ds
