From ed8d44335348c239f2b9794f02a61ba52a76849a Mon Sep 17 00:00:00 2001 From: Edoardo Pasca Date: Tue, 5 Mar 2019 14:44:44 +0000 Subject: fixed linux test --- recipe/build.sh | 14 +- recipe/meta.yaml | 10 +- recipe/run_test.py | 821 ------------------------------------------ test/test_CPU_regularisers.py | 2 +- test/test_run_test.py | 821 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 829 insertions(+), 839 deletions(-) delete mode 100755 recipe/run_test.py create mode 100755 test/test_run_test.py diff --git a/recipe/build.sh b/recipe/build.sh index a156193..ad78cca 100644 --- a/recipe/build.sh +++ b/recipe/build.sh @@ -1,18 +1,8 @@ - -#mkdir "$SRC_DIR/ccpi" -#cp -rv "$RECIPE_DIR/../src/Matlab" "$SRC_DIR/ccpi" -#cp -rv "$RECIPE_DIR/../src/Python" "$SRC_DIR/ccpi" -#cp -rv "$RECIPE_DIR/../src/Core" "$SRC_DIR/Core" +set -xe +cp -rv "$RECIPE_DIR/../test/" "$SRC_DIR/" cd $SRC_DIR -##cuda=off cmake -G "Unix Makefiles" $RECIPE_DIR/../ -DBUILD_PYTHON_WRAPPER=ON -DCONDA_BUILD=ON -DBUILD_CUDA=ON -DCMAKE_BUILD_TYPE="Release" -DLIBRARY_LIB=$CONDA_PREFIX/lib -DLIBRARY_INC=$CONDA_PREFIX -DCMAKE_INSTALL_PREFIX=$PREFIX - make install - -#$PYTHON setup-regularisers.py build_ext -#$PYTHON setup-regularisers.py install - - diff --git a/recipe/meta.yaml b/recipe/meta.yaml index 6f36906..6ff4e31 100644 --- a/recipe/meta.yaml +++ b/recipe/meta.yaml @@ -9,14 +9,14 @@ build: - CIL_VERSION test: - files: - - ../test/lena_gray_512.tif + source_files: + - ./test/ requires: - pillow - pillow=4.1.1 # [win] -# command: -# - unittest -d discover .... ../test - + commands: + - python -c "import os; print (os.getcwd())" + - python -m unittest discover -s test requirements: build: - python diff --git a/recipe/run_test.py b/recipe/run_test.py deleted file mode 100755 index f551616..0000000 --- a/recipe/run_test.py +++ /dev/null @@ -1,821 +0,0 @@ -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() diff --git a/test/test_CPU_regularisers.py b/test/test_CPU_regularisers.py index 379b989..851569c 100644 --- a/test/test_CPU_regularisers.py +++ b/test/test_CPU_regularisers.py @@ -11,7 +11,7 @@ from testroutines import * class TestRegularisers(unittest.TestCase): def getPars(self): - filename = os.path.join("lena_gray_512.tif") + filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image Im = plt.imread(filename) diff --git a/test/test_run_test.py b/test/test_run_test.py new file mode 100755 index 0000000..5a688c9 --- /dev/null +++ b/test/test_run_test.py @@ -0,0 +1,821 @@ +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("test","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("test","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("test","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("test","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("test","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("test","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("test","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("test","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("test","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("test","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("test","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("test","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() -- cgit v1.2.3