all python code updated

2 files changed, 286 insertions, 290 deletions

diff --git a/test/test_CPU_regularisers.py b/test/test_CPU_regularisers.py
index 851569c..5e3f303 100644
--- a/test/test_CPU_regularisers.py
+++ b/test/test_CPU_regularisers.py
@@ -32,7 +32,7 @@ class TestRegularisers(unittest.TestCase):
     def test_FGP_TV_CPU(self):
         Im,input,ref = self.getPars()
 
-        fgp_cpu = FGP_TV(input,0.04,1200,1e-5,0,0,0,'cpu');
+        fgp_cpu,info = FGP_TV(input,0.02,300,0.0,0,0,'cpu');
 
         rms = rmse(Im, fgp_cpu)
 
@@ -42,7 +42,7 @@ class TestRegularisers(unittest.TestCase):
         # set parameters
         Im, input,ref = self.getPars()
         # call routine
-        fgp_cpu = ROF_TV(input,0.04,1200,2e-5, 'cpu')
+        fgp_cpu,info = ROF_TV(input,0.02,1000,0.001,0.0, 'cpu')
 
         rms = rmse(Im, fgp_cpu)
 
@@ -53,7 +53,7 @@ class TestRegularisers(unittest.TestCase):
         # set parameters
         Im, input,ref = self.getPars()
         # call routine
-        sb_cpu = SB_TV(input,0.04,150,1e-5,0,0,'cpu')
+        sb_cpu,info = SB_TV(input,0.02,150,0.0,0,'cpu')
 
         rms = rmse(Im, sb_cpu)
 
@@ -64,9 +64,9 @@ class TestRegularisers(unittest.TestCase):
         # set parameters
         Im, input,ref = self.getPars()
         # call routine
-        sb_cpu = TGV(input,0.04,1.0,2.0,250,12,'cpu')
+        tgv_cpu,info = TGV(input,0.02,1.0,2.0,500,12,0.0,'cpu')
 
-        rms = rmse(Im, sb_cpu)
+        rms = rmse(Im, tgv_cpu)
 
         # now test that it generates some expected output
         self.assertAlmostEqual(rms,0.02,delta=0.01)
@@ -75,7 +75,7 @@ class TestRegularisers(unittest.TestCase):
         # set parameters
         Im, input,ref = self.getPars()
         # call routine
-        sb_cpu = LLT_ROF(input,0.04,0.01,1000,1e-4,'cpu')
+        sb_cpu,info = LLT_ROF(input,0.01,0.008,1000,0.001,0.0,'cpu')
 
         rms = rmse(Im, sb_cpu)
 
@@ -86,7 +86,7 @@ class TestRegularisers(unittest.TestCase):
         # set parameters
         Im, input,ref = self.getPars()
         # call routine
-        sb_cpu = NDF(input, 0.06, 0.04,1000,0.025,1, 'cpu')
+        sb_cpu,info = NDF(input, 0.02, 0.17,1000,0.01,1,0.0, 'cpu')
 
         rms = rmse(Im, sb_cpu)
 
@@ -97,7 +97,7 @@ class TestRegularisers(unittest.TestCase):
         # set parameters
         Im, input,ref = self.getPars()
         # call routine
-        sb_cpu = Diff4th(input, 3.5,0.02,500,0.001, 'cpu')
+        sb_cpu,info = Diff4th(input, 0.8,0.02,1000,0.001,0.0, 'cpu')
 
         rms = rmse(Im, sb_cpu)
 
@@ -108,7 +108,7 @@ class TestRegularisers(unittest.TestCase):
         # set parameters
         Im, input,ref = self.getPars()
         # call routine
-        sb_cpu = FGP_dTV(input,ref,0.04,1000,1e-7,0.2,0,0,0, 'cpu')
+        sb_cpu,info = FGP_dTV(input,ref,0.02,500,0.0,0.2,0,0, 'cpu')
 
         rms = rmse(Im, sb_cpu)
 
diff --git a/test/test_run_test.py b/test/test_run_test.py
index 5a688c9..1174c5b 100755
--- a/test/test_run_test.py
+++ b/test/test_run_test.py
@@ -27,14 +27,14 @@ def nrmse(im1, im2):
     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")

@@ -42,53 +42,55 @@ class TestRegularisers(unittest.TestCase):
         filename = os.path.join("test","lena_gray_512.tif")

         plt = TiffReader()

         # read image

-        Im = plt.imread(filename)                     

+        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 , 

+                                          scale = perc * Im ,

                                           size = np.shape(Im))

         u_ref = Im + np.random.normal(loc = 0 ,

-                                          scale = 0.01 * Im , 

+                                          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

-        }

+        'regularisation_parameter':0.02,\

+        'number_of_iterations': 1000,\

+        'time_marching_parameter': 0.001,\

+        'tolerance_constant':0.0}

         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')

+        (rof_cpu, infocpu) = ROF_TV(pars['input'],

+             pars['regularisation_parameter'],

+             pars['number_of_iterations'],

+             pars['time_marching_parameter'],

+             pars['tolerance_constant'],'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')

+            (rof_gpu, infogpu) = ROF_TV(pars['input'],

+             pars['regularisation_parameter'],

+             pars['number_of_iterations'],

+             pars['time_marching_parameter'],

+             pars['tolerance_constant'],'gpu')

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

 

@@ -99,78 +101,74 @@ class TestRegularisers(unittest.TestCase):
         txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)

         print (txtstr)

         print ("--------Compare the results--------")

-        tolerance = 1e-04

+        tolerance = 1e-05

         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 = 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 , 

+                                          scale = perc * Im ,

                                           size = np.shape(Im))

         u_ref = Im + np.random.normal(loc = 0 ,

-                                          scale = 0.01 * Im , 

+                                          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 

-                }

-                

+        'input' : u0,\

+        'regularisation_parameter':0.02, \

+        'number_of_iterations' :400 ,\

+        'tolerance_constant':0.0,\

+        'methodTV': 0 ,\

+        'nonneg': 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')  

-                     

-                     

+        (fgp_cpu,infocpu) =  FGP_TV(pars['input'],

+              pars['regularisation_parameter'],

+              pars['number_of_iterations'],

+              pars['tolerance_constant'],

+              pars['methodTV'],

+              pars['nonneg'],'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')

+            (fgp_gpu,infogpu) =  FGP_TV(pars['input'],

+              pars['regularisation_parameter'],

+              pars['number_of_iterations'],

+              pars['tolerance_constant'],

+              pars['methodTV'],

+              pars['nonneg'],'gpu')

 

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

@@ -181,7 +179,7 @@ class TestRegularisers(unittest.TestCase):
         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))

@@ -195,65 +193,60 @@ class TestRegularisers(unittest.TestCase):
         filename = os.path.join("test","lena_gray_512.tif")

         plt = TiffReader()

         # read image

-        Im = plt.imread(filename)                     

+        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 , 

+                                          scale = perc * Im ,

                                           size = np.shape(Im))

         u_ref = Im + np.random.normal(loc = 0 ,

-                                          scale = 0.01 * Im , 

+                                          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 

-                }

-                

+        'input' : u0,\

+        'regularisation_parameter':0.02, \

+        'number_of_iterations' :250 ,\

+        'tolerance_constant':0.0,\

+        'methodTV': 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')  

-                     

-                     

+        (sb_cpu, info_vec_cpu) = SB_TV(pars['input'],

+              pars['regularisation_parameter'],

+              pars['number_of_iterations'],

+              pars['tolerance_constant'],

+              pars['methodTV'], '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')

+            (sb_gpu, info_vec_gpu) = SB_TV(pars['input'],

+              pars['regularisation_parameter'],

+              pars['number_of_iterations'],

+              pars['tolerance_constant'],

+              pars['methodTV'], 'gpu')

 

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

@@ -276,64 +269,65 @@ class TestRegularisers(unittest.TestCase):
         filename = os.path.join("test","lena_gray_512.tif")

         plt = TiffReader()

         # read image

-        Im = plt.imread(filename)                     

+        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 , 

+                                          scale = perc * Im ,

                                           size = np.shape(Im))

         u_ref = Im + np.random.normal(loc = 0 ,

-                                          scale = 0.01 * Im , 

+                                          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 ,\

-                }

-                

+        'input' : u0,\

+        'regularisation_parameter':0.02, \

+        'alpha1':1.0,\

+        'alpha0':2.0,\

+        'number_of_iterations' :1000 ,\

+        'LipshitzConstant' :12 ,\

+        'tolerance_constant':0.0}

+

         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')

-                     

+        (tgv_cpu, info_vec_cpu) = TGV(pars['input'],

+              pars['regularisation_parameter'],

+              pars['alpha1'],

+              pars['alpha0'],

+              pars['number_of_iterations'],

+              pars['LipshitzConstant'],

+              pars['tolerance_constant'],'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')

-

+            (tgv_gpu, info_vec_gpu) = TGV(pars['input'],

+              pars['regularisation_parameter'],

+              pars['alpha1'],

+              pars['alpha0'],

+              pars['number_of_iterations'],

+              pars['LipshitzConstant'],

+              pars['tolerance_constant'],'gpu')

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

 

@@ -355,60 +349,62 @@ class TestRegularisers(unittest.TestCase):
         filename = os.path.join("test","lena_gray_512.tif")

         plt = TiffReader()

         # read image

-        Im = plt.imread(filename)                     

+        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 , 

+                                          scale = perc * Im ,

                                           size = np.shape(Im))

         u_ref = Im + np.random.normal(loc = 0 ,

-                                          scale = 0.01 * Im , 

+                                          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 ,\

-                }

-                

+        'input' : u0,\

+        'regularisation_parameterROF':0.01, \

+        'regularisation_parameterLLT':0.0085, \

+        'number_of_iterations' : 1000 ,\

+        'time_marching_parameter' :0.0001 ,\

+        'tolerance_constant':0.0}

+

         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')

-        

+        (lltrof_cpu, info_vec_cpu) = LLT_ROF(pars['input'],

+              pars['regularisation_parameterROF'],

+              pars['regularisation_parameterLLT'],

+              pars['number_of_iterations'],

+              pars['time_marching_parameter'],

+              pars['tolerance_constant'], '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')

-        

+            (lltrof_gpu, info_vec_gpu) = LLT_ROF(pars['input'],

+              pars['regularisation_parameterROF'],

+              pars['regularisation_parameterLLT'],

+              pars['number_of_iterations'],

+              pars['time_marching_parameter'],

+              pars['tolerance_constant'], 'gpu')

+

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

 

@@ -419,7 +415,7 @@ class TestRegularisers(unittest.TestCase):
         txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)

         print (txtstr)

         print ("--------Compare the results--------")

-        tolerance = 1e-04

+        tolerance = 1e-05

         diff_im = np.zeros(np.shape(lltrof_gpu))

         diff_im = abs(lltrof_cpu - lltrof_gpu)

         diff_im[diff_im > tolerance] = 1

@@ -430,64 +426,66 @@ class TestRegularisers(unittest.TestCase):
         filename = os.path.join("test","lena_gray_512.tif")

         plt = TiffReader()

         # read image

-        Im = plt.imread(filename)                     

+        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 , 

+                                          scale = perc * Im ,

                                           size = np.shape(Im))

         u_ref = Im + np.random.normal(loc = 0 ,

-                                          scale = 0.01 * Im , 

+                                          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

-                }

-                

+        'input' : u0,\

+        'regularisation_parameter':0.02, \

+        'edge_parameter':0.017,\

+        'number_of_iterations' :1500 ,\

+        'time_marching_parameter':0.01,\

+        'penalty_type':1,\

+        'tolerance_constant':0.0}

+

         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')

-                     

+        (ndf_cpu,info_vec_cpu) = NDF(pars['input'],

+              pars['regularisation_parameter'],

+              pars['edge_parameter'],

+              pars['number_of_iterations'],

+              pars['time_marching_parameter'],

+              pars['penalty_type'],

+              pars['tolerance_constant'],'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')

-                     

+            (ndf_gpu,info_vec_gpu) = NDF(pars['input'],

+              pars['regularisation_parameter'],

+              pars['edge_parameter'],

+              pars['number_of_iterations'],

+              pars['time_marching_parameter'],

+              pars['penalty_type'],

+              pars['tolerance_constant'],'gpu')

+

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

         rms = rmse(Im, ndf_gpu)

@@ -503,49 +501,50 @@ class TestRegularisers(unittest.TestCase):
         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 = 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 , 

+                                          scale = perc * Im ,

                                           size = np.shape(Im))

         u_ref = Im + np.random.normal(loc = 0 ,

-                                          scale = 0.01 * Im , 

+                                          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, \

+        'regularisation_parameter':0.8, \

         'edge_parameter':0.02,\

-        'number_of_iterations' :500 ,\

-        'time_marching_parameter':0.001

-        }

-        

+        'number_of_iterations' :1000 ,\

+        'time_marching_parameter':0.0001,\

+        'tolerance_constant':0.0}

+

         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')

-                     

+        (diff4th_cpu,info_vec_cpu) = Diff4th(pars['input'],

+              pars['regularisation_parameter'],

+              pars['edge_parameter'],

+              pars['number_of_iterations'],

+              pars['time_marching_parameter'],

+              pars['tolerance_constant'],'cpu')

+

         rms = rmse(Im, diff4th_cpu)

         pars['rmse'] = rms

 

@@ -555,12 +554,13 @@ class TestRegularisers(unittest.TestCase):
         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')

-                     

+            (diff4th_gpu,info_vec_gpu) = Diff4th(pars['input'],

+              pars['regularisation_parameter'],

+              pars['edge_parameter'],

+              pars['number_of_iterations'],

+              pars['time_marching_parameter'],

+              pars['tolerance_constant'],'gpu')

+

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

         rms = rmse(Im, diff4th_gpu)

@@ -580,72 +580,68 @@ class TestRegularisers(unittest.TestCase):
         filename = os.path.join("test","lena_gray_512.tif")

         plt = TiffReader()

         # read image

-        Im = plt.imread(filename)                     

+        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 , 

+                                          scale = perc * Im ,

                                           size = np.shape(Im))

         u_ref = Im + np.random.normal(loc = 0 ,

-                                          scale = 0.01 * Im , 

+                                          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 

-                }

-                

+        'input' : u0,\

+        'refdata' : u_ref,\

+        'regularisation_parameter':0.02, \

+        'number_of_iterations' :500 ,\

+        'tolerance_constant':0.0,\

+        'eta_const':0.2,\

+        'methodTV': 0 ,\

+        'nonneg': 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')

-                     

-                     

+        (fgp_dtv_cpu,info_vec_cpu) = FGP_dTV(pars['input'],

+              pars['refdata'],

+              pars['regularisation_parameter'],

+              pars['number_of_iterations'],

+              pars['tolerance_constant'],

+              pars['eta_const'],

+              pars['methodTV'],

+              pars['nonneg'],'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')

+            (fgp_dtv_gpu,info_vec_gpu) = FGP_dTV(pars['input'],

+              pars['refdata'],

+              pars['regularisation_parameter'],

+              pars['number_of_iterations'],

+              pars['tolerance_constant'],

+              pars['eta_const'],

+              pars['methodTV'],

+              pars['nonneg'],'gpu')

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

         rms = rmse(Im, fgp_dtv_gpu)

@@ -660,23 +656,23 @@ class TestRegularisers(unittest.TestCase):
         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 = 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')

-        """

+        #Im = plt.imread(filename)

+        #Im = np.asarray(Im, dtype='float32')

+

         tolerance = 1e-05

         rms_rof_exp = 8.313131464999238e-05 #expected value for ROF model

 

@@ -695,27 +691,27 @@ class TestRegularisers(unittest.TestCase):
              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 = 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')

-        """

+        # 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, \

@@ -723,18 +719,18 @@ class TestRegularisers(unittest.TestCase):
                             'tolerance_constant':1e-06,\

                             'methodTV': 0 ,\

                             'nonneg': 0 ,\

-                            'printingOut': 0 

+                            'printingOut': 0

                             }

         print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

         print ("_________testing FGP-TV (2D, CPU)__________")

         print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

-        fgp_cpu = FGP_TV(pars_fgp_tv['input'], 

+        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['tolerance_constant'],

               pars_fgp_tv['methodTV'],

               pars_fgp_tv['nonneg'],

-              pars_fgp_tv['printingOut'],'cpu')  

+              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)

@@ -748,10 +744,10 @@ class TestRegularisers(unittest.TestCase):
         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,\

@@ -773,20 +769,20 @@ class TestRegularisers(unittest.TestCase):
         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 = 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,\

@@ -795,19 +791,19 @@ class TestRegularisers(unittest.TestCase):
                             'tolerance_constant':1e-06,\

                             'methodTV': 0 ,\

                             'nonneg': 0 ,\

-                            'printingOut': 0 

+                            'printingOut': 0

                             }

         print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

         print ("_________testing FGP-TV (2D, GPU)__________")

         print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

         try:

-            fgp_gpu = FGP_TV(pars_fgp_tv['input'], 

+            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['tolerance_constant'],

               pars_fgp_tv['methodTV'],

               pars_fgp_tv['nonneg'],

-              pars_fgp_tv['printingOut'],'gpu')  

+              pars_fgp_tv['printingOut'],'gpu')

         except ValueError as ve:

             self.skipTest("Results not comparable. GPU computing error.")

         rms_fgp = rmse(Im, fgp_gpu)

@@ -815,7 +811,7 @@ class TestRegularisers(unittest.TestCase):
 

         self.assertLess(abs(rms_fgp-rms_fgp_exp) , tolerance)

 

-

+"""

 

 if __name__ == '__main__':

     unittest.main()