import unittest
import numpy as np
import os
import timeit
from ccpi.filters.regularisers import ROF_TV, FGP_TV, SB_TV, TGV, LLT_ROF, FGP_dTV, NDF, Diff4th
from PIL import Image
class TiffReader(object):
def imread(self, filename):
return np.asarray(Image.open(filename))
###############################################################################
def printParametersToString(pars):
txt = r''
for key, value in pars.items():
if key== 'algorithm' :
txt += "{0} = {1}".format(key, value.__name__)
elif key == 'input':
txt += "{0} = {1}".format(key, np.shape(value))
elif key == 'refdata':
txt += "{0} = {1}".format(key, np.shape(value))
else:
txt += "{0} = {1}".format(key, value)
txt += '\n'
return txt
def nrmse(im1, im2):
rmse = np.sqrt(np.sum((im2 - im1) ** 2) / float(im1.size))
max_val = max(np.max(im1), np.max(im2))
min_val = min(np.min(im1), np.min(im2))
return 1 - (rmse / (max_val - min_val))
def rmse(im1, im2):
rmse = np.sqrt(np.sum((im1 - im2) ** 2) / float(im1.size))
return rmse
###############################################################################
class TestRegularisers(unittest.TestCase):
def test_ROF_TV_CPU_vs_GPU(self):
#print ("tomas debug test function")
print(__name__)
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
perc = 0.05
u0 = Im + np.random.normal(loc = 0 ,
scale = perc * Im ,
size = np.shape(Im))
u_ref = Im + np.random.normal(loc = 0 ,
scale = 0.01 * Im ,
size = np.shape(Im))
# map the u0 u0->u0>0
# f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
u0 = u0.astype('float32')
u_ref = u_ref.astype('float32')
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("____________ROF-TV bench___________________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
# set parameters
pars = {'algorithm': ROF_TV, \
'input' : u0,\
'regularisation_parameter':0.04,\
'number_of_iterations': 2500,\
'time_marching_parameter': 0.00002
}
print ("#############ROF TV CPU####################")
start_time = timeit.default_timer()
rof_cpu = ROF_TV(pars['input'],
pars['regularisation_parameter'],
pars['number_of_iterations'],
pars['time_marching_parameter'],'cpu')
rms = rmse(Im, rof_cpu)
pars['rmse'] = rms
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("##############ROF TV GPU##################")
start_time = timeit.default_timer()
try:
rof_gpu = ROF_TV(pars['input'],
pars['regularisation_parameter'],
pars['number_of_iterations'],
pars['time_marching_parameter'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms = rmse(Im, rof_gpu)
pars['rmse'] = rms
pars['algorithm'] = ROF_TV
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("--------Compare the results--------")
tolerance = 1e-04
diff_im = np.zeros(np.shape(rof_cpu))
diff_im = abs(rof_cpu - rof_gpu)
diff_im[diff_im > tolerance] = 1
self.assertLessEqual(diff_im.sum() , 1)
def test_FGP_TV_CPU_vs_GPU(self):
print(__name__)
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
perc = 0.05
u0 = Im + np.random.normal(loc = 0 ,
scale = perc * Im ,
size = np.shape(Im))
u_ref = Im + np.random.normal(loc = 0 ,
scale = 0.01 * Im ,
size = np.shape(Im))
# map the u0 u0->u0>0
# f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
u0 = u0.astype('float32')
u_ref = u_ref.astype('float32')
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("____________FGP-TV bench___________________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
# set parameters
pars = {'algorithm' : FGP_TV, \
'input' : u0,\
'regularisation_parameter':0.04, \
'number_of_iterations' :1200 ,\
'tolerance_constant':0.00001,\
'methodTV': 0 ,\
'nonneg': 0 ,\
'printingOut': 0
}
print ("#############FGP TV CPU####################")
start_time = timeit.default_timer()
fgp_cpu = FGP_TV(pars['input'],
pars['regularisation_parameter'],
pars['number_of_iterations'],
pars['tolerance_constant'],
pars['methodTV'],
pars['nonneg'],
pars['printingOut'],'cpu')
rms = rmse(Im, fgp_cpu)
pars['rmse'] = rms
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("##############FGP TV GPU##################")
start_time = timeit.default_timer()
try:
fgp_gpu = FGP_TV(pars['input'],
pars['regularisation_parameter'],
pars['number_of_iterations'],
pars['tolerance_constant'],
pars['methodTV'],
pars['nonneg'],
pars['printingOut'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms = rmse(Im, fgp_gpu)
pars['rmse'] = rms
pars['algorithm'] = FGP_TV
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("--------Compare the results--------")
tolerance = 1e-05
diff_im = np.zeros(np.shape(fgp_cpu))
diff_im = abs(fgp_cpu - fgp_gpu)
diff_im[diff_im > tolerance] = 1
self.assertLessEqual(diff_im.sum() , 1)
def test_SB_TV_CPU_vs_GPU(self):
print(__name__)
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
perc = 0.05
u0 = Im + np.random.normal(loc = 0 ,
scale = perc * Im ,
size = np.shape(Im))
u_ref = Im + np.random.normal(loc = 0 ,
scale = 0.01 * Im ,
size = np.shape(Im))
# map the u0 u0->u0>0
# f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
u0 = u0.astype('float32')
u_ref = u_ref.astype('float32')
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("____________SB-TV bench___________________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
# set parameters
pars = {'algorithm' : SB_TV, \
'input' : u0,\
'regularisation_parameter':0.04, \
'number_of_iterations' :150 ,\
'tolerance_constant':1e-05,\
'methodTV': 0 ,\
'printingOut': 0
}
print ("#############SB-TV CPU####################")
start_time = timeit.default_timer()
sb_cpu = SB_TV(pars['input'],
pars['regularisation_parameter'],
pars['number_of_iterations'],
pars['tolerance_constant'],
pars['methodTV'],
pars['printingOut'],'cpu')
rms = rmse(Im, sb_cpu)
pars['rmse'] = rms
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("##############SB TV GPU##################")
start_time = timeit.default_timer()
try:
sb_gpu = SB_TV(pars['input'],
pars['regularisation_parameter'],
pars['number_of_iterations'],
pars['tolerance_constant'],
pars['methodTV'],
pars['printingOut'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms = rmse(Im, sb_gpu)
pars['rmse'] = rms
pars['algorithm'] = SB_TV
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("--------Compare the results--------")
tolerance = 1e-05
diff_im = np.zeros(np.shape(sb_cpu))
diff_im = abs(sb_cpu - sb_gpu)
diff_im[diff_im > tolerance] = 1
self.assertLessEqual(diff_im.sum(), 1)
def test_TGV_CPU_vs_GPU(self):
print(__name__)
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
perc = 0.05
u0 = Im + np.random.normal(loc = 0 ,
scale = perc * Im ,
size = np.shape(Im))
u_ref = Im + np.random.normal(loc = 0 ,
scale = 0.01 * Im ,
size = np.shape(Im))
# map the u0 u0->u0>0
# f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
u0 = u0.astype('float32')
u_ref = u_ref.astype('float32')
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("____________TGV bench___________________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
# set parameters
pars = {'algorithm' : TGV, \
'input' : u0,\
'regularisation_parameter':0.04, \
'alpha1':1.0,\
'alpha0':2.0,\
'number_of_iterations' :250 ,\
'LipshitzConstant' :12 ,\
}
print ("#############TGV CPU####################")
start_time = timeit.default_timer()
tgv_cpu = TGV(pars['input'],
pars['regularisation_parameter'],
pars['alpha1'],
pars['alpha0'],
pars['number_of_iterations'],
pars['LipshitzConstant'],'cpu')
rms = rmse(Im, tgv_cpu)
pars['rmse'] = rms
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("##############TGV GPU##################")
start_time = timeit.default_timer()
try:
tgv_gpu = TGV(pars['input'],
pars['regularisation_parameter'],
pars['alpha1'],
pars['alpha0'],
pars['number_of_iterations'],
pars['LipshitzConstant'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms = rmse(Im, tgv_gpu)
pars['rmse'] = rms
pars['algorithm'] = TGV
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("--------Compare the results--------")
tolerance = 1e-05
diff_im = np.zeros(np.shape(tgv_gpu))
diff_im = abs(tgv_cpu - tgv_gpu)
diff_im[diff_im > tolerance] = 1
self.assertLessEqual(diff_im.sum() , 1)
def test_LLT_ROF_CPU_vs_GPU(self):
print(__name__)
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
perc = 0.05
u0 = Im + np.random.normal(loc = 0 ,
scale = perc * Im ,
size = np.shape(Im))
u_ref = Im + np.random.normal(loc = 0 ,
scale = 0.01 * Im ,
size = np.shape(Im))
# map the u0 u0->u0>0
# f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
u0 = u0.astype('float32')
u_ref = u_ref.astype('float32')
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("____________LLT-ROF bench___________________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
# set parameters
pars = {'algorithm' : LLT_ROF, \
'input' : u0,\
'regularisation_parameterROF':0.04, \
'regularisation_parameterLLT':0.01, \
'number_of_iterations' :1000 ,\
'time_marching_parameter' :0.0001 ,\
}
print ("#############LLT- ROF CPU####################")
start_time = timeit.default_timer()
lltrof_cpu = LLT_ROF(pars['input'],
pars['regularisation_parameterROF'],
pars['regularisation_parameterLLT'],
pars['number_of_iterations'],
pars['time_marching_parameter'],'cpu')
rms = rmse(Im, lltrof_cpu)
pars['rmse'] = rms
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("#############LLT- ROF GPU####################")
start_time = timeit.default_timer()
try:
lltrof_gpu = LLT_ROF(pars['input'],
pars['regularisation_parameterROF'],
pars['regularisation_parameterLLT'],
pars['number_of_iterations'],
pars['time_marching_parameter'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms = rmse(Im, lltrof_gpu)
pars['rmse'] = rms
pars['algorithm'] = LLT_ROF
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("--------Compare the results--------")
tolerance = 1e-04
diff_im = np.zeros(np.shape(lltrof_gpu))
diff_im = abs(lltrof_cpu - lltrof_gpu)
diff_im[diff_im > tolerance] = 1
self.assertLessEqual(diff_im.sum(), 1)
def test_NDF_CPU_vs_GPU(self):
print(__name__)
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
perc = 0.05
u0 = Im + np.random.normal(loc = 0 ,
scale = perc * Im ,
size = np.shape(Im))
u_ref = Im + np.random.normal(loc = 0 ,
scale = 0.01 * Im ,
size = np.shape(Im))
# map the u0 u0->u0>0
# f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
u0 = u0.astype('float32')
u_ref = u_ref.astype('float32')
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("_______________NDF bench___________________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
# set parameters
pars = {'algorithm' : NDF, \
'input' : u0,\
'regularisation_parameter':0.06, \
'edge_parameter':0.04,\
'number_of_iterations' :1000 ,\
'time_marching_parameter':0.025,\
'penalty_type': 1
}
print ("#############NDF CPU####################")
start_time = timeit.default_timer()
ndf_cpu = NDF(pars['input'],
pars['regularisation_parameter'],
pars['edge_parameter'],
pars['number_of_iterations'],
pars['time_marching_parameter'],
pars['penalty_type'],'cpu')
rms = rmse(Im, ndf_cpu)
pars['rmse'] = rms
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("##############NDF GPU##################")
start_time = timeit.default_timer()
try:
ndf_gpu = NDF(pars['input'],
pars['regularisation_parameter'],
pars['edge_parameter'],
pars['number_of_iterations'],
pars['time_marching_parameter'],
pars['penalty_type'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms = rmse(Im, ndf_gpu)
pars['rmse'] = rms
pars['algorithm'] = NDF
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("--------Compare the results--------")
tolerance = 1e-05
diff_im = np.zeros(np.shape(ndf_cpu))
diff_im = abs(ndf_cpu - ndf_gpu)
diff_im[diff_im > tolerance] = 1
self.assertLessEqual(diff_im.sum(), 1)
def test_Diff4th_CPU_vs_GPU(self):
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
perc = 0.05
u0 = Im + np.random.normal(loc = 0 ,
scale = perc * Im ,
size = np.shape(Im))
u_ref = Im + np.random.normal(loc = 0 ,
scale = 0.01 * Im ,
size = np.shape(Im))
# map the u0 u0->u0>0
# f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
u0 = u0.astype('float32')
u_ref = u_ref.astype('float32')
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("___Anisotropic Diffusion 4th Order (2D)____")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
# set parameters
pars = {'algorithm' : Diff4th, \
'input' : u0,\
'regularisation_parameter':3.5, \
'edge_parameter':0.02,\
'number_of_iterations' :500 ,\
'time_marching_parameter':0.001
}
print ("#############Diff4th CPU####################")
start_time = timeit.default_timer()
diff4th_cpu = Diff4th(pars['input'],
pars['regularisation_parameter'],
pars['edge_parameter'],
pars['number_of_iterations'],
pars['time_marching_parameter'],'cpu')
rms = rmse(Im, diff4th_cpu)
pars['rmse'] = rms
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("##############Diff4th GPU##################")
start_time = timeit.default_timer()
try:
diff4th_gpu = Diff4th(pars['input'],
pars['regularisation_parameter'],
pars['edge_parameter'],
pars['number_of_iterations'],
pars['time_marching_parameter'], 'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms = rmse(Im, diff4th_gpu)
pars['rmse'] = rms
pars['algorithm'] = Diff4th
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("--------Compare the results--------")
tolerance = 1e-05
diff_im = np.zeros(np.shape(diff4th_cpu))
diff_im = abs(diff4th_cpu - diff4th_gpu)
diff_im[diff_im > tolerance] = 1
self.assertLessEqual(diff_im.sum() , 1)
def test_FDGdTV_CPU_vs_GPU(self):
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
perc = 0.05
u0 = Im + np.random.normal(loc = 0 ,
scale = perc * Im ,
size = np.shape(Im))
u_ref = Im + np.random.normal(loc = 0 ,
scale = 0.01 * Im ,
size = np.shape(Im))
# map the u0 u0->u0>0
# f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
u0 = u0.astype('float32')
u_ref = u_ref.astype('float32')
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("____________FGP-dTV bench___________________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
# set parameters
pars = {'algorithm' : FGP_dTV, \
'input' : u0,\
'refdata' : u_ref,\
'regularisation_parameter':0.04, \
'number_of_iterations' :1000 ,\
'tolerance_constant':1e-07,\
'eta_const':0.2,\
'methodTV': 0 ,\
'nonneg': 0 ,\
'printingOut': 0
}
print ("#############FGP dTV CPU####################")
start_time = timeit.default_timer()
fgp_dtv_cpu = FGP_dTV(pars['input'],
pars['refdata'],
pars['regularisation_parameter'],
pars['number_of_iterations'],
pars['tolerance_constant'],
pars['eta_const'],
pars['methodTV'],
pars['nonneg'],
pars['printingOut'],'cpu')
rms = rmse(Im, fgp_dtv_cpu)
pars['rmse'] = rms
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("##############FGP dTV GPU##################")
start_time = timeit.default_timer()
try:
fgp_dtv_gpu = FGP_dTV(pars['input'],
pars['refdata'],
pars['regularisation_parameter'],
pars['number_of_iterations'],
pars['tolerance_constant'],
pars['eta_const'],
pars['methodTV'],
pars['nonneg'],
pars['printingOut'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms = rmse(Im, fgp_dtv_gpu)
pars['rmse'] = rms
pars['algorithm'] = FGP_dTV
txtstr = printParametersToString(pars)
txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
print (txtstr)
print ("--------Compare the results--------")
tolerance = 1e-05
diff_im = np.zeros(np.shape(fgp_dtv_cpu))
diff_im = abs(fgp_dtv_cpu - fgp_dtv_gpu)
diff_im[diff_im > tolerance] = 1
self.assertLessEqual(diff_im.sum(), 1)
def test_cpu_ROF_TV(self):
#filename = os.path.join(".." , ".." , ".." , "data" ,"testLena.npy")
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
"""
# read noiseless image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
"""
tolerance = 1e-05
rms_rof_exp = 8.313131464999238e-05 #expected value for ROF model
# set parameters for ROF-TV
pars_rof_tv = {'algorithm': ROF_TV, \
'input' : Im,\
'regularisation_parameter':0.04,\
'number_of_iterations': 50,\
'time_marching_parameter': 0.00001
}
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("_________testing ROF-TV (2D, CPU)__________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
rof_cpu = ROF_TV(pars_rof_tv['input'],
pars_rof_tv['regularisation_parameter'],
pars_rof_tv['number_of_iterations'],
pars_rof_tv['time_marching_parameter'],'cpu')
rms_rof = rmse(Im, rof_cpu)
# now compare obtained rms with the expected value
self.assertLess(abs(rms_rof-rms_rof_exp) , tolerance)
def test_cpu_FGP_TV(self):
#filename = os.path.join(".." , ".." , ".." , "data" ,"testLena.npy")
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
"""
# read noiseless image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
"""
tolerance = 1e-05
rms_fgp_exp = 0.019152347 #expected value for FGP model
pars_fgp_tv = {'algorithm' : FGP_TV, \
'input' : Im,\
'regularisation_parameter':0.04, \
'number_of_iterations' :50 ,\
'tolerance_constant':1e-06,\
'methodTV': 0 ,\
'nonneg': 0 ,\
'printingOut': 0
}
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("_________testing FGP-TV (2D, CPU)__________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
fgp_cpu = FGP_TV(pars_fgp_tv['input'],
pars_fgp_tv['regularisation_parameter'],
pars_fgp_tv['number_of_iterations'],
pars_fgp_tv['tolerance_constant'],
pars_fgp_tv['methodTV'],
pars_fgp_tv['nonneg'],
pars_fgp_tv['printingOut'],'cpu')
rms_fgp = rmse(Im, fgp_cpu)
# now compare obtained rms with the expected value
self.assertLess(abs(rms_fgp-rms_fgp_exp) , tolerance)
def test_gpu_ROF(self):
#filename = os.path.join(".." , ".." , ".." , "data" ,"testLena.npy")
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
tolerance = 1e-05
rms_rof_exp = 8.313131464999238e-05 #expected value for ROF model
# set parameters for ROF-TV
pars_rof_tv = {'algorithm': ROF_TV, \
'input' : Im,\
'regularisation_parameter':0.04,\
'number_of_iterations': 50,\
'time_marching_parameter': 0.00001
}
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("_________testing ROF-TV (2D, GPU)__________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
try:
rof_gpu = ROF_TV(pars_rof_tv['input'],
pars_rof_tv['regularisation_parameter'],
pars_rof_tv['number_of_iterations'],
pars_rof_tv['time_marching_parameter'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms_rof = rmse(Im, rof_gpu)
# now compare obtained rms with the expected value
self.assertLess(abs(rms_rof-rms_rof_exp) , tolerance)
def test_gpu_FGP(self):
#filename = os.path.join(".." , ".." , ".." , "data" ,"testLena.npy")
filename = os.path.join("lena_gray_512.tif")
plt = TiffReader()
# read image
Im = plt.imread(filename)
Im = np.asarray(Im, dtype='float32')
Im = Im/255
tolerance = 1e-05
rms_fgp_exp = 0.019152347 #expected value for FGP model
# set parameters for FGP-TV
pars_fgp_tv = {'algorithm' : FGP_TV, \
'input' : Im,\
'regularisation_parameter':0.04, \
'number_of_iterations' :50 ,\
'tolerance_constant':1e-06,\
'methodTV': 0 ,\
'nonneg': 0 ,\
'printingOut': 0
}
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print ("_________testing FGP-TV (2D, GPU)__________")
print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
try:
fgp_gpu = FGP_TV(pars_fgp_tv['input'],
pars_fgp_tv['regularisation_parameter'],
pars_fgp_tv['number_of_iterations'],
pars_fgp_tv['tolerance_constant'],
pars_fgp_tv['methodTV'],
pars_fgp_tv['nonneg'],
pars_fgp_tv['printingOut'],'gpu')
except ValueError as ve:
self.skipTest("Results not comparable. GPU computing error.")
rms_fgp = rmse(Im, fgp_gpu)
# now compare obtained rms with the expected value
self.assertLess(abs(rms_fgp-rms_fgp_exp) , tolerance)
if __name__ == '__main__':
unittest.main()