def erosion_filter(
in_raster,
width=3,
iterations=1,
circular=True,
weighted_distance=True,
sigma=3.5,
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
weighted_edges=True,
weighted_distance=weighted_distance,
sigma=sigma,
normalise=False,
))
if iterations == 1:
return kernel_filter(in_raster, kernel,
"erode").astype(in_raster.dtype)
else:
result = kernel_filter(in_raster, kernel,
"erode").astype(in_raster.dtype)
for _ in range(iterations - 1):
result = kernel_filter(result, kernel,
"erode").astype(in_raster.dtype)
return result
def mean_deviation_filter(
in_raster,
width=3,
absolute_value=False,
circular=True,
weighted_edges=True,
holed=True,
weighted_distance=True,
distance_calc="gaussian",
sigma=2,
dtype='float32',
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
holed=holed,
weighted_edges=weighted_edges,
weighted_distance=weighted_distance,
distance_calc=distance_calc,
sigma=sigma,
))
result = in_raster - mean_filter(in_raster, _kernel=kernel)
if absolute_value is True:
return np.abs(result).astype(dtype)
return result.astype(dtype)
def fast_sum_filter(
in_raster,
width=3,
circular=True,
holed=False,
weighted_edges=True,
weighted_distance=False,
distance_calc="gaussian",
sigma=2,
dtype=False,
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
holed=holed,
normalise=False,
weighted_edges=weighted_edges,
weighted_distance=weighted_distance,
distance_calc=distance_calc,
sigma=sigma,
))
# TODO: HANDLE NODATA
# return fast_sum(in_raster, kernel).astype(in_raster.dtype)
return scipy.signal.fftconvolve(in_raster, kernel,
mode='same').astype(in_raster.dtype)
def sum_filter(
in_raster,
width=3,
circular=True,
holed=False,
weighted_edges=True,
weighted_distance=False,
distance_calc="gaussian",
sigma=2,
dtype=False,
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
holed=holed,
normalise=False,
weighted_edges=weighted_edges,
weighted_distance=weighted_distance,
distance_calc=distance_calc,
sigma=sigma,
))
if dtype is False:
return kernel_filter(in_raster, kernel, "mean").astype(in_raster.dtype)
return kernel_filter(in_raster, kernel, "mean").astype(dtype)
def median_filter(
in_raster,
width=3,
iterations=1,
circular=True,
holed=False,
weighted_edges=True,
weighted_distance=True,
distance_calc="gaussian",
sigma=2,
dtype='float32',
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
holed=holed,
weighted_edges=weighted_edges,
weighted_distance=weighted_distance,
distance_calc=distance_calc,
sigma=sigma,
))
if iterations == 1:
return kernel_filter(in_raster, kernel, "median", dtype)
else:
result = kernel_filter(in_raster, kernel, "median", dtype)
for _ in range(iterations - 1):
result = kernel_filter(result, kernel, "median", dtype)
return result
def feather_s2_filter(tracking_image, value_to_count, width=21, circular=True):
kernel = create_kernel(
width,
circular=circular,
holed=False,
normalise=False,
weighted_edges=False,
weighted_distance=False,
)
return feather_s2_array(tracking_image, value_to_count, kernel)
def assess_radiometric_quality(metadata, calc_quality='high', score=False):
if calc_quality == 'high':
scl = raster_to_array(metadata['path']['20m']['SCL']).astype('intc')
aot = raster_to_array(metadata['path']['20m']['AOT']).astype('intc')
band_02 = raster_to_array(
metadata['path']['20m']['B02']).astype('intc')
band_12 = raster_to_array(
metadata['path']['20m']['B12']).astype('intc')
band_cldprb = raster_to_array(metadata['path']['QI']['CLDPRB_20m'])
distance = 63
else:
scl = raster_to_array(metadata['path']['60m']['SCL']).astype('intc')
aot = raster_to_array(metadata['path']['60m']['AOT']).astype('intc')
band_cldprb = raster_to_array(metadata['path']['QI']['CLDPRB_60m'])
band_02 = raster_to_array(
metadata['path']['60m']['B02']).astype('intc')
band_12 = raster_to_array(
metadata['path']['60m']['B12']).astype('intc')
distance = 21
kernel_nodata = create_kernel(201,
weighted_edges=False,
weighted_distance=False,
normalise=False).astype('uint8')
# Dilate nodata values by 1km each side
nodata_dilated = cv2.dilate((scl == 0).astype('uint8'),
kernel_nodata).astype('intc')
darkprb = np.zeros(scl.shape)
darkprb = np.where(scl == 2, 55, 0)
darkprb = np.where(scl == 3, 45, darkprb).astype('uint8')
darkprb = cv2.GaussianBlur(darkprb, (distance, distance),
0).astype(np.double)
band_cldprb = cv2.GaussianBlur(band_cldprb, (distance, distance),
0).astype(np.double)
quality = np.zeros(scl.shape, dtype=np.double)
td = 0.0 if score is True else metadata['time_difference'] / 86400
# OBS: the radiometric_quality functions mutates the quality input.
combined_score = radiometric_quality(scl, band_02, band_12, band_cldprb,
darkprb, aot, nodata_dilated, quality,
td, metadata['SUN_ELEVATION'])
if score is True:
return combined_score
blur_dist = 31
quality_blurred = cv2.GaussianBlur(quality, (blur_dist, blur_dist),
0).astype(np.double)
return quality_blurred, scl
def cdef_difference_filter(
in_raster_master,
in_raster_slave,
width=3,
circular=True,
holed=False,
weighted_edges=True,
weighted_distance=False,
distance_calc="gaussian",
sigma=2,
dtype='float32',
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
holed=holed,
normalise=True,
weighted_edges=weighted_edges,
weighted_distance=weighted_distance,
distance_calc=distance_calc,
sigma=sigma,
))
master_mean = kernel_filter(in_raster_master, kernel, 'mean')
slave_mean = kernel_filter(in_raster_slave, kernel, 'mean')
master_median = kernel_filter(in_raster_master, kernel, "median")
slave_median = kernel_filter(in_raster_slave, kernel, 'median')
abs_median_diff = np.abs(master_median - slave_median)
master_mean_difference = np.abs(master_mean -
np.abs(master_median - slave_median))
slave_mean_difference = np.abs(slave_mean -
np.abs(master_median - slave_median))
master_mad_std = kernel_filter(in_raster_master, kernel, 'mad_std')
slave_mad_std = kernel_filter(in_raster_slave, kernel, 'mad_std')
with np.errstate(divide='ignore', invalid='ignore'):
zscores_master = (master_mean -
master_mean_difference) / master_mad_std
zscores_master[master_mad_std == 0] = 0
zscores_slave = (slave_mean - slave_mean_difference) / slave_mad_std
zscores_slave[slave_mad_std == 0] = 0
return np.min([zscores_master, zscores_slave], axis=0)
def mode_filter(in_raster, width=5, iterations=1, circular=True):
kernel = create_kernel(
width,
circular=circular,
holed=False,
normalise=False,
weighted_edges=False,
weighted_distance=False,
)
if iterations == 1:
# return mode_array(in_raster, kernel)
return majority(in_raster, kernel)
else:
# result = mode_array(in_raster, kernel)
result = majority(in_raster, kernel)
for x in range(iterations - 1):
result = majority(result, kernel)
# result = mode_array(result, kernel)
return result
def close_filter(
in_raster,
width=3,
circular=True,
weighted_distance=True,
sigma=3.5,
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
weighted_edges=True,
weighted_distance=weighted_distance,
sigma=sigma,
normalise=False,
))
return kernel_filter(
kernel_filter(in_raster, kernel, "dilate"),
kernel,
"erode",
).astype(in_raster.dtype)
def kurtosis_filter(
in_raster,
width=3,
circular=True,
holed=False,
weighted_edges=True,
weighted_distance=True,
distance_calc="gaussian",
sigma=2,
dtype='float32',
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
holed=holed,
weighted_edges=weighted_edges,
weighted_distance=weighted_distance,
distance_calc=distance_calc,
sigma=sigma,
))
return kernel_filter(in_raster, kernel, "kurtosis", dtype)
def snr_filter(
in_raster,
width=3,
circular=True,
weighted_edges=True,
weighted_distance=True,
distance_calc="gaussian",
sigma=2,
dtype="float32",
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
holed=True,
weighted_edges=weighted_edges,
weighted_distance=weighted_distance,
distance_calc=distance_calc,
sigma=sigma,
))
return np.power(mean_filter(in_raster, _kernel=kernel),
2) / variance_filter(in_raster,
_kernel=kernel).astype(dtype)
def z_filter(
in_raster,
width=3,
circular=True,
holed=False,
weighted_edges=True,
weighted_distance=True,
distance_calc="gaussian",
sigma=2,
dtype='float32',
_kernel=False,
):
kernel = (_kernel if _kernel is not False else create_kernel(
width,
circular=circular,
holed=holed,
weighted_edges=weighted_edges,
weighted_distance=weighted_distance,
distance_calc=distance_calc,
sigma=sigma,
))
return ((in_raster - mean_filter(in_raster, _kernel=kernel)) /
standard_deviation_filter(in_raster, _kernel=kernel)).astype(dtype)
sys.path.append('..')
from matplotlib import pyplot as plt
from lib.raster_io import raster_to_array, array_to_raster
from lib.stats_kernel import create_kernel
folder = 'C:\\Users\\caspe\\Desktop\\Data\\Sentinel1\\'
in_raster = f'{folder}accra_s1.tif'
out_figure = f'{folder}accra_s1_fkernel.png'
data = raster_to_array(in_raster)
kernel_size = 5
kernel = create_kernel(kernel_size,
circular=True,
weighted_edges=True,
inverted=False,
holed=False,
normalise=True,
weighted_distance=True,
sigma=2,
distance_calc='guassian',
plot=True).astype(np.float)
fig, ax = plt.subplots()
im = ax.imshow(kernel, cmap='bone_r', interpolation=None) # no vmin=0, vmax=1
radius = kernel_size // 2
circle = plt.Circle((radius, radius),
radius + 0.5,
color='black',
fill=False,
linestyle='--')
