def test_ssim(self): """Test ssim.""" npt.assert_almost_equal( metrics.ssim(self.data1, self.data1**2), self.ssim_res, err_msg='Incorrect SSIM result', ) npt.assert_almost_equal( metrics.ssim(self.data1, self.data1**2, mask=self.mask), self.ssim_mask_res, err_msg='Incorrect SSIM result', ) npt.assert_raises( ValueError, metrics.ssim, self.data1, self.data1, mask=1, )
# undersample the k-space using a cartesian acquisition mask # We then reconstruct the zero order solution as a baseline # Get the locations of the kspace samples kspace_loc = convert_mask_to_locations(mask.data) # Generate the subsampled kspace fourier_op = FFT(samples=kspace_loc, shape=image.shape) kspace_data = fourier_op.op(image) # Zero order solution image_rec0 = pysap.Image(data=fourier_op.adj_op(kspace_data), metadata=image.metadata) # image_rec0.show() # Calculate SSIM base_ssim = ssim(image_rec0, image) print(base_ssim) ############################################################################# # FISTA optimization # ------------------ # # We now want to refine the zero order solution using a FISTA optimization. # The cost function is set to Proximity Cost + Gradient Cost # Setup the operators linear_op = WaveletN( wavelet_name="sym8", nb_scales=4, dim=3, padding_mode="periodization",
mask = loadmat(samples_dirpath + path) mask = mask['samples'] # Normalisation between [-0.5, 0.5[ mask = mask / (2 * np.abs(mask).max()) # means of metrics gamma_temp = [[], [], [], []] for j in range(X_train.shape[0]): image = X_train[j] img_recons, cost = g(image, mask, **kwargs) m = np.array([ snr(image, img_recons), psnr(image, img_recons), ssim(image, img_recons, None), nrmse(image, img_recons) ]) print('ID img, decay, tau, recons metric: ({}, {}, {},' '{})\n'.format(j, decay, tau, m)) # gamma_temp = gamma_temp + m for i in range(len(m)): gamma_temp[i].append(m[i]) cnt += 1 print('PROGRESSION: {:4f}%\n'.format( (cnt * 100) / (len(decays) * len(taus) * X_train.shape[0]))) # Save metrics and data of the reconstructions res_dict['mean_snr'] = np.mean(gamma_temp[0])
atol=1e-4, verbose=1, get_cost=True) imshow3D(np.abs(x_final), display=True) plt.figure() plt.plot(cost) plt.show() print('Saving the cube') np.save('/volatile/bsarthou/datas/XP_pysap/save_FISTA_300_sym8_mu5e-6.npy', x_final) ref = np.load('/volatile/bsarthou/datas/XP_pysap/ref_Ipat4.npy') print('SSIM iPAT4:', ssim(mat2gray(ref), mat2gray(x_final), mask=None)) # # ############################################################################# # # Condata-Vu optimization # # ----------------------- # # # # We now want to refine the zero order solution using a Condata-Vu # # optimization. # # Here no cost function is set, and the optimization will reach the # # maximum number of iterations. Fill free to play with this parameter. # # # Start the CONDAT-VU reconstruction # max_iter = 1 # gradient_op_cd = Gradient_pMRI(data=kspace_data, # fourier_op=fourier_op,
fourier_op = NonCartesianFFT( samples=kspace_loc, shape=image.shape, implementation='gpuNUFFT', ) fourier_op_density_comp = NonCartesianFFT( samples=kspace_loc, shape=image.shape, implementation='gpuNUFFT', density_comp=density_comp ) # Get the kspace data retrospectively. Note that this can be done with # `fourier_op_density_comp` as the forward operator is the same kspace_obs = fourier_op.op(image.data) # Simple adjoint image_rec0 = pysap.Image(data=np.abs(fourier_op.adj_op(kspace_obs))) # image_rec0.show() base_ssim = ssim(image_rec0, image) print('The SSIM from Adjoint is : ' + str(base_ssim)) # Density Compensation adjoint: # This preconditions k-space giving a result closer to inverse image_rec1 = pysap.Image(data=np.abs( fourier_op_density_comp.adj_op(kspace_obs)) ) # image_rec1.show() new_ssim = ssim(image_rec1, image) print('The SSIM from Density ' 'compensated Adjoint is : ' + str(new_ssim))
def pdhg(data, p, **kwargs): # -- # -- MAIN LOWER LEVEL FUNCTION # -- # INPUTS: - data: kspace measurements # - p: p[:-1]=subsampling mask S(p), p[-1]=regularisation parameter alpha(p) # So len(p)=len(data)+1 # - fourier_op: fourier operator from a full mask of same shape as the final image. # - linear_op: linear operator used in regularisation functions # For the moment, only use waveletN. # - param: lower level energy parameters # Must contain parameters keys "epsilon" and "gamma". # mask_type (optional): type of mask used ("cartesian", "radial"). Assume a cartesian mask if not given. # -- # OPTIONAL INPUTS: # - const: algorithm constants if we already know the values we want to use for tau and sigma # If not given, will compute them according to what is said in the article. # - compute_energy: bool, we compute and return energy over iterations if True (default: False) # - ground_truth: matrix representing the true image the data come from (default: None). If not None, we compute the ssim over iterations. # - maxit,tol: We stop the algorithm when the norm of the difference between two steps # is smaller than tol or after maxit iterations (default: 200, 1e-4) # -- # OUTPUTS: - uk: final image # - norms(, energy, ssims): evolution of stopping criterion (and energy if compute_energy is True / ssims if ground_truth not None) fourier_op = kwargs.get("fourier_op", None) linear_op = kwargs.get("linear_op", None) param = kwargs.get("param", None) # Create fourier_op and linear_op if not given for multithreading if fourier_op is None: samples = kwargs.get("samples", []) shape = kwargs.get("shape", ()) if samples is not None: fourier_op = NonCartesianFFT(samples=samples, shape=shape, implementation='cpu') if fourier_op is None: raise ValueError("A fourier operator fourier_op must be given") if linear_op is None: wavelet_name = kwargs.get("wavelet_name", "") wavelet_scale = kwargs.get("wavelet_scale", 1) if wavelet_name != "": linear_op = WaveletN(wavelet_name=wavelet_name, nb_scale=wavelet_scale, padding_mode="periodization") if linear_op is None: raise ValueError("A linear operator linear_op must be given") if param is None: raise ValueError("Lower level parameters must be given") mask_type = kwargs.get("mask_type", "") const = kwargs.get("const", {}) compute_energy = kwargs.get("compute_energy", False) ground_truth = kwargs.get("ground_truth", None) maxit = kwargs.get("maxit", 200) tol = kwargs.get("tol", 1e-6) verbose = kwargs.get("verbose", 1) #Global parameters p, pn1 = p[:-1], p[-1] epsilon = param["epsilon"] gamma = param["gamma"] n_iter = 0 #Algorithm constants const = compute_constants(param, const, p) if verbose >= 0: print("Sigma:", const["sigma"], "\nTau:", const["tau"]) #Initializing uk = fourier_op.adj_op(p * data) vk = np.copy(uk) wk = linear_op.op(uk) uk_bar = np.copy(uk) norm = 2 * tol #For plots if compute_energy: energy = [] if ground_truth is not None: ssims = [] norms = [] #Main loop t1 = time.time() while n_iter < maxit and norm > tol: uk, vk, wk, uk_bar, norm = step(uk, vk, wk, uk_bar, const, p, pn1, data, param, linear_op, fourier_op, mask_type) n_iter += 1 #Saving informations norms.append(norm) if compute_energy: energy.append( energy_wavelet(uk, p, pn1, data, gamma, epsilon, linear_op, fourier_op)) if ground_truth is not None: ssims.append(ssim(uk, ground_truth)) #Printing if n_iter % 10 == 0 and verbose > 0: if compute_energy: print(n_iter, " iterations:\nCost:", energy[-1], "\nNorm:", norm, "\n") else: print(n_iter, " iterations:\nNorm:", norm, "\n") if verbose >= 0: print("Finished in", time.time() - t1, "seconds.") #Return if compute_energy and ground_truth is not None: return uk, norms, energy, ssims elif ground_truth is not None: return uk, norms, ssims elif compute_energy: return uk, norms, energy else: return uk, norms
def ssim_ssos(test, ref, mask=None): test = ssos(test) return ssim(test, ref, mask=mask)
lambda_init=1.0, max_nb_of_iter=max_iter, atol=1e-4, verbose=1, get_cost=False) # print(np.abs(x_final)) imshow3D(np.abs(x_final), display=True) # plt.figure() # plt.plot(cost) # plt.show() np.save('/volatile/bsarthou/datas/save_baboon_128_NUFFT_cubic_GPU_sp3d.npy', x_final) print('FISTA Mu:{} SSIM: {}'.format( mu, ssim(mat2grey(Iref), mat2grey(x_final), None))) print('FISTA Mu:{} PSNR: {}'.format( mu, psnr(mat2grey(Iref), mat2grey(x_final), None))) # # gradient_op_cd = Gradient_pMRI(data=kspace_data, # fourier_op=fourier_op) # x_final, transform, cost = sparse_rec_condatvu( # gradient_op=gradient_op_cd, # linear_op=linear_op, # std_est=None, # std_est_method=None, # std_thr=2., # mu=mu, # tau=None, # sigma=None,
linear_op=linear_op) x_final, transform, cost = sparse_rec_fista(gradient_op=gradient_op, linear_op=linear_op, mu=0, lambda_init=1.0, max_nb_of_iter=max_iter, atol=1e-4, verbose=1, get_cost=True) end = time.clock() tab_time[0, run] = end - start tab_metrics[0, run] = ssim(np.abs(Iref), np.abs(x_final), mask=None) tab_metrics[1, run] = snr(np.abs(Iref), np.abs(x_final), mask=None) tab_metrics[2, run] = psnr(np.abs(Iref), np.abs(x_final), mask=None) tab_metrics[3, run] = nrmse(np.abs(Iref), np.abs(x_final), mask=None) list_cost.append(cost) else: for run in range(nb_runs): start = time.clock() if PWT: linear_op = pyWavelet3(wavelet_name=pwt_name, nb_scale=3) else: # import ipdb; ipdb.set_trace()