initial work and example

2 files changed, 400 insertions, 382 deletions

diff --git a/Wrappers/Python/ccpi/framework.py b/Wrappers/Python/ccpi/framework.py
index ba24bef..035c729 100644
--- a/Wrappers/Python/ccpi/framework.py
+++ b/Wrappers/Python/ccpi/framework.py
@@ -118,6 +118,7 @@ class DataSet():
         else:
             raise TypeError('Array must be NumpyArray, passed {0}'\
                             .format(type(array)))
+        
 
     def as_array(self, dimensions=None):
         '''Returns the DataSet as Numpy Array
@@ -286,76 +287,108 @@ class SinogramData(DataSet):
             # assume it is parallel beam
             pass
             
-        
-class InstrumentGeometry(CCPiBaseClass):
-    def __init__(self, **kwargs):
-        CCPiBaseClass.__init__(self, **kwargs)
-        
-    def convertToAstra():
-        pass
-        
-        
-        
-class DataSetProcessor1(CCPiBaseClass):
-    '''Abstract class for a DataSetProcessor
+class DataSetProcessor():
+    '''Defines a generic DataSet processor
     
-    inputs: dictionary of inputs
-    outputs: dictionary of outputs
+    accepts DataSet as inputs and 
+    outputs DataSet
+    additional attributes can be defined with __setattr__
     '''
     
-    def __init__(self, **inputs):
-        if 'hold_input' in inputs.keys():
-            hold_input = inputs.pop('hold_input')
+    def __init__(self, **attributes):
+        if not 'store_output' in attributes.keys():
+            attributes['store_output'] = True
+            attributes['output'] = False
+            attributes['runTime'] = -1
+            attributes['mTime'] = datetime.now()
+            attributes['input'] = None
+        for key, value in attributes.items():
+            self.__dict__[key] = value
+        
+    
+    def __setattr__(self, name, value):
+        if name == 'input':
+            self.setInput(value)
+        elif name in self.__dict__.keys():
+            self.__dict__[name] = value
+            self.__dict__['mTime'] = datetime.now()
         else:
-            hold_input = True
-        if 'hold_output' in inputs.keys():
-            hold_output = inputs.pop('hold_output')
+            raise KeyError('Attribute {0} not found'.format(name))
+        #pass
+    
+    def setInput(self, dataset):
+        if issubclass(type(dataset), DataSet):
+            if self.checkInput(dataset):
+                self.__dict__['input'] = dataset
         else:
-            hold_output = True
-                
-        self.number_of_inputs = len (inputs)
-        #pars = ['hold_output', 'hold_input'] 
-        wargs = {}
-        wargs['hold_output'] = hold_output
-        wargs['hold_input'] = hold_input
-        wargs['output'] = None
-        
-        # add the hold_output and hold_input to the wargs
-        for key, value in wargs.items():
-            if not key in inputs.keys():
-                inputs[key] = value
-                
-        self.runTime = None
-        self.mTime = datetime.now()
+            raise TypeError("Input type mismatch: got {0} expecting {1}"\
+                            .format(type(dataset), DataSet))
+    
+    def checkInput(self, dataset):
+        '''Checks parameters of the input DataSet
+        
+        Should raise an Error if the DataSet does not match expectation, e.g.
+        if the expected input DataSet is 3D and the Processor expects 2D.
+        '''
+        raise NotImplementedError('Implement basic checks for input DataSet')
         
-        CCPiBaseClass.__init__(self, **inputs)
-                
     def getOutput(self):
+        if None in self.__dict__.values():
+            raise ValueError('Not all parameters have been passed')
         shouldRun = False
-        if self.runTime is None:
+        if self.runTime == -1:
             shouldRun = True
         elif self.mTime > self.runTime:
             shouldRun = True
             
-        if self.getParameter('hold_output'):
-            if shouldRun:
-                output = self.__execute__()
-                self.setParameter(output=output)
-            return self.getParameter( 'output' )
-        else:
-            return self.__execute__()
-        
-    def __execute__(self):
-        print ("__execute__")
+        if self.store_output and shouldRun:
+            self.runTime = datetime.now()
+            self.output = self.process()
+            return self.output
         self.runTime = datetime.now()
-        return self.apply()
+        return self.process()
     
-    def apply(self):
-        raise NotImplementedError('The apply method is not implemented!')
+    def setInputProcessor(self, processor):
+        if issubclass(type(processor), DataSetProcessor):
+            self.__dict__['input'] = processor
+        else:
+            raise TypeError("Input type mismatch: got {0} expecting {1}"\
+                            .format(type(processor), DataSetProcessor))
+        
+    def getInput(self):
+        '''returns the input DataSet
+        
+        It is useful in the case the user has provided a DataSetProcessor as
+        input
+        '''
+        if issubclass(type(self.input), DataSetProcessor):
+            dsi = self.input.getOutput()
+        else:
+            dsi = self.input
+        return dsi
         
+    def process(self):
+        raise NotImplementedError('process must be implemented')
+
+class DataSetProcessor23D(DataSetProcessor):
+    '''Regularizers DataSetProcessor
+    '''
+            
+    def checkInput(self, dataset):
+        '''Checks number of dimensions input DataSet
         
+        Expected input is 2D or 3D
+        '''
+        if dataset.number_of_dimensions == 2 or \
+           dataset.number_of_dimensions == 3:
+               return True
+        else:
+            raise ValueError("Expected input dimensions is 2 or 3, got {0}"\
+                             .format(dataset.number_of_dimensions))
     
-class AX(DataSetProcessor1):
+###### Example of DataSetProcessors
+
+class AX(DataSetProcessor):
     '''Example DataSetProcessor
     The AXPY routines perform a vector multiplication operation defined as
 
@@ -367,28 +400,31 @@ class AX(DataSetProcessor1):
     x a DataSet.
     '''
     
-    def __init__(self, scalar, input_dataset, **wargs):
-        kwargs = {'scalar':scalar, 
-                  'input_dataset':input_dataset, 
-                  'output': None
+    def __init__(self):
+        kwargs = {'scalar':None, 
+                  'input':None, 
                   }
-        for key, value in wargs.items():
-            kwargs[key] = value
-        DataSetProcessor1.__init__(self, **kwargs)
         
+        DataSetProcessor.__init__(self, **kwargs)
         
+    
+    def checkInput(self, dataset):
+        return True
+        
+    def process(self):
         
-    def apply(self):
-        a, x = self.getParameter(['scalar' , 'input_dataset' ])
-        y = DataSet( a * x.as_array() , True, 
-                    dimension_labels=x.dimension_labels )
+        dsi = self.getInput()
+        a = self.scalar
+        
+        y = DataSet( a * dsi.as_array() , True, 
+                    dimension_labels=dsi.dimension_labels )
         #self.setParameter(output_dataset=y)
         return y
     
         
     
     
-class PixelByPixelDataSetProcessor(DataSetProcessor1):
+class PixelByPixelDataSetProcessor(DataSetProcessor):
     '''Example DataSetProcessor
     
     This processor applies a python function to each pixel of the DataSet
@@ -398,78 +434,29 @@ class PixelByPixelDataSetProcessor(DataSetProcessor1):
     x a DataSet.
     '''
     
-    def __init__(self, pyfunc, input_dataset):
-        kwargs = {'pyfunc':pyfunc, 
-                  'input_dataset':input_dataset, 
-                  'output_dataset': None}
-        DataSetProcessor1.__init__(self, **kwargs)
+    def __init__(self):
+        kwargs = {'pyfunc':None, 
+                  'input':None, 
+                  }
+        DataSetProcessor.__init__(self, **kwargs)
         
         
+    def checkInput(self, dataset):
+        return True
+    
+    def process(self):
         
-    def apply(self):
-        pyfunc, x = self.getParameter(['pyfunc' , 'input_dataset' ])
+        pyfunc = self.pyfunc
+        dsi = self.getInput()
         
         eval_func = numpy.frompyfunc(pyfunc,1,1)
 
         
-        y = DataSet( eval_func( x.as_array() ) , True, 
-                    dimension_labels=x.dimension_labels )
+        y = DataSet( eval_func( dsi.as_array() ) , True, 
+                    dimension_labels=dsi.dimension_labels )
         return y
     
-class DataSetProcessor():
-    '''Defines a generic DataSet processor
-    
-    accepts DataSet as inputs and 
-    outputs DataSet
-    additional attributes can be defined with __setattr__
-    '''
-    
-    def __init__(self):
-        pass
-    
-    def __setattr__(self, name, value):
-        if name == 'input':
-            self.setInput(value)
-        elif name in self.__dict__.keys():
-            self.__dict__[name] = value
-        else:
-            raise KeyError('Attribute {0} not found'.format(name))
-        #pass
-    
-    def setInput(self, dataset):
-        print('Setting input as {0}...'.format(dataset))
-        if issubclass(type(dataset), DataSet):
-            if self.checkInput(dataset):
-                self.__dict__['input'] = dataset
-        else:
-            raise TypeError("Input type mismatch: got {0} expecting {1}"\
-                            .format(type(dataset), DataSet))
-    
-    def checkInput(self, dataset):
-        '''Checks parameters of the input DataSet
-        
-        Should raise an Error if the DataSet does not match expectation, e.g.
-        if the expected input DataSet is 3D and the Processor expects 2D.
-        '''
-        raise NotImplementedError('Implement basic checks for input DataSet')
-        
-    def getOutput(self):
-        if None in self.__dict__.values():
-            raise ValueError('Not all parameters have been passed')
-        return self.process()
-    
-    def setInputProcessor(self, processor):
-        print('Setting input as {0}...'.format(processor))
-        if issubclass(type(processor), DataSetProcessor):
-            self.__dict__['input'] = processor
-        else:
-            raise TypeError("Input type mismatch: got {0} expecting {1}"\
-                            .format(type(processor), DataSetProcessor))
-        
-    
-    def process(self):
-        raise NotImplementedError('process must be implemented')
-        
+
         
         
 if __name__ == '__main__':
@@ -510,11 +497,15 @@ if __name__ == '__main__':
     # single number DataSet
     sn = DataSet(numpy.asarray([1]))
     
-    ax = AX(scalar = 2 , input_dataset=c)
+    ax = AX()
+    ax.scalar = 2
+    ax.setInput(c)
     #ax.apply()
     print ("ax  in {0} out {1}".format(c.as_array().flatten(),
            ax.getOutput().as_array().flatten()))
-    axm = AX(hold_output=False, scalar = 0.5 , input_dataset=ax.getOutput())
+    axm = AX()
+    axm.scalar = 0.5
+    axm.setInput(c)
     #axm.apply()
     print ("axm in {0} out {1}".format(c.as_array(), axm.getOutput().as_array()))
     
@@ -522,17 +513,21 @@ if __name__ == '__main__':
     
     #define a python function which will take only one input (the pixel value)
     pyfunc = lambda x: -x if x > 20 else x
-    clip = PixelByPixelDataSetProcessor(pyfunc,c)    
+    clip = PixelByPixelDataSetProcessor()
+    clip.pyfunc = pyfunc 
+    clip.setInput(c)    
     #clip.apply()
     
     print ("clip in {0} out {1}".format(c.as_array(), clip.getOutput().as_array()))
     
-    dsp = DataSetProcessor()
-    dsp.setInput(ds)
-    dsp.input = a
+    #dsp = DataSetProcessor()
+    #dsp.setInput(ds)
+    #dsp.input = a
     # pipeline
-#    Pipeline
-#    Pipeline.setProcessor(0, ax)
-#    Pipeline.setProcessor(1, axm)
-#    Pipeline.execute()     
+
+    chain = AX()
+    chain.scalar = 0.5
+    chain.setInputProcessor(ax)
+    print ("chain in {0} out {1}".format(ax.getOutput().as_array(), chain.getOutput().as_array()))
+    
         
\ No newline at end of file
diff --git a/Wrappers/Python/test/regularizers.py b/Wrappers/Python/test/regularizers.py
index 4ac8d28..25873c7 100644
--- a/Wrappers/Python/test/regularizers.py
+++ b/Wrappers/Python/test/regularizers.py
@@ -1,198 +1,246 @@
 # -*- coding: utf-8 -*-
-"""
-Created on Tue Jan 30 16:19:03 2018
+#   This work is part of the Core Imaging Library developed by
+#   Visual Analytics and Imaging System Group of the Science Technology
+#   Facilities Council, STFC
 
-@author: ofn77899
-"""
+#   Copyright 2018 Edoardo Pasca
+
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
 
 import matplotlib.pyplot as plt
 import numpy as np
 import os    
-from enum import Enum
-import timeit
+from ccpi.framework import DataSetProcessor, DataSetProcessor23D , DataSet
 from ccpi.filters.cpu_regularizers_boost import SplitBregman_TV , FGP_TV ,\
-                                                 LLT_model, PatchBased_Regul ,\
-                                                 TGV_PD
-from ccpi.framework import DataSetProcessor, DataSetProcessor1, DataSet
+                                                LLT_model, PatchBased_Regul ,\
+                                                TGV_PD
+#from ccpi.filters.cpu_regularizers_cython import some
 
-class SplitBregmanTVRegularizer(DataSetProcessor1):
-    '''Regularizers DataSetProcessor
-    '''
-    
-    
-    
-    def __init__(self, input , regularization_parameter , number_of_iterations  = 35 ,\
-                 tolerance_constant = 0.0001 , TV_penalty= 0, **wargs):
-        kwargs = {'regularization_parameter':regularization_parameter, 
-                  'number_of_iterations':number_of_iterations, 
-                  'tolerance_constant':tolerance_constant, 
-                  'TV_penalty':TV_penalty, 
-                  'input' : input,
-                  'output': None
-                  }
-        for key, value in wargs.items():
-            kwargs[key] = value
-        DataSetProcessor1.__init__(self, **kwargs)
-        
-        
-        
-    def apply(self):
-        pars = self.getParameterMap(['input' , 'regularization_parameter' ,
-                                  'number_of_iterations', 'tolerance_constant' ,
-                                  'TV_penalty' ])
-    
-        out = SplitBregman_TV (pars['input'].as_array(), pars['regularization_parameter'],
-                              pars['number_of_iterations'],
-                              pars['tolerance_constant'],
-                              pars['TV_penalty'])  
-        print (type(out))
-        y = DataSet( out[0] , False )
-        #self.setParameter(output_dataset=y)
-        return y
-    
-class FGPTVRegularizer(DataSetProcessor1):
-    '''Regularizers DataSetProcessor
-    '''
-    
-    
-    
-    def __init__(self, input , regularization_parameter , number_of_iterations  = 35 ,\
-                 tolerance_constant = 0.0001 , TV_penalty= 0, **wargs):
-        kwargs = {'regularization_parameter':regularization_parameter, 
-                  'number_of_iterations':number_of_iterations, 
-                  'tolerance_constant':tolerance_constant, 
-                  'TV_penalty':TV_penalty, 
-                  'input' : input,
-                  'output': None
-                  }
-        for key, value in wargs.items():
-            kwargs[key] = value
-        DataSetProcessor1.__init__(self, **kwargs)
+try:
+    from ccpi.filter import gpu_regularizers as gpu
+    class PatchBasedRegGPU(DataSetProcessor23D):
+        '''Regularizers DataSetProcessor for PatchBasedReg
         
         
+        '''
         
-    def apply(self):
+        def __init__(self):
+            attributes = {'regularization_parameter':None, 
+                          'searching_window_ratio': None, 
+                          'similarity_window_ratio': None, 
+                          'PB_filtering_parameter': None
+                      }
+            DataSetProcessor.__init__(self, **attributes)
+                
+            
+        def process(self):
+            '''Executes the processor
+                
+            '''
+            dsi = self.getInput()
+            out = gpu.NML (dsi.as_array(), 
+                             self.searching_window_ratio,
+                             self.similarity_window_ratio,
+                             self.regularization_parameter,
+                             self.PB_filtering_parameter)  
+            y = DataSet( out , False )
+            return y
+    class Diff4thHajiaboli(DataSetProcessor23D):
+        '''Regularizers DataSetProcessor for PatchBasedReg
         
-        pars = self.getParameterMap(['input' , 'regularization_parameter' ,
-                                  'number_of_iterations', 'tolerance_constant' ,
-                                  'TV_penalty' ])
         
-        if issubclass(type(pars['input']) , DataSetProcessor):
-            pars['input'] = pars['input'].getOutput()
+        '''
         
-        out = FGP_TV (pars['input'].as_array(), 
-              pars['regularization_parameter'],
-              pars['number_of_iterations'],
-              pars['tolerance_constant'], 
-              pars['TV_penalty'])  
-        y = DataSet( out[0] , False )
-        #self.setParameter(output_dataset=y)
-        return y
+        def __init__(self):
+            attributes = {'regularization_parameter':None, 
+                          'searching_window_ratio': None, 
+                          'similarity_window_ratio': None, 
+                          'PB_filtering_parameter': None
+                      }
+            DataSetProcessor.__init__(self, **attributes)
+                
+            
+        def process(self):
+            '''Executes the processor
+                
+            '''
+            dsi = self.getInput()
+            out = gpu.Diff4thHajiaboli (dsi.as_array(), 
+                                        self.regularization_parameter, 
+                                        self.number_of_iterations,
+                                        self.edge_preserving_parameter)  
+            y = DataSet( out , False )
+            return y
+
+except ImportError as ie:
+    print (ie)
     
-    def chain(self, other):
-        if issubclass(type(other) , DataSetProcessor):
-            self.setParameter(input = other.getOutput()[0])
-       
-class SBTV(DataSetProcessor):
+
+
+class SBTV(DataSetProcessor23D):
     '''Regularizers DataSetProcessor
     '''
     
-    
-    
     def __init__(self):
         attributes = {'regularization_parameter':None, 
                   'number_of_iterations': 35, 
                   'tolerance_constant': 0.0001, 
-                  'TV_penalty':0, 
-                  'input' : None
+                  'TV_penalty':0
                   }
-        for key, value in attributes.items():
-            self.__dict__[key] = value
+        DataSetProcessor.__init__(self, **attributes)
+            
             
-    def checkInput(self, dataset):
-        '''Checks number of dimensions input DataSet
-        
-        Expected input is 2D or 3D
-        '''
-        if dataset.number_of_dimensions == 2 or \
-           dataset.number_of_dimensions == 3:
-               return True
-        else:
-            raise ValueError("Expected input dimensions is 2 or 3, got {0}"\
-                             .format(dataset.number_of_dimensions))
-        
     def process(self):
         '''Executes the processor
         
-        Basic checks are run in here
         '''
     
-        if issubclass(type(self.input), DataSetProcessor):
-            dsi = self.input.getOutput()[0]
-        else:
-            dsi = self.input
-        if None in self.__dict__.values():
-            raise ValueError('Not all parameters have been passed')
+        dsi = self.getInput()
         out = SplitBregman_TV (dsi.as_array(), 
                                self.regularization_parameter,
                                self.number_of_iterations,
                                self.tolerance_constant,
                                self.TV_penalty)  
-        print (type(out))
         y = DataSet( out[0] , False )
-        #self.setParameter(output_dataset=y)
         return y
     
-class FGPTV(DataSetProcessor):
+class FGPTV(DataSetProcessor23D):
     '''Regularizers DataSetProcessor
     '''
     
-    
-    
     def __init__(self):
         attributes = {'regularization_parameter':None, 
                   'number_of_iterations': 35, 
                   'tolerance_constant': 0.0001, 
-                  'TV_penalty':0, 
-                  'input' : None
+                  'TV_penalty':0
                   }
-        for key, value in attributes.items():
-            self.__dict__[key] = value
+        DataSetProcessor.__init__(self, **attributes)
             
-    def checkInput(self, dataset):
-        '''Checks number of dimensions input DataSet
         
-        Expected input is 2D or 3D
+    def process(self):
+        '''Executes the processor
+            
         '''
-        if dataset.number_of_dimensions == 2 or \
-           dataset.number_of_dimensions == 3:
-               return True
-        else:
-            raise ValueError("Expected input dimensions is 2 or 3, got {0}"\
-                             .format(dataset.number_of_dimensions))
+        dsi = self.getInput()
+        out = FGP_TV (dsi.as_array(), 
+                      self.regularization_parameter,
+                      self.number_of_iterations,
+                      self.tolerance_constant,
+                      self.TV_penalty)  
+        y = DataSet( out[0] , False )
+        return y
+    
+class LLT(DataSetProcessor23D):
+    '''Regularizers DataSetProcessor for LLT_model
+    
+    
+    '''
+    
+    def __init__(self):
+        attributes = {'regularization_parameter':None, 
+                      'time_step': 0.0001, 
+                      'number_of_iterations': 35, 
+                      'tolerance_constant': 0, 
+                      'restrictive_Z_smoothing': None 
+                  }
+        DataSetProcessor.__init__(self, **attributes)
+            
         
     def process(self):
         '''Executes the processor
-        
-        Basic checks are run in here
+            
         '''
+        dsi = self.getInput()
+        out = LLT_model (dsi.as_array(), 
+                         self.regularization_parameter,
+                         self.time_step,
+                         self.number_of_iterations,
+                         self.tolerance_constant,
+                         self.restrictive_Z_smoothing)  
+        y = DataSet( out[0] , False )
+        return y
     
-        if issubclass(type(self.input), DataSetProcessor):
-            dsi = self.input.getOutput()
-        else:
-            dsi = self.input
-        if None in self.__dict__.values():
-            raise ValueError('Not all parameters have been passed')
-        out = FGP_TV (dsi.as_array(), 
-                               self.regularization_parameter,
-                               self.number_of_iterations,
-                               self.tolerance_constant,
-                               self.TV_penalty)  
-        print (type(out))
+class PatchBasedReg(DataSetProcessor23D):
+    '''Regularizers DataSetProcessor for PatchBasedReg
+    
+    
+    '''
+    
+    def __init__(self):
+        attributes = {'regularization_parameter':None, 
+                      'searching_window_ratio': None, 
+                      'similarity_window_ratio': None, 
+                      'PB_filtering_parameter': None
+                  }
+        DataSetProcessor.__init__(self, **attributes)
+            
+        
+    def process(self):
+        '''Executes the processor
+            
+        '''
+        dsi = self.getInput()
+        out = PatchBased_Regul (dsi.as_array(), 
+                         self.regularization_parameter,
+                         self.searching_window_ratio,
+                         self.similarity_window_ratio,
+                         self.PB_filtering_parameter)  
         y = DataSet( out[0] , False )
-        #self.setParameter(output_dataset=y)
         return y
     
+class TGVPD(DataSetProcessor23D):
+    '''Regularizers DataSetProcessor for PatchBasedReg
+    
+    
+    '''
+    
+    def __init__(self):
+        attributes = {'regularization_parameter':None, 
+                      'first_order_term': None, 
+                      'second_order_term': None, 
+                      'number_of_iterations': None
+                  }
+        DataSetProcessor.__init__(self, **attributes)
+            
+        
+    def process(self):
+        '''Executes the processor
+            
+        '''
+        dsi = self.getInput()
+        if dsi.number_of_dimensions == 2:
+            out = TGV_PD(dsi.as_array(), 
+                         self.regularization_parameter,
+                         self.first_order_term, 
+                         self.second_order_term , 
+                         self.number_of_iterations)
+            y = DataSet( out[0] , False )
+        elif len(np.shape(input)) == 3:
+            #assuming it's 3D
+            # run independent calls on each slice
+            out3d = dsi.as_array().copy()
+            for i in range(np.shape(dsi.as_array())[0]):
+                out = TGV_PD(dsi.as_array()[i], 
+                                     self.regularization_parameter,
+                                     self.first_order_term, 
+                                     self.second_order_term , 
+                                     self.number_of_iterations)
+                # copy the result in the 3D image
+                out3d[i] = out[0].copy()
+            y = DataSet (out3d , False)
+        return y
+    
+## self contained test
 if __name__ == '__main__':
     filename = os.path.join(".." , ".." , ".." , ".." , 
                             "CCPi-FISTA_Reconstruction", "data" ,
@@ -222,80 +270,7 @@ if __name__ == '__main__':
     ##############################################################################
     # Call regularizer
     
-    ####################### SplitBregman_TV #####################################
-    # u = SplitBregman_TV(single(u0), 10, 30, 1e-04);
-    
-    start_time = timeit.default_timer()
-    pars = {'algorithm' : SplitBregman_TV , \
-            'input' : lena,
-            'regularization_parameter':40 , \
-    'number_of_iterations' :350 ,\
-    'tolerance_constant':0.01 , \
-    'TV_penalty': 0
-    }
-    
-    
-    reg = SplitBregmanTVRegularizer(pars['input'],
-                                             pars['regularization_parameter'],
-                              pars['number_of_iterations'],
-                              pars['tolerance_constant'],
-                              pars['TV_penalty'], 
-                              hold_input=False, hold_output=True)
-    splitbregman = reg.getOutput()
-    
-    #txtstr = printParametersToString(pars) 
-    #txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
-    #print (txtstr)
-        
-    
-    a=fig.add_subplot(2,3,2)
-    
-    
-    # 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, 'SplitBregman', transform=a.transAxes, fontsize=14,
-            verticalalignment='top', bbox=props)
-    imgplot = plt.imshow(splitbregman.as_array(),\
-                         #cmap="gray"
-                         )
-    pars = {'algorithm' : FGP_TV , \
-        'input' : lena,
-        'regularization_parameter':5e-5, \
-        'number_of_iterations' :10 ,\
-        'tolerance_constant':0.001,\
-        'TV_penalty': 0
-}
-    reg2 = FGPTVRegularizer(pars['input'],
-                              pars['regularization_parameter'],
-                              pars['number_of_iterations'],
-                              pars['tolerance_constant'],
-                              pars['TV_penalty'], 
-                              hold_input=False, hold_output=True)
-    fgp = reg2.getOutput()
-    
-    #txtstr = printParametersToString(pars) 
-    #txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
-    #print (txtstr)
-        
-    
-    a=fig.add_subplot(2,3,3)
-    
-    
-    # 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, 'FGPTV', transform=a.transAxes, fontsize=14,
-            verticalalignment='top', bbox=props)
-    imgplot = plt.imshow(fgp.as_array(),\
-                         #cmap="gray"
-                         )
-    
-    
-#    'regularization_parameter':40 , \
-#    'number_of_iterations' :350 ,\
-#    'tolerance_constant':0.01 , \
-#    'TV_penalty': 0
+  
     reg3 = SBTV()
     reg3.number_of_iterations = 350
     reg3.tolerance_constant = 0.01
@@ -304,14 +279,9 @@ if __name__ == '__main__':
     reg3.setInput(lena)
     dataprocessoroutput = reg3.getOutput()
     
-    #txtstr = printParametersToString(pars) 
-    #txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
-    #print (txtstr)
-        
-    
-    a=fig.add_subplot(2,3,4)
-    
     
+    # plot
+    a=fig.add_subplot(2,3,2)
     # 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
@@ -320,6 +290,8 @@ if __name__ == '__main__':
     imgplot = plt.imshow(dataprocessoroutput.as_array(),\
                          #cmap="gray"
                          )
+    ##########################################################################
+    
     reg4 = FGPTV()
     reg4.number_of_iterations = 350
     reg4.tolerance_constant = 0.01
@@ -327,15 +299,9 @@ if __name__ == '__main__':
     reg4.TV_penalty = 0
     reg4.setInput(lena)
     dataprocessoroutput2 = reg4.getOutput()
-    
-    #txtstr = printParametersToString(pars) 
-    #txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
-    #print (txtstr)
-        
-    
-    a=fig.add_subplot(2,3,5)
-    
-    
+   
+    # plot
+    a=fig.add_subplot(2,3,3)    
     # 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
@@ -345,25 +311,82 @@ if __name__ == '__main__':
                          #cmap="gray"
                          )
     
-    
-    #reg4.input = None
-    reg4.setInputProcessor(reg3)
-    chain = reg4.process()
-    
-    #txtstr = printParametersToString(pars) 
-    #txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time)
-    #print (txtstr)
-        
-    
-    a=fig.add_subplot(2,3,6)
-    
-    
+    ###########################################################################
+    reg6 = LLT()
+    reg6.regularization_parameter = 25
+    reg6.time_step = 0.0003
+    reg6.number_of_iterations = 300
+    reg6.tolerance_constant = 0.001
+    reg6.restrictive_Z_smoothing = 0
+    reg6.setInput(lena)
+    llt = reg6.getOutput()
+    # plot
+    a=fig.add_subplot(2,3,4)    
+    # 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, 'LLT', transform=a.transAxes, fontsize=14,
+            verticalalignment='top', bbox=props)
+    imgplot = plt.imshow(llt.as_array(),\
+                         #cmap="gray"
+                         )
+    ###########################################################################
+    
+    reg7 = PatchBasedReg()
+    reg7.regularization_parameter = 0.05
+    reg7.searching_window_ratio = 3
+    reg7.similarity_window_ratio = 1
+    reg7.PB_filtering_parameter = 0.08
+    reg7.setInput(lena)
+    pbr = reg7.getOutput()
+    # plot
+    a=fig.add_subplot(2,3,5)    
     # 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, 'SBTV + FGPTV', transform=a.transAxes, fontsize=14,
+    a.text(0.05, 0.95, 'PatchBasedReg', transform=a.transAxes, fontsize=14,
             verticalalignment='top', bbox=props)
-    imgplot = plt.imshow(chain.as_array(),\
+    imgplot = plt.imshow(pbr.as_array(),\
                          #cmap="gray"
                          )
+    ###########################################################################
+    
+    reg5 = TGVPD()
+    reg5.regularization_parameter = 0.05
+    reg5.first_order_term = 1.3
+    reg5.second_order_term = 1
+    reg5.number_of_iterations = 550
+    reg5.setInput(lena)
+    tgvpd = reg5.getOutput()
+    # plot
+    a=fig.add_subplot(2,3,6)    
+    # 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, 'TGVPD', transform=a.transAxes, fontsize=14,
+            verticalalignment='top', bbox=props)
+    imgplot = plt.imshow(tgvpd.as_array(),\
+                         #cmap="gray"
+                         )
+    if False:
+        #reg4.input = None
+        reg5 = FGPTV()
+        reg5.number_of_iterations = 350
+        reg5.tolerance_constant = 0.01
+        reg5.regularization_parameter = 40
+        reg5.TV_penalty = 0
+        reg5.setInputProcessor(reg3)
+        chain = reg5.process()
+       
+        a=fig.add_subplot(2,3,6)
+        
+        
+        # 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, 'SBTV + FGPTV', transform=a.transAxes, fontsize=14,
+                verticalalignment='top', bbox=props)
+        imgplot = plt.imshow(chain.as_array(),\
+                             #cmap="gray"
+                             )
     plt.show()
\ No newline at end of file