def test_inpaint_biharmonic_2d_color_deprecated():
img = img_as_float(data.astronaut()[:64, :64])
mask = np.zeros(img.shape[:2], dtype=bool)
mask[8:16, :16] = 1
img_defect = img * ~mask[..., np.newaxis]
mse_defect = mean_squared_error(img, img_defect)
# providing multichannel argument positionally also warns
channel_warning = "`multichannel` is a deprecated argument"
matrix_warning = "the matrix subclass is not the recommended way"
with expected_warnings([channel_warning + '|' + matrix_warning]):
img_restored = inpaint.inpaint_biharmonic(img_defect,
mask,
multichannel=True)
mse_restored = mean_squared_error(img, img_restored)
assert mse_restored < 0.01 * mse_defect
# providing multichannel argument positionally also warns
channel_warning = "Providing the `multichannel` argument"
with expected_warnings([channel_warning + '|' + matrix_warning]):
img_restored = inpaint.inpaint_biharmonic(img_defect, mask, True)
mse_restored = mean_squared_error(img, img_restored)
assert mse_restored < 0.01 * mse_defect
def test_inpaint_biharmonic_3d():
img = np.tile(np.square(np.linspace(0, 1, 5)), (5, 1))
img = np.dstack((img, img.T))
mask = np.zeros_like(img)
mask[2, 2:, :] = 1
mask[1, 3:, :] = 1
mask[0, 4:, :] = 1
img[np.where(mask)] = 0
out = inpaint.inpaint_biharmonic(img, mask)
ref = np.dstack(
(
np.array(
[
[0.0000, 0.0625, 0.25000000, 0.56250000, 0.53752796],
[0.0000, 0.0625, 0.25000000, 0.44443780, 0.53762210],
[0.0000, 0.0625, 0.23693666, 0.46621112, 0.68615592],
[0.0000, 0.0625, 0.25000000, 0.56250000, 1.00000000],
[0.0000, 0.0625, 0.25000000, 0.56250000, 1.00000000],
]
),
np.array(
[
[0.0000, 0.0000, 0.00000000, 0.00000000, 0.19621902],
[0.0625, 0.0625, 0.06250000, 0.17470756, 0.30140091],
[0.2500, 0.2500, 0.27241289, 0.35155440, 0.43068654],
[0.5625, 0.5625, 0.56250000, 0.56250000, 0.56250000],
[1.0000, 1.0000, 1.00000000, 1.00000000, 1.00000000],
]
),
)
)
assert_allclose(ref, out)
def infill_small_regions(I):
"""Infill small nan regions within an image using a tiling approach to save
on memory.
Arguments:
I: the image
Returns:
The infilled image.
"""
n_tiles = 4 # ntiles horizontally.
assert I.shape[0] == I.shape[1]
tile_size = I.shape[0] // (n_tiles - 1)
tile_delta = tile_size // 2
k = 0
I_stack = np.ones(I.shape + (2, 2)) * np.nan
for j in range(n_tiles * 2 - 1):
for i in range(n_tiles * 2 - 1):
dy = slice(tile_delta * j, tile_delta * (j + 2))
dx = slice(tile_delta * i, tile_delta * (i + 2))
S = I[dy, dx]
M = ndimage.binary_dilation(np.isnan(S), iterations=2)
image_inpainted = inpaint.inpaint_biharmonic(S, M, multichannel=False)
I_stack[dy, dx, j % 2, i % 2] = image_inpainted
k += 1
return np.nanmean(np.nanmean(I_stack, axis=2), axis=2)
def process_image(extend_img):
print('yes')
mask = np.where(np.isnan(extend_img), 255, 0)
img_test = np.where(np.isnan(extend_img), 0, extend_img)
extend_img = inpaint.inpaint_biharmonic(img_test, mask, multichannel=False)
print('done')
return extend_img
def visualize_natural_color_bi(product, B):
#reference: https://stackoverflow.com/questions/42872293/channel-mix-with-pillow
global product_name
name = product_name + ".png"
#read radiance channels
# rads = product.load_radiances()
# s1 = rads["S1_radiance_an"].values
# s3 = rads["S3_radiance_an"].values
# s5 = rads["S5_radiance_an"].values
refs = product.load_reflectances()
s1 = refs["S1_reflectance_an"].values * 255
s3 = refs["S3_reflectance_an"].values * 255
s5 = refs["S5_reflectance_an"].values * 255
#----------test--------------
start_time = time.time()
row, col = s1.shape
s1 = s1[5:row - 5, 100:col - 80]
#fill s1 NaNs
mask1 = numpy.isnan(s1)
f_s1 = inpaint.inpaint_biharmonic(s1, mask1)
print("--- %s seconds ---" % (time.time() - start_time))
start_time = time.time()
s3 = s3[5:row - 5, 100:col - 80]
#fill s3 NaNs
mask3 = numpy.isnan(s3)
f_s3 = inpaint.inpaint_biharmonic(s3, mask3)
print("--- %s seconds ---" % (time.time() - start_time))
start_time = time.time()
s5 = s5[5:row - 5, 100:col - 80]
#fill s5 NaNs
mask5 = numpy.isnan(s5)
f_s5 = inpaint.inpaint_biharmonic(s5, mask5)
print("--- %s seconds ---" % (time.time() - start_time))
#-----------------------------
# # Transform channel data
r, g, b = (f_s3 + f_s5) / 2, f_s3, (f_s3 + f_s1) / 2
# Merge channels
out_data = numpy.stack((r, g, b), axis=2).astype('uint8')
out_img = Image.fromarray(out_data)
out_img.save(B + "/" + "origin/" + name, "PNG", optimize=True)
def _inpainting_fill(self, img, mask):
"""
"""
img[np.where(mask ==1)] =1
image_result = inpaint.inpaint_biharmonic(img, mask,
multichannel=False)
return image_result
def process_cloud(cloud):
# start = time.time()
# remove all non ground points; gnd labels = [40, 44, 48, 49]
# gnd, obs = segment_cloud(cloud,[40, 44, 48, 49])
gnd, obs = segment_cloud(cloud,[40, 44, 48, 49,60,72])
visualize = True
if visualize:
fig.clear()
voxel_size = 1
grid_size = np.array([-50, -50, 50, 50])
gnd_img = lidar_to_img(np.copy(gnd), grid_size, voxel_size, fill = 1)
gnd_heightmap = lidar_to_heightmap(np.copy(gnd), grid_size, voxel_size, max_points = 100)
fig.add_subplot(2, 3, 1)
plt.imshow(gnd_img, interpolation='nearest')
kernel = np.ones((5,5),np.uint8)
gnd_img_dil = cv2.dilate(gnd_img,kernel,iterations = 2)
fig.add_subplot(2, 3, 2)
plt.imshow(gnd_img_dil, interpolation='nearest')
mask = gnd_img_dil - gnd_img
fig.add_subplot(2, 3, 3)
plt.imshow(mask, interpolation='nearest')
# mask = mask.clip(min=0)
fig.add_subplot(2, 3, 4)
cs = plt.imshow(gnd_heightmap, interpolation='nearest')
cbar = fig.colorbar(cs)
image_result = inpaint.inpaint_biharmonic(gnd_heightmap, mask)
fig.add_subplot(2, 3, 5)
cs = plt.imshow(image_result, interpolation='nearest')
cbar = fig.colorbar(cs)
image_result = signal.convolve2d(image_result, kernel, boundary='wrap', mode='same')/kernel.sum()
# image_result = inpaint.inpaint_biharmonic(image_result, mask)
# image_result = cv2.dilate(image_result,kernel,iterations = 1)
# kernel = np.array([[0,1,0],
# [1,0,1],
# [0,1,0]])
# kernel = np.ones((7,7),np.uint8)
# kernel[3,3] = 0
# ind = mask == 1
# for i in range(10):
# conv_out = signal.convolve2d(gnd_heightmap, kernel, boundary='wrap', mode='same')/kernel.sum()
# gnd_heightmap[ind] = conv_out[ind]
fig.add_subplot(2, 3, 6)
cs = plt.imshow(image_result, interpolation='nearest')
cbar = fig.colorbar(cs)
plt.show()
# cbar.remove()
seg = semantically_segment_cloud(cloud.copy(), grid_size, voxel_size, image_result)
return gnd, image_result.T, seg
def solve_frame(image):
h, w, c = image.shape
wt_size = 128
mask = np.zeros((h, w), dtype=np.uint8)
mask[h-10-wt_size:h-10, 10:10+wt_size] = 1
# res = cv2.inpaint(image, mask, 3, cv2.INPAINT_TELEA)
res = inpaint.inpaint_biharmonic(image, mask, multichannel=True)
return res
def pseudo_healthy_with_texture(scan_slice,
lesions_all,
coords_all,
masks_all,
names_all,
texture,
iter_erosion_dilation=1,
plot=False,
Tp=20):
'''1. Read all clusters' masks in a lesion (a cluster is a part of a lesion obtained with slic)
2. Replace them for the synthetic healthy texture. 3. Make a mask ring on the outer perimeter of
the mask and inpaint to blend the image '''
slice_healthy = copy(scan_slice)
mask_for_inpain = np.zeros_like(slice_healthy)
Tp = 20
for idx_x, (lesion, coord, mask, name) in enumerate(
zip(lesions_all, coords_all, masks_all, names_all)):
coords_big = [int(i) for i in name.split('_')[1:5]]
coords_sums = coord + coords_big
# print('LOADING: ', coord, coords_big, coords_sums[0], coords_sums[2], name)
new_coords_mask = np.where(mask == 1)[0] + coords_sums[0], np.where(
mask == 1)[1] + coords_sums[2]
slice_healthy[new_coords_mask] = texture[new_coords_mask]
# rings to inpaint
mask_closed = binary_fill_holes(mask, )
mask_in = (mask_closed).astype('int') - binary_erosion(
mask_closed, iterations=iter_erosion_dilation)
mask_out = binary_dilation(
mask_closed,
iterations=iter_erosion_dilation) - (mask_closed).astype('int')
mask_ring = mask_in + mask_out
new_coords_mask_inpain = np.where(
mask_ring == 1)[0] + coords_sums[0], np.where(
mask_ring == 1)[1] + coords_sums[
2] # mask outer rings for inpaint
mask_for_inpain[new_coords_mask_inpain] = 1
slice_healthy_inpain = inpaint.inpaint_biharmonic(slice_healthy,
mask_for_inpain)
if plot:
fig, ax = plt.subplots(1, 3, figsize=(18, 6))
ax[0].imshow(scan_slice[coords_big[0] - Tp:coords_big[1] + Tp,
coords_big[2] - Tp:coords_big[3] + Tp])
ax[0].imshow(scan_mask_slice[coords_big[0] - Tp:coords_big[1] + Tp,
coords_big[2] - Tp:coords_big[3] + Tp],
alpha=.3)
ax[1].imshow(slice_healthy[coords_big[0] - Tp:coords_big[1] + Tp,
coords_big[2] - Tp:coords_big[3] + Tp])
ax[2].imshow(
slice_healthy_inpain[coords_big[0] - Tp:coords_big[1] + Tp,
coords_big[2] - Tp:coords_big[3] + Tp])
return slice_healthy_inpain
def test_inpaint_nrmse(dtype, order, channel_axis, split_into_regions):
image_orig = data.astronaut()[:, :200]
float_dtype = np.float32 if dtype == np.float32 else np.float64
image_orig = image_orig.astype(float_dtype, copy=False)
# Create mask with six block defect regions
mask = np.zeros(image_orig.shape[:-1], dtype=bool)
mask[20:50, 3:20] = 1
mask[165:180, 90:155] = 1
mask[40:60, 170:195] = 1
mask[-60:-40, 170:195] = 1
mask[-180:-165, 90:155] = 1
mask[-50:-20, :20] = 1
# add a few long, narrow defects
mask[200:205, -200:] = 1
mask[150:255, 20:22] = 1
mask[365:368, 60:130] = 1
# add randomly positioned small point-like defects
rstate = np.random.default_rng(0)
for radius in [0, 2, 4]:
# larger defects are less common
thresh = 3.25 + 0.25 * radius # larger defects less commmon
tmp_mask = rstate.standard_normal(image_orig.shape[:-1]) > thresh
if radius > 0:
tmp_mask = binary_dilation(tmp_mask, disk(radius, dtype=bool))
mask[tmp_mask] = 1
# Defect image over the same region in each color channel
image_defect = image_orig.copy()
for layer in range(image_defect.shape[-1]):
image_defect[np.where(mask)] = 0
if channel_axis is None:
image_orig = rgb2gray(image_orig)
image_defect = rgb2gray(image_defect)
image_orig = image_orig.astype(dtype, copy=False)
image_defect = image_defect.astype(dtype, copy=False)
image_defect = np.asarray(image_defect, order=order)
image_result = inpaint.inpaint_biharmonic(
image_defect,
mask,
channel_axis=channel_axis,
split_into_regions=split_into_regions)
assert image_result.dtype == float_dtype
nrmse_defect = normalized_root_mse(image_orig, image_defect)
nrmse_result = normalized_root_mse(img_as_float(image_orig), image_result)
assert nrmse_result < 0.2 * nrmse_defect
def create_background(img: "np.ndarray") -> "np.ndarray":
mask = create_mask(img)
kernel = np.ones((8, 8), np.uint8)
mask_dilation = cv2.dilate(img_as_ubyte(mask), kernel, iterations=2)
# Defect image over the same region in each color channel
image_defect = img.copy()
for layer in range(image_defect.shape[-1]):
image_defect[np.where(mask_dilation)] = 0
image_result = inpaint.inpaint_biharmonic(image_defect, mask_dilation, multichannel=True)
return image_result
def vec_to_sevelev_newlayout(x):
''' convert a vector consisting of 32 electrodes to a 7x11 matrix using
inpainting '''
x = np.squeeze(x)
w = 11
h = 7
elcpos = np.empty((h, w))
elcpos[:] = np.nan
elcpos[0, 4] = x[0]
elcpos[1, 3] = x[1]
elcpos[1, 2] = x[2]
elcpos[2, 0] = x[3]
elcpos[2, 2] = x[4]
elcpos[2, 4] = x[5]
elcpos[3, 3] = x[6]
elcpos[3, 1] = x[7]
elcpos[4, 0] = x[8]
elcpos[4, 2] = x[9]
elcpos[4, 4] = x[10]
elcpos[5, 5] = x[11]
elcpos[5, 3] = x[12]
elcpos[5, 2] = x[13]
elcpos[6, 4] = x[14]
elcpos[6, 5] = x[15]
elcpos[6, 6] = x[16]
elcpos[5, 7] = x[17]
elcpos[5, 8] = x[18]
elcpos[4, 10] = x[19]
elcpos[4, 8] = x[20]
elcpos[4, 6] = x[21]
elcpos[3, 5] = x[22]
elcpos[3, 7] = x[23]
elcpos[3, 9] = x[24]
elcpos[2, 10] = x[25] # FT10
elcpos[2, 8] = x[26]
elcpos[2, 6] = x[27]
elcpos[1, 7] = x[28]
elcpos[1, 8] = x[29]
elcpos[0, 6] = x[30]
# elcpos[1, 5] = 5 Fz was reference
# elcpos[6, 2] = 28 PO9 deleted
# elcpos[6, 8] = 32 PO10 deleted
mask = np.zeros((elcpos.shape))
mask[np.isnan(elcpos)] = 1
return inpaint.inpaint_biharmonic(elcpos, mask, multichannel=False)
def denoiseInpaint(imagen,mask,multichannel):
noisy = img_as_float(imagen)
image_orig = noisy
# Afecta a la imagen original en las regiones marcadas por la mascara
# Se puede cambiar de acuerdo a lo que se necesite
# En este caso produce defectos en la zona
image_defect = image_orig.copy()
for layer in range(image_defect.shape[-1]):
image_defect[np.where(mask)] = 1
image_result = inpaint.inpaint_biharmonic(image_defect, mask, multichannel)
return image_result
def inpaint_biharmonic(frame, mask):
"""
This function ...
:param frame:
:param mask:
:return:
"""
maximum = np.nanmax(frame)
normalized = frame / maximum
data = inpaint.inpaint_biharmonic(normalized, mask, multichannel=False)
return data * maximum
def test_inpaint_biharmonic_2d():
img = np.tile(np.square(np.linspace(0, 1, 5)), (5, 1))
mask = np.zeros_like(img)
mask[2, 2:] = 1
mask[1, 3:] = 1
mask[0, 4:] = 1
img[np.where(mask)] = 0
out = inpaint.inpaint_biharmonic(img, mask)
ref = np.array([[0., 0.0625, 0.25000000, 0.5625000, 0.73925058],
[0., 0.0625, 0.25000000, 0.5478048, 0.76557821],
[0., 0.0625, 0.25842878, 0.5623079, 0.85927796],
[0., 0.0625, 0.25000000, 0.5625000, 1.00000000],
[0., 0.0625, 0.25000000, 0.5625000, 1.00000000]])
assert_allclose(ref, out)
def inpaint_biharmonic(frame, mask):
"""
This function ...
:param frame:
:param mask:
:return:
"""
maximum = np.nanmax(frame)
normalized = frame / maximum
data = inpaint.inpaint_biharmonic(normalized, mask, multichannel=False)
return data * maximum
def paintNaN(array):
# Should be equivalent to the 3rd method in the MATLAB nanpaint function
print("Painting NaNs")
t0 = time.time()
mask = np.zeros(array.shape)
mask[np.isnan(array)] = 1
fixed = inpaint.inpaint_biharmonic(array, mask)
del mask
t1 = time.time()
print("Paint NaNs Time: " + str(t1 - t0))
return fixed
def test_inpaint_biharmonic_2d_float_dtypes(dtype):
img = np.tile(np.square(np.linspace(0, 1, 5)), (5, 1))
mask = np.zeros_like(img)
mask[2, 2:] = 1
mask[1, 3:] = 1
mask[0, 4:] = 1
img[np.where(mask)] = 0
img = img.astype(dtype, copy=False)
out = inpaint.inpaint_biharmonic(img, mask)
assert out.dtype == img.dtype
ref = np.array([[0., 0.0625, 0.25000000, 0.5625000, 0.73925058],
[0., 0.0625, 0.25000000, 0.5478048, 0.76557821],
[0., 0.0625, 0.25842878, 0.5623079, 0.85927796],
[0., 0.0625, 0.25000000, 0.5625000, 1.00000000],
[0., 0.0625, 0.25000000, 0.5625000, 1.00000000]])
assert_allclose(ref, out, rtol=1e-5)
def test_inpaint_biharmonic_2d():
img = np.tile(np.square(np.linspace(0, 1, 5)), (5, 1))
mask = np.zeros_like(img)
mask[2, 2:] = 1
mask[1, 3:] = 1
mask[0, 4:] = 1
img[np.where(mask)] = 0
out = inpaint.inpaint_biharmonic(img, mask)
ref = np.array(
[[0., 0.0625, 0.25000000, 0.5625000, 0.73925058],
[0., 0.0625, 0.25000000, 0.5478048, 0.76557821],
[0., 0.0625, 0.25842878, 0.5623079, 0.85927796],
[0., 0.0625, 0.25000000, 0.5625000, 1.00000000],
[0., 0.0625, 0.25000000, 0.5625000, 1.00000000]]
)
assert_allclose(ref, out)
def test_inpaint_biharmonic_2d_color(channel_axis):
img = img_as_float(data.astronaut()[:64, :64])
mask = np.zeros(img.shape[:2], dtype=bool)
mask[8:16, :16] = 1
img_defect = img * ~mask[..., np.newaxis]
mse_defect = mean_squared_error(img, img_defect)
img_defect = np.moveaxis(img_defect, -1, channel_axis)
img_restored = inpaint.inpaint_biharmonic(img_defect,
mask,
channel_axis=channel_axis)
img_restored = np.moveaxis(img_restored, channel_axis, -1)
mse_restored = mean_squared_error(img, img_restored)
assert mse_restored < 0.01 * mse_defect
def inpaint_image(image, mask):
image = np.array(image.copy())
mask = np.array(mask.copy())
image_orig = rescale(image, 1.0 / 5.0, anti_aliasing=False)
mask = color.rgb2gray(mask)
rescaled_mask = rescale(mask, 1.0 / 5.0, anti_aliasing=False)
thresh = threshold_otsu(rescaled_mask)
binary = rescaled_mask > thresh
image_defect = image_orig.copy()
for layer in range(image_defect.shape[-1]):
image_defect[np.where(binary)] = 0
image_result = inpaint.inpaint_biharmonic(image_defect, binary,
multichannel=True)
image_result = rescale(image_result, 5.0, anti_aliasing=False)
return image_result, mask
def test_invalid_input():
img, mask = np.zeros([]), np.zeros([])
with pytest.raises(ValueError):
inpaint.inpaint_biharmonic(img, mask)
img, mask = np.zeros((2, 2)), np.zeros((4, 1))
with pytest.raises(ValueError):
inpaint.inpaint_biharmonic(img, mask)
img = np.ma.array(np.zeros((2, 2)), mask=[[0, 0], [0, 0]])
mask = np.zeros((2, 2))
with pytest.raises(TypeError):
inpaint.inpaint_biharmonic(img, mask)
def test_invalid_input():
img, mask = np.zeros([]), np.zeros([])
with testing.raises(ValueError):
inpaint.inpaint_biharmonic(img, mask)
img, mask = np.zeros((2, 2)), np.zeros((4, 1))
with testing.raises(ValueError):
inpaint.inpaint_biharmonic(img, mask)
img = np.ma.array(np.zeros((2, 2)), mask=[[0, 0], [0, 0]])
mask = np.zeros((2, 2))
with testing.raises(TypeError):
inpaint.inpaint_biharmonic(img, mask)
def test_inpaint_biharmonic_2d(dtype, split_into_regions):
img = np.tile(np.square(np.linspace(0, 1, 5, dtype=dtype)), (5, 1))
mask = np.zeros_like(img)
mask[2, 2:] = 1
mask[1, 3:] = 1
mask[0, 4:] = 1
img[np.where(mask)] = 0
out = inpaint.inpaint_biharmonic(img,
mask,
split_into_regions=split_into_regions)
assert out.dtype == _supported_float_type(img)
ref = np.array([[0., 0.0625, 0.25000000, 0.5625000, 0.73925058],
[0., 0.0625, 0.25000000, 0.5478048, 0.76557821],
[0., 0.0625, 0.25842878, 0.5623079, 0.85927796],
[0., 0.0625, 0.25000000, 0.5625000, 1.00000000],
[0., 0.0625, 0.25000000, 0.5625000, 1.00000000]])
rtol = 1e-7 if dtype == np.float64 else 1e-6
assert_allclose(ref, out, rtol=rtol)
def test_inpaint_biharmonic_3d():
img = np.tile(np.square(np.linspace(0, 1, 5)), (5, 1))
img = np.dstack((img, img.T))
mask = np.zeros_like(img)
mask[2, 2:, :] = 1
mask[1, 3:, :] = 1
mask[0, 4:, :] = 1
img[np.where(mask)] = 0
out = inpaint.inpaint_biharmonic(img, mask)
ref = np.dstack(
(np.array([[0.0000, 0.0625, 0.25000000, 0.56250000, 0.53752796],
[0.0000, 0.0625, 0.25000000, 0.44443780, 0.53762210],
[0.0000, 0.0625, 0.23693666, 0.46621112, 0.68615592],
[0.0000, 0.0625, 0.25000000, 0.56250000, 1.00000000],
[0.0000, 0.0625, 0.25000000, 0.56250000, 1.00000000]]),
np.array([[0.0000, 0.0000, 0.00000000, 0.00000000, 0.19621902],
[0.0625, 0.0625, 0.06250000, 0.17470756, 0.30140091],
[0.2500, 0.2500, 0.27241289, 0.35155440, 0.43068654],
[0.5625, 0.5625, 0.56250000, 0.56250000, 0.56250000],
[1.0000, 1.0000, 1.00000000, 1.00000000, 1.00000000]])))
assert_allclose(ref, out)
def save_image_in_actual_size(data_set, saving_folder):
"""Takes a data set and save it as .png image"""
global product_name
global name
sleep(0.01)
#dpi = 80
dpi = matplotlib.rcParams['figure.dpi']
img = data_set.values
r, c = img.shape
#img = img[5:r-5,100:c-80]
#fill NaNs
mask = numpy.isnan(img)
start_time = time.time()
print("Start processing: " + product_name + "--" + data_set.name)
try:
im_data = inpaint.inpaint_biharmonic(img, mask)
print("--- %s seconds ---" % (time.time() - start_time))
height, width = im_data.shape
print(im_data.shape)
# What size does the figure need to be in inches to fit the image?
figsize = width / float(dpi), height / float(dpi)
# Create a figure of the right size with one axes that takes up the full figure
fig = plt.figure(figsize=figsize)
ax = fig.add_axes([0, 0, 1, 1])
# Hide spines, ticks, etc.
ax.axis('off')
# Save the image.
name = product_name + ".png"
ax.imshow(im_data, cmap='gray')
plt.savefig(saving_folder + name)
plt.close()
except ValueError: #raised if xx is empty.
print("++++++++ValueError in this product: " + product_name + "--" +
data_set.name)
pass
def call_inpaint(self, coordinates):
image_orig = imageio.imread(self.image1.image_path)
mask = np.zeros(image_orig.shape[:-1])
mask[coordinates[0][1]:coordinates[1][1], coordinates[0][0]:coordinates[1][0]] = 1
image_defect = image_orig.copy()
for layer in range(image_defect.shape[-1]):
image_defect[np.where(mask)] = 0
image_result = inpaint.inpaint_biharmonic(image_defect, mask, multichannel=True)
if debug:
fig, axes = plt.subplots(ncols=2, nrows=2)
ax = axes.ravel()
ax[0].set_title('Original image')
ax[0].imshow(image_orig)
ax[1].set_title('Mask')
ax[1].imshow(mask, cmap=plt.cm.gray)
ax[2].set_title('Defected image')
ax[2].imshow(image_defect)
ax[3].set_title('Inpainted image')
ax[3].imshow(image_result)
for a in ax:
a.axis('off')
fig.tight_layout()
plt.show()
imageio.imwrite(self.image1.image_path, image_result)
self.image1.selection.hide()
def _make_movie(h5file,
outfile,
timestep,
duration,
title='',
usewcs=False,
startw=None,
stopw=None,
startt=None,
stopt=None,
fps=False,
showaxes=False,
inpainting=False,
cps_cutoff=5000,
maskbadpix=False,
colormap='Blue',
dpi=400):
"""returns the movie frames"""
global _cache
movietype = os.path.splitext(outfile)[1].lower()
if movietype not in ('.mp4', '.gif'):
raise ValueError('Only mp4 and gif movies are supported')
try:
cube, wcs, nfo = _cache
if (h5file, timestep, startt, stopt, usewcs, startw, stopw) != nfo:
raise ValueError
except Exception:
getLogger(__name__).info(
'Fetching temporal cube from {}'.format(h5file))
of = mkidpipeline.hdf.photontable.Photontable(h5file)
cube = of.getTemporalCube(firstSec=startt,
integrationTime=stopt,
timeslice=timestep,
startw=startw,
stopw=stopw,
applyWeight=True,
applyTPFWeight=True)
wcs = of.get_wcs(wcs_timestep=startt) if usewcs else None
del of
_cache = cube, wcs, (h5file, timestep, startt, stopt, usewcs, startw,
stopw)
getLogger(__name__).info(
'Retrieved a temporal cube of shape {}'.format(
str(cube['cube'].shape)))
if inpainting:
getLogger(__name__).info(
'Inpainting requested - note this will significantly slow down movie creation'
)
full_frames, times = cube['cube'].T, cube['timeslices']
input_frames = full_frames[:, 10:140, 80:122]
masked_array = np.ma.masked_where(input_frames < cps_cutoff * timestep,
input_frames)
count_masks = np.ma.getmaskarray(masked_array)
masks = count_masks
frames = np.zeros(full_frames.shape)
for i, mask in enumerate(masks):
frames[i, 10:140,
80:122] = inpaint.inpaint_biharmonic(input_frames[i],
mask,
multichannel=False)
getLogger(__name__).info('Completed inpainting process!')
else:
frames, times = cube['cube'].T, cube['timeslices']
if len(frames) == 0:
getLogger(__name__).info(
'No frames in the specified timerange - check your stop and start times'
)
raise ValueError
if not fps:
fps = frames.shape[2] / duration
#Load the writer
Writer = manimation.writers[
'ffmpeg'] if movietype is 'mp4' else manimation.writers['imagemagick']
comment = 't0={:.0f} dt={:.1f}s {:.0f} - {:.0f} nm'.format(
times[0], timestep, startw if startw is not None else 0,
stopw if stopw is not None else np.inf)
metadata = dict(title=title,
artist=__name__,
genre='Astronomy',
comment=comment)
writer = Writer(fps=fps, metadata=metadata, bitrate=-1)
fig = plt.figure()
if usewcs:
plt.subplot(projection=wcs)
if maskbadpix:
of = mkidpipeline.hdf.photontable.Photontable(h5file)
for i in range(frames.shape[0]):
frames[i][of.pixelBadMask.T] = np.nan
im = plt.imshow(frames[0],
interpolation='none',
origin='lower',
vmin=0,
vmax=cps_cutoff * timestep,
cmap=plt.get_cmap(colormap))
im.cmap.set_bad('black')
cbar = plt.colorbar()
ticks = cbar.get_ticks()
cbar.set_label('Photons/s')
cbar.set_ticks(ticks)
cbar.set_ticklabels(list(map('{:.0f}'.format, ticks / timestep)))
if not showaxes:
fig.patch.set_visible(False)
plt.gca().axis('off')
else:
if usewcs:
plt.xlabel('RA')
plt.ylabel('RA')
else:
plt.xlabel('Pixel')
plt.ylabel('Pixel')
plt.tight_layout()
with writer.saving(fig, outfile, dpi):
for a in frames:
im.set_array(a)
writer.grab_frame()
return frames
plt.imshow(np.log(out[251])) plt.show() eros = ndi.grey_erosion(signal, footprint=ball(3)) eros2 = ndi.grey_erosion(image, footprint=disk(3)) opened = opening(image) closed = closing(image) opened = opening(signal) closed = closing(signal) gf = ndi.gaussian_filter(image, 1) opened = opening(gf) closed = closing(gf) eros = erosion(gf) # Finding local maxima # http://scikit-image.org/docs/dev/auto_examples/segmentation/plot_peak_local_max.html coordinates = peak_local_max(image, min_distance=20) plt.imshow(np.log(image), cmap=plt.cm.gray) plt.plot(coordinates[:, 1], coordinates[:, 0], 'r.') plt.show() # Inpainting # http://scikit-image.org/docs/dev/auto_examples/filters/plot_inpaint.html s = signal[251] result = inpaint.inpaint_biharmonic(s, np.isnan(s))
from skimage.restoration import inpaint
#2
# Import the module from restoration
from skimage.restoration import inpaint
# Show the defective image
show_image(defect_image, 'Image to restore')
#3
# Import the module from restoration
from skimage.restoration import inpaint
# Show the defective image
show_image(defect_image, 'Image to restore')
# Apply the restoration function to the image using the mask
restored_image = inpaint.inpaint_biharmonic(defect_image, get_mask(defect_image), multichannel=True)
show_image(restored_image)
--------------------------------------------------
# Exercise_2
# Initialize the mask
mask = np.zeros(image_with_logo.shape[:-1])
# Set the pixels where the logo is to 1
mask[210:272, 360:425] = 1
# Apply inpainting to remove the logo
image_logo_removed = inpaint.inpaint_biharmonic(image_with_logo,
mask,
multichannel=True)
def inpainting(image, mask_map):
ex = norm(image)
ex[np.where(mask_map)] = 0
return inpaint.inpaint_biharmonic(ex, mask_map)
for d in detected:
# Obtain the face rectangle from detected coordinates
face = getFaceRectangle(d)
# Apply gaussian filter to extracted face
blurred_face = gaussian(face, multichannel=True, sigma = 8)
# Merge this blurry face to our final image and show it
resulting_image = mergeBlurryFace(group_image, blurred_face)
show_image(resulting_image, "Blurred faces")
--------------------------------------------------
# Exercise_9
# Import the necessary modules
from skimage.restoration import denoise_tv_chambolle, inpaint
from skimage import transform
# Transform the image so it's not rotated
upright_img = rotate(damaged_image, 20)
# Remove noise from the image, using the chambolle method
upright_img_without_noise = denoise_tv_chambolle(upright_img,weight=0.1, multichannel=True)
# Reconstruct the image missing parts
mask = get_mask(upright_img)
result = inpaint.inpaint_biharmonic(upright_img_without_noise, mask, multichannel=True)
show_image(result)
--------------------------------------------------
def preproc_field(field,
mask,
inpaint=True,
median=True,
med_size=(3, 1),
downscale=True,
dscale_size=(2, 2),
sigmoid=False,
scale=None,
expon=None,
only_inpaint=False,
gradient=False,
log_scale=False):
"""
Preprocess an input field image with a series of steps:
1. Inpainting
2. Median
3. Downscale
4. Sigmoid
5. Scale
6. Remove mean
Parameters
----------
field : np.ndarray
mask : np.ndarray
Data mask. True = masked
inpaint : bool, optional
if True, inpaint masked values
median : bool, optional
If True, apply a median filter
med_size : tuple
Median window to apply
downscale : bool, optional
If True downscale the image
dscale_size : tuple, optional
Size to rescale by
scale : float
Scale the SSTa values by this multiplicative factor
expon : float
Exponate the SSTa values by this exponent
gradient : bool, optional
If True, apply a Sobel gradient enhancing filter
Returns
-------
pp_field, meta_dict : np.ndarray, dict
Pre-processed field, mean temperature
"""
meta_dict = {}
# Inpaint?
if inpaint:
if mask.dtype.name != 'uint8':
mask = np.uint8(mask)
field = sk_inpaint.inpaint_biharmonic(field, mask, multichannel=False)
if only_inpaint:
if np.any(np.isnan(field)):
return None, None
else:
return field, None
# Capture more metadata
srt = np.argsort(field.flatten())
meta_dict['Tmax'] = field.flatten()[srt[-1]]
meta_dict['Tmin'] = field.flatten()[srt[0]]
i10 = int(0.1 * field.size)
i90 = int(0.9 * field.size)
meta_dict['T10'] = field.flatten()[srt[i10]]
meta_dict['T90'] = field.flatten()[srt[i90]]
# Median
if median:
field = median_filter(field, size=med_size)
# Reduce to 64x64
if downscale:
field = downscale_local_mean(field, dscale_size)
# Check for junk
if np.any(np.isnan(field)):
return None, None
# De-mean the field
mu = np.mean(field)
pp_field = field - mu
meta_dict['mu'] = mu
# Sigmoid?
if sigmoid:
pp_field = special.erf(pp_field)
# Scale?
if scale is not None:
pp_field *= scale
# Exponate?
if expon is not None:
neg = pp_field < 0.
pos = np.logical_not(neg)
pp_field[pos] = pp_field[pos]**expon
pp_field[neg] = -1 * (-1 * pp_field[neg])**expon
# Sobel Gradient?
if gradient:
pp_field = filters.sobel(pp_field)
# Log?
if log_scale:
if not gradient:
raise IOError("Only implemented with gradient=True so far")
# Set 0 values to the lowest non-zero value
zero = pp_field == 0.
if np.any(zero):
min_nonz = np.min(pp_field[np.logical_not(zero)])
pp_field[zero] = min_nonz
# Take log
pp_field = np.log(pp_field)
# Return
return pp_field, meta_dict
image_orig = data.astronaut()[0:200, 0:200]
# Create mask with three defect regions: left, middle, right respectively
mask = np.zeros(image_orig.shape[:-1])
mask[20:60, 0:20] = 1
mask[160:180, 70:155] = 1
mask[30:60, 170:195] = 1
# Defect image over the same region in each color channel
image_defect = image_orig.copy()
for layer in range(image_defect.shape[-1]):
image_defect[np.where(mask)] = 0
image_result = inpaint.inpaint_biharmonic(image_defect,
mask,
multichannel=True)
fig, axes = plt.subplots(ncols=2, nrows=2)
ax = axes.ravel()
ax[0].set_title('Original image')
ax[0].imshow(image_orig)
ax[1].set_title('Mask')
ax[1].imshow(mask, cmap=plt.cm.gray)
ax[2].set_title('Defected image')
ax[2].imshow(image_defect)
ax[3].set_title('Inpainted image')
def biharmonic_eq(im_path, mask_path):
im = io.imread(im_path)
mask = io.imread(mask_path)
dst = inpaint.inpaint_biharmonic(image_defect, mask, multichannel=True)
return dst
from skimage.restoration import inpaint
image_orig = data.astronaut()
# Create mask with three defect regions: left, middle, right respectively
mask = np.zeros(image_orig.shape[:-1])
mask[20:60, 0:20] = 1
mask[200:300, 150:170] = 1
mask[50:100, 400:430] = 1
# Defect image over the same region in each color channel
image_defect = image_orig.copy()
for layer in range(image_defect.shape[-1]):
image_defect[np.where(mask)] = 0
image_result = inpaint.inpaint_biharmonic(image_defect, mask, multichannel=True)
fig, axes = plt.subplots(ncols=2, nrows=2)
ax0, ax1, ax2, ax3 = axes.ravel()
ax0.set_title('Original image')
ax0.imshow(image_orig)
ax0.axis('off')
ax1.set_title('Mask')
ax1.imshow(mask, cmap=plt.cm.gray)
ax1.axis('off')
ax2.set_title('Defected image')
ax2.imshow(image_defect)
ax2.axis('off')
# Loaded as defect_image.
# We'll work on an image from the data module, obtained by data.astronaut(). Some of the pixels have been replaced by 1s using a binary mask, on purpose, to simulate a damaged image. Replacing pixels with 1s turns them totally black. The defective image is saved as an array called defect_image.
# The mask is a black and white image with patches that have the position of the image bits that have been corrupted. We can apply the restoration function on these areas. This mask is preloaded as mask.
# Remember that inpainting is the process of reconstructing lost or deteriorated parts of images and videos.
# Instructions 1/3
# 35 XP
# Import the inpaint function in the restoration module in scikit-image (skimage).
# Instructions 2/3
# 35 XP
# Show the defective image using show_image().
# Instructions 3/3
# 30 XP
# Call the correct function from inpaint. Use the corrupted image as the first parameter, then the mask and multichannel boolean.
# Import the module from restoration (Instruction 1)
from skimage.restoration import inpaint
# Show the defective image (Instruction 2)
show_image(defect_image, 'Image to restore')
# Apply the restoration function to the image using the mask (Instruction 3)
restored_image = inpaint.inpaint_biharmonic(defect_image,
mask,
multichannel=True)
show_image(restored_image)