def denoiser_test(denoiser):
ldct_list = sorted(glob(args.ldct_test_file_path))
ndct_list = sorted(glob(args.ndct_test_file_path))
denoiser.test(ldct_list,
ndct_list,
ckpt_dir=args.ckpt_dir,
save_dir=args.test_dir)
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# apply log(x+1) to the raw value
#--------------------------------------------------------------------------
# # maxV
# maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
# maxV = maxV['maxV']
# print maxV
#--------------------------------------------------------------------------
# read yaoshen's journal2 data
#--------------------------------------------------------------------------
snr_dir = '/space/neza/2/users/yaoshen/NEU/Research/MRI filtering/mcxlab_nightlybuild/data'
#-------#
# 1e5
#-------#
snr_dat = get_snr_data(
snr_dir +
'/journal2_50ns_vol100_homo_1e5_pack1.mat') # return 100 x (100x100)
print("[Test] input shape : {}, min_val = {}\n".format(
snr_dat.shape, np.amin(snr_dat)))
[samples, im_h, im_w] = snr_dat.shape
input_dat = np.reshape(snr_dat,
(samples, im_h, im_w, 1)) # extend 1 dimension
# preprocess
input_dat = np.log(input_dat + 1.)
# input_dat = input_dat / maxV
denoiser.test(input_dat,
ckpt_dir=args.ckpt_dir,
outFile='snr_hom1e5_nn.mat')
def denoiser_test(denoiser):
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
#--------------------------------------------------------------------------
#
#--------------------------------------------------------------------------
im_h, im_w = 100, 100
input_noisy1 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_noisy50 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_noisy1[0, :, :, :] = mat2np('../../data/rand2d/1e+05/test1.mat', maxV=maxV, im_h=im_h, im_w=im_w)
input_noisy50[0, :, :, :] = mat2np('../../data/rand2d/1e+05/test50.mat', maxV=maxV, im_h=im_h, im_w=im_w)
denoiser.test(input_noisy1, ckpt_dir=args.ckpt_dir,
outFile='rand2d1e5-test1.mat')
denoiser.test(input_noisy50, ckpt_dir=args.ckpt_dir,
outFile='rand2d1e5-test50.mat')
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# plan B : apply log(x+1) to the raw value
#--------------------------------------------------------------------------
#------------
# 1e5
#------------
noisy50 = '../data/osa_data/1e+05/1/osa_phn1e+05_test1_img50.mat'
noisymat50 = spio.loadmat(noisy50, squeeze_me=True) # the output is a dict
noisyData50 = noisymat50['currentImage']
(im_h, im_w) = noisyData50.shape
noisyData50 = np.reshape(noisyData50,
(im_h, im_w, 1)) # extend one dimension
# normalize data
noisyData50 = np.log(noisyData50 + 1.)
# assume it is 100 x 100 x 100 voxel
input_noisy50 = np.zeros((100, im_h, im_w, 1),
dtype=np.float32) # 4D matrix
# update
for i in xrange(100):
input_noisy50[i, :, :, :] = noisyData50
# startT = time.time()
denoiser.test(input_noisy50,
ckpt_dir=args.ckpt_dir,
outFile='1e5model-1e5-log_all.mat')
def denoiser_test(denoiser):
test_files_clean = sorted(
glob('./data/test/{}/*.png'.format(args.test_set_clean)))
test_files_noisy = sorted(
glob('./data/test/{}/*.png'.format(args.test_set_noisy)))
print(test_files_clean)
denoiser.test(test_files_clean,
test_files_noisy,
ckpt_dir=checkpoint_dir,
save_dir=test_dir)
def denoiser_test(denoiser):
test_data = args.test_data
print(
"[*] Start testing on real data. Working directory: %s. Collecting data from %s and storing test results in %s"
% (os.getcwd(), test_data, args.test_dir))
test_files = glob((test_data + '/*.npy').format('float32'))
denoiser.test(test_files,
ckpt_dir=checkpoint_dir,
save_dir=args.test_dir,
dataset_dir=test_data,
stride=args.stride_size)
def denoiser_test(denoiser, save_dir):
noisy_test_set_path = './data/test/{}/sigma{}'.format(
args.test_set, int(args.sigma))
assert os.path.exists(
noisy_test_set_path
) == True, 'No noisy test set available! Create using create_noisy_test_sets.py'
noisy_files = natsort.natsorted(
glob('{}/*.npy'.format(noisy_test_set_path)))
test_files = natsort.natsorted(
glob('./data/test/{}/*.png'.format(args.test_set)))
denoiser.test(test_files, noisy_files, save_dir)
def denoiser_test(denoiser):
noisy_eval_files = glob('./data/test/noisy/*.png')
# n = [int(i) for i in map(lambda x: x.split('/')[-1].split('.png')[0], noisy_eval_files)]
# noisy_eval_files = [x for (y, x) in sorted(zip(n, noisy_eval_files))]
noisy_eval_files = sorted(noisy_eval_files)
eval_files = glob('./data/test/original/*.png')
eval_files = sorted(eval_files)
start = time.time()
denoiser.test(eval_files, noisy_eval_files, ckpt_dir=args.ckpt_dir, save_dir='./data/denoised', temporal=args.temporal)
end = time.time()
print ("Elapsed time:", end-start);
def denoiser_test(denoiser):
noisy_eval_files = glob('/home/mli/tomograms/pycharm_demos/single_density/without_Gaussian_shapes/normal_test/with_noise/1024*1024_with_oversampling=2/phase_contrast_images/Gaussian_noise_PPSNR=12dB/npy_format/phase_contrast_image_distance_4_in_npy_format/test/*.npy')
# n = [int(i) for i in map(lambda x: x.split('/')[-1].split('.png')[0], noisy_eval_files)]
# noisy_eval_files = [x for (y, x) in sorted(zip(n, noisy_eval_files))]
noisy_eval_files = sorted(noisy_eval_files)
eval_files = glob('/home/mli/tomograms/pycharm_demos/single_density/without_Gaussian_shapes/normal_test/without_noise/1024*1024_with_oversampling=2/phase_contrast_images_1_without_elliptical_cylinder/nd_zoom_order=1/npy_format/phase_contrast_image_distance_4_in_npy_format/test/*.npy')
eval_files = sorted(eval_files)
start = time.time()
denoiser.test(eval_files, noisy_eval_files, ckpt_dir=args.ckpt_dir, save_dir='./data/denoised') # temporal=args.temporal
end = time.time()
print
"Elapsed time:", end - start
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# apply log(x+1) to the raw value
#--------------------------------------------------------------------------
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
#------------
# 1e5 osa simulation: 100 images along y-axis
#------------
im_h, im_w = 100, 100
N = 100
input_noisy1 = np.zeros((N, im_h, im_w, 1), dtype=np.float32) # 4D matrix
for i in xrange(1, 101):
noisy1 = '../../data/hetero3d/1e+05/img_[X].mat'
noisy1 = noisy1.replace('[X]', str(i))
# read mat file into np array
noisymat1 = spio.loadmat(noisy1, squeeze_me=True) # the output is a dict
noisyData1 = noisymat1['currentImage']
noisyData1 = np.reshape(noisyData1, (im_h, im_w, 1))
# preprocess
noisyData1 = np.log(noisyData1 + 1.)
noisyData1 = noisyData1 / maxV
# store the data into 4D tensor, indexing starting from 0
input_noisy1[i-1, :, :, :] = noisyData1
#
# resize the input image from 100x100 to 128x128
#
noisy_data_resize = transform_resize(input_noisy1)
#
# the output will be the (residual) noise in this case
#
denoiser.test(noisy_data_resize, ckpt_dir=args.ckpt_dir,
outFile='hetero3d.mat')
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# apply log(x+1) to the raw value
#--------------------------------------------------------------------------
#------------
# 1e5
#------------
noisy1 = '../../data/rand2d/1e+05/test1.mat'
noisy50 = '../../data/rand2d/1e+05/test50.mat'
noisymat1 = spio.loadmat(noisy1, squeeze_me=True) # the output is a dict
noisymat50 = spio.loadmat(noisy50, squeeze_me=True) # the output is a dict
noisyData1 = noisymat1['currentImage']
noisyData50 = noisymat50['currentImage']
(im_h, im_w) = noisyData1.shape
noisyData1 = np.reshape(noisyData1, (im_h, im_w, 1))
noisyData50 = np.reshape(noisyData50, (im_h, im_w, 1))
# normalize data
noisyData1 = np.log(noisyData1 + 1.)
noisyData50 = np.log(noisyData50 + 1.)
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
noisyData1 = noisyData1 / maxV
noisyData50 = noisyData50 / maxV
input_noisy1 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_noisy50 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
### update
input_noisy1[0, :, :, :] = noisyData1
input_noisy50[0, :, :, :] = noisyData50
denoiser.test(input_noisy1, ckpt_dir=args.ckpt_dir,
outFile='1e5model-test1.mat')
denoiser.test(input_noisy50, ckpt_dir=args.ckpt_dir,
outFile='1e5model-test50.mat')
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# apply log(x+1) to the raw value
#--------------------------------------------------------------------------
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
#--------------------------------------------------------------------------
# rand2d mcx for a squre image, using yaoshen's journal2 data
#--------------------------------------------------------------------------
#snr_dir = '/home/users/leiming/files_on_pangu/denoising_mcx/prepare_data/spie2d_customize/test_snr/het_absorber_square_x10_yy/1e+05'
snr_dir = '../../prepare_data/spie2d_customize/test_snr/het_absorber_square_x10_yy/1e+05'
im_h, im_w = 100, 100
N = 100
input_noisy = np.zeros((N, im_h, im_w, 1), dtype=np.float32) # 4D matrix
#-------#
# 1e5
#-------#
for i in xrange(1, N + 1):
noisy_file = snr_dir + '/test[X].mat'
noisy_file = noisy_file.replace('[X]', str(i))
# read mat
noisymat = spio.loadmat(noisy_file,
squeeze_me=True) # the output is a dict
noisyData = noisymat['currentImage']
noisyData = np.reshape(noisyData, (im_h, im_w, 1))
# store the data into 4D tensor, indexing starting from 0
input_noisy[i - 1, :, :, :] = noisyData
# preprocess
input_noisy = np.log(input_noisy + 1.)
input_noisy = input_noisy / maxV
denoiser.test(input_noisy,
ckpt_dir=args.ckpt_dir,
outFile='snr_2d_het_absorber_square_x10_p5nn_yy.mat')
def denoiser_test(denoiser):
noisy_eval_files = glob(f'{args.dir}/test/noisy/*.png')
# n = [int(i) for i in map(lambda x: x.split('/')[-1].split('.png')[0], noisy_eval_files)]
# noisy_eval_files = [x for (y, x) in sorted(zip(n, noisy_eval_files))]
noisy_eval_files = sorted(noisy_eval_files)
eval_files = glob(f'{args.dir}/test/original/*.png')
eval_files = sorted(eval_files)
start = time.time()
print(args)
denoiser.test(eval_files,
noisy_eval_files,
ckpt_dir=os.path.join(args.dir, args.ckpt_dir),
save_dir=os.path.join(args.dir, args.test_dir),
temporal=0) #args.temporal)
end = time.time()
print("Elapsed time:", end - start)
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# apply log(x+1) to the raw value
#--------------------------------------------------------------------------
## maxV
#maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
#maxV = maxV['maxV']
#print maxV
#------------
# 1e5 osa simulation: 100 images along y-axis
#------------
im_h, im_w = 100, 100
N = 100
input_noisy1 = np.zeros((N, im_h, im_w, 1), dtype=np.float32) # 4D matrix
for i in xrange(1, 101):
noisy1 = '../../data/hetero3d/1e+05/img_[X].mat'
noisy1 = noisy1.replace('[X]', str(i))
# read mat file into np array
noisymat1 = spio.loadmat(noisy1,
squeeze_me=True) # the output is a dict
noisyData1 = noisymat1['currentImage']
noisyData1 = np.reshape(noisyData1, (im_h, im_w, 1))
# preprocess
noisyData1 = np.log(noisyData1 + 1.)
# noisyData1 = noisyData1 / maxV
# store the data into 4D tensor, indexing starting from 0
input_noisy1[i - 1, :, :, :] = noisyData1
print("[Test] input_noisy shape : {}, min_val = {}\n".format(
input_noisy1.shape, np.amin(input_noisy1)))
denoiser.test(input_noisy1,
ckpt_dir=args.ckpt_dir,
outFile='test_hetero3d.mat')
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# apply log(x+1) to the raw value
#--------------------------------------------------------------------------
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
#------------
# 1e5 osa simulation: 100 images along y-axis
#------------
im_h, im_w = 100, 100
N = 100
input_noisy1 = np.zeros((N, im_h, im_w, 1), dtype=np.float32) # 4D matrix
for i in xrange(1, 101):
noisy1 = '../../data/osa/1e+05/1/y/osa_phn1e+05_test1_img[X].mat'
noisy1 = noisy1.replace('[X]', str(i))
# read mat file into np array
noisymat1 = spio.loadmat(noisy1, squeeze_me=True) # the output is a dict
noisyData1 = noisymat1['currentImage']
noisyData1 = np.reshape(noisyData1, (im_h, im_w, 1))
# preprocess
noisyData1 = np.log(noisyData1 + 1.)
noisyData1 = noisyData1 / maxV
# store the data into 4D tensor, indexing starting from 0
input_noisy1[i-1, :, :, :] = noisyData1
# the output will be the residual
denoiser.test(input_noisy1, ckpt_dir=args.ckpt_dir,
outFile='residual-h**o-test1.mat')
def Denoising(denoiser, X):
(im_h, im_w) = X.shape
X_new = np.reshape(X, (im_h, im_w, 1)) # extend one dimension
# normalize data
X_new = np.log(X_new + 1.)
inputX = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
# update
inputX[0, :, :, :] = X_new
return denoiser.test(inputX, ckpt_dir=args.ckpt_dir)
def denoiser_test(denoiser):
test_files = glob('{}/*.png'.format(args.test_set))
denoiser.test(test_files, ckpt_dir=args.ckpt_dir, save_dir=args.test_dir)
def denoiser_test(denoiser):
test_files = glob('./data/test/Set12/*.png'.format(args.test_set))
denoiser.test(test_files, ckpt_dir=args.ckpt_dir, save_dir=args.test_dir)
def denoiser_test(denoiser):
ldct_files= sorted(glob('./noisydata/sparse/test/*img.flt'.format(args.test_set)))
ldct_files= load_floats(ldct_files)
ndct_files= sorted(glob('./noisydata/ndct/test/*img.flt'.format(args.test_set)))
ndct_files= load_floats(ndct_files)
denoiser.test(ldct_files, ndct_files, ckpt_dir=args.ckpt_dir, save_dir=args.test_dir)
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# apply log(x+1) to the raw value
#--------------------------------------------------------------------------
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
#
# train model with 1-2K hom, and 1-4K het
# test the model with 2001
#
im_h, im_w = 100, 100
N = 4 # 1e4, 1e5, 1e6, 1e7
#--------------------------------------------------------------------------
# het
#--------------------------------------------------------------------------
input_noisy = np.zeros((N, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_noisy[0, :, :, :] = mat2np(
'../../data/spie2d_old/het/1e+04/test4001.mat',
maxV=maxV,
im_h=im_h,
im_w=im_w)
input_noisy[1, :, :, :] = mat2np(
'../../data/spie2d_old/het/1e+05/test4001.mat',
maxV=maxV,
im_h=im_h,
im_w=im_w)
input_noisy[2, :, :, :] = mat2np(
'../../data/spie2d_old/het/1e+06/test4001.mat',
maxV=maxV,
im_h=im_h,
im_w=im_w)
input_noisy[3, :, :, :] = mat2np(
'../../data/spie2d_old/het/1e+07/test4001.mat',
maxV=maxV,
im_h=im_h,
im_w=im_w)
print("[Test] input_noisy shape : {}, min_val = {}\n".format(
input_noisy.shape, np.amin(input_noisy)))
denoiser.test(input_noisy, ckpt_dir=args.ckpt_dir, outFile='test_het.mat')
#--------------------------------------------------------------------------
# hom
#--------------------------------------------------------------------------
input_noisy = np.zeros((N, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_noisy[0, :, :, :] = mat2np(
'../../data/spie2d_old/hom/1e+04/test2001.mat',
maxV=maxV,
im_h=im_h,
im_w=im_w)
input_noisy[1, :, :, :] = mat2np(
'../../data/spie2d_old/hom/1e+05/test2001.mat',
maxV=maxV,
im_h=im_h,
im_w=im_w)
input_noisy[2, :, :, :] = mat2np(
'../../data/spie2d_old/hom/1e+06/test2001.mat',
maxV=maxV,
im_h=im_h,
im_w=im_w)
input_noisy[3, :, :, :] = mat2np(
'../../data/spie2d_old/hom/1e+07/test2001.mat',
maxV=maxV,
im_h=im_h,
im_w=im_w)
print("[Test] input_noisy shape : {}, min_val = {}\n".format(
input_noisy.shape, np.amin(input_noisy)))
denoiser.test(input_noisy, ckpt_dir=args.ckpt_dir, outFile='test_hom.mat')
def denoiser_test(denoiser, save_dir):
print('Testing on {} dataset'.format(args.test_set))
test_files = natsort.natsorted(
glob('./data/test/{}/*.png'.format(args.test_set)))
denoiser.test(test_files, save_dir)
def denoiser_test(denoiser):
#--------------------------------------------------------------------------
# apply log(x+1) to the raw value
#--------------------------------------------------------------------------
#------------
# hom square
#------------
p5 = '../../prepare_data/spie2d_customize/journal2_hom/square_1e5.mat'
p6 = '../../prepare_data/spie2d_customize/journal2_hom/square_1e6.mat'
matp5 = spio.loadmat(p5, squeeze_me=True) # the output is a dict
matp6 = spio.loadmat(p6, squeeze_me=True) # the output is a dict
datap5 = matp5['currentImage']
datap6 = matp6['currentImage']
(im_h, im_w) = datap5.shape
datap5 = np.reshape(datap5, (im_h, im_w, 1))
datap6 = np.reshape(datap6, (im_h, im_w, 1))
# normalize data
datap5 = np.log(datap5 + 1.)
datap6 = np.log(datap6 + 1.)
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
datap5 = datap5 / maxV
datap6 = datap6 / maxV
input_p5 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_p6 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
### update
input_p5[0, :, :, :] = datap5
input_p6[0, :, :, :] = datap6
denoiser.test(input_p5,
ckpt_dir=args.ckpt_dir,
outFile='j2-hom-square-p5.mat')
denoiser.test(input_p6,
ckpt_dir=args.ckpt_dir,
outFile='j2-hom-square-p6.mat')
#------------
# hom square02
#------------
p5 = '../../prepare_data/spie2d_customize/journal2_hom/square02_1e5.mat'
p6 = '../../prepare_data/spie2d_customize/journal2_hom/square02_1e6.mat'
matp5 = spio.loadmat(p5, squeeze_me=True) # the output is a dict
matp6 = spio.loadmat(p6, squeeze_me=True) # the output is a dict
datap5 = matp5['currentImage']
datap6 = matp6['currentImage']
(im_h, im_w) = datap5.shape
datap5 = np.reshape(datap5, (im_h, im_w, 1))
datap6 = np.reshape(datap6, (im_h, im_w, 1))
# normalize data
datap5 = np.log(datap5 + 1.)
datap6 = np.log(datap6 + 1.)
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
datap5 = datap5 / maxV
datap6 = datap6 / maxV
input_p5 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_p6 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
### update
input_p5[0, :, :, :] = datap5
input_p6[0, :, :, :] = datap6
denoiser.test(input_p5,
ckpt_dir=args.ckpt_dir,
outFile='j2-hom-square02-p5.mat')
denoiser.test(input_p6,
ckpt_dir=args.ckpt_dir,
outFile='j2-hom-square02-p6.mat')
#--------------------------------------------------------------------------
# absorber
#--------------------------------------------------------------------------
p5 = '../../prepare_data/spie2d_customize/journal2_absorber/square_1e5.mat'
p6 = '../../prepare_data/spie2d_customize/journal2_absorber/square_1e6.mat'
matp5 = spio.loadmat(p5, squeeze_me=True) # the output is a dict
matp6 = spio.loadmat(p6, squeeze_me=True) # the output is a dict
datap5 = matp5['currentImage']
datap6 = matp6['currentImage']
(im_h, im_w) = datap5.shape
datap5 = np.reshape(datap5, (im_h, im_w, 1))
datap6 = np.reshape(datap6, (im_h, im_w, 1))
# normalize data
datap5 = np.log(datap5 + 1.)
datap6 = np.log(datap6 + 1.)
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
datap5 = datap5 / maxV
datap6 = datap6 / maxV
input_p5 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_p6 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
### update
input_p5[0, :, :, :] = datap5
input_p6[0, :, :, :] = datap6
denoiser.test(input_p5,
ckpt_dir=args.ckpt_dir,
outFile='j2-absorber-square-p5.mat')
denoiser.test(input_p6,
ckpt_dir=args.ckpt_dir,
outFile='j2-absorber-square-p6.mat')
#------------
# absorber square02
#------------
p5 = '../../prepare_data/spie2d_customize/journal2_absorber/square02_1e5.mat'
p6 = '../../prepare_data/spie2d_customize/journal2_absorber/square02_1e6.mat'
matp5 = spio.loadmat(p5, squeeze_me=True) # the output is a dict
matp6 = spio.loadmat(p6, squeeze_me=True) # the output is a dict
datap5 = matp5['currentImage']
datap6 = matp6['currentImage']
(im_h, im_w) = datap5.shape
datap5 = np.reshape(datap5, (im_h, im_w, 1))
datap6 = np.reshape(datap6, (im_h, im_w, 1))
# normalize data
datap5 = np.log(datap5 + 1.)
datap6 = np.log(datap6 + 1.)
# maxV
maxV = spio.loadmat('maxV.mat', squeeze_me=True) # the output is a dict
maxV = maxV['maxV']
print maxV
datap5 = datap5 / maxV
datap6 = datap6 / maxV
input_p5 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
input_p6 = np.zeros((1, im_h, im_w, 1), dtype=np.float32) # 4D matrix
### update
input_p5[0, :, :, :] = datap5
input_p6[0, :, :, :] = datap6
denoiser.test(input_p5,
ckpt_dir=args.ckpt_dir,
outFile='j2-absorber-square02-p5.mat')
denoiser.test(input_p6,
ckpt_dir=args.ckpt_dir,
outFile='j2-absorber-square02-p6.mat')
def denoiser_test(denoiser):
test_files = glob('./data/test/{}/*.jpg'.format(args.test_set))
denoiser.test(test_files, ckpt_dir=args.ckpt_dir, save_dir=args.test_dir)
