def test_wiener(dtype): psf = np.ones((5, 5), dtype=dtype) / 25 data = convolve2d(test_img, psf, 'same') np.random.seed(0) data += 0.1 * data.std() * np.random.standard_normal(data.shape) data = data.astype(dtype, copy=False) deconvolved = restoration.wiener(data, psf, 0.05) assert deconvolved.dtype == _supported_float_type(dtype) rtol, atol = _get_rtol_atol(dtype) path = fetch('restoration/tests/camera_wiener.npy') np.testing.assert_allclose(deconvolved, np.load(path), rtol=rtol, atol=atol) _, laplacian = uft.laplacian(2, data.shape) otf = uft.ir2tf(psf, data.shape, is_real=False) assert otf.real.dtype == _supported_float_type(dtype) deconvolved = restoration.wiener(data, otf, 0.05, reg=laplacian, is_real=False) assert deconvolved.real.dtype == _supported_float_type(dtype) np.testing.assert_allclose(np.real(deconvolved), np.load(path), rtol=rtol, atol=atol)
def test_wiener(): psf = np.ones((5, 5)) / 25 data = convolve2d(test_img, psf, "same") np.random.seed(0) data += 0.1 * data.std() * np.random.standard_normal(data.shape) deconvolved = restoration.wiener(data, psf, 0.05) path = pjoin(dirname(abspath(__file__)), "camera_wiener.npy") np.testing.assert_allclose(deconvolved, np.load(path), rtol=1e-3) _, laplacian = uft.laplacian(2, data.shape) otf = uft.ir2tf(psf, data.shape, is_real=False) deconvolved = restoration.wiener(data, otf, 0.05, reg=laplacian, is_real=False) np.testing.assert_allclose(np.real(deconvolved), np.load(path), rtol=1e-3)
def _wiener_deconvolve(self, image, psf, balance=5e8): '''Perform Wiener-Hunt deconvolution given an impulse response''' deconvolved = restoration.wiener(image, psf, balance) deconvolved = deconvolved - np.min(deconvolved) return deconvolved
def deblur_image(image): psf = np.ones((5, 5)) / 25 image = conv2(image, psf, 'same') image += 0.1 * image.std() * np.random.standard_normal(image.shape) deconvolved = restoration.wiener(image, psf, 1, clip=False) return deconvolved
def denoiser(denoiser_name, img, sigma): ''' :param denoiser_name: str| 'wavelet' or 'TVM' or 'bilateral' or 'deconv' or 'NLM' :param img: (H,W,C) | np.array | [0,1] :param sigma: for wavelet :return:(H,W,C) | np.array | [0,1] ''' from skimage.restoration import (denoise_tv_chambolle, denoise_bilateral, denoise_wavelet, denoise_nl_means, wiener) if denoiser_name == 'wavelet': return denoise_wavelet(img, sigma=sigma, mode='soft', multichannel=True, convert2ycbcr=True, method='BayesShrink') elif denoiser_name == 'TVM': return denoise_tv_chambolle(img, multichannel=True) elif denoiser_name == 'bilateral': return denoise_bilateral(img, bins=1000, multichannel=True) elif denoiser_name == 'deconv': return wiener(img) elif denoiser_name == 'NLM': return denoise_nl_means(img, multichannel=True) else: raise Exception( 'Incorrect denoiser mentioned. Options: wavelet, TVM, bilateral, deconv, NLM' )
def wiener_restoration(noisePicture): # wiener滤波复原 psf = np.ones((5, 5)) / 25 img = convolve2d(noisePicture, psf, 'same') img += 0.1 * img.std() * np.random.standard_normal(img.shape) deconvolved_img = restoration.wiener(image=img, psf=psf, balance=1100) return deconvolved_img
def wiener(img): psf = np.ones((5, 5)) / 25 img = convolve2d(img, psf, 'same') img += 0.1 * img.std() * np.random.standard_normal(img.shape) deconvolved_img = restoration.wiener(img, psf, 1100) # deconvolved_img = restoration.unsupervised_wiener(img, psf) return deconvolved_img
def deblur(image,n=5,m=25): psf = np.ones((n, n)) / m B = image.reshape(image.shape[0],image.shape[1],3)[:,:,0] G = image.reshape(image.shape[0],image.shape[1],3)[:,:,1] R = image.reshape(image.shape[0],image.shape[1],3)[:,:,2] deconvolved_B = restoration.wiener(B, psf,1,clip=False) deconvolved_G = restoration.wiener(G, psf,1,clip=False) deconvolved_R = restoration.wiener(R, psf,1,clip=False) rgbArray = np.zeros((image.shape[0], image.shape[1], 3)) rgbArray[..., 0] = deconvolved_B rgbArray[..., 1] = deconvolved_G rgbArray[..., 2] = deconvolved_R #print(rgbArray) #rgbArray[rgbArray < 0] = 0 #rgbArray[rgbArray >= 1] = 1 - EPSILON return rgbArray
def reconstruct(sample, Cx, Cz, half_width=140, deconvolve=False): """ Reconstruct the multiview data. Parameters: sample : data (ordered as angle, z, x) cx: x coordinate of the rotation axis cz: z coordinate of the rotation axis half_width: semize of the reconstructed rectangle deconvolve: if True apply xz devonvolution on each view before reconstruction Return: reconstructed: reconstructed section """ sample_selection = sample[:, Cz - half_width:Cz + half_width, Cx - half_width:Cx + half_width] sum_im = np.zeros((2 * half_width, 2 * half_width)) for angle_index, angle in enumerate(np.arange(0, 360, rotation_angle)): if deconvolve: view = wiener(sample_selection[angle_index, :, :], psf, balance=0.1) else: view = sample_selection[angle_index, :, :] rotated = rotate(view, angle, preserve_range=True, mode='reflect') sum_im += rotated reconstructed = sum_im / nangles return (reconstructed)
def transform(img, source, target, **kwargs): kernelSize = int(kwargs['kernelSize']) if 'kernelSize' in kwargs else 25 rgb = img.convert('RGB') cv_image = numpy.array(rgb) if 'inputmaskname' in kwargs: mask = numpy.asarray( tool_set.openImageFile(kwargs['inputmaskname']).to_mask()) mask[mask > 0] == 1 else: mask = numpy.ones( (cv_image.shape[0], cv_image.shape[1])).astype('uint8') inverted_mask = numpy.ones( (cv_image.shape[0], cv_image.shape[1])).astype('uint8') inverted_mask[mask == 1] = 0 side = int(kernelSize**(1 / 2.0)) psf = numpy.ones((side, side)) / kernelSize img = color.rgb2grey(cv_image) deconvolved_img = restoration.wiener(img, psf, 1)[0] for c in range(3): cv_image[:, :, c] = deconvolved_img * cv_image[:, :, c] * mask + cv_image[:, :, c] * inverted_mask Image.fromarray(cv_image, 'RGB').save(target) return {'Blur Type': 'Wiener'}, None
def blind_lucy_wrapper(image, max_its=8, its=5, N_filter=3, weiner=False, estimation_noise=0, filter_estimation=1, observation_noise=0): f = io.imread('../data/'+image+'.png', dtype=float) if len(f.shape) == 3: f = f.mean(axis=2) f /= f.max() print(f.shape) g = helper.gaussian(sigma=N_filter/3, N=N_filter) g_k = helper.gaussian(sigma=N_filter/3 * filter_estimation, N=N_filter) g_0 = g_k.copy() c = fftconvolve(f, g, mode='same') #c += observation_noise*np.random.randn(*c.shape) f_k = f + estimation_noise*np.random.randn(*f.shape) #f_k = c.copy() for k in range(int(max_its)): g_k = richardson_lucy(g_k, f_k, iterations=int(its), clip=True) if weiner: f_k = wiener(f_k, g_k, 1e-5) else: f_k = richardson_lucy(f_k, g_k, iterations=int(its), clip=True) print("on {}, f.max() = {:0.3e}, g.max() = {:0.3e}".format(k, np.abs(f_k.max()), np.abs(g_k.max()))) f_k, g_k = np.abs(f_k), np.abs(g_k) helper.show_images({'estimation':f_k, 'original':f, 'observations':c})
def test_wiener(): psf = np.ones((5, 5)) / 25 data = convolve2d(test_img, psf, 'same') np.random.seed(0) data += 0.1 * data.std() * np.random.standard_normal(data.shape) deconvolved = restoration.wiener(data, psf, 0.05) path = fetch('restoration/tests/camera_wiener.npy') np.testing.assert_allclose(deconvolved, np.load(path), rtol=1e-3) _, laplacian = uft.laplacian(2, data.shape) otf = uft.ir2tf(psf, data.shape, is_real=False) deconvolved = restoration.wiener(data, otf, 0.05, reg=laplacian, is_real=False) np.testing.assert_allclose(np.real(deconvolved), np.load(path), rtol=1e-3)
def deblurring(self): psf = np.ones((25, 25)) m_temporaryImageList = [] m_temporaryImageList[:] = ImageConverter.imageFIFO[:] ImageConverter.imageFIFO[:] = [] for image in m_temporaryImageList: # deconvulating image data ; tbh; i don't understand this code snippet, copied from stackoverflow deconvolved_image = restoration.wiener(image, psf, balance=2110) ImageConverter.imageFIFO.append(deconvolved_image) del m_temporaryImageList
def weiner_noise_reduction(img): # data.astronaut() img = color.rgb2gray(img) from scipy.signal import convolve2d psf = np.ones((5, 5)) / 25 img = convolve2d(img, psf, 'same') img += 0.1 * img.std() * np.random.standard_normal(img.shape) deconvolved_img = restoration.wiener(img, psf, 1100) return deconvolved_img
def wiener(): img = color.rgb2gray(data.astronaut()) imgO = img.copy() psf = np.ones((5, 5)) / 25 img = convolve2d(img, psf, 'same') img += 0.1 * img.std() * np.random.standard_normal(img.shape) imgN = img.copy() deconvolved_img = restoration.wiener(img, psf, 1100) imgR = img.copy() return [imgO, imgN, imgR]
def deconvolve(image, psf, iterations=7, clip=False): ''' performs the Richardson-Lucy deconvolution ''' # return res.unsupervised_wiener(image, psf)[0] return res.wiener(image, psf, balance=0.001, clip=clip, is_real=True, reg=0 * np.sqrt(image))
def img_deblur_gaussian(img, blurMap, k_size, step_size, coef=50, plot=False): """ Operation: Returns the result of the deblurring img according to blurMap Inputs: 2d image array 2d blur map array of the image integer width of the square Gaussian kernel integer of the distance between each segment (needs to be smaller or equal than k_size) a float coefficient to determine the linear ratio between the blur level and the kernel's standard deviation a boolean to plot the blur map or not Outputs: 2d deblured image array """ x_end = img.shape[1] - k_size + 1 y_end = img.shape[0] - k_size + 1 deblur = np.zeros_like(img, dtype=np.float64) aveMap = np.zeros_like(img, dtype=np.float64) for stride_x in range(0, x_end, step_size): xStart = stride_x xStop = stride_x + k_size xCentre = stride_x + k_size // 2 for stride_y in range(0, y_end, step_size): yStart = stride_y yStop = stride_y + k_size yCentre = stride_y + k_size // 2 b = img[yStart:yStop, xStart:xStop] g = fspecial( (k_size, k_size), coef * blurMap[yCentre, xCentre] ) # generate a Gaussian kernel accordiing to bler map value d = ski.wiener(b, g, balance=0.1, clip=False) # deblur using Wiener deconvolution deblur[yStart:yStop, xStart:xStop] = deblur[yStart:yStop, xStart:xStop] + d aveMap[yStart:yStop, xStart:xStop] = aveMap[yStart:yStop, xStart:xStop] + 1 # Normalize the deblur to be between 0 and the max value of the img deblur_norm = deblur / aveMap deblur_norm = deblur_norm - deblur_norm.min() deblur_norm = (deblur_norm * img.max() / deblur_norm.max()).astype( np.uint8) if plot: fig, ax = plt.subplots(1, 2, figsize=(20, 20)) display_image(img, axes=ax[0]) ax[0].set_title('Input Image') display_image(deblur_norm, axes=ax[1]) ax[1].set_title('Deblured') return deblur_norm
def main(): image = imread("/Users/gsamaras/Downloads/boat.tif") #plt.imshow(arr, cmap='gray') #plt.show() #blurred_arr = imfilter(arr, "blur") psf = np.ones((5, 5)) / 25 image = conv2(image, psf, 'same') image += 0.1 * image.std() * np.random.standard_normal(image.shape) deconvolved = restoration.wiener(image, psf, 1, clip=False) #print deconvolved plt.imshow(deconvolved, cmap='gray') plt.show()
def simple_deblur(blurred_noised): """Deblur a blurred image with Wiener filter Args: blurred_noised: blurred image with noise Returns: Deblurred image """ img = np.copy(blurred_noised) psf = np.ones((5, 5)) / 25 # img = signal.convolve2d(img, psf, 'same') # img += 0.1 * img.std() * np.random.standard_normal(img.shape) deblurred = restoration.wiener(img, psf, 1100) return deblurred
def deconv(self, other, balance=1000, reg=None, is_real=True, clip=False, postnormalize=True): """Perform the deconvolution of this convolvable object by another. Parameters ---------- other : `Convolvable` another convolvable object, used as the PSF in a Wiener deconvolution balance : `float`, optional regularization parameter; passed through to skimage reg : `numpy.ndarray`, optional regularization operator, passed through to skimage is_real : `bool`, optional True if self and other are both real clip : `bool`, optional clips self and other into (0,1) postnormalize : `bool`, optional normalize the result such that it falls in [0,1] Returns ------- `Convolvable` a new Convolable object Notes ----- See skimage: http://scikit-image.org/docs/dev/api/skimage.restoration.html#skimage.restoration.wiener """ from skimage.restoration import wiener result = wiener(self.data, other.data, balance=balance, reg=reg, is_real=is_real, clip=clip) if postnormalize: result += result.min() result /= result.max() return Convolvable(result, self.x, self.y, False)
def denoise(denoiser_name, img, sigma): from skimage.restoration import (denoise_tv_chambolle, denoise_bilateral, denoise_wavelet, denoise_nl_means, wiener) if denoiser_name == 'wavelet': """Input scale - [0, 1] """ return denoise_wavelet(img, sigma=sigma, mode='soft', multichannel=True, convert2ycbcr=True, method='BayesShrink') elif denoiser_name == 'TVM': return denoise_tv_chambolle(img, multichannel=True) elif denoiser_name == 'bilateral': return denoise_bilateral(img, bins=1000, multichannel=True) elif denoiser_name == 'deconv': return wiener(img) elif denoiser_name == 'NLM': return denoise_nl_means(img, multichannel=True) else: raise Exception('Incorrect denoiser mentioned. Options: wavelet, TVM, bilateral, deconv, NLM')
def clean_noise(image: np.ndarray)->np.ndarray: image = np.where(image<-1, -1, image) image = np.where(image>1, 1, image) p2, p98 = np.percentile(image, (2, 98)) image_rescale = exposure.rescale_intensity(image, in_range=(p2, p98)) # Adaptive Equalization image_adapteq = exposure.equalize_adapthist(image, clip_limit=0.03) psf = np.ones((5, 5)) / 25 img = convolve2d(image_adapteq, psf, 'same') img += 0.1*img.std() * np.random.standard_normal(img.shape) deconvolved_image = restoration.wiener(img, psf, 1100) return deconvolved_image
def wiener_filter(img, unsupervised=True, wiener_balance=1100, psf_size=5, psf_numerator=25): """Wiener filter to sharpen an image This filter is used to estimate the desired value of a noisy signal. The Wiener filter minimizes the root mean square error between the estimated random process and the desired process. Arguments: img {array} -- Image array [Non-normalize (0-255)] Keyword Arguments: unsupervised {bool} -- true for supervised algorithm, false otherwise (default: {True}) wiener_balance {int} -- Wiener balance parameter (default: {1100}) psf_size {int} -- PSF kernel size (default: {5}) psf_numerator {int} -- PSF kernel numerator (default: {25}) Returns: array -- Filtered image [Non-normalize (0-255)] """ img = np.array(img, np.float32) img = cv2.normalize(img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F) # Allow to normalize image psf = np.ones((psf_size, psf_size)) / psf_numerator convolved_img = convolve2d(img, psf, 'same') convolved_img += 0.1 * convolved_img.std() * \ np.random.standard_normal(convolved_img.shape) deconvolved = None if unsupervised: deconvolved, _ = unsupervised_wiener(convolved_img, psf) else: deconvolved = wiener(convolved_img, psf, wiener_balance) cv2.absdiff(deconvolved, deconvolved) return deconvolved * 255
def denoiser(denoiser_name, img, sigma): # For bilateral: sigma is sigma_spatial : float # Standard deviation for range distance. # A larger value results in averaging of pixels with larger spatial differences. # For wavelet: sigma is The noise standard deviation used # when computing the wavelet detail coefficient threshold(s) from skimage.restoration import (denoise_tv_chambolle, denoise_bilateral, denoise_wavelet, denoise_nl_means, wiener, estimate_sigma) batch_shape = img.shape images = np.zeros(batch_shape) batch_size = batch_shape[0] for idx in range(batch_size): # change to [0 1] for image processing img[idx, :, :, :] = (img[idx, :, :, :] + 1) / 2.0 sigma1 = estimate_sigma(img[idx, :, :, :], average_sigmas=False, multichannel=True) if denoiser_name == 'wavelet': images[idx, :, :, :] = denoise_wavelet(img[idx, :, :, :], sigma=sigma1, mode='soft', multichannel=True, convert2ycbcr=True, method='BayesShrink') elif denoiser_name == 'TVM': images[idx, :, :, :] = denoise_tv_chambolle(img[idx, :, :, :], multichannel=True) elif denoiser_name == 'bilateral': images[idx, :, :, :] = denoise_bilateral(img[idx, :, :, :], sigma_spatial=sigma, bins=1000, multichannel=True) elif denoiser_name == 'deconv': images[idx, :, :, :] = wiener(img[idx, :, :, :]) elif denoiser_name == 'NLM': images[idx, :, :, :] = denoise_nl_means(img[idx, :, :, :], multichannel=True) else: raise Exception( 'Incorrect denoiser mentioned. Options: wavelet, TVM, bilateral, deconv, NLM' ) # change back to [-1 1] images[idx, :, :, :] = images[idx, :, :, :] * 2.0 - 1.0 return images
def wiener_denoise(prj_norm, wiener_param, denoise_flag): import skimage.restoration as skr if not denoise_flag or not len(wiener_param): return prj_norm ss = prj_norm.shape psf = wiener_param['psf'] reg = wiener_param['reg'] balance = wiener_param['balance'] is_real = wiener_param['is_real'] clip = wiener_param['clip'] for j in range(ss[0]): prj_norm[j] = skr.wiener(prj_norm[j], psf=psf, reg=reg, balance=balance, is_real=is_real, clip=clip) return prj_norm
def test_image_shape(): """Test that shape of output image in deconvolution is same as input. This addresses issue #1172. """ point = np.zeros((5, 5), np.float) point[2, 2] = 1.0 psf = nd.gaussian_filter(point, sigma=1.0) # image shape: (45, 45), as reported in #1172 image = skimage.img_as_float(camera()[110:155, 225:270]) # just the face image_conv = nd.convolve(image, psf) deconv_sup = restoration.wiener(image_conv, psf, 1) deconv_un = restoration.unsupervised_wiener(image_conv, psf)[0] # test the shape np.testing.assert_equal(image.shape, deconv_sup.shape) np.testing.assert_equal(image.shape, deconv_un.shape) # test the reconstruction error sup_relative_error = np.abs(deconv_sup - image) / image un_relative_error = np.abs(deconv_un - image) / image np.testing.assert_array_less(np.median(sup_relative_error), 0.1) np.testing.assert_array_less(np.median(un_relative_error), 0.1)
def test_image_shape(): """Test that shape of output image in deconvolution is same as input. This addresses issue #1172. """ point = np.zeros((5, 5), np.float) point[2, 2] = 1. psf = ndi.gaussian_filter(point, sigma=1.) # image shape: (45, 45), as reported in #1172 image = util.img_as_float(camera()[65:165, 215:315]) # just the face image_conv = ndi.convolve(image, psf) deconv_sup = restoration.wiener(image_conv, psf, 1) deconv_un = restoration.unsupervised_wiener(image_conv, psf)[0] # test the shape np.testing.assert_equal(image.shape, deconv_sup.shape) np.testing.assert_equal(image.shape, deconv_un.shape) # test the reconstruction error sup_relative_error = np.abs(deconv_sup - image) / image un_relative_error = np.abs(deconv_un - image) / image np.testing.assert_array_less(np.median(sup_relative_error), 0.1) np.testing.assert_array_less(np.median(un_relative_error), 0.1)
def denoise(prj, denoise_flag): if denoise_flag == 1: # Wiener denoise import skimage.restoration as skr ss = prj.shape psf = np.ones([2, 2]) / (2**2) reg = None balance = 0.3 is_real = True clip = True for j in range(ss[0]): prj[j] = skr.wiener(prj[j], psf=psf, reg=reg, balance=balance, is_real=is_real, clip=clip) elif denoise_flag == 2: # Gaussian denoise from skimage.filters import gaussian as gf prj = gf(prj, [0, 1, 1]) return prj
def removeMotionBlur(image, kernelSize, angle): kernel = makeKernel(kernelSize, angle) return restoration.wiener(image, kernel, 0.1)
convolver = 10*np.ones((30,30)) convolver[10:20,10:20]=0 data2D = data_prospa.read_2d_file(datafolder+"dataIMG.2d") data3D=data_prospa.read_3d_file(datafolder+"data.3d") #params=ConfigParser.ConfigParser() #params.read(datafolder+"acqu.par") #implement gating on 3d dataset data2D*=0.01 data3D*=0.01 processedout=np.sum(data3D.real[:,:,0:],2) processedout*= (data2D.real.max() / processedout.max()) deconv80=restoration.wiener(processedout,convolver,200,clip=False) data2D=data_prospa.read_2d_file("data/6 - ring 2mm/dataIMG.2d") data2D=0.01*data2D.real deconv40=restoration.wiener(data2D,convolver[::2,::2],200,clip=False) fig1,ax=plt.subplots(nrows=1,ncols=5,squeeze=False,figsize=(15,5)) ax[0,0].matshow(convolver) ax[0,0].set_title('original') ms11=ax[0,1].matshow(processedout) ax[0,1].set_title('imagedata80') fixclim=ms11.get_clim() ms12=ax[0,2].matshow(data2D)
#!/usr/bin/env python import numpy as np from skimage import color, data, restoration from matplotlib.pyplot import subplots, show from scipy.signal import convolve2d img = color.rgb2gray(data.astronaut()) psf = np.ones((5, 5)) / 25 noisy = convolve2d(img, psf, 'same') noisy += 0.1 * noisy.std() * np.random.standard_normal(noisy.shape) deconvolved_img = restoration.wiener(noisy, psf, 1100) fg, ax = subplots(1, 2, figsize=(12, 5)) ax[0].imshow(img) ax[1].imshow(deconvolved_img) show()
convolver=np.load('psf40.npy') convolver=5.0*img.imread(datafolder+"pattern2mm.png",flatten=True)/255.0 convolver+=5 data2D = data_prospa.read_2d_file(datafolder+"dataIMG.2d") data3D=data_prospa.read_3d_file(datafolder+"data.3d") #params=ConfigParser.ConfigParser() #params.read(datafolder+"acqu.par") #implement gating on 3d dataset data2D*=0.01 data3D*=0.01 processedout=np.sum(data3D.real[:,:,0:],2) processedout*= (data2D.real.max() / processedout.max()) deconv=restoration.wiener(processedout,convolver,3e-1,clip=False) deconv=restoration.wiener(processedout,convolver,200,clip=False) #np.save('psf40.npy', deconv) fig1,ax=plt.subplots(nrows=1,ncols=4,squeeze=False,figsize=(15,5)) ms11=ax[0,0].matshow(data2D.real) ax[0,0].set_title('Sumimage') fixclim=ms11.get_clim() ms12=ax[0,1].matshow(processedout) ms12.set_clim(fixclim) ax[0,1].set_title('Gateimage') ms13=ax[0,2].matshow(convolver) ax[0,2].set_title('Convolver')
#padsmp[10:-10,-10:-1]=trainsmp[:,0:9] FO=fft.fftshift(fft.fft2(padsmp)) FTSlev=np.percentile(np.abs(FTS),80) FOlev=np.percentile(np.abs(FO),80) threshFTS=np.where(np.abs(FTS)<FTSlev,0,FTS) threshFO=np.where(np.abs(FO)<FOlev,0,FO) threshFSS=np.where(np.abs(threshFO)>0,threshFTS/threshFO,0)#threshFTS) iFSS=fft.ifftshift(fft.ifft2(threshFSS)) psfstart=(iFSS.shape[0]/2)-9 psf = np.abs(iFSS)[psfstart:psfstart+20,psfstart:psfstart+20] psf=restoration.wiener(trainsig,trainsmp,balance=500)[psfstart:psfstart+20,psfstart:psfstart+20] ##%% Make psf2 #reTrain=restoration.wiener(trainsig,psf,balance=90) #FRT=fft.fftshift(fft.fft2(reTrain)) #FRTlev=np.percentile(np.abs(FRT),90) #threshFRT=np.where(np.abs(FRT)<FRTlev, 0, FRT) #threshFSS2=np.where(np.abs(threshFO)>0, threshFRT/threshFO, threshFRT) #iFSS2=fft.ifftshift(fft.ifft2(threshFSS2)) #plt.matshow(np.abs(iFSS2)) #plt.title('SweetSpot 2') #FRT2=restoration.wiener(reTrain,np.abs(iFSS2)[14:19,14:19],balance=90) #plt.matshow(reTrain) #plt.title('reconstructed training sample') #plt.matshow(FRT2) #plt.title('rereconstructed training sample') #%%Display fourier
plt.show() ############ Wiener ##################### # create the motion blur kernel im = cv2.imread(('../images/lena_gray_512.tif'), 0) size = 5 # generating the kernel kernel_motion_blur = np.zeros((size, size)) kernel_motion_blur[int((size - 1) / 2), :] = np.ones(size) kernel_motion_blur = kernel_motion_blur / size H_kernel = np.pad(kernel_motion_blur, (((im.shape[0] - size) // 2, (im.shape[0] - size) // 2), ((im.shape[1] - size) // 2, (im.shape[1] - size) // 2))) output = cv2.filter2D(im, -1, H_kernel) Degradate_image = random_noise(output, mode='gaussian', seed=None, clip=True) psf = kernel_motion_blur deconvolved_img = wiener(Degradate_image, psf, 10) deconvolvedW, _ = unsupervised_wiener(Degradate_image, psf) plt.subplot(221), plt.imshow(im, cmap='gray'), plt.title('Origin') plt.subplot(222), plt.imshow(Degradate_image, cmap='gray'), plt.title('G_image') plt.subplot(223), plt.imshow(deconvolved_img, cmap='gray'), plt.title('Wiener') plt.subplot(224), plt.imshow(deconvolvedW, cmap='gray'), plt.title('unsupervised_wiener') plt.show() ######
Image._show(ImageChops.subtract(im, im8), title="im-ImageFilter.Kernel") Image._show(ImageChops.subtract(im, im9), title="im-ImageFilter.RankFilter") # In[10]: img = np.float32(io.imread(img_name, as_gray=True)) # img = color.rgb2gray(io.imread('image.jpg')) img = color.rgb2gray(img) psf = np.ones((7, 7)) / 49 # img = convolve2d(img, psf, 'same') # Add noise # img += 0.01 * img.std() * np.random.standard_normal(img.shape) deconv_img = restoration.wiener(img, psf, 1100) deconv_img2, _ = restoration.unsupervised_wiener(img, psf) # ImageViewer(img).show() # ImageViewer(deconv_img).show() # ImageViewer(deconv_img2).show() cv2.imshow("Input Image", img) cv2.imshow("Deconv1 Image", deconv_img) cv2.imshow("Deconv2 Image", deconv_img2) cv2.waitKey(0) cv2.destroyAllWindows() # In[11]: