def test_print_geom_size(self):
in_path = os.path.join(datadir, 'WBDHU12.shp')
with ShapefileLayer(in_path) as in_lyr:
log = Logger('TEST')
for feature, _counter, progbar in in_lyr.iterate_features(
"GettingSize"):
geom = GeopackageLayer.ogr2shapely(feature)
progbar.erase()
vector_ops.print_geom_size(log, geom)
def test_ogr2shapely(self):
# test bad objects
self.assertRaises(
VectorBaseException,
lambda: GeopackageLayer.ogr2shapely("this is not valid"))
with GeopackageLayer(os.path.join(datadir, 'sample.gpkg',
'WBDHU12')) as gpkg_lyr:
for feat, _counter, _prog in gpkg_lyr.iterate_features():
geom = feat.GetGeometryRef()
shply_obj = GeopackageLayer.ogr2shapely(feat)
self.assertTrue(shply_obj.is_valid)
self.assertFalse(shply_obj.has_z)
self.assertTrue(shply_obj.area > 0)
self.assertAlmostEqual(geom.Area(), shply_obj.area, 6)
# Make sure it works with geometries as well as features
shply_obj = GeopackageLayer.ogr2shapely(geom)
self.assertTrue(shply_obj.is_valid)
self.assertFalse(shply_obj.has_z)
self.assertTrue(shply_obj.area > 0)
self.assertAlmostEqual(geom.Area(), shply_obj.area, 6)
with ShapefileLayer(os.path.join(datadir,
'NHDFlowline.shp')) as shp_lyr:
for feat, _counter, _prog in shp_lyr.iterate_features():
geom = feat.GetGeometryRef()
shply_obj = GeopackageLayer.ogr2shapely(feat)
self.assertTrue(shply_obj.is_valid)
self.assertFalse(shply_obj.has_z)
self.assertTrue(shply_obj.length > 0)
self.assertEqual(geom.Length(), shply_obj.length)
def confinement(huc: int,
flowlines_orig: Path,
confining_polygon_orig: Path,
output_folder: Path,
buffer_field: str,
confinement_type: str,
reach_codes: List[str],
min_buffer: float = 0.0,
bankfull_expansion_factor: float = 1.0,
debug: bool = False,
meta=None):
"""Generate confinement attribute for a stream network
Args:
huc (integer): Huc identifier
flowlines (path): input flowlines layer
confining_polygon (path): valley bottom or other boundary defining confining margins
output_folder (path): location to store confinement project and output geopackage
buffer_field (string): name of float field with buffer values in meters (i.e. 'BFWidth')
confinement_type (string): name of type of confinement generated
reach_codes (List[int]): NHD reach codes for features to include in outputs
min_buffer (float): minimum bankfull value to use in buffers e.g. raster cell resolution
bankfull_expansion_factor (float): factor to expand bankfull on each side of bank
debug (bool): run tool in debug mode (save intermediate outputs). Default = False
meta (Dict[str,str]): dictionary of riverscapes metadata key: value pairs
"""
log = Logger("Confinement")
log.info(f'Confinement v.{cfg.version}') # .format(cfg.version))
try:
int(huc)
except ValueError:
raise Exception(
'Invalid HUC identifier "{}". Must be an integer'.format(huc))
if not (len(huc) == 4 or len(huc) == 8):
raise Exception('Invalid HUC identifier. Must be four digit integer')
# Make the projectXML
project, _realization, proj_nodes, report_path = create_project(
huc, output_folder, {'ConfinementType': confinement_type})
# Incorporate project metadata to the riverscapes project
if meta is not None:
project.add_metadata(meta)
# Copy input shapes to a geopackage
flowlines_path = os.path.join(
output_folder, LayerTypes['INPUTS'].rel_path,
LayerTypes['INPUTS'].sub_layers['FLOWLINES'].rel_path)
confining_path = os.path.join(
output_folder, LayerTypes['INPUTS'].rel_path,
LayerTypes['INPUTS'].sub_layers['CONFINING_POLYGON'].rel_path)
copy_feature_class(flowlines_orig, flowlines_path, epsg=cfg.OUTPUT_EPSG)
copy_feature_class(confining_polygon_orig,
confining_path,
epsg=cfg.OUTPUT_EPSG)
_nd, _inputs_gpkg_path, inputs_gpkg_lyrs = project.add_project_geopackage(
proj_nodes['Inputs'], LayerTypes['INPUTS'])
output_gpkg = os.path.join(output_folder,
LayerTypes['CONFINEMENT'].rel_path)
intermediates_gpkg = os.path.join(output_folder,
LayerTypes['INTERMEDIATES'].rel_path)
# Creates an empty geopackage and replaces the old one
GeopackageLayer(output_gpkg, delete_dataset=True)
GeopackageLayer(intermediates_gpkg, delete_dataset=True)
# Add the flowlines file with some metadata
project.add_metadata({'BufferField': buffer_field},
inputs_gpkg_lyrs['FLOWLINES'][0])
# Add the confinement polygon
project.add_project_geopackage(proj_nodes['Intermediates'],
LayerTypes['INTERMEDIATES'])
_nd, _inputs_gpkg_path, out_gpkg_lyrs = project.add_project_geopackage(
proj_nodes['Outputs'], LayerTypes['CONFINEMENT'])
# Additional Metadata
project.add_metadata(
{
'Min Buffer': str(min_buffer),
"Expansion Factor": str(bankfull_expansion_factor)
}, out_gpkg_lyrs['CONFINEMENT_BUFFERS'][0])
# Generate confining margins
log.info(f"Preparing output geopackage: {output_gpkg}")
log.info(f"Generating Confinement from buffer field: {buffer_field}")
# Load input datasets and set the global srs and a meter conversion factor
with GeopackageLayer(flowlines_path) as flw_lyr:
srs = flw_lyr.spatial_ref
meter_conversion = flw_lyr.rough_convert_metres_to_vector_units(1)
geom_confining_polygon = get_geometry_unary_union(confining_path,
cfg.OUTPUT_EPSG)
# Calculate Spatial Constants
# Get a very rough conversion factor for 1m to whatever units the shapefile uses
offset = 0.1 * meter_conversion
selection_buffer = 0.1 * meter_conversion
# Standard Outputs
field_lookup = {
'side': ogr.FieldDefn("Side", ogr.OFTString),
'flowlineID': ogr.FieldDefn(
"NHDPlusID", ogr.OFTString
), # ArcGIS cannot read Int64 and will show up as 0, however data is stored correctly in GPKG
'confinement_type': ogr.FieldDefn("Confinement_Type", ogr.OFTString),
'confinement_ratio': ogr.FieldDefn("Confinement_Ratio", ogr.OFTReal),
'constriction_ratio': ogr.FieldDefn("Constriction_Ratio", ogr.OFTReal),
'length': ogr.FieldDefn("ApproxLeng", ogr.OFTReal),
'confined_length': ogr.FieldDefn("ConfinLeng", ogr.OFTReal),
'constricted_length': ogr.FieldDefn("ConstrLeng", ogr.OFTReal),
'bankfull_width': ogr.FieldDefn("Bankfull_Width", ogr.OFTReal),
'buffer_width': ogr.FieldDefn("Buffer_Width", ogr.OFTReal),
# Couple of Debug fields too
'process': ogr.FieldDefn("ErrorProcess", ogr.OFTString),
'message': ogr.FieldDefn("ErrorMessage", ogr.OFTString)
}
field_lookup['side'].SetWidth(5)
field_lookup['confinement_type'].SetWidth(5)
# Here we open all the necessary output layers and write the fields to them. There's no harm in quickly
# Opening these layers to instantiate them
# Standard Outputs
with GeopackageLayer(output_gpkg,
layer_name=LayerTypes['CONFINEMENT'].
sub_layers["CONFINEMENT_MARGINS"].rel_path,
write=True) as margins_lyr:
margins_lyr.create(ogr.wkbLineString, spatial_ref=srs)
margins_lyr.ogr_layer.CreateField(field_lookup['side'])
margins_lyr.ogr_layer.CreateField(field_lookup['flowlineID'])
margins_lyr.ogr_layer.CreateField(field_lookup['length'])
with GeopackageLayer(output_gpkg,
layer_name=LayerTypes['CONFINEMENT'].
sub_layers["CONFINEMENT_RAW"].rel_path,
write=True) as raw_lyr:
raw_lyr.create(ogr.wkbLineString, spatial_ref=srs)
raw_lyr.ogr_layer.CreateField(field_lookup['flowlineID'])
raw_lyr.ogr_layer.CreateField(field_lookup['confinement_type'])
raw_lyr.ogr_layer.CreateField(field_lookup['length'])
with GeopackageLayer(output_gpkg,
layer_name=LayerTypes['CONFINEMENT'].
sub_layers["CONFINEMENT_RATIO"].rel_path,
write=True) as ratio_lyr:
ratio_lyr.create(ogr.wkbLineString, spatial_ref=srs)
ratio_lyr.ogr_layer.CreateField(field_lookup['flowlineID'])
ratio_lyr.ogr_layer.CreateField(field_lookup['confinement_ratio'])
ratio_lyr.ogr_layer.CreateField(field_lookup['constriction_ratio'])
ratio_lyr.ogr_layer.CreateField(field_lookup['length'])
ratio_lyr.ogr_layer.CreateField(field_lookup['confined_length'])
ratio_lyr.ogr_layer.CreateField(field_lookup['constricted_length'])
with GeopackageLayer(intermediates_gpkg,
layer_name=LayerTypes['INTERMEDIATES'].
sub_layers["CONFINEMENT_BUFFER_SPLIT"].rel_path,
write=True) as lyr:
lyr.create(ogr.wkbPolygon, spatial_ref=srs)
lyr.ogr_layer.CreateField(field_lookup['side'])
lyr.ogr_layer.CreateField(field_lookup['flowlineID'])
lyr.ogr_layer.CreateField(field_lookup['bankfull_width'])
lyr.ogr_layer.CreateField(field_lookup['buffer_width'])
with GeopackageLayer(output_gpkg,
layer_name=LayerTypes['CONFINEMENT'].
sub_layers["CONFINEMENT_BUFFERS"].rel_path,
write=True) as lyr:
lyr.create(ogr.wkbPolygon, spatial_ref=srs)
lyr.ogr_layer.CreateField(field_lookup['flowlineID'])
lyr.ogr_layer.CreateField(field_lookup['bankfull_width'])
lyr.ogr_layer.CreateField(field_lookup['buffer_width'])
with GeopackageLayer(intermediates_gpkg,
layer_name=LayerTypes['INTERMEDIATES'].
sub_layers["SPLIT_POINTS"].rel_path,
write=True) as lyr:
lyr.create(ogr.wkbPoint, spatial_ref=srs)
lyr.ogr_layer.CreateField(field_lookup['side'])
lyr.ogr_layer.CreateField(field_lookup['flowlineID'])
with GeopackageLayer(intermediates_gpkg,
layer_name=LayerTypes['INTERMEDIATES'].
sub_layers["FLOWLINE_SEGMENTS"].rel_path,
write=True) as lyr:
lyr.create(ogr.wkbLineString, spatial_ref=srs)
lyr.ogr_layer.CreateField(field_lookup['side'])
lyr.ogr_layer.CreateField(field_lookup['flowlineID'])
with GeopackageLayer(intermediates_gpkg,
layer_name=LayerTypes['INTERMEDIATES'].
sub_layers["ERROR_POLYLINES"].rel_path,
write=True) as lyr:
lyr.create(ogr.wkbLineString, spatial_ref=srs)
lyr.ogr_layer.CreateField(field_lookup['process'])
lyr.ogr_layer.CreateField(field_lookup['message'])
with GeopackageLayer(intermediates_gpkg,
layer_name=LayerTypes['INTERMEDIATES'].
sub_layers["ERROR_POLYGONS"].rel_path,
write=True) as lyr:
lyr.create(ogr.wkbPolygon, spatial_ref=srs)
lyr.ogr_layer.CreateField(field_lookup['process'])
lyr.ogr_layer.CreateField(field_lookup['message'])
# Generate confinement per Flowline
with GeopackageLayer(flowlines_path) as flw_lyr, \
GeopackageLayer(output_gpkg, layer_name=LayerTypes['CONFINEMENT'].sub_layers["CONFINEMENT_MARGINS"].rel_path, write=True) as margins_lyr, \
GeopackageLayer(output_gpkg, layer_name=LayerTypes['CONFINEMENT'].sub_layers["CONFINEMENT_RAW"].rel_path, write=True) as raw_lyr, \
GeopackageLayer(output_gpkg, layer_name=LayerTypes['CONFINEMENT'].sub_layers["CONFINEMENT_RATIO"].rel_path, write=True) as ratio_lyr, \
GeopackageLayer(intermediates_gpkg, layer_name=LayerTypes['INTERMEDIATES'].sub_layers["SPLIT_POINTS"].rel_path, write=True) as dbg_splitpts_lyr, \
GeopackageLayer(intermediates_gpkg, layer_name=LayerTypes['INTERMEDIATES'].sub_layers["FLOWLINE_SEGMENTS"].rel_path, write=True) as dbg_flwseg_lyr, \
GeopackageLayer(intermediates_gpkg, layer_name=LayerTypes['INTERMEDIATES'].sub_layers["CONFINEMENT_BUFFER_SPLIT"].rel_path, write=True) as conf_buff_split_lyr, \
GeopackageLayer(output_gpkg, layer_name=LayerTypes['CONFINEMENT'].sub_layers["CONFINEMENT_BUFFERS"].rel_path, write=True) as buff_lyr, \
GeopackageLayer(intermediates_gpkg, layer_name=LayerTypes['INTERMEDIATES'].sub_layers["ERROR_POLYLINES"].rel_path, write=True) as dbg_err_lines_lyr, \
GeopackageLayer(intermediates_gpkg, layer_name=LayerTypes['INTERMEDIATES'].sub_layers["ERROR_POLYGONS"].rel_path, write=True) as dbg_err_polygons_lyr:
err_count = 0
for flowline, _counter, progbar in flw_lyr.iterate_features(
"Generating confinement for flowlines",
attribute_filter="FCode IN ({0})".format(','.join(
[key for key in reach_codes])),
write_layers=[
margins_lyr, raw_lyr, ratio_lyr, dbg_splitpts_lyr,
dbg_flwseg_lyr, buff_lyr, conf_buff_split_lyr,
dbg_err_lines_lyr, dbg_err_polygons_lyr
]):
# Load Flowline
flowlineID = int(flowline.GetFieldAsInteger64("NHDPlusID"))
bankfull_width = flowline.GetField(buffer_field)
buffer_value = max(bankfull_width, min_buffer)
geom_flowline = GeopackageLayer.ogr2shapely(flowline)
if not geom_flowline.is_valid or geom_flowline.is_empty or geom_flowline.length == 0:
progbar.erase()
log.warning("Invalid flowline with id: {}".format(flowlineID))
continue
# Generate buffer on each side of the flowline
geom_buffer = geom_flowline.buffer(
((buffer_value * meter_conversion) / 2) *
bankfull_expansion_factor,
cap_style=2)
# inital cleanup if geom is multipolygon
if geom_buffer.geom_type == "MultiPolygon":
log.warning(f"Cleaning multipolygon for id{flowlineID}")
polys = [g for g in geom_buffer if g.intersects(geom_flowline)]
if len(polys) == 1:
geom_buffer = polys[0]
if not geom_buffer.is_valid or geom_buffer.is_empty or geom_buffer.area == 0 or geom_buffer.geom_type not in [
"Polygon"
]:
progbar.erase()
log.warning("Invalid flowline (after buffering) id: {}".format(
flowlineID))
dbg_err_lines_lyr.create_feature(
geom_flowline, {
"ErrorProcess": "Generate Buffer",
"ErrorMessage": "Invalid Buffer"
})
err_count += 1
continue
buff_lyr.create_feature(
geom_buffer, {
"NHDPlusID": flowlineID,
"Buffer_Width": buffer_value,
"Bankfull_Width": bankfull_width
})
# Split the Buffer by the flowline
geom_buffer_splits = split(
geom_buffer, geom_flowline
) # snap(geom, geom_buffer)) <--shapely does not snap vertex to edge. need to make new function for this to ensure more buffers have 2 split polygons
# Process only if 2 buffers exist
if len(geom_buffer_splits) != 2:
# Lets try to split this again by slightly extending the line
geom_newline = scale(geom_flowline, 1.1, 1.1, origin='center')
geom_buffer_splits = split(geom_buffer, geom_newline)
if len(geom_buffer_splits) != 2:
# triage the polygon if still cannot split it
error_message = f"WARNING: Flowline FID {flowline.GetFID()} | Incorrect number of split buffer polygons: {len(geom_buffer_splits)}"
progbar.erase()
log.warning(error_message)
dbg_err_lines_lyr.create_feature(
geom_flowline, {
"ErrorProcess": "Buffer Split",
"ErrorMessage": error_message
})
err_count += 1
if len(geom_buffer_splits) > 1:
for geom in geom_buffer_splits:
dbg_err_polygons_lyr.create_feature(
geom, {
"ErrorProcess": "Buffer Split",
"ErrorMessage": error_message
})
else:
dbg_err_polygons_lyr.create_feature(
geom_buffer_splits, {
"ErrorProcess": "Buffer Split",
"ErrorMessage": error_message
})
continue
# Generate point to test side of flowline
geom_offset = geom_flowline.parallel_offset(offset, "left")
if not geom_offset.is_valid or geom_offset.is_empty or geom_offset.length == 0:
progbar.erase()
log.warning("Invalid flowline (after offset) id: {}".format(
flowlineID))
err_count += 1
dbg_err_lines_lyr.create_feature(
geom_flowline, {
"ErrorProcess":
"Offset Error",
"ErrorMessage":
"Invalid flowline (after offset) id: {}".format(
flowlineID)
})
continue
geom_side_point = geom_offset.interpolate(0.5, True)
# Store output segements
lgeoms_right_confined_flowline_segments = []
lgeoms_left_confined_flowline_segments = []
for geom_side in geom_buffer_splits:
# Identify side of flowline
side = "LEFT" if geom_side.contains(
geom_side_point) else "RIGHT"
# Save the polygon
conf_buff_split_lyr.create_feature(
geom_side, {
"Side": side,
"NHDPlusID": flowlineID,
"Buffer_Width": buffer_value,
"Bankfull_Width": bankfull_width
})
# Generate Confining margins
geom_confined_margins = geom_confining_polygon.boundary.intersection(
geom_side) # make sure intersection splits lines
if geom_confined_margins.is_empty:
continue
# Multilinestring to individual linestrings
lines = [
line for line in geom_confined_margins
] if geom_confined_margins.geom_type == 'MultiLineString' else [
geom_confined_margins
]
for line in lines:
margins_lyr.create_feature(
line, {
"Side": side,
"NHDPlusID": flowlineID,
"ApproxLeng": line.length / meter_conversion
})
# Split flowline by Near Geometry
pt_start = nearest_points(Point(line.coords[0]),
geom_flowline)[1]
pt_end = nearest_points(Point(line.coords[-1]),
geom_flowline)[1]
for point in [pt_start, pt_end]:
dbg_splitpts_lyr.create_feature(
point, {
"Side": side,
"NHDPlusID": flowlineID
})
distance_sorted = sorted([
geom_flowline.project(pt_start),
geom_flowline.project(pt_end)
])
segment = substring(geom_flowline, distance_sorted[0],
distance_sorted[1])
# Store the segment by flowline side
if segment.is_valid and segment.geom_type in [
"LineString", "MultiLineString"
]:
if side == "LEFT":
lgeoms_left_confined_flowline_segments.append(
segment)
else:
lgeoms_right_confined_flowline_segments.append(
segment)
dbg_flwseg_lyr.create_feature(segment, {
"Side": side,
"NHDPlusID": flowlineID
})
# Raw Confinement Output
# Prepare flowline splits
splitpoints = [
Point(x, y)
for line in lgeoms_left_confined_flowline_segments +
lgeoms_right_confined_flowline_segments for x, y in line.coords
]
cut_distances = sorted(
list(
set([
geom_flowline.project(point) for point in splitpoints
])))
lgeoms_flowlines_split = []
current_line = geom_flowline
cumulative_distance = 0.0
while len(cut_distances) > 0:
distance = cut_distances.pop(0) - cumulative_distance
if not distance == 0.0:
outline = cut(current_line, distance)
if len(outline) == 1:
current_line = outline[0]
else:
current_line = outline[1]
lgeoms_flowlines_split.append(outline[0])
cumulative_distance = cumulative_distance + distance
lgeoms_flowlines_split.append(current_line)
# Confined Segments
lgeoms_confined_left_split = select_geoms_by_intersection(
lgeoms_flowlines_split,
lgeoms_left_confined_flowline_segments,
buffer=selection_buffer)
lgeoms_confined_right_split = select_geoms_by_intersection(
lgeoms_flowlines_split,
lgeoms_right_confined_flowline_segments,
buffer=selection_buffer)
lgeoms_confined_left = select_geoms_by_intersection(
lgeoms_confined_left_split,
lgeoms_confined_right_split,
buffer=selection_buffer,
inverse=True)
lgeoms_confined_right = select_geoms_by_intersection(
lgeoms_confined_right_split,
lgeoms_confined_left_split,
buffer=selection_buffer,
inverse=True)
geom_confined = unary_union(lgeoms_confined_left_split +
lgeoms_confined_right_split)
# Constricted Segments
lgeoms_constricted_l = select_geoms_by_intersection(
lgeoms_confined_left_split,
lgeoms_confined_right_split,
buffer=selection_buffer)
lgeoms_constrcited_r = select_geoms_by_intersection(
lgeoms_confined_right_split,
lgeoms_confined_left_split,
buffer=selection_buffer)
lgeoms_constricted = []
for geom in lgeoms_constricted_l + lgeoms_constrcited_r:
if not any(g.equals(geom) for g in lgeoms_constricted):
lgeoms_constricted.append(geom)
geom_constricted = MultiLineString(lgeoms_constricted)
# Unconfined Segments
lgeoms_unconfined = select_geoms_by_intersection(
lgeoms_flowlines_split,
lgeoms_confined_left_split + lgeoms_confined_right_split,
buffer=selection_buffer,
inverse=True)
# Save Raw Confinement
for con_type, geoms in zip(["Left", "Right", "Both", "None"], [
lgeoms_confined_left, lgeoms_confined_right,
lgeoms_constricted, lgeoms_unconfined
]):
for g in geoms:
if g.geom_type == "LineString":
raw_lyr.create_feature(
g, {
"NHDPlusID": flowlineID,
"Confinement_Type": con_type,
"ApproxLeng": g.length / meter_conversion
})
elif geoms.geom_type in ["Point", "MultiPoint"]:
progbar.erase()
log.warning(
f"Flowline FID: {flowline.GetFID()} | Point geometry identified generating outputs for Raw Confinement."
)
else:
progbar.erase()
log.warning(
f"Flowline FID: {flowline.GetFID()} | Unknown geometry identified generating outputs for Raw Confinement."
)
# Calculated Confinement per Flowline
confinement_ratio = geom_confined.length / geom_flowline.length if geom_confined else 0.0
constricted_ratio = geom_constricted.length / geom_flowline.length if geom_constricted else 0.0
# Save Confinement Ratio
attributes = {
"NHDPlusID":
flowlineID,
"Confinement_Ratio":
confinement_ratio,
"Constriction_Ratio":
constricted_ratio,
"ApproxLeng":
geom_flowline.length / meter_conversion,
"ConfinLeng":
geom_confined.length /
meter_conversion if geom_confined else 0.0,
"ConstrLeng":
geom_constricted.length /
meter_conversion if geom_constricted else 0.0
}
ratio_lyr.create_feature(geom_flowline, attributes)
# Write a report
report = ConfinementReport(output_gpkg, report_path, project)
report.write()
progbar.finish()
log.info(f"Count of Flowline segments with errors: {err_count}")
log.info('Confinement Finished')
return
def test_get_geometry_union(self):
in_path = os.path.join(datadir, 'WBDHU12.shp')
# Use this for the clip shape
clip_path = os.path.join(datadir, 'WBDHU10.shp')
# This is the whole file unioned
result_all = vector_ops.get_geometry_union(in_path, 4326)
# This is one huc12
result201 = vector_ops.get_geometry_union(
in_path, 4326, attribute_filter="HUC12 = '170603040201'")
result202 = vector_ops.get_geometry_union(
in_path, 4326, attribute_filter="HUC12 = '170603040202'")
result203 = vector_ops.get_geometry_union(
in_path, 4326, attribute_filter="HUC12 = '170603040203'")
result101 = vector_ops.get_geometry_union(
in_path, 4326, attribute_filter="HUC12 = '170603040101'")
result102 = vector_ops.get_geometry_union(
in_path, 4326, attribute_filter="HUC12 = '170603040102'")
result103 = vector_ops.get_geometry_union(
in_path, 4326, attribute_filter="HUC12 = '170603040103'")
# This is every huc12 with the pattern 1706030402%
result20 = vector_ops.get_geometry_union(
in_path, 4326, attribute_filter="HUC12 LIKE '1706030402%'")
result10 = vector_ops.get_geometry_union(
in_path, 4326, attribute_filter="HUC12 LIKE '1706030401%'")
self.assertAlmostEqual(result_all.area, 0.06580, 4)
self.assertAlmostEqual(
result_all.area, result201.area + result202.area + result203.area +
result101.area + result102.area + result103.area, 4)
self.assertAlmostEqual(
result10.area, result101.area + result102.area + result103.area, 4)
self.assertAlmostEqual(
result20.area, result201.area + result202.area + result203.area, 4)
# Build a library of shapes to clip
clip_shapes = {}
# Now test with clip_shape enabled
with ShapefileLayer(clip_path) as clip_lyr:
for clip_feat, _counter, _progbar in clip_lyr.iterate_features(
"Gettingshapes"):
huc10 = clip_feat.GetFieldAsString("HUC10")
clip_shapes[huc10] = GeopackageLayer.ogr2shapely(clip_feat)
for huc10, clip_shape in clip_shapes.items():
debug_path = os.path.join(
datadir, 'test_get_geometry_union_{}.gpkg'.format(huc10))
buffered_clip_shape = clip_shape.buffer(-0.004)
# Write the clipping shape
with GeopackageLayer(debug_path,
'CLIP_{}'.format(huc10),
write=True) as deb_lyr:
deb_lyr.create_layer_from_ref(clip_lyr)
out_feature = ogr.Feature(deb_lyr.ogr_layer_def)
out_feature.SetGeometry(
GeopackageLayer.shapely2ogr(buffered_clip_shape))
deb_lyr.ogr_layer.CreateFeature(out_feature)
# This is every huc12 within a single huc 10 unioned
result_clipped = vector_ops.get_geometry_union(
in_path, clip_shape=buffered_clip_shape)
with ShapefileLayer(in_path) as in_lyr, GeopackageLayer(
debug_path, 'result_{}'.format(huc10),
write=True) as deb_lyr:
deb_lyr.create(in_lyr.ogr_geom_type,
spatial_ref=in_lyr.spatial_ref)
out_feature = ogr.Feature(deb_lyr.ogr_layer_def)
out_feature.SetGeometry(
GeopackageLayer.shapely2ogr(result_clipped))
deb_lyr.ogr_layer.CreateFeature(out_feature)
self.assertAlmostEqual(clip_shape.area, result_clipped.area, 4)
def split_geoms(base_feature_path: str, intersect_feature_path: str,
split_feats: Dict[int, List[LineString]]) -> List[Point]:
"""Loop over base_feature_path and split it everywhere we find it intersecting with intersect_feature_path
This creates the splits to be used later
Args:
base_feature_path (str): [description]
intersect_feature_path (str): [description]
split_feats (Dict[List[LineString]]): [description]
Returns:
(List[Point]): Returns all the intersection points.
"""
log = Logger('split_geoms')
log.info('Finding intersections')
# We collect the raw NHD to use as a filter only
base_collection = collect_feature_class(base_feature_path)
# Then we use the same collection method to get a collection of intersected features that are likely to touch
# our base_collection. This seems a bit redundantly redundant but it does speed things up.
intersect_collection = GeopackageLayer.ogr2shapely(
collect_feature_class(intersect_feature_path,
clip_shape=base_collection))
intersection_pts = []
# Now go through using a clip_shape filter and do the actual splits. These features are likely to intersect
# but not guaranteed so we still need to check.
with get_shp_or_gpkg(base_feature_path) as in_lyr:
for feat, _counter, _progbar in in_lyr.iterate_features(
"Finding intersections", clip_shape=intersect_collection):
fid = feat.GetFID()
shply_geom = GeopackageLayer.ogr2shapely(feat)
if fid in split_feats:
# If a previous incarnation of split_geoms already split this feature we have to work on the splits.
candidates = split_feats[fid]
else:
candidates = [shply_geom]
new_splits = []
for candidate in candidates:
# This call is not really related to the segmentation but we write it back to a point layer
# for use in other tools.
intersection = candidate.intersection(intersect_collection)
# Split this candidate geometry by the intersect collection
geom_split = split(candidate, intersect_collection)
new_splits += list(geom_split)
# Now add the intersection points to the list
# >1 length means there was an intersection
if len(geom_split) > 1:
if isinstance(intersection, Point):
intersection_pts.append(intersection)
elif isinstance(intersection, MultiPoint):
intersection_pts += list(intersection)
else:
raise Exception('Unhandled type: {}'.format(
intersection.type))
split_feats[fid] = new_splits
return intersection_pts