def test_compare_label_stats(filleddata, bspotdata):
speedups.disable()
assert not speedups.enabled
stats = label.label_stats(filleddata, bspotdata)
speedups.enable()
assert speedups.enabled
statsopt = label.label_stats(filleddata, bspotdata)
for s, so in zip(stats, statsopt):
assert s == so
def test_nofilter(bspotdata, depthsdata):
raw_bluespot_stats = label.label_stats(depthsdata, bspotdata)
filter_function = lambda r: True
keepers = bluespots.filterbluespots(filter_function, 1.0,
raw_bluespot_stats)
assert len(keepers) == len(raw_bluespot_stats)
assert sum(keepers) == len(raw_bluespot_stats)
def process_bspots(depths, out, filter):
"""Label bluespots.
Assign unique bluespot ID to all cells belonging to a bluespot. Optionally disregarding some bluespots based on a
filter expression. ID 0 (zero) is used for cells not belonging to a bluespot.
"""
depths_reader = io.RasterReader(depths)
labeled_writer = io.RasterWriter(out, depths_reader.transform,
depths_reader.crs, 0)
filter_function = parse_filter(filter)
transform = depths_reader.transform
cell_width = abs(transform[1])
cell_height = abs(transform[5])
cell_area = cell_width * cell_height
depths_data = depths_reader.read()
raw_labeled, raw_nlabels = label.connected_components(depths_data)
if not filter:
# This is the end my friend
labeled_writer.write(raw_labeled)
return
del depths
raw_bluespot_stats = label.label_stats(depths_data, raw_labeled)
keepers = filterbluespots(filter_function, cell_area, raw_bluespot_stats)
new_components = label.keep_labels(raw_labeled, keepers)
labeled, nlabels = label.connected_components(new_components)
labeled_writer.write(labeled)
def bluespot_hypsometry_stats(bluespotlabels,
dem,
resolution,
labels_max=None,
background=0):
if not speedups.enabled:
logger.warning(
'Warning: Speedups are not available. If you have more than toy data you want them to be!'
)
if labels_max is None:
labels_max = np.max(bluespotlabels)
logger.debug("Calculate z stats for each bluespot")
label_z_stats = label_stats(dem, bluespotlabels, labels_max)
logger.debug("Collecting label data values")
label_data_values = label_data(dem,
bluespotlabels,
labels_max,
background=background)
logger.debug("Calculating histograms")
for label, data in enumerate(label_data_values):
if label == background:
bins = HistogramBinsInfo(0, 0, 0, -1)
counts = []
else:
bins = histogram_bins(label_z_stats[label]["min"],
label_z_stats[label]["max"], resolution)
counts, _ = np.histogram(data, bins.num_bins,
(bins.lower_bound, bins.upper_bound))
yield label, HypsometryStats(Histogram(counts, bins),
label_z_stats[label]["min"],
label_z_stats[label]["max"])
def test_filter(bspotdata, depthsdata):
raw_bluespot_stats = label.label_stats(depthsdata, bspotdata)
filter_function = lambda r: r['max'] > 2 and r['count'] > 5 and r['sum'
] > 1
keepers = bluespots.filterbluespots(filter_function, 1.0,
raw_bluespot_stats)
assert len(keepers) == len(raw_bluespot_stats)
assert sum(keepers) == 19
def process_pourpoints(bluespots, depths, watersheds, dem, accum, out, format,
layername, dsco, lco):
"""Determine pour points.
\b
Determines a pour point for each bluespot using one of two methods:
* Random candidate. Requires DEM only
* Maximum accumulated flow candidate. Requires accumulated flow
The output of the two methods only differ when there are more than one pour point candidate (ie multiple threshold
cells with identical Z) for a given bluespot.
For documentation of OGR features (format, dsco and lco) see http://www.gdal.org/ogr_formats.html
"""
bspot_reader = io.RasterReader(bluespots)
depths_reader = io.RasterReader(depths)
wsheds_reader = io.RasterReader(watersheds)
data = accum if accum else dem
if not data:
raise Exception('Either accum or dem must be specified')
data_reader = io.RasterReader(data)
format = str(format)
layername = str(layername)
pourpnt_writer = io.VectorWriter(format, out, layername, [], ogr.wkbPoint,
depths_reader.crs, dsco, lco)
# Recalculate stats on filtered bluespots
labeled_data = bspot_reader.read()
depths_data = depths_reader.read()
bluespot_stats = label.label_stats(depths_data, labeled_data)
del depths_data
if accum:
pp_pix = label.label_max_index(data_reader.read(), labeled_data)
elif dem:
dem_data = data_reader.read()
short, diag = fill.minimum_safe_short_and_diag(dem_data)
filled_no_flats = fill.fill_terrain_no_flats(dem_data, short, diag)
pp_pix = label.label_min_index(filled_no_flats, labeled_data)
del dem_data
watershed_stats = label.label_count(wsheds_reader.read())
pour_points = assemble_pourpoints(depths_reader.transform, pp_pix,
bluespot_stats, watershed_stats)
feature_collection = dict(type="FeatureCollection", features=pour_points)
pourpnt_writer.write_geojson_features(feature_collection)
def test_label_stats_optimized(filleddata, bspotdata):
speedups.enable()
assert speedups.enabled
stats = label.label_stats(filleddata, bspotdata)
assert len(stats) == np.max(bspotdata) + 1
assert np.all(stats[:]['min'] <= stats[:]['max'])
assert np.sum(stats[:]['count']) == bspotdata.shape[0] * bspotdata.shape[1]
assert np.min(stats[:]['min']) == np.min(filleddata)
assert np.max(stats[:]['max']) == np.max(filleddata)
# Check label with most cells
lbl = np.argmax(stats[:]['count'])
lblix = bspotdata == lbl
assert stats[lbl]['min'] == np.min(filleddata[lblix])
assert stats[lbl]['max'] == np.max(filleddata[lblix])
np.testing.assert_almost_equal(
stats[lbl]['sum'], np.sum(filleddata.astype(np.float64)[lblix]))
assert stats[lbl]['count'] == np.sum(lblix)