def refined_t(normI,w=15): tmin=0.2 r=40 eps=1e-3 t = transmission_map(normI,w) refinedt_blue = np.maximum(t[:,:,0], tmin) refinedt_green = np.maximum(t[:,:,1], tmin) refinedt_blue = guided_filter(normI, refinedt_blue, r, eps) refinedt_green = guided_filter(normI, refinedt_green, r, eps) return refinedt_blue, refinedt_green
def usemodel(dehazenet, hazy_image): patch_size = 16 p = 0.001 L = 256 height = hazy_image.shape[0] width = hazy_image.shape[1] channel = hazy_image.shape[2] if height % patch_size != 0: height = height // patch_size * patch_size if width % patch_size != 0: width = width // patch_size * patch_size hazy_image = cv2.resize(hazy_image, (width, height), interpolation = cv2.INTER_AREA) trans_map = np.zeros((height, width)) for i in range(height // patch_size): for j in range(width // patch_size): hazy_patch = hazy_image[(i * 16) : (16 * i + 16), (j * 16) : (j * 16 + 16), :] hazy_input = np.reshape(hazy_patch, (1, patch_size, patch_size, channel)) / 255.0 trans = dehazenet.predict(hazy_input) trans_map[(i * 16) : (16 * i + 16), (j * 16) : (j * 16 + 16)] = trans norm_hazy_image = (hazy_image - hazy_image.min()) / (hazy_image.max() - hazy_image.min()) refined_trans_map = guided_filter(norm_hazy_image, trans_map) Airlight = get_airlight(hazy_image, refined_trans_map, p) clear_image = get_radiance(hazy_image, Airlight, refined_trans_map, L) return clear_image
def smooth_tmap(img, tmap, constants): epsilon = constants.EPSILON radius = constants.GUIDED_RADIUS normI = (img - img.min()) / (img.max() - img.min()) smooth_tmap = guided_filter(normI.astype(np.float32), tmap.astype(np.float32), radius, epsilon) smooth_tmap = cv2.bilateralFilter(smooth_tmap.astype(np.float32), 0, 0.1, 5) return smooth_tmap
def dehaze_raw(I, tmin=0.2, Amax=220, w=15, p=0.0001, omega=0.95, guided=False, r=40, eps=1e-3): """ Get the dark channel prior, atmosphere light, transmission rate and refined transmission rate for raw RGB image data. Parameters: I: M * N * 3 data as numpy array for the hazy Image tmin: threshold of transmission rate Amax: threshold of atmosphere light w: window size of the dark channel prior p: percentage of pixels for estimating the atmosphere light omega: bias for the transmission estimate guided: whether to use the guided filter to fine the image r: the radius of the guidance eps: epsilon for the guided filter Return: (Idark, A, rawt, refinedt) if guided = False, then rawt == refinedt """ m, n, _ = I.shape Idark = get_dark_channel(I, w) A = get_atmosphere(I, Idark, p) A = np.minimum(A, Amax) print 'Atmosphere: ', A rawt = get_transmission(I, A, Idark, omega, w) print 'raw transmission rate', print 'between [%.4f, %.4f]' % (rawt.min(), rawt.max()) rawt = refinedt = np.maximum(rawt, tmin) if guided: normI = (I - I.min()) / (I.max() - I.min()) refinedt = guided_filter(normI, refinedt, r, eps) print 'refined transmission rate', print 'between [%.4f, %.4f]' % (refinedt.min(), refinedt.max()) return Idark, A, rawt, refinedt
def transmission(img, A, blocksize, bol): omega = 0.95 imageGray = np.empty(img.shape, img.dtype) # imageGray = np.min(img, axis=2) # print(A) for i in range(3): imageGray[:, :, i] = img[:, :, i]/A[0, i] #print(imageGray) #print(A) # print(getDarkChannel(imageGray, blocksize)) t = 1 - omega * getDarkChannel(imageGray, blocksize) # print(t) t[t<0.1]= 0.1 if bol == True: normI = (img - img.min()) / (img.max() - img.min()) t = guided_filter(normI, t, 40, 0.0001) #print(t) return t
def adaptiveExp_map(normI,w=15): r=40 eps=1e-3 restored = RC_correction(normI,w) R = (restored*255).astype(np.uint8) I = (normI*255).astype(np.uint8) YjCrCb = cv2.cvtColor(R, cv2.COLOR_BGR2YCrCb) YiCrCb = cv2.cvtColor(I, cv2.COLOR_BGR2YCrCb) normYjCrCb = (YjCrCb - YjCrCb.min())/(YjCrCb.max() - YjCrCb.min()) normYiCrCb = (YiCrCb - YiCrCb.min())/(YiCrCb.max() - YiCrCb.min()) Yi = normYiCrCb[:,:,0] Yj = normYjCrCb[:,:,0] S = (Yj*Yi + 0.3*Yi**2)/(Yj**2 + 0.3*Yi**2) refinedS = guided_filter(normYiCrCb, S, r, eps) M,N = S.shape rs = np.zeros((M,N,3)) rs[:,:,0] = rs[:,:,1] = rs[:,:,2] = refinedS OutputExp = restored*rs return (OutputExp - OutputExp.min())/(OutputExp.max() - OutputExp.min())
def dehaze_raw(I, tmin=0.2, Amax=220, w=15, p=0.0001, omega=0.95, guided=True, r=40, eps=1e-3): """Get the dark channel prior, atmosphere light, transmission rate and refined transmission rate for raw RGB image data. Parameters ----------- I: M * N * 3 data as numpy array for the hazy image tmin: threshold of transmission rate Amax: threshold of atmosphere light w: window size of the dark channel prior p: percentage of pixels for estimating the atmosphere light omega: bias for the transmission estimate guided: whether to use the guided filter to fine the image r: the radius of the guidance eps: epsilon for the guided filter Return ----------- (Idark, A, rawt, refinedt) if guided=False, then rawt == refinedt """ m, n, _ = I.shape Idark = get_dark_channel(I, w) A = get_atmosphere(I, Idark, p) A = np.minimum(A, Amax) # threshold A print 'atmosphere', A rawt = get_transmission(I, A, Idark, omega, w) print 'raw transmission rate', print 'between [%.4f, %.4f]' % (rawt.min(), rawt.max()) rawt = refinedt = np.maximum(rawt, tmin) # threshold t if guided: normI = (I - I.min()) / (I.max() - I.min()) # normalize I refinedt = guided_filter(normI, refinedt, r, eps) print 'refined transmission rate', print 'between [%.4f, %.4f]' % (refinedt.min(), refinedt.max()) return Idark, A, rawt, refinedt
def dehaze_1(im, tmin = 0.1, w = 15, p = 0.001, omega = 0.95, r = 40, eps = 1e-3, L = 256): ''' p percent of pixels W window size omega before transmission L highest pixel value ''' I = np.asarray(im, dtype=np.float64) m, n, _ = I.shape Idark = get_dark_channel(I, w) A = get_atmosphere(I, Idark, p) rawt = get_transmission(I, A, Idark, omega, w) normI = (I - I.min()) / (I.max() - I.min()) # normalize I refinedt = guidedfilter.guided_filter(normI, rawt, r, eps) refinedt = np.maximum(refinedt, tmin) clear_image = get_radiance(I, A, refinedt) return np.maximum(np.minimum(clear_image, L - 1), 0).astype(np.uint8)
def dehaze(I, tmin, w, alpha, omega, p, eps, reduce=False): m, n, _ = I.shape Idark, Ibright = get_illumination_channel(I, w) A = get_atmosphere(I, Ibright, p) init_t = get_initial_transmission(A, Ibright) if reduce: init_t = reduce_init_t(init_t) corrected_t = get_corrected_transmission(I, A, Idark, Ibright, init_t, alpha, omega, w) normI = (I - I.min()) / (I.max() - I.min()) refined_t = guided_filter(normI, corrected_t, w, eps) J_refined = get_final_image(I, A, refined_t, tmin) enhanced = (J_refined * 255).astype(np.uint8) f_enhanced = cv2.detailEnhance(enhanced, sigma_s=10, sigma_r=0.15) f_enhanced = cv2.edgePreservingFilter(f_enhanced, flags=1, sigma_s=64, sigma_r=0.2) return enhanced
def dehaze_raw(I, t_min=0.2, atm_max=220, w=15, p=0.0001, omega=0.95, guided=True, r=40, eps=1e-3, flag_uw=False, depth_img=None): """Get the dark channel prior, atmosphere light, transmission rate and refined transmission rate for raw RGB image data. Parameters ----------- I: M * N * 3 data as numpy array for the hazy image t_min: threshold of transmission rate atm_max:threshold of atmosphere light w: window size of the dark channel prior p: percentage of pixels for estimating the atmosphere light omega: bias for the transmission estimate flag_uw:enable DCP for underwater imgs guided: whether to use the guided filter to fine the image r: the radius of the guidance eps: epsilon for the guided filter Return ----------- (Idark, A, rawt, refinedt) if guided=False, then rawt == refinedt """ # NOTE:Check if depth image was provided flag_use_depth = False if depth_img is not None: flag_use_depth = True # NOTE:First, get dark channel image # NOTE:Change color space if dealing with underwater images Iprime = np.zeros(I.shape, dtype=np.float64) if flag_uw: Iprime[:, :, 0] = 255. - I[:, :, 0] Iprime[:, :, 1] = 255. - I[:, :, 1] Iprime[:, :, 2] = I[:, :, 2] else: Iprime = I Idark = [] if flag_use_depth else get_dark_channel(Iprime, w) # NOTE:Estimate the atmospheric light, this is done always with the original image atm_light = get_atmosphere(I, Idark, p, depth_img) atm_light = np.minimum(atm_light, atm_max) print('atmosphere', atm_light) # NOTE:Estimate transmission image which correlates to depth if flag_use_depth: M, N, _ = I.shape white = np.full_like(np.zeros((M, N), dtype=np.float64), max_color_val - 1) return white, atm_light, white, white else: rawt = get_transmission(Iprime, atm_light, omega, w) print('raw transmission rate between [%.4f, %.4f]' % (rawt.min(), rawt.max())) # NOTE: Refine transmission rate through guided filter (edge-preserving filter) rawt = refinedt = np.maximum(rawt, t_min) if guided: normI = (I - I.min()) / (I.max() - I.min()) refinedt = guided_filter(normI, refinedt, r, eps) print('refined transmission rate between [%.4f, %.4f]' % (refinedt.min(), refinedt.max())) return Idark, atm_light, rawt, refinedt
def dehaze(I, tmin, w, alpha, omega, p, eps): m, n, _ = I.shape Idark, Ibright = get_illumination_channel(I, w) print("dark max:{} min:{}".format( np.max(Idark), np.min(Idark))) # dark max:0.776470588235 min:0.0 print("bright max:{} min:{}".format( np.max(Ibright), np.min(Ibright))) # bright max:0.988235294118 min:0.00392156862745 cv2.imwrite(folder + '/init_bright_channel_prior.png', Ibright * 255) cv2.imwrite(folder + '/init_dark_channel_prior.png', Idark * 255) white = np.full_like(Idark, L - 1) A = get_atmosphere(I, Ibright, p) print('atmosphere:{}'.format(A)) ################################################################# init_t = get_initial_transmission(A, Ibright) cv2.imwrite(folder + '/transmission_init.png', init_t * white) print('initial (bright) transmission rate between [%.4f, %.4f]' % (init_t.min(), init_t.max())) J_init = get_final_image(I, A, init_t, tmin) cv2.imwrite(folder + '/J_init.png', J_init * 255) ################################################################# corrected_t, dark_t = get_corrected_transmission(I, A, Idark, Ibright, init_t, alpha, omega, w) cv2.imwrite(folder + '/transmission_corrected.png', corrected_t * white) print('corrected transmission rate between [%.4f, %.4f]' % (corrected_t.min(), corrected_t.max())) cv2.imwrite(folder + '/transmission_a_dark.png', dark_t * white) print('dark transmission rate between [%.4f, %.4f]' % (dark_t.min(), dark_t.max())) J_corrected = get_final_image(I, A, corrected_t, tmin) cv2.imwrite(folder + '/J_corrected.png', J_corrected * 255) J_dark = get_final_image(I, A, dark_t, tmin) cv2.imwrite(folder + '/J_dark.png', J_dark * 255) ################################################################# # guided filter normI = (I - I.min()) / (I.max() - I.min()) # min-max normalize I refined_t = guided_filter(normI, corrected_t, w, eps) refined_dark_t = guided_filter(normI, dark_t, w, eps) #refined_t = (refined_t - np.min(refined_t))/(np.max(refined_t) - np.min(refined_t)) # min-max normalization. #refined_dark_t = (refined_dark_t - np.min(refined_dark_t))/(np.max(refined_dark_t) - np.min(refined_dark_t)) # min-max normalization. cv2.imwrite(folder + '/refined.png', refined_t * white) print('refined transmission rate between [%.4f, %.4f]' % (refined_t.min(), refined_t.max())) J_refined = get_final_image(I, A, refined_t, tmin) cv2.imwrite(folder + '/J_refined.png', J_refined * 255) cv2.imwrite(folder + '/transmission_a_refined_dark.png', refined_dark_t * white) print('refined dark transmission rate between [%.4f, %.4f]' % (refined_dark_t.min(), refined_dark_t.max())) J_refined_dark = get_final_image(I, A, refined_dark_t, tmin) cv2.imwrite(folder + '/J_refined_dark.png', J_refined_dark * 255)