def ogr_geom_build_from_edges_3():
if gdaltest.have_geos == 0:
return 'skip'
src_geom = ogr.CreateGeometryFromWkt('POINT (0 1)')
try:
gdal.PushErrorHandler('CPLQuietErrorHandler')
poly = ogr.BuildPolygonFromEdges(src_geom)
gdal.PopErrorHandler()
if poly is not None:
return 'fail'
except:
pass
src_geom = ogr.CreateGeometryFromWkt(
'GEOMETRYCOLLECTION (LINESTRING(0 1,2 3),POINT(0 1),LINESTRING(0 1,-2 3),LINESTRING(-2 3,2 3))'
)
try:
gdal.PushErrorHandler('CPLQuietErrorHandler')
poly = ogr.BuildPolygonFromEdges(src_geom)
gdal.PopErrorHandler()
if poly is not None:
return 'fail'
except:
pass
return 'success'
def ogr_geom_build_from_edges_2():
if gdaltest.have_geos == 0:
return 'skip'
link_coll = ogr.Geometry(type=ogr.wkbMultiLineString)
wkt_array = [
'LINESTRING (-87.601595 30.999522,-87.599623 31.000059,-87.599219 31.00017)',
'LINESTRING (-87.601595 30.999522,-87.604349 30.999493,-87.606935 30.99952)',
'LINESTRING (-87.59966 31.000756,-87.599851 31.000805,-87.599992 31.000805,-87.600215 31.000761,-87.600279 31.000723,-87.600586 31.000624,-87.601256 31.000508,-87.602501 31.000447,-87.602801 31.000469,-87.603108 31.000579,-87.603331 31.000716,-87.603523 31.000909,-87.603766 31.001233,-87.603913 31.00136)',
'LINESTRING (-87.606134 31.000182,-87.605885 31.000325,-87.605343 31.000716,-87.60466 31.001117,-87.604468 31.0012,-87.603913 31.00136)',
'LINESTRING (-87.599219 31.00017,-87.599289 31.0003,-87.599398 31.000426,-87.599564 31.000547,-87.599609 31.000701,-87.59966 31.000756)',
'LINESTRING (-87.606935 30.99952,-87.606713 30.999799,-87.6064 30.999981,-87.606134 31.000182)'
]
for wkt in wkt_array:
geom = ogr.CreateGeometryFromWkt(wkt)
#print "geom is",geom
link_coll.AddGeometry(geom)
geom.Destroy()
try:
poly = ogr.BuildPolygonFromEdges(link_coll)
if poly is None:
return 'fail'
poly.Destroy()
except:
return 'fail'
return 'success'
def points2ogr_polygon(points):
"""Construct a OGR polygon from an input point list (not closed)"""
# input an iterable of 2d 'points', slow interface for large collections...
s = ogr.Geometry(ogr.wkbLineString)
for p in points:
s.AddPoint_2D(p[0], p[1])
s.AddPoint_2D(points[0][0], points[0][1]) # close
p = ogr.BuildPolygonFromEdges(ogr.ForceToMultiLineString(s))
return p
def _create_polygon(self, geom, i, z):
"""Create polygon from closed linestring geometry.
If input geometry is not closed linestring that PolygonError
is raised.
:param geom: input linestring geometry
:param line_id: ID of an input geometry
:return: polygon geometry
"""
if geom == []:
pass
else:
ring = ogr.ForceToMultiLineString(geom)
poly = ogr.BuildPolygonFromEdges(ring, 0, 1)
# Add polygon to polygon_list
new_poly = MyPolygon(i, z, poly)
self.polygon_list.append(new_poly)
def ogr_geom_build_from_edges_4():
if int(gdal.VersionInfo('VERSION_NUM')) < 1900:
gdaltest.post_reason('would crash')
return 'skip'
if gdaltest.have_geos == 0:
return 'skip'
link_coll = ogr.Geometry(type=ogr.wkbGeometryCollection)
wkt_array = [
'LINESTRING EMPTY', 'LINESTRING (1 1,1 2)', 'LINESTRING EMPTY',
'LINESTRING (1 2,2 2)', 'LINESTRING (2 2,2 1)', 'LINESTRING (2 1,1 1)',
'LINESTRING (0 0,0 10)', 'LINESTRING (0 10,10 10)',
'LINESTRING (10 10,10 0)', 'LINESTRING (10 0,0 0)'
]
for wkt in wkt_array:
geom = ogr.CreateGeometryFromWkt(wkt)
#print "geom is",geom
link_coll.AddGeometry(geom)
geom.Destroy()
try:
poly = ogr.BuildPolygonFromEdges(link_coll)
if poly is None:
return 'fail'
wkt = poly.ExportToWkt()
if wkt != 'POLYGON ((0 0,0 10,10 10,10 0,0 0),(1 1,1 2,2 2,2 1,1 1))':
print(wkt)
return 'fail'
poly.Destroy()
except:
return 'fail'
return 'success'
link_list = feat.GetField(link_field)
# If the list is in string form we need to convert it.
if type(link_list).__name__ == 'str':
colon = link_list.find(':')
items = link_list[colon + 1:-1].split(',')
link_list = []
for item in items:
try:
link_list.append(int(item))
except:
print('item failed to translate: ', item)
link_coll = ogr.Geometry(type=ogr.wkbGeometryCollection)
for geom_id in link_list:
geom = lines_hash[tile_ref][geom_id]
link_coll.AddGeometry(geom)
try:
poly = ogr.BuildPolygonFromEdges(link_coll)
print(poly.ExportToWkt())
feat.SetGeometryDirectly(poly)
except:
print('BuildPolygonFromEdges failed.')
# For now we don't actually write back the assembled polygons.
# poly_layer.SetFeature( feat )
feat.Destroy()
feat = poly_layer.GetNextFeature()
def doit(name):
# Open the datasource to operate on.
# ds = ogr.Open( '/u/data/ntf/bl2000/HALTON.NTF' )
ds = ogr.Open(name, update=1)
# layer_count = ds.GetLayerCount()
# -
# Establish access to the line and polygon layers. Eventually we shouldn't
# hardcode this.
line_layer = ds.GetLayer(0)
poly_layer = ds.GetLayer(1)
#############################################################################
# Read all features in the line layer, holding just the geometry in a hash
# for fast lookup by GEOM_ID.
lines_hash = {}
feat = line_layer.GetNextFeature()
geom_id_field = feat.GetFieldIndex('GEOM_ID')
tile_ref_field = feat.GetFieldIndex('TILE_REF')
while feat is not None:
geom_id = feat.GetField(geom_id_field)
tile_ref = feat.GetField(tile_ref_field)
if tile_ref not in lines_hash:
lines_hash[tile_ref] = {}
sub_hash = lines_hash[tile_ref]
sub_hash[geom_id] = feat.GetGeometryRef().Clone()
feat.Destroy()
feat = line_layer.GetNextFeature()
print('Got %d lines.' % len(lines_hash))
#############################################################################
# Read all polygon features.
feat = poly_layer.GetNextFeature()
link_field = feat.GetFieldIndex('GEOM_ID_OF_LINK')
tile_ref_field = feat.GetFieldIndex('TILE_REF')
while feat is not None:
tile_ref = feat.GetField(tile_ref_field)
link_list = feat.GetField(link_field)
# If the list is in string form we need to convert it.
if type(link_list).__name__ == 'str':
colon = link_list.find(':')
items = link_list[colon + 1:-1].split(',')
link_list = []
for item in items:
try:
link_list.append(int(item))
except:
print('item failed to translate: ', item)
link_coll = ogr.Geometry(type=ogr.wkbGeometryCollection)
for geom_id in link_list:
geom = lines_hash[tile_ref][geom_id]
link_coll.AddGeometry(geom)
try:
poly = ogr.BuildPolygonFromEdges(link_coll)
print(poly.ExportToWkt())
feat.SetGeometryDirectly(poly)
except:
print('BuildPolygonFromEdges failed.')
# For now we don't actually write back the assembled polygons.
# poly_layer.SetFeature( feat )
feat.Destroy()
feat = poly_layer.GetNextFeature()
def main(argv=sys.argv):
infile = None
outfile = None
i = 1
while i < len(argv):
arg = argv[i]
if infile is None:
infile = arg
elif outfile is None:
outfile = arg
else:
return Usage()
i = i + 1
if outfile is None:
outfile = 'poly.shp'
if infile is None:
return Usage()
#############################################################################
# Open the datasource to operate on.
ds = ogr.Open(infile, update=0)
poly_layer = ds.GetLayerByName('Polygon')
#############################################################################
# Create output file for the composed polygons.
nad83 = osr.SpatialReference()
nad83.SetFromUserInput('NAD83')
shp_driver = ogr.GetDriverByName('ESRI Shapefile')
shp_driver.DeleteDataSource(outfile)
shp_ds = shp_driver.CreateDataSource(outfile)
shp_layer = shp_ds.CreateLayer('out', geom_type=ogr.wkbPolygon, srs=nad83)
src_defn = poly_layer.GetLayerDefn()
poly_field_count = src_defn.GetFieldCount()
for fld_index in range(poly_field_count):
src_fd = src_defn.GetFieldDefn(fld_index)
fd = ogr.FieldDefn(src_fd.GetName(), src_fd.GetType())
fd.SetWidth(src_fd.GetWidth())
fd.SetPrecision(src_fd.GetPrecision())
shp_layer.CreateField(fd)
#############################################################################
# Read all features in the line layer, holding just the geometry in a hash
# for fast lookup by TLID.
line_layer = ds.GetLayerByName('CompleteChain')
line_count = 0
modules_hash = {}
feat = line_layer.GetNextFeature()
geom_id_field = feat.GetFieldIndex('TLID')
tile_ref_field = feat.GetFieldIndex('MODULE')
while feat is not None:
geom_id = feat.GetField(geom_id_field)
tile_ref = feat.GetField(tile_ref_field)
try:
module = modules_hash[tile_ref]
except KeyError:
module = Module()
modules_hash[tile_ref] = module
module.lines[geom_id] = feat.GetGeometryRef().Clone()
line_count = line_count + 1
feat.Destroy()
feat = line_layer.GetNextFeature()
print('Got %d lines in %d modules.' % (line_count, len(modules_hash)))
#############################################################################
# Read all polygon/chain links and build a hash keyed by POLY_ID listing
# the chains (by TLID) attached to it.
link_layer = ds.GetLayerByName('PolyChainLink')
feat = link_layer.GetNextFeature()
geom_id_field = feat.GetFieldIndex('TLID')
tile_ref_field = feat.GetFieldIndex('MODULE')
lpoly_field = feat.GetFieldIndex('POLYIDL')
rpoly_field = feat.GetFieldIndex('POLYIDR')
link_count = 0
while feat is not None:
module = modules_hash[feat.GetField(tile_ref_field)]
tlid = feat.GetField(geom_id_field)
lpoly_id = feat.GetField(lpoly_field)
rpoly_id = feat.GetField(rpoly_field)
if lpoly_id == rpoly_id:
feat.Destroy()
feat = link_layer.GetNextFeature()
continue
try:
module.poly_line_links[lpoly_id].append(tlid)
except KeyError:
module.poly_line_links[lpoly_id] = [tlid]
try:
module.poly_line_links[rpoly_id].append(tlid)
except KeyError:
module.poly_line_links[rpoly_id] = [tlid]
link_count = link_count + 1
feat.Destroy()
feat = link_layer.GetNextFeature()
print('Processed %d links.' % link_count)
#############################################################################
# Process all polygon features.
feat = poly_layer.GetNextFeature()
tile_ref_field = feat.GetFieldIndex('MODULE')
polyid_field = feat.GetFieldIndex('POLYID')
poly_count = 0
degenerate_count = 0
while feat is not None:
module = modules_hash[feat.GetField(tile_ref_field)]
polyid = feat.GetField(polyid_field)
tlid_list = module.poly_line_links[polyid]
link_coll = ogr.Geometry(type=ogr.wkbGeometryCollection)
for tlid in tlid_list:
geom = module.lines[tlid]
link_coll.AddGeometry(geom)
try:
poly = ogr.BuildPolygonFromEdges(link_coll)
if poly.GetGeometryRef(0).GetPointCount() < 4:
degenerate_count = degenerate_count + 1
poly.Destroy()
feat.Destroy()
feat = poly_layer.GetNextFeature()
continue
# print poly.ExportToWkt()
# feat.SetGeometryDirectly( poly )
feat2 = ogr.Feature(feature_def=shp_layer.GetLayerDefn())
for fld_index in range(poly_field_count):
feat2.SetField(fld_index, feat.GetField(fld_index))
feat2.SetGeometryDirectly(poly)
shp_layer.CreateFeature(feat2)
feat2.Destroy()
poly_count = poly_count + 1
except:
print('BuildPolygonFromEdges failed.')
feat.Destroy()
feat = poly_layer.GetNextFeature()
if degenerate_count:
print('Discarded %d degenerate polygons.' % degenerate_count)
print('Built %d polygons.' % poly_count)
#############################################################################
# Cleanup
shp_ds.Destroy()
ds.Destroy()
return 0
