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