summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorEdoardo Pasca <edo.paskino@gmail.com>2017-08-23 14:27:28 +0100
committerEdoardo Pasca <edo.paskino@gmail.com>2017-08-23 14:27:28 +0100
commita9274a7533b6d33a99810b2c1f1ad455768820ae (patch)
tree5270babaebdd4341e67cb1ad29a6087246a7e618 /src
parent5ed47a3fc9839b1803731fe5f422d43689f66763 (diff)
downloadregularization-a9274a7533b6d33a99810b2c1f1ad455768820ae.tar.gz
regularization-a9274a7533b6d33a99810b2c1f1ad455768820ae.tar.bz2
regularization-a9274a7533b6d33a99810b2c1f1ad455768820ae.tar.xz
regularization-a9274a7533b6d33a99810b2c1f1ad455768820ae.zip
updated test for regularizer API
Diffstat (limited to 'src')
-rw-r--r--src/Python/test_regularizers.py590
1 files changed, 290 insertions, 300 deletions
diff --git a/src/Python/test_regularizers.py b/src/Python/test_regularizers.py
index 6a34749..5d25f02 100644
--- a/src/Python/test_regularizers.py
+++ b/src/Python/test_regularizers.py
@@ -8,216 +8,37 @@ Created on Fri Aug 4 11:10:05 2017
from ccpi.viewer.CILViewer2D import Converter
import vtk
-import regularizers
import matplotlib.pyplot as plt
import numpy as np
import os
from enum import Enum
-
-class Regularizer():
- '''Class to handle regularizer algorithms to be used during reconstruction
-
- Currently 5 regularization algorithms are available:
-
- 1) SplitBregman_TV
- 2) FGP_TV
- 3)
- 4)
- 5)
-
- Usage:
- the regularizer can be invoked as object or as static method
- Depending on the actual regularizer the input parameter may vary, and
- a different default setting is defined.
- reg = Regularizer(Regularizer.Algorithm.SplitBregman_TV)
-
- out = reg(input=u0, regularization_parameter=10., number_of_iterations=30,
- tolerance_constant=1e-4,
- TV_Penalty=Regularizer.TotalVariationPenalty.l1)
-
- out2 = Regularizer.SplitBregman_TV(input=u0, regularization_parameter=10.,
- number_of_iterations=30, tolerance_constant=1e-4,
- TV_Penalty=Regularizer.TotalVariationPenalty.l1)
-
- A number of optional parameters can be passed or skipped
- out2 = Regularizer.SplitBregman_TV(input=u0, regularization_parameter=10. )
-
- '''
- class Algorithm(Enum):
- SplitBregman_TV = regularizers.SplitBregman_TV
- FGP_TV = regularizers.FGP_TV
- LLT_model = regularizers.LLT_model
- PatchBased_Regul = regularizers.PatchBased_Regul
- TGV_PD = regularizers.TGV_PD
- # Algorithm
-
- class TotalVariationPenalty(Enum):
- isotropic = 0
- l1 = 1
- # TotalVariationPenalty
-
- def __init__(self , algorithm):
- self.setAlgorithm ( algorithm )
- # __init__
-
- def setAlgorithm(self, algorithm):
- self.algorithm = algorithm
- self.pars = self.parsForAlgorithm(algorithm)
- # setAlgorithm
-
- def parsForAlgorithm(self, algorithm):
- pars = dict()
-
- if algorithm == Regularizer.Algorithm.SplitBregman_TV :
- pars['algorithm'] = algorithm
- pars['input'] = None
- pars['regularization_parameter'] = None
- pars['number_of_iterations'] = 35
- pars['tolerance_constant'] = 0.0001
- pars['TV_penalty'] = Regularizer.TotalVariationPenalty.isotropic
-
- elif algorithm == Regularizer.Algorithm.FGP_TV :
- pars['algorithm'] = algorithm
- pars['input'] = None
- pars['regularization_parameter'] = None
- pars['number_of_iterations'] = 50
- pars['tolerance_constant'] = 0.001
- pars['TV_penalty'] = Regularizer.TotalVariationPenalty.isotropic
-
- elif algorithm == Regularizer.Algorithm.LLT_model:
- pars['algorithm'] = algorithm
- pars['input'] = None
- pars['regularization_parameter'] = None
- pars['time_step'] = None
- pars['number_of_iterations'] = None
- pars['tolerance_constant'] = None
- pars['restrictive_Z_smoothing'] = 0
-
- elif algorithm == Regularizer.Algorithm.PatchBased_Regul:
- pars['algorithm'] = algorithm
- pars['input'] = None
- pars['searching_window_ratio'] = None
- pars['similarity_window_ratio'] = None
- pars['PB_filtering_parameter'] = None
- pars['regularization_parameter'] = None
-
- elif algorithm == Regularizer.Algorithm.TGV_PD:
- pars['algorithm'] = algorithm
- pars['input'] = None
- pars['first_order_term'] = None
- pars['second_order_term'] = None
- pars['number_of_iterations'] = None
- pars['regularization_parameter'] = None
-
-
-
- return pars
- # parsForAlgorithm
-
- def __call__(self, input, regularization_parameter, **kwargs):
-
- if kwargs is not None:
- for key, value in kwargs.items():
- #print("{0} = {1}".format(key, value))
- self.pars[key] = value
- self.pars['input'] = input
- self.pars['regularization_parameter'] = regularization_parameter
- #for key, value in self.pars.items():
- # print("{0} = {1}".format(key, value))
- if None in self.pars:
- raise Exception("Not all parameters have been provided")
-
- if self.algorithm == Regularizer.Algorithm.SplitBregman_TV :
- return self.algorithm(input, regularization_parameter,
- self.pars['number_of_iterations'],
- self.pars['tolerance_constant'],
- self.pars['TV_penalty'].value )
- elif self.algorithm == Regularizer.Algorithm.FGP_TV :
- return self.algorithm(input, regularization_parameter,
- self.pars['number_of_iterations'],
- self.pars['tolerance_constant'],
- self.pars['TV_penalty'].value )
- elif self.algorithm == Regularizer.Algorithm.LLT_model :
- #LLT_model(np::ndarray input, double d_lambda, double d_tau, int iter, double d_epsil, int switcher)
- # no default
- return self.algorithm(input,
- regularization_parameter,
- self.pars['time_step'] ,
- self.pars['number_of_iterations'],
- self.pars['tolerance_constant'],
- self.pars['restrictive_Z_smoothing'] )
- elif self.algorithm == Regularizer.Algorithm.PatchBased_Regul :
- #LLT_model(np::ndarray input, double d_lambda, double d_tau, int iter, double d_epsil, int switcher)
- # no default
- return self.algorithm(input, regularization_parameter,
- self.pars['searching_window_ratio'] ,
- self.pars['similarity_window_ratio'] ,
- self.pars['PB_filtering_parameter'])
- elif self.algorithm == Regularizer.Algorithm.TGV_PD :
- #LLT_model(np::ndarray input, double d_lambda, double d_tau, int iter, double d_epsil, int switcher)
- # no default
- return self.algorithm(input, regularization_parameter,
- self.pars['first_order_term'] ,
- self.pars['second_order_term'] ,
- self.pars['number_of_iterations'])
-
-
-
- # __call__
-
- @staticmethod
- def SplitBregman_TV(input, regularization_parameter , **kwargs):
- reg = Regularizer(Regularizer.Algorithm.SplitBregman_TV)
- out = list( reg(input, regularization_parameter, **kwargs) )
- out.append(reg.pars)
- return out
-
- @staticmethod
- def FGP_TV(input, regularization_parameter , **kwargs):
- reg = Regularizer(Regularizer.Algorithm.FGP_TV)
- out = list( reg(input, regularization_parameter, **kwargs) )
- out.append(reg.pars)
- return out
-
- @staticmethod
- def LLT_model(input, regularization_parameter , time_step, number_of_iterations,
- tolerance_constant, restrictive_Z_smoothing=0):
- reg = Regularizer(Regularizer.Algorithm.LLT_model)
- out = list( reg(input, regularization_parameter, time_step=time_step,
- number_of_iterations=number_of_iterations,
- tolerance_constant=tolerance_constant,
- restrictive_Z_smoothing=restrictive_Z_smoothing) )
- out.append(reg.pars)
- return out
-
- @staticmethod
- def PatchBased_Regul(input, regularization_parameter,
- searching_window_ratio,
- similarity_window_ratio,
- PB_filtering_parameter):
- reg = Regularizer(Regularizer.Algorithm.PatchBased_Regul)
- out = list( reg(input,
- regularization_parameter,
- searching_window_ratio=searching_window_ratio,
- similarity_window_ratio=similarity_window_ratio,
- PB_filtering_parameter=PB_filtering_parameter )
- )
- out.append(reg.pars)
- return out
-
- @staticmethod
- def TGV_PD(input, regularization_parameter , first_order_term,
- second_order_term, number_of_iterations):
-
- reg = Regularizer(Regularizer.Algorithm.TGV_PD)
- out = list( reg(input, regularization_parameter,
- first_order_term=first_order_term,
- second_order_term=second_order_term,
- number_of_iterations=number_of_iterations) )
- out.append(reg.pars)
- return out
-
-
+import timeit
+
+from Regularizer import Regularizer
+
+###############################################################################
+#https://stackoverflow.com/questions/13875989/comparing-image-in-url-to-image-in-filesystem-in-python/13884956#13884956
+#NRMSE a normalization of the root of the mean squared error
+#NRMSE is simply 1 - [RMSE / (maxval - minval)]. Where maxval is the maximum
+# intensity from the two images being compared, and respectively the same for
+# minval. RMSE is given by the square root of MSE:
+# sqrt[(sum(A - B) ** 2) / |A|],
+# where |A| means the number of elements in A. By doing this, the maximum value
+# given by RMSE is maxval.
+
+def nrmse(im1, im2):
+ a, b = im1.shape
+ rmse = np.sqrt(np.sum((im2 - im1) ** 2) / float(a * b))
+ 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))
+###############################################################################
+
+###############################################################################
+#
+# 2D Regularizers
+#
+###############################################################################
#Example:
# figure;
# Im = double(imread('lena_gray_256.tif'))/255; % loading image
@@ -255,49 +76,55 @@ reg_output = []
####################### SplitBregman_TV #####################################
# u = SplitBregman_TV(single(u0), 10, 30, 1e-04);
-reg = Regularizer(Regularizer.Algorithm.SplitBregman_TV)
+use_object = True
+if use_object:
+ reg = Regularizer(Regularizer.Algorithm.SplitBregman_TV)
+ reg.setParameter(input=u0)
+ reg.setParameter(regularization_parameter=10.)
+ # or
+ # reg.setParameter(input=u0, regularization_parameter=10., #number_of_iterations=30,
+ #tolerance_constant=1e-4,
+ #TV_Penalty=Regularizer.TotalVariationPenalty.l1)
+ plotme = reg() [0]
+ pars = reg.pars
+ textstr = reg.printParametersToString()
+
+ #out = reg(input=u0, regularization_parameter=10., #number_of_iterations=30,
+ #tolerance_constant=1e-4,
+ # TV_Penalty=Regularizer.TotalVariationPenalty.l1)
+
+#out2 = Regularizer.SplitBregman_TV(input=u0, regularization_parameter=10., number_of_iterations=30,
+# tolerance_constant=1e-4,
+# TV_Penalty=Regularizer.TotalVariationPenalty.l1)
-out = reg(input=u0, regularization_parameter=10., #number_of_iterations=30,
- #tolerance_constant=1e-4,
- TV_Penalty=Regularizer.TotalVariationPenalty.l1)
-
-out2 = Regularizer.SplitBregman_TV(input=u0, regularization_parameter=10., number_of_iterations=30,
- tolerance_constant=1e-4,
- TV_Penalty=Regularizer.TotalVariationPenalty.l1)
-out2 = Regularizer.SplitBregman_TV(input=u0, regularization_parameter=10. )
-pars = out2[2]
-reg_output.append(out2)
+else:
+ out2 = Regularizer.SplitBregman_TV(input=u0, regularization_parameter=10. )
+ pars = out2[2]
+ reg_output.append(out2)
+ plotme = reg_output[-1][0]
+ textstr = out2[-1]
a=fig.add_subplot(2,3,2)
-a.set_title('SplitBregman_TV')
-textstr = 'regularization_parameter=%.2f\niterations=%d\ntolerance=%.2e\npenalty=%s'
-textstr = textstr % (pars['regularization_parameter'],
- pars['number_of_iterations'],
- pars['tolerance_constant'],
- pars['TV_penalty'].name)
+
# these are matplotlib.patch.Patch properties
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
# place a text box in upper left in axes coords
a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
verticalalignment='top', bbox=props)
-imgplot = plt.imshow(reg_output[-1][0])
+imgplot = plt.imshow(plotme)
###################### FGP_TV #########################################
# u = FGP_TV(single(u0), 0.05, 100, 1e-04);
-out2 = Regularizer.FGP_TV(input=u0, regularization_parameter=0.05,
- number_of_iterations=10)
-pars = out2[-1]
+out2 = Regularizer.FGP_TV(input=u0, regularization_parameter=0.005,
+ number_of_iterations=200)
+pars = out2[-2]
reg_output.append(out2)
a=fig.add_subplot(2,3,3)
-a.set_title('FGP_TV')
-textstr = 'regularization_parameter=%.2f\niterations=%d\ntolerance=%.2e\npenalty=%s'
-textstr = textstr % (pars['regularization_parameter'],
- pars['number_of_iterations'],
- pars['tolerance_constant'],
- pars['TV_penalty'].name)
+
+textstr = out2[-1]
# these are matplotlib.patch.Patch properties
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
@@ -316,50 +143,12 @@ out2 = Regularizer.LLT_model(input=u0, regularization_parameter=25,
time_step=0.0003,
tolerance_constant=0.0001,
number_of_iterations=300)
-pars = out2[-1]
+pars = out2[-2]
reg_output.append(out2)
a=fig.add_subplot(2,3,4)
-a.set_title('LLT_model')
-textstr = 'regularization_parameter=%.2f\niterations=%d\ntolerance=%.2e\ntime-step=%f'
-textstr = textstr % (pars['regularization_parameter'],
- pars['number_of_iterations'],
- pars['tolerance_constant'],
- pars['time_step']
- )
-
-# these are matplotlib.patch.Patch properties
-props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
-# place a text box in upper left in axes coords
-a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
- verticalalignment='top', bbox=props)
-imgplot = plt.imshow(reg_output[-1][0])
-
-###################### PatchBased_Regul #########################################
-# Quick 2D denoising example in Matlab:
-# Im = double(imread('lena_gray_256.tif'))/255; % loading image
-# u0 = Im + .03*randn(size(Im)); u0(u0<0) = 0; % adding noise
-# ImDen = PB_Regul_CPU(single(u0), 3, 1, 0.08, 0.05);
-
-out2 = Regularizer.PatchBased_Regul(input=u0, regularization_parameter=0.05,
- searching_window_ratio=3,
- similarity_window_ratio=1,
- PB_filtering_parameter=0.08)
-pars = out2[-1]
-reg_output.append(out2)
-
-a=fig.add_subplot(2,3,5)
-a.set_title('PatchBased_Regul')
-textstr = 'regularization_parameter=%.2f\nsearching_window_ratio=%d\nsimilarity_window_ratio=%.2e\nPB_filtering_parameter=%f'
-textstr = textstr % (pars['regularization_parameter'],
- pars['searching_window_ratio'],
- pars['similarity_window_ratio'],
- pars['PB_filtering_parameter'])
-
-
-
-
+textstr = out2[-1]
# these are matplotlib.patch.Patch properties
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
# place a text box in upper left in axes coords
@@ -367,6 +156,215 @@ a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
verticalalignment='top', bbox=props)
imgplot = plt.imshow(reg_output[-1][0])
+# ###################### PatchBased_Regul #########################################
+# # Quick 2D denoising example in Matlab:
+# # Im = double(imread('lena_gray_256.tif'))/255; % loading image
+# # u0 = Im + .03*randn(size(Im)); u0(u0<0) = 0; % adding noise
+# # ImDen = PB_Regul_CPU(single(u0), 3, 1, 0.08, 0.05);
+
+# out2 = Regularizer.PatchBased_Regul(input=u0, regularization_parameter=0.05,
+ # searching_window_ratio=3,
+ # similarity_window_ratio=1,
+ # PB_filtering_parameter=0.08)
+# pars = out2[-2]
+# reg_output.append(out2)
+
+# a=fig.add_subplot(2,3,5)
+
+
+# textstr = out2[-1]
+
+# # these are matplotlib.patch.Patch properties
+# props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
+# # place a text box in upper left in axes coords
+# a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
+ # verticalalignment='top', bbox=props)
+# imgplot = plt.imshow(reg_output[-1][0])
+
+
+# ###################### TGV_PD #########################################
+# # Quick 2D denoising example in Matlab:
+# # Im = double(imread('lena_gray_256.tif'))/255; % loading image
+# # u0 = Im + .03*randn(size(Im)); u0(u0<0) = 0; % adding noise
+# # u = PrimalDual_TGV(single(u0), 0.02, 1.3, 1, 550);
+
+
+# out2 = Regularizer.TGV_PD(input=u0, regularization_parameter=0.05,
+ # first_order_term=1.3,
+ # second_order_term=1,
+ # number_of_iterations=550)
+# pars = out2[-2]
+# reg_output.append(out2)
+
+# a=fig.add_subplot(2,3,6)
+
+
+# textstr = out2[-1]
+
+
+# # these are matplotlib.patch.Patch properties
+# props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
+# # place a text box in upper left in axes coords
+# a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
+ # verticalalignment='top', bbox=props)
+# imgplot = plt.imshow(reg_output[-1][0])
+
+
+plt.show()
+
+################################################################################
+##
+## 3D Regularizers
+##
+################################################################################
+##Example:
+## figure;
+## Im = double(imread('lena_gray_256.tif'))/255; % loading image
+## u0 = Im + .05*randn(size(Im)); u0(u0 < 0) = 0;
+## u = SplitBregman_TV(single(u0), 10, 30, 1e-04);
+#
+##filename = r"C:\Users\ofn77899\Documents\GitHub\CCPi-Reconstruction\python\test\reconstruction_example.mha"
+#filename = r"C:\Users\ofn77899\Documents\GitHub\CCPi-Simpleflex\data\head.mha"
+#
+#reader = vtk.vtkMetaImageReader()
+#reader.SetFileName(os.path.normpath(filename))
+#reader.Update()
+##vtk returns 3D images, let's take just the one slice there is as 2D
+#Im = Converter.vtk2numpy(reader.GetOutput())
+#Im = Im.astype('float32')
+##imgplot = plt.imshow(Im)
+#perc = 0.05
+#u0 = Im + (perc* np.random.normal(size=np.shape(Im)))
+## map the u0 u0->u0>0
+#f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1)
+#u0 = f(u0).astype('float32')
+#converter = Converter.numpy2vtkImporter(u0, reader.GetOutput().GetSpacing(),
+# reader.GetOutput().GetOrigin())
+#converter.Update()
+#writer = vtk.vtkMetaImageWriter()
+#writer.SetInputData(converter.GetOutput())
+#writer.SetFileName(r"C:\Users\ofn77899\Documents\GitHub\CCPi-FISTA_reconstruction\data\noisy_head.mha")
+##writer.Write()
+#
+#
+### plot
+#fig3D = plt.figure()
+##a=fig.add_subplot(3,3,1)
+##a.set_title('Original')
+##imgplot = plt.imshow(Im)
+#sliceNo = 32
+#
+#a=fig3D.add_subplot(2,3,1)
+#a.set_title('noise')
+#imgplot = plt.imshow(u0.T[sliceNo])
+#
+#reg_output3d = []
+#
+###############################################################################
+## Call regularizer
+#
+######################## SplitBregman_TV #####################################
+## u = SplitBregman_TV(single(u0), 10, 30, 1e-04);
+#
+##reg = Regularizer(Regularizer.Algorithm.SplitBregman_TV)
+#
+##out = reg(input=u0, regularization_parameter=10., #number_of_iterations=30,
+## #tolerance_constant=1e-4,
+## TV_Penalty=Regularizer.TotalVariationPenalty.l1)
+#
+#out2 = Regularizer.SplitBregman_TV(input=u0, regularization_parameter=10., number_of_iterations=30,
+# tolerance_constant=1e-4,
+# TV_Penalty=Regularizer.TotalVariationPenalty.l1)
+#
+#
+#pars = out2[-2]
+#reg_output3d.append(out2)
+#
+#a=fig3D.add_subplot(2,3,2)
+#
+#
+#textstr = out2[-1]
+#
+#
+## these are matplotlib.patch.Patch properties
+#props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
+## place a text box in upper left in axes coords
+#a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
+# verticalalignment='top', bbox=props)
+#imgplot = plt.imshow(reg_output3d[-1][0].T[sliceNo])
+#
+####################### FGP_TV #########################################
+## u = FGP_TV(single(u0), 0.05, 100, 1e-04);
+#out2 = Regularizer.FGP_TV(input=u0, regularization_parameter=0.005,
+# number_of_iterations=200)
+#pars = out2[-2]
+#reg_output3d.append(out2)
+#
+#a=fig3D.add_subplot(2,3,2)
+#
+#
+#textstr = out2[-1]
+#
+#
+## these are matplotlib.patch.Patch properties
+#props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
+## place a text box in upper left in axes coords
+#a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
+# verticalalignment='top', bbox=props)
+#imgplot = plt.imshow(reg_output3d[-1][0].T[sliceNo])
+#
+####################### LLT_model #########################################
+## * u0 = Im + .03*randn(size(Im)); % adding noise
+## [Den] = LLT_model(single(u0), 10, 0.1, 1);
+##Den = LLT_model(single(u0), 25, 0.0003, 300, 0.0001, 0);
+##input, regularization_parameter , time_step, number_of_iterations,
+## tolerance_constant, restrictive_Z_smoothing=0
+#out2 = Regularizer.LLT_model(input=u0, regularization_parameter=25,
+# time_step=0.0003,
+# tolerance_constant=0.0001,
+# number_of_iterations=300)
+#pars = out2[-2]
+#reg_output3d.append(out2)
+#
+#a=fig3D.add_subplot(2,3,2)
+#
+#
+#textstr = out2[-1]
+#
+#
+## these are matplotlib.patch.Patch properties
+#props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
+## place a text box in upper left in axes coords
+#a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
+# verticalalignment='top', bbox=props)
+#imgplot = plt.imshow(reg_output3d[-1][0].T[sliceNo])
+#
+####################### PatchBased_Regul #########################################
+## Quick 2D denoising example in Matlab:
+## Im = double(imread('lena_gray_256.tif'))/255; % loading image
+## u0 = Im + .03*randn(size(Im)); u0(u0<0) = 0; % adding noise
+## ImDen = PB_Regul_CPU(single(u0), 3, 1, 0.08, 0.05);
+#
+#out2 = Regularizer.PatchBased_Regul(input=u0, regularization_parameter=0.05,
+# searching_window_ratio=3,
+# similarity_window_ratio=1,
+# PB_filtering_parameter=0.08)
+#pars = out2[-2]
+#reg_output3d.append(out2)
+#
+#a=fig3D.add_subplot(2,3,2)
+#
+#
+#textstr = out2[-1]
+#
+#
+## these are matplotlib.patch.Patch properties
+#props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
+## place a text box in upper left in axes coords
+#a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
+# verticalalignment='top', bbox=props)
+#imgplot = plt.imshow(reg_output3d[-1][0].T[sliceNo])
+#
###################### TGV_PD #########################################
# Quick 2D denoising example in Matlab:
@@ -375,30 +373,22 @@ imgplot = plt.imshow(reg_output[-1][0])
# u = PrimalDual_TGV(single(u0), 0.02, 1.3, 1, 550);
-out2 = Regularizer.TGV_PD(input=u0, regularization_parameter=0.05,
- first_order_term=1.3,
- second_order_term=1,
- number_of_iterations=550)
-pars = out2[-1]
-reg_output.append(out2)
-
-a=fig.add_subplot(2,3,6)
-a.set_title('TGV_PD')
-textstr = 'regularization_parameter=%.2f\nfirst_order_term=%.2f\nsecond_order_term=%.2f\nnumber_of_iterations=%d'
-textstr = textstr % (pars['regularization_parameter'],
- pars['first_order_term'],
- pars['second_order_term'],
- pars['number_of_iterations'])
-
-
-
-
-# these are matplotlib.patch.Patch properties
-props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
-# place a text box in upper left in axes coords
-a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
- verticalalignment='top', bbox=props)
-imgplot = plt.imshow(reg_output[-1][0])
-
-
-
+#out2 = Regularizer.TGV_PD(input=u0, regularization_parameter=0.05,
+# first_order_term=1.3,
+# second_order_term=1,
+# number_of_iterations=550)
+#pars = out2[-2]
+#reg_output3d.append(out2)
+#
+#a=fig3D.add_subplot(2,3,2)
+#
+#
+#textstr = out2[-1]
+#
+#
+## these are matplotlib.patch.Patch properties
+#props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
+## place a text box in upper left in axes coords
+#a.text(0.05, 0.95, textstr, transform=a.transAxes, fontsize=14,
+# verticalalignment='top', bbox=props)
+#imgplot = plt.imshow(reg_output3d[-1][0].T[sliceNo])