Merge pull request #104 from vais-ral/newdirstructure

New directory structure, Merged other changes. The build script checks old and new structure.

5 files changed, 911 insertions, 0 deletions

diff --git a/recipe/bld.bat b/recipe/bld.bat
new file mode 100644
index 0000000..6c84355
--- /dev/null
+++ b/recipe/bld.bat
@@ -0,0 +1,20 @@
+IF NOT DEFINED CIL_VERSION (
+ECHO CIL_VERSION Not Defined.
+exit 1
+)
+
+mkdir "%SRC_DIR%\ccpi"
+ROBOCOPY /E "%RECIPE_DIR%\..\.." "%SRC_DIR%\ccpi"
+ROBOCOPY /E "%RECIPE_DIR%\..\..\..\Core" "%SRC_DIR%\Core"
+::cd %SRC_DIR%\ccpi\Python
+cd %SRC_DIR%
+
+:: issue cmake to create setup.py
+cmake -G "NMake Makefiles" %RECIPE_DIR%\..\..\..\ -DBUILD_PYTHON_WRAPPERS=ON -DCONDA_BUILD=ON -DBUILD_CUDA=OFF -DCMAKE_BUILD_TYPE="Release" -DLIBRARY_LIB="%CONDA_PREFIX%\lib" -DLIBRARY_INC="%CONDA_PREFIX%" -DCMAKE_INSTALL_PREFIX="%PREFIX%\Library" 
+
+::%PYTHON% setup-regularisers.py build_ext
+::if errorlevel 1 exit 1
+::%PYTHON% setup-regularisers.py install
+::if errorlevel 1 exit 1
+nmake install
+if errorlevel 1 exit 1
\ No newline at end of file
diff --git a/recipe/build.sh b/recipe/build.sh
new file mode 100644
index 0000000..a156193
--- /dev/null
+++ b/recipe/build.sh
@@ -0,0 +1,18 @@
+
+#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"
+
+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/conda_build_config.yaml b/recipe/conda_build_config.yaml
new file mode 100644
index 0000000..fbe82dc
--- /dev/null
+++ b/recipe/conda_build_config.yaml
@@ -0,0 +1,9 @@
+python:
+  - 2.7 # [not win]
+  - 3.5
+  - 3.6
+#  - 3.7
+numpy:
+  - 1.12
+  - 1.14
+  - 1.15
diff --git a/recipe/meta.yaml b/recipe/meta.yaml
new file mode 100644
index 0000000..6f36906
--- /dev/null
+++ b/recipe/meta.yaml
@@ -0,0 +1,43 @@
+package:
+  name: ccpi-regulariser
+  version: {{CIL_VERSION}}
+  
+build:
+  preserve_egg_dir: False
+  number: 0
+  script_env:
+    - CIL_VERSION
+  
+test:
+  files:
+    - ../test/lena_gray_512.tif
+  requires:
+    - pillow
+    - pillow=4.1.1 # [win]
+#  command:
+#    - unittest -d discover .... ../test
+
+requirements:
+  build:
+    - python
+    - numpy {{ numpy }}
+    - setuptools
+    - cython
+    - vc 14 # [win and py36] 
+    - vc 14 # [win and py35] 
+    - vc 9  # [win and py27]
+    - cmake 
+
+  run:
+    - {{ pin_compatible('numpy', max_pin='x.x') }}
+    - python
+    - numpy
+    - vc 14 # [win and py36] 
+    - vc 14 # [win and py35] 
+    - vc 9  # [win and py27]
+    - libgcc-ng
+
+about:
+  home: http://www.ccpi.ac.uk
+  license:  BSD license
+  summary: 'CCPi Core Imaging Library Quantification Toolbox'
diff --git a/recipe/run_test.py b/recipe/run_test.py
new file mode 100755
index 0000000..f551616
--- /dev/null
+++ b/recipe/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("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()