def lee_enhanced_filter(img, win_size, k, cu, cmax):
"""
Apply Enhanced Lee filter to a numpy matrix containing the image, with a
window of win_size x win_size.
"""
assert_window_size(win_size)
assert_parameters(k, cu, cmax)
# we process the entire img as float64 to avoid type overflow error
img = np.float64(img)
img_filtered = np.zeros_like(img)
N, M = img.shape
win_offset = win_size / 2
for i in xrange(0, N):
xleft = i - win_offset
xright = i + win_offset
if xleft < 0:
xleft = 0
if xright >= N:
xright = N
for j in xrange(0, M):
yup = j - win_offset
ydown = j + win_offset
if yup < 0:
yup = 0
if ydown >= M:
ydown = M
assert_indices_in_range(N, M, xleft, xright, yup, ydown)
pix_value = img[i, j]
window = img[xleft:xright, yup:ydown]
w_t = weighting(pix_value, window, k, cu, cmax)
window_mean = window.mean()
if w_t == np.nan:
new_pix_value = 0
else:
new_pix_value = (window_mean * w_t) + (pix_value * (1.0 - w_t))
"""
if new_pix_value is np.ma.masked:
new_pix_value=9999
assert new_pix_value >= 0.0, \
"ERROR: lee_enhanced_filter(), pix " \
"filter can't be negative"
"""
#PAUL img_filtered[i, j] = round(new_pix_value)
img_filtered[i, j] = new_pix_value
return img_filtered
def lee_enhanced_filter(img, win_size=3, k=K_DEFAULT, cu=CU_DEFAULT,
cmax=CMAX_DEFAULT):
"""
Apply Enhanced Lee filter to a numpy matrix containing the image, with a
window of win_size x win_size.
"""
assert_window_size(win_size)
assert_parameters(k, cu, cmax)
# we process the entire img as float64 to avoid type overflow error
img = np.float64(img)
img_filtered = np.zeros_like(img)
N, M = img.shape
win_offset = win_size / 2
for i in xrange(0, N):
xleft = i - win_offset
xright = i + win_offset
if xleft < 0:
xleft = 0
if xright >= N:
xright = N
for j in xrange(0, M):
yup = j - win_offset
ydown = j + win_offset
if yup < 0:
yup = 0
if ydown >= M:
ydown = M
assert_indices_in_range(N, M, xleft, xright, yup, ydown)
pix_value = img[i, j]
window = img[xleft:xright, yup:ydown]
w_t = weighting(pix_value, window, k, cu, cmax)
window_mean = window.mean()
new_pix_value = (window_mean * w_t) + (pix_value * (1.0 - w_t))
assert new_pix_value >= 0.0, \
"ERROR: lee_enhanced_filter(), pix " \
"filter can't be negative"
img_filtered[i, j] = round(new_pix_value)
return img_filtered
def lee_filter(img, win_size=3, cu=CU_DEFAULT):
"""
Apply lee to a numpy matrix containing the image, with a window of
win_size x win_size.
"""
assert_window_size(win_size)
# we process the entire img as float64 to avoid type overflow error
img = np.float64(img)
img_filtered = np.zeros_like(img)
N, M = img.shape
win_offset = win_size // 2
for i in range(0, N):
xleft = i - win_offset
xright = i + win_offset
if xleft < 0:
xleft = 0
if xright >= N:
xright = N
for j in range(0, M):
yup = j - win_offset
ydown = j + win_offset
if yup < 0:
yup = 0
if ydown >= M:
ydown = M
assert_indices_in_range(N, M, xleft, xright, yup, ydown)
pix_value = img[i, j]
window = img[xleft:xright, yup:ydown]
w_t = weighting(window, cu)
window_mean = window.mean()
new_pix_value = (pix_value * w_t) + (window_mean * (1.0 - w_t))
#assert new_pix_value >= 0.0, \
# "ERROR: lee_filter(), pixel filtered can't be negative"
img_filtered[i, j] = new_pix_value
return img_filtered
def frost_filter(img, damping_factor=2.0, win_size=3):
"""
Apply frost filter to a numpy matrix containing the image, with a window of
win_size x win_size.
By default, the window size is 3x3.
"""
assert_window_size(win_size)
img_filtered = np.zeros_like(img)
N, M = img.shape
win_offset = win_size / 2
for i in xrange(0, N):
xleft = i - win_offset
xright = i + win_offset
if xleft < 0:
xleft = 0
if xright >= N:
xright = N - 1
for j in xrange(0, M):
yup = j - win_offset
ydown = j + win_offset
if yup < 0:
yup = 0
if ydown >= M:
ydown = M - 1
assert_indices_in_range(N, M, xleft, xright, yup, ydown)
# inspired by http://www.pcigeomatics.com/cgi-bin/pcihlp/FFROST
variation_coef = compute_coef_var(img, xleft, xright, yup, ydown)
window = img[xleft:xright, yup:ydown]
window_mean = window.mean()
sigma_zero = variation_coef / window_mean # var / u^2
factor_A = damping_factor * sigma_zero
weights_array = calculate_local_weight_matrix(window, factor_A)
pixels_array = window.flatten()
weighted_values = weights_array * pixels_array
img_filtered[i, j] = weighted_values.sum() / weights_array.sum()
return img_filtered
def kuan_filter(img, win_size=3, cu=CU_DEFAULT):
"""
Apply kuan to a numpy matrix containing the image, with a window of
win_size x win_size.
"""
assert_window_size(win_size)
# we process the entire img as float64 to avoid type overflow error
img = np.float64(img)
img_filtered = np.zeros_like(img)
N, M = img.shape
win_offset = win_size / 2
for i in xrange(0, N):
xleft = i - win_offset
xright = i + win_offset
if xleft < 0:
xleft = 0
if xright >= N:
xright = N
for j in xrange(0, M):
yup = j - win_offset
ydown = j + win_offset
if yup < 0:
yup = 0
if ydown >= M:
ydown = M
assert_indices_in_range(N, M, xleft, xright, yup, ydown)
pix_value = img[i, j]
window = img[xleft:xright, yup:ydown]
w_t = weighting(window, cu)
window_mean = window.mean()
new_pix_value = (pix_value * w_t) + (window_mean * (1.0 - w_t))
img_filtered[i, j] = round(new_pix_value)
return img_filtered
def frost_filter(img, damping_factor=2.0, win_size=3):
"""
Apply frost filter to a numpy matrix containing the image, with a window of
win_size x win_size.
By default, the window size is 3x3.
"""
assert_window_size(win_size)
img_filtered = np.zeros_like(img)
N, M = img.shape
win_offset = win_size / 2
for i in range(0, N):
xleft = i - win_offset
xright = i + win_offset
if xleft < 0:
xleft = 0
if xright >= N:
xright = N - 1
for j in range(0, M):
yup = j - win_offset
ydown = j + win_offset
if yup < 0:
yup = 0
if ydown >= M:
ydown = M - 1
assert_indices_in_range(N, M, xleft, xright, yup, ydown)
# inspired by http://www.pcigeomatics.com/cgi-bin/pcihlp/FFROST
variation_coef = compute_coef_var(img, xleft, xright, yup, ydown)
window = img[xleft:xright, yup:ydown]
window_mean = window.mean()
sigma_zero = variation_coef / window_mean # var / u^2
factor_A = damping_factor * sigma_zero
weights_array = calculate_local_weight_matrix(window, factor_A)
pixels_array = window.flatten()
weighted_values = weights_array * pixels_array
img_filtered[i, j] = weighted_values.sum() / weights_array.sum()
return img_filtered
def median_filter(img, win_size=3):
"""
Apply a 'median filter' to 'img' with a window size equal to 'win_size'.
Parameters:
- img: a numpy matrix representing the image.
- win_size: the size of the windows (by default 3)
"""
assert_window_size(win_size)
N, M = img.shape
win_offset = win_size // 2
img_filtered = np.zeros_like(img)
for i in range(0, N):
xleft = i - win_offset
xright = i + win_offset
if xleft < 0:
xleft = 0
if xright >= N:
xright = N
for j in range(0, M):
yup = j - win_offset
ydown = j + win_offset
if yup < 0:
yup = 0
if ydown >= M:
ydown = M
assert_indices_in_range(N, M, xleft, xright, yup, ydown)
window = img[xleft:xright, yup:ydown]
window_median = np.median(window)
img_filtered[i, j] = window_median
return img_filtered
def median_filter(img, win_size=3):
"""
Apply a 'median filter' to 'img' with a window size equal to 'win_size'.
Parameters:
- img: a numpy matrix representing the image.
- win_size: the size of the windows (by default 3)
"""
assert_window_size(win_size)
N, M = img.shape
win_offset = win_size / 2
img_filtered = np.zeros_like(img)
for i in xrange(0, N):
xleft = i - win_offset
xright = i + win_offset
if xleft < 0:
xleft = 0
if xright >= N:
xright = N
for j in xrange(0, M):
yup = j - win_offset
ydown = j + win_offset
if yup < 0:
yup = 0
if ydown >= M:
ydown = M
assert_indices_in_range(N, M, xleft, xright, yup, ydown)
window = img[xleft:xright, yup:ydown]
window_median = np.median(window)
img_filtered[i, j] = round(window_median)
return img_filtered
