def smooth_mask(mask, dilate_size=7, erode_size=7):
_erode_kernel, erode_offsets, _erode_weights = create_kernel(
(erode_size, erode_size),
spherical=True,
edge_weights=False,
offsets=True,
normalised=False,
distance_calc=False,
output_2d=True,
remove_zero_weights=True,
)
_dilate_kernel, dilate_offsets, _dilate_weights = create_kernel(
(dilate_size, dilate_size),
spherical=True,
edge_weights=False,
offsets=True,
normalised=False,
distance_calc=False,
output_2d=True,
remove_zero_weights=True,
)
eroded = convolve_2D(mask, erode_offsets, operation="erode")
dilated = convolve_2D(eroded, dilate_offsets, operation="dilate")
return dilated
def smooth_quality(quality, dilate_size=5, erode_size=15):
_dilate_kernel, dilate_offsets, _dilate_weights = create_kernel(
(dilate_size, dilate_size),
spherical=True,
edge_weights=False,
offsets=True,
normalised=False,
distance_calc=False,
output_2d=True,
remove_zero_weights=True,
)
_erode_kernel, erode_offsets, _erode_weights = create_kernel(
(erode_size, erode_size),
spherical=True,
edge_weights=False,
offsets=True,
normalised=False,
distance_calc=False,
output_2d=True,
remove_zero_weights=True,
)
dilated = convolve_2D(quality, dilate_offsets, operation="dilate")
eroded = convolve_2D(dilated, erode_offsets, operation="erode")
return eroded
def filter_array(
arr,
shape,
sigma=1,
spherical=True,
edge_weights=True,
normalised=True,
nodata=False,
nodata_value=0,
quantile=0.5,
distance_calc="gaussian",
radius_method="ellipsoid",
remove_zero_weights=True,
operation="sum",
kernel=None,
):
if len(arr.shape) == 3 and len(shape) != 3:
shape = (shape[0], shape[1], 1)
if len(arr.shape) == 2:
if len(shape) == 3:
if shape[0] != 1:
shape[0] = 1
elif len(shape) == 2:
arr = arr[np.newaxis, :, :]
else:
raise ValueError("Unable to merge shape and array.")
if kernel is None:
_kernel, offsets, weights = create_kernel(
shape,
sigma=sigma,
spherical=spherical,
edge_weights=edge_weights,
offsets=True,
normalised=normalised,
distance_calc=distance_calc,
radius_method=radius_method,
remove_zero_weights=remove_zero_weights,
)
else:
_kernel, offsets, weights = kernel
return convolve_3d(
arr,
offsets,
weights,
operation=operation,
nodata=nodata,
nodata_value=nodata_value,
quantile=quantile,
)
def feather(arr, values_to_count, size=11):
_kernel, offsets, _weights = create_kernel(
(size, size),
spherical=True,
edge_weights=False,
offsets=True,
normalised=False,
distance_calc=False,
output_2d=True,
remove_zero_weights=True,
)
return _feather_2d(arr, offsets, values_to_count)
def pansharpen(pan_path, tar_path, out_path):
target = resample_raster(tar_path, pan_path, resample_alg="bilinear")
aligned = align_rasters(target, master=pan_path)
target = aligned[0]
tar_arr = raster_to_array(target, output_2d=True)
tar_arr = (tar_arr - tar_arr.min()) / (tar_arr.max() - tar_arr.min())
pan_arr = raster_to_array(pan_path, output_2d=True)
_kernel, offsets, weights = create_kernel(
[5, 5], sigma=2, output_2d=True, offsets=True
)
pan = pansharpen_filter(pan_arr, tar_arr, offsets, weights.astype("float32"))
array_to_raster(pan, reference=target, out_path=out_path)
folder + "vv_01.tif",
folder + "vv_02.tif",
folder + "vv_03.tif",
]
sar_data = raster_to_array(layers)
kernel_size = 3
nodata_value = -9999.0
_kernel, offsets_3D, weights_3D = create_kernel(
(kernel_size, kernel_size, sar_data.shape[2]),
distance_calc=False, # "gaussian"
sigma=1,
spherical=True,
radius_method="ellipsoid",
offsets=True,
edge_weights=True,
normalised=True,
remove_zero_weights=True,
)
_kernel, offsets_2D, weights_2D = create_kernel(
(kernel_size, kernel_size, 1),
distance_calc=False, # "gaussian"
spherical=True,
radius_method="ellipsoid",
offsets=True,
edge_weights=True,
normalised=True,
remove_zero_weights=True,
def process_aligned(
aligned_rasters,
out_path,
folder_tmp,
chunks,
master_raster,
nodata_value,
feather_weights=None,
):
kernel_size = 3
chunk_offset = kernel_size // 2
_kernel, offsets, weights = create_kernel(
(kernel_size, kernel_size, len(aligned_rasters)),
distance_calc=False, # "gaussian"
sigma=1,
spherical=True,
radius_method="ellipsoid",
offsets=True,
edge_weights=True,
normalised=True,
remove_zero_weights=True,
)
arr_aligned = raster_to_array(aligned_rasters)
if feather_weights is not None:
feather_weights_arr = raster_to_array(feather_weights)
if not rasters_are_aligned(aligned_rasters):
raise Exception("Rasters not aligned")
if chunks > 1:
chunks_list = []
print("Chunking rasters")
uids = uuid4()
for chunk in range(chunks):
print(f"Chunk {chunk + 1} of {chunks}")
cut_start = False
cut_end = False
if chunk == 0:
chunk_start = 0
else:
chunk_start = (chunk *
(arr_aligned.shape[0] // chunks)) - chunk_offset
cut_start = True
if chunk == chunks - 1:
chunk_end = arr_aligned.shape[0]
else:
chunk_end = ((chunk + 1) *
(arr_aligned.shape[0] // chunks)) + chunk_offset
cut_end = True
arr_chunk = arr_aligned[chunk_start:chunk_end]
if feather_weights is not None:
weights_chunk = feather_weights_arr[chunk_start:chunk_end]
else:
weights_chunk = np.ones_like(arr_chunk)
print(" Collapsing...")
arr_collapsed = s1_collapse(
arr_chunk,
offsets,
weights,
weights_chunk,
weighted=True,
nodata_value=nodata_value,
nodata=True,
)
offset_start = chunk_offset if cut_start else 0
offset_end = (arr_collapsed.shape[0] -
chunk_offset if cut_end else arr_collapsed.shape[0])
chunk_path = folder_tmp + f"{uids}_chunk_{chunk}.npy"
chunks_list.append(chunk_path)
np.save(chunk_path, arr_collapsed[offset_start:offset_end])
arr_chunk = None
arr_collapsed = None
print("Merging Chunks")
arr_aligned = None
merged = []
for chunk in chunks_list:
merged.append(np.load(chunk))
merged = np.concatenate(merged)
merged = np.ma.masked_array(merged, mask=merged == nodata_value)
merged.fill_value = nodata_value
print("Writing raster.")
array_to_raster(
merged,
master_raster,
out_path=out_path,
)
merged = None
return out_path
if feather_weights is not None:
weights_borders = feather_weights
else:
weights_borders = np.ones_like(arr_aligned)
print("Collapsing rasters")
arr_collapsed = s1_collapse(
arr_aligned,
offsets,
weights,
weights_borders,
weighted=True,
nodata_value=nodata_value,
nodata=True,
)
arr_collapsed = np.ma.masked_array(arr_collapsed,
mask=arr_collapsed == nodata_value)
arr_collapsed.fill_value = nodata_value
arr_aligned = None
print("Writing raster.")
array_to_raster(
arr_collapsed,
master_raster,
out_path=out_path,
)
arr_collapsed = None
return out_path
def conv_filter(in_raster, kernel=None, filter="sum", iterations=1):
_kernel = kernel if kernel != None else create_kernel()
return filter_array(in_raster, _kernel, filter, iterations)
