From ed8d44335348c239f2b9794f02a61ba52a76849a Mon Sep 17 00:00:00 2001
From: Edoardo Pasca <edo.paskino@gmail.com>
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