def positive_proximal(self, x, tau, out=None):

    pars = {'algorithm' : TGV, \
                    'input' : np.asarray(x.as_array(), dtype=np.float32),\
                    'regularisation_parameter':self.regularisation_parameter, \
                    'alpha1':self.alpha1,\
                    'alpha0':self.alpha2,\
                    'number_of_iterations' :self.iter_TGV ,\
                    'LipshitzConstant' :self.LipshitzConstant ,\
                    'tolerance_constant':self.torelance}

    res, info = regularisers.TGV(pars['input'],
                                 pars['regularisation_parameter'],
                                 pars['alpha1'], pars['alpha0'],
                                 pars['number_of_iterations'],
                                 pars['LipshitzConstant'],
                                 pars['tolerance_constant'], self.device)

    self.info = info

    res[res < 0] = 0

    if out is not None:
        out.fill(res)
    else:
        out = x.copy()
        out.fill(res)
        return out
Exemple #2
0
    def proximal(self, x, tau, out=None):

        pars = {'algorithm' : TGV, \
                'input' : np.asarray(x.as_array(), dtype=np.float32),\
                'regularisation_parameter':self.regularisation_parameter, \
                'alpha1':self.alpha1,\
                'alpha0':self.alpha2,\
                'number_of_iterations' :self.iter_TGV ,\
                'LipshitzConstant' :self.LipshitzConstant ,\
                'tolerance_constant':self.torelance}

        res, info = regularisers.TGV(pars['input'],
                                     pars['regularisation_parameter'],
                                     pars['alpha1'], pars['alpha0'],
                                     pars['number_of_iterations'],
                                     pars['LipshitzConstant'],
                                     pars['tolerance_constant'], self.device)

        # info: return number of iteration and reached tolerance
        # https://github.com/vais-ral/CCPi-Regularisation-Toolkit/blob/master/src/Core/regularisers_CPU/TGV_core.c#L168
        # Stopping Criteria  || u^k - u^(k-1) ||_{2} / || u^{k} ||_{2}

        self.info = info

        if out is not None:
            out.fill(res)
        else:
            out = x.copy()
            out.fill(res)
            return out
Exemple #3
0
 def proximal_numpy(self, in_arr, tau, out = None):
     res , info = regularisers.TGV(in_arr,
           self.regularisation_parameter,
           self.alpha1,
           self.alpha2,
           self.iter_TGV,
           self.LipshitzConstant,
           self.torelance,
           self.device)
             
     # info: return number of iteration and reached tolerance
     # https://github.com/vais-ral/CCPi-Regularisation-Toolkit/blob/master/src/Core/regularisers_CPU/TGV_core.c#L168
     # Stopping Criteria  || u^k - u^(k-1) ||_{2} / || u^{k} ||_{2}    
     return res, info
    def test_functionality_TGV(self):

        data = dataexample.CAMERA.get(size=(256,256))
        datarr = data.as_array()
        from cil.plugins.ccpi_regularisation.functions import TGV
        from ccpi.filters import regularisers

        tau = 1.
        fcil = TGV()
        outcil = fcil.proximal(data, tau=tau)
        # use CIL defaults
        outrgl, info = regularisers.TGV(datarr, fcil.alpha*tau, 1,1, fcil.max_iteration, 12, fcil.tolerance, 'cpu' )

        np.testing.assert_almost_equal(outrgl, outcil.as_array())
    def proximal(self, x, tau, out=None):
        in_arr = np.asarray(x.as_array(), dtype=np.float32, order='C')
        res, info = regularisers.TGV(in_arr, self.regularisation_parameter,
                                     self.alpha1, self.alpha2, self.iter_TGV,
                                     self.LipshitzConstant, self.torelance,
                                     self.device)

        # info: return number of iteration and reached tolerance
        # https://github.com/vais-ral/CCPi-Regularisation-Toolkit/blob/master/src/Core/regularisers_CPU/TGV_core.c#L168
        # Stopping Criteria  || u^k - u^(k-1) ||_{2} / || u^{k} ||_{2}

        self.info = info

        if out is not None:
            out.fill(res)
        else:
            out = x.copy()
            out.fill(res)
            return out