From 61bfe1f57fbda958e24e227e567676fafd7f6d3e Mon Sep 17 00:00:00 2001 From: Tomas Kulhanek Date: Thu, 21 Feb 2019 02:11:13 -0500 Subject: restructured sources --- test/lena_gray_512.tif | Bin 0 -> 262598 bytes test/test_ROF_TV.py | 127 +++++++++++++++++++++++++++++++++++++++++++++++++ test/testroutines.py | 37 ++++++++++++++ 3 files changed, 164 insertions(+) create mode 100644 test/lena_gray_512.tif create mode 100644 test/test_ROF_TV.py create mode 100644 test/testroutines.py (limited to 'test') diff --git a/test/lena_gray_512.tif b/test/lena_gray_512.tif new file mode 100644 index 0000000..f80cafc Binary files /dev/null and b/test/lena_gray_512.tif differ diff --git a/test/test_ROF_TV.py b/test/test_ROF_TV.py new file mode 100644 index 0000000..dda38b7 --- /dev/null +++ b/test/test_ROF_TV.py @@ -0,0 +1,127 @@ +import unittest +import math +import os +import timeit +from ccpi.filters.regularisers import ROF_TV +#, FGP_TV, SB_TV, TGV, LLT_ROF, FGP_dTV, NDF, Diff4th +from testroutines import * + +class TestRegularisers(unittest.TestCase): + + def test_ROF_TV_CPU(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') + + + # 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) + + self.assertTrue(math.isclose(rms,0.02067839,rel_tol=1e-2)) + + + def test_ROF_TV_CPU_vs_GPU(self): + # print ("tomas debug test function") + print(__name__) + self.fail("testfail2") + 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 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("#############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("--------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) + +if __name__ == '__main__': + unittest.main() diff --git a/test/testroutines.py b/test/testroutines.py new file mode 100644 index 0000000..8da5c5e --- /dev/null +++ b/test/testroutines.py @@ -0,0 +1,37 @@ +import numpy as np +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 + + +############################################################################### -- cgit v1.2.3 From 4505a79103e98adb33bfb4c10391319e56ae7031 Mon Sep 17 00:00:00 2001 From: Tomas Kulhanek Date: Fri, 22 Feb 2019 06:44:53 -0500 Subject: UPDATE: docs -> demos and update paths in m and py demos --- test/test_CPU_regularisers.py | 91 +++++++++++++++++++++++++ test/test_FGP_TV.py | 152 ++++++++++++++++++++++++++++++++++++++++++ test/test_ROF_TV.py | 3 - 3 files changed, 243 insertions(+), 3 deletions(-) create mode 100644 test/test_CPU_regularisers.py create mode 100644 test/test_FGP_TV.py (limited to 'test') diff --git a/test/test_CPU_regularisers.py b/test/test_CPU_regularisers.py new file mode 100644 index 0000000..42e4735 --- /dev/null +++ b/test/test_CPU_regularisers.py @@ -0,0 +1,91 @@ +import unittest +import math +import os +import timeit +from ccpi.filters.regularisers import FGP_TV, SB_TV, TGV, LLT_ROF, FGP_dTV, NDF, Diff4th, ROF_TV +from testroutines import * + +############################################################################### + +class TestRegularisers(unittest.TestCase): + + def getPars(self,alg,noi=1200): + 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') + # set parameters + pars = {'algorithm': alg, \ + 'input': u0, \ + 'regularisation_parameter': 0.04, \ + 'number_of_iterations': noi, \ + 'tolerance_constant': 0.00001, \ + 'methodTV': 0, \ + 'nonneg': 0, \ + 'printingOut': 0, \ + 'time_marching_parameter': 0.00002 + } + return Im, pars + + + def test_FGP_TV_CPU(self): + Im, pars = self.getPars(FGP_TV) + + 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 + self.assertAlmostEqual(rms,0.02,delta=0.01) + + def test_TV_ROF_CPU(self): + # set parameters + Im, pars = self.getPars(ROF_TV) + # call routine + fgp_cpu = ROF_TV(pars['input'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['time_marching_parameter'], 'cpu') + + rms = rmse(Im, fgp_cpu) + pars['rmse'] = rms + + #txtstr = printParametersToString(pars) + #print(txtstr) + # now test that it generates some expected output + self.assertAlmostEqual(rms,0.02,delta=0.01) + + def test_SB_TV_CPU(self): + # set parameters + Im, pars = self.getPars(SB_TV) + # call routine + fgp_cpu = SB_TV(pars['input'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['time_marching_parameter'], 'cpu') + + rms = rmse(Im, fgp_cpu) + pars['rmse'] = rms + + #txtstr = printParametersToString(pars) + #print(txtstr) + # now test that it generates some expected output + self.assertAlmostEqual(rms,0.02,delta=0.01) diff --git a/test/test_FGP_TV.py b/test/test_FGP_TV.py new file mode 100644 index 0000000..f0dc540 --- /dev/null +++ b/test/test_FGP_TV.py @@ -0,0 +1,152 @@ +import unittest +import math +import os +import timeit +from ccpi.filters.regularisers import FGP_TV +#, FGP_TV, SB_TV, TGV, LLT_ROF, FGP_dTV, NDF, Diff4th +from testroutines import * + +############################################################################### + +class TestRegularisers(unittest.TestCase): + + def test_FGP_TV_CPU(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) + self.assertTrue(math.isclose(rms,0.02,rel_tol=1e-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) + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_ROF_TV.py b/test/test_ROF_TV.py index dda38b7..fa35680 100644 --- a/test/test_ROF_TV.py +++ b/test/test_ROF_TV.py @@ -53,9 +53,6 @@ class TestRegularisers(unittest.TestCase): def test_ROF_TV_CPU_vs_GPU(self): - # print ("tomas debug test function") - print(__name__) - self.fail("testfail2") filename = os.path.join("lena_gray_512.tif") plt = TiffReader() # read image -- cgit v1.2.3 From 5a2fd376130ea2c7c4ac1704bc9d2f087522855d Mon Sep 17 00:00:00 2001 From: Tomas Kulhanek Date: Fri, 22 Feb 2019 08:10:48 -0500 Subject: UPDATE:test and pycharm project files --- test/test_CPU_regularisers.py | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'test') diff --git a/test/test_CPU_regularisers.py b/test/test_CPU_regularisers.py index 8940926..552e64e 100644 --- a/test/test_CPU_regularisers.py +++ b/test/test_CPU_regularisers.py @@ -126,3 +126,8 @@ class TestRegularisers(unittest.TestCase): # now test that it generates some expected output self.assertAlmostEqual(rms, 0.02, delta=0.01) + + + +if __name__ == '__main__': + unittest.main() -- cgit v1.2.3 From 047d9e2a7dda92e13414b980a93c3f1724665241 Mon Sep 17 00:00:00 2001 From: Tomas Kulhanek Date: Mon, 25 Feb 2019 03:35:50 -0500 Subject: MOVE: Wrappers/Python/supp to src/Python/ccpi/supp --- test/test_CPU_regularisers.py | 2 -- 1 file changed, 2 deletions(-) (limited to 'test') diff --git a/test/test_CPU_regularisers.py b/test/test_CPU_regularisers.py index 552e64e..3a90d49 100644 --- a/test/test_CPU_regularisers.py +++ b/test/test_CPU_regularisers.py @@ -127,7 +127,5 @@ class TestRegularisers(unittest.TestCase): # now test that it generates some expected output self.assertAlmostEqual(rms, 0.02, delta=0.01) - - if __name__ == '__main__': unittest.main() -- cgit v1.2.3 From fc941e0941facb9437dab667ba3350db071769da Mon Sep 17 00:00:00 2001 From: Tomas Kulhanek Date: Mon, 25 Feb 2019 03:58:51 -0500 Subject: UPDATE: unit test --- test/test_CPU_regularisers.py | 13 ------------- 1 file changed, 13 deletions(-) (limited to 'test') diff --git a/test/test_CPU_regularisers.py b/test/test_CPU_regularisers.py index 3a90d49..6af4cd4 100644 --- a/test/test_CPU_regularisers.py +++ b/test/test_CPU_regularisers.py @@ -23,21 +23,8 @@ class TestRegularisers(unittest.TestCase): 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') - # set parameters - #pars = {'algorithm': alg, \ - # 'input': u0, \ - # 'regularisation_parameter': 0.04, \ - # 'number_of_iterations': noi, \ - # 'tolerance_constant': 0.00001, \ - # 'methodTV': 0, \ - # 'nonneg': 0, \ - # 'printingOut': 0, \ - # 'time_marching_parameter': 0.00002 - # } return Im,u0,u_ref -- cgit v1.2.3 From 68e6f3397e8a450854f39a5d514e1f747b9031a4 Mon Sep 17 00:00:00 2001 From: Tomas Kulhanek Date: Thu, 28 Feb 2019 15:22:10 +0000 Subject: merge --- test/test_CPU_regularisers.py | 1 + 1 file changed, 1 insertion(+) (limited to 'test') diff --git a/test/test_CPU_regularisers.py b/test/test_CPU_regularisers.py index 6af4cd4..379b989 100644 --- a/test/test_CPU_regularisers.py +++ b/test/test_CPU_regularisers.py @@ -2,6 +2,7 @@ import unittest import math import os import timeit +import numpy as np from ccpi.filters.regularisers import FGP_TV, SB_TV, TGV, LLT_ROF, FGP_dTV, NDF, Diff4th, ROF_TV from testroutines import * -- cgit v1.2.3