def test_allocation():
# create test raster, all non-zero cells are unique,
# this is to test against corresponding proximity
raster = create_test_raster()
allocation_agg = allocation(raster, x='lon', y='lat')
# output must be an xarray DataArray
assert isinstance(allocation_agg, xa.DataArray)
assert type(allocation_agg.values[0][0]) == raster.dtype
assert allocation_agg.shape == raster.shape
# targets not specified,
# Thus, targets are set to non-zero values of input @raster
targets = np.unique(raster.data[np.where((raster.data != 0)
& np.isfinite(raster.data))])
# non-zero cells (a.k.a targets) remain the same
for t in targets:
ry, rx = np.where(raster.data == t)
for y, x in zip(ry, rx):
assert allocation_agg.values[y, x] == t
# values of allocation output
assert (np.unique(allocation_agg.data) == targets).all()
# check against corresponding proximity
proximity_agg = proximity(raster, x='lon', y='lat')
xcoords = allocation_agg['lon'].data
ycoords = allocation_agg['lat'].data
for y in range(raster.shape[0]):
for x in range(raster.shape[1]):
a = allocation_agg.data[y, x]
py, px = np.where(raster.data == a)
# non-zero cells in raster are unique, thus len(px)=len(py)=1
d = euclidean_distance(xcoords[x], xcoords[px[0]], ycoords[y],
ycoords[py[0]])
assert proximity_agg.data[y, x] == d
def test_manhattan_proximity(test_raster, result_manhattan_proximity):
manhattan_prox = proximity(test_raster,
x='lon',
y='lat',
distance_metric='MANHATTAN')
general_output_checks(test_raster,
manhattan_prox,
result_manhattan_proximity,
verify_dtype=True)
def test_great_circle_proximity(test_raster, result_great_circle_proximity):
great_circle_prox = proximity(test_raster,
x='lon',
y='lat',
distance_metric='GREAT_CIRCLE')
general_output_checks(test_raster,
great_circle_prox,
result_great_circle_proximity,
verify_dtype=True)
def test_max_distance_proximity(test_raster, result_max_distance_proximity):
max_distance, expected_result = result_max_distance_proximity
max_distance_prox = proximity(test_raster,
x='lon',
y='lat',
max_distance=max_distance)
general_output_checks(test_raster,
max_distance_prox,
expected_result,
verify_dtype=True)
def test_target_proximity(test_raster, result_target_proximity):
target_values, expected_result = result_target_proximity
target_prox = proximity(test_raster,
x='lon',
y='lat',
target_values=target_values)
general_output_checks(test_raster,
target_prox,
expected_result,
verify_dtype=True)
def test_proximity_distance_metric():
# distance_metric SETTING
dm_proximity = proximity(raster, distance_metric='GREAT_CIRCLE')
# output must be an xarray DataArray
assert isinstance(dm_proximity, xa.DataArray)
assert isinstance(dm_proximity.values, np.ndarray)
assert type(dm_proximity.values[0][0]) == np.float64
assert dm_proximity.values.shape[0] == height
assert dm_proximity.values.shape[1] == width
def test_proximity_great_circle():
# distance_metric SETTING
dm_proximity = proximity(raster, distance_metric='GREAT_CIRCLE')
# output must be an xarray DataArray
assert isinstance(dm_proximity, xa.DataArray)
assert isinstance(dm_proximity.values, np.ndarray)
assert type(dm_proximity.values[0][0]) == np.float64
assert dm_proximity.values.shape[0] == height
assert dm_proximity.values.shape[1] == width
# all output values must be in range [0, max_possible_distance]
max_possible_distance = great_circle_distance(
raster.coords['x'].values[0], raster.coords['x'].values[-1],
raster.coords['y'].values[0], raster.coords['y'].values[-1])
assert np.nanmax(dm_proximity.values) <= max_possible_distance
assert np.nanmin(dm_proximity.values) == 0
def test_proximity_target_value():
# TARGET VALUES SETTING
target_values = [2, 3]
num_target = (raster == 2).sum() + (raster == 3).sum()
tv_proximity = proximity(raster, target_values=target_values)
tv_proximity_img = tv_proximity.values
tv_zeros = (tv_proximity_img == 0).sum()
# output must be an xarray DataArray
assert isinstance(tv_proximity, xa.DataArray)
assert isinstance(tv_proximity.values, np.ndarray)
assert type(tv_proximity.values[0][0]) == np.float64
assert tv_proximity.values.shape[0] == height
assert tv_proximity.values.shape[1] == width
assert num_target == tv_zeros
def test_proximity_manhattan():
# distance_metric SETTING
dm_proximity = proximity(raster, 'lat', 'lon', distance_metric='MANHATTAN')
# output must be an xarray DataArray
assert isinstance(dm_proximity, xa.DataArray)
assert isinstance(dm_proximity.values, np.ndarray)
assert type(dm_proximity.values[0][0]) == np.float64
assert dm_proximity.values.shape[0] == height
assert dm_proximity.values.shape[1] == width
# all output values must be in range [0, max_possible_distance]
max_possible_distance = manhattan_distance(raster.coords['lat'].values[0],
raster.coords['lat'].values[-1],
raster.coords['lon'].values[0],
raster.coords['lon'].values[-1])
assert np.nanmax(dm_proximity.values) <= max_possible_distance
assert np.nanmin(dm_proximity.values) == 0
def test_proximity_default():
# DEFAULT SETTINGS
# proximity(img, max_distance=None, target_values=[], dist_units=PIXEL,
# nodata=np.nan)
default_proximity = proximity(raster)
default_proximity_img = default_proximity.values
zeros_default = (default_proximity_img == 0).sum()
# output must be an xarray DataArray
assert isinstance(default_proximity, xa.DataArray)
assert isinstance(default_proximity.values, np.ndarray)
assert type(default_proximity.values[0][0]) == np.float64
assert default_proximity.values.shape[0] == height
assert default_proximity.values.shape[1] == width
# number of non-zeros (target pixels) in original image
# must be equal to the number of zeros (target pixels) in proximity matrix
assert nonzeros_raster == zeros_default
def test_proximity():
raster = create_test_raster()
# DEFAULT SETTINGS
default_prox = proximity(raster, x='lon', y='lat')
# output must be an xarray DataArray
assert isinstance(default_prox, xa.DataArray)
assert isinstance(default_prox.values, np.ndarray)
assert type(default_prox.values[0][0]) == np.float64
assert default_prox.shape == raster.shape
# number of non-zeros (target pixels) in original image
# must be equal to the number of zeros (target pixels) in proximity matrix
assert len(np.where(raster.data != 0)[0]) == \
len(np.where(default_prox.data == 0)[0])
# TARGET VALUES SETTING
target_values = [2, 3]
target_prox = proximity(raster,
x='lon',
y='lat',
target_values=target_values)
# output must be an xarray DataArray
assert isinstance(target_prox, xa.DataArray)
assert isinstance(target_prox.values, np.ndarray)
assert type(target_prox.values[0][0]) == np.float64
assert target_prox.shape == raster.shape
assert (len(np.where(raster.data == 2)[0]) +
len(np.where(raster.data == 3)[0])) == \
len(np.where(target_prox.data == 0)[0])
# distance_metric SETTING: MANHATTAN
manhattan_prox = proximity(raster,
x='lon',
y='lat',
distance_metric='MANHATTAN')
# output must be an xarray DataArray
assert isinstance(manhattan_prox, xa.DataArray)
assert isinstance(manhattan_prox.values, np.ndarray)
assert type(manhattan_prox.values[0][0]) == np.float64
assert manhattan_prox.shape == raster.shape
# all output values must be in range [0, max_possible_dist]
max_possible_dist = manhattan_distance(raster.coords['lon'].values[0],
raster.coords['lon'].values[-1],
raster.coords['lat'].values[0],
raster.coords['lat'].values[-1])
assert np.nanmax(manhattan_prox.values) <= max_possible_dist
assert np.nanmin(manhattan_prox.values) == 0
# distance_metric SETTING: GREAT_CIRCLE
great_circle_prox = proximity(raster,
x='lon',
y='lat',
distance_metric='GREAT_CIRCLE')
# output must be an xarray DataArray
assert isinstance(great_circle_prox, xa.DataArray)
assert isinstance(great_circle_prox.values, np.ndarray)
assert type(great_circle_prox.values[0][0]) == np.float64
assert great_circle_prox.shape == raster.shape
# all output values must be in range [0, max_possible_dist]
max_possible_dist = great_circle_distance(raster.coords['lon'].values[0],
raster.coords['lon'].values[-1],
raster.coords['lat'].values[0],
raster.coords['lat'].values[-1])
assert np.nanmax(great_circle_prox.values) <= max_possible_dist
assert np.nanmin(great_circle_prox.values) == 0
def test_proximity():
raster = create_test_raster()
# add crs for tests
raster_for_default = _add_EPSG4326_crs_to_da(raster)
# DEFAULT SETTINGS
default_prox = proximity(raster_for_default, x='lon', y='lat')
# output must be an xarray DataArray
assert isinstance(default_prox, xa.DataArray)
assert type(default_prox.values[0][0]) == np.float64
assert default_prox.shape == raster_for_default.shape
# crs tests
assert default_prox.attrs == raster_for_default.attrs
for coord in raster_for_default.coords:
assert np.all(default_prox[coord] == raster_for_default[coord])
# in this test case, where no polygon is completely inside another polygon,
# number of non-zeros (target pixels) in original image
# must be equal to the number of zeros (target pixels) in proximity matrix
assert len(np.where((raster.data != 0) & np.isfinite(raster.data))[0]) == \
len(np.where(default_prox.data == 0)[0])
# TARGET VALUES SETTING
target_values = [2, 3]
target_prox = proximity(raster,
x='lon',
y='lat',
target_values=target_values)
# output must be an xarray DataArray
assert isinstance(target_prox, xa.DataArray)
assert type(target_prox.values[0][0]) == np.float64
assert target_prox.shape == raster.shape
assert (len(np.where(raster.data == 2)[0]) +
len(np.where(raster.data == 3)[0])) == \
len(np.where(target_prox.data == 0)[0])
# distance_metric SETTING: MANHATTAN
manhattan_prox = proximity(raster,
x='lon',
y='lat',
distance_metric='MANHATTAN')
# output must be an xarray DataArray
assert isinstance(manhattan_prox, xa.DataArray)
assert type(manhattan_prox.values[0][0]) == np.float64
assert manhattan_prox.shape == raster.shape
# all output values must be in range [0, max_possible_dist]
max_possible_dist = manhattan_distance(raster.coords['lon'].values[0],
raster.coords['lon'].values[-1],
raster.coords['lat'].values[0],
raster.coords['lat'].values[-1])
assert np.nanmax(manhattan_prox.values) <= max_possible_dist
assert np.nanmin(manhattan_prox.values) == 0
# distance_metric SETTING: GREAT_CIRCLE
great_circle_prox = proximity(raster,
x='lon',
y='lat',
distance_metric='GREAT_CIRCLE')
# output must be an xarray DataArray
assert isinstance(great_circle_prox, xa.DataArray)
assert type(great_circle_prox.values[0][0]) == np.float64
assert great_circle_prox.shape == raster.shape
# all output values must be in range [0, max_possible_dist]
max_possible_dist = great_circle_distance(raster.coords['lon'].values[0],
raster.coords['lon'].values[-1],
raster.coords['lat'].values[0],
raster.coords['lat'].values[-1])
assert np.nanmax(great_circle_prox.values) <= max_possible_dist
assert np.nanmin(great_circle_prox.values) == 0
def test_default_proximity(test_raster, result_default_proximity):
default_prox = proximity(test_raster, x='lon', y='lat')
general_output_checks(test_raster,
default_prox,
result_default_proximity,
verify_dtype=True)
