Beispiel #1
0
    def external_update(self, u, f, uf, f0,
                        u0):  # overload the update function

        CsSolver.checkmax(self.st['sensemap'])
        tmpuf = u * self.st['sensemap']

        tmpuf = numpy.transpose(tmpuf, (1, 2, 3, 0))
        tmp_shape = tmpuf.shape
        tmpuf = numpy.reshape(tmpuf,
                              tmp_shape[0:2] + (numpy.prod(tmp_shape[2:4]), ),
                              order='F')
        tmpuf = self.CsTransform.forwardbackward(tmpuf)
        tmpuf = numpy.reshape(tmpuf, tmp_shape, order='F')
        tmpuf = numpy.transpose(tmpuf, (3, 0, 1, 2))
        tmpuf = tmpuf * self.st['sensemap'].conj()

        #        tmpuf=self.st['sensemap'].conj()*(
        #                self.CsTransform.forwardbackward(
        #                        u*self.st['sensemap']))

        if self.st['senseflag'] == 1:
            tmpuf = CsSolver.CombineMulti(tmpuf, -1)

        print('start of ext_update')

        #        checkmax(u)
        #        checkmax(tmpuf)
        #        checkmax(self.u0)
        #        checkmax(uf)

        fact = numpy.sum((self.u0 - tmpuf)**2) / numpy.sum((u0)**2)
        fact = numpy.abs(fact.real)
        fact = numpy.sqrt(fact)
        print('fact', fact)
        #        fact=1.0/(1.0+numpy.exp(-(fact-0.5)*self.thresh_scale))
        tmpuf = CsSolver.Normalize(tmpuf) * numpy.max(numpy.abs(u0[:]))
        uf = uf + (u0 - tmpuf) * 1.0  #*fact
        uf = CsSolver.Normalize(uf) * numpy.max(numpy.abs(u0[:]))

        CsSolver.checkmax(tmpuf)
        CsSolver.checkmax(u0)
        CsSolver.checkmax(uf)

        #        for jj in range(0,u.shape[-1]):
        #            u[...,jj] = u[...,jj]*self.st['sn']# rescale the final image intensity

        print('end of ext_update')
        murf = uf
        return (f, uf, murf, u)
Beispiel #2
0
    def kernel(self, f_internal, st, mu, LMBD, gamma, nInner, nBreg):
        self.st['sensemap'] = self.st['sensemap'] * self.st['mask']
        tse = self.f.tse
        #        tse=numpy.abs(numpy.mean(self.st['sensemap'],-1))

        tse = CsSolver.appendmat(tse, self.st['Nd'][1])
        #tse=Normalize(tse)
        tse = numpy.transpose(tse, (0, 1, 3, 2))
        self.ttse = CsSolver.Normalize(tse)

        self.tse0 = CsSolver.CombineMulti(tse, -1)

        self.filter = numpy.ones(tse.shape)
        dpss = numpy.kaiser(tse.shape[1], 1.0) * 10.0
        for ppp in range(0, tse.shape[1]):
            self.filter[:, ppp, :, :] = self.filter[:, ppp, :, :] * dpss[ppp]

        print('tse.shape', tse.shape)
        #        L= numpy.size(f)/st['M']
        #        image_dim=st['Nd']+(L,)
        #
        #        if numpy.ndim(f) == 1:# preventing row vector
        #            f=numpy.reshape(f,(numpy.shape(f)[0],1),order='F')
        #        f0 = numpy.copy(f) # deep copy to prevent scope f0 to f
        ##        u = numpy.zeros(image_dim,dtype=numpy.complex64)
        f0 = numpy.copy(f_internal)
        f = numpy.copy(f_internal)

        #        u0=self.data2rho(f_internal,
        #                         self.f.dim_x,
        #                         self.st['Nd'][0],
        #                         self.st['Nd'][1],
        #                         self.f.ncoils,
        #                         self.CsTransform
        #                         ) # doing spatial transform
        u0 = self.fun1(f_internal)

        pdf = self.f.pdf
        pdf = CsSolver.appendmat(pdf, self.st['Nd'][1])
        pdf = numpy.transpose(pdf, (0, 1, 3, 2))

        #        u0 = scipy.fftpack.fftn(u0,axes=(1,))
        #        u0 = scipy.fftpack.fftshift(u0,axes=(1,))
        #        #u0[:,:,u0.shape[2]/2,:] = u0[:,:,u0.shape[2]/2,:]/pdf[:,:,u0.shape[2]/2,:]
        #        u0 = u0#/pdf
        #        u0 = scipy.fftpack.ifftshift(u0,axes=(1,))
        #        u0 = scipy.fftpack.ifftn(u0,axes=(1,))

        #        print('self.f.pdf.shape',self.f.pdf.shape)
        #        for pj in range(0,4):
        #            matplotlib.pyplot.imshow(self.f.pdf[:,:,pj].real)
        #            matplotlib.pyplot.show()

        u0 = self.fun2(u0)

        u0 = self.fun3(u0)

        u0 = u0 * self.st['sensemap'].conj()

        u0 = CsSolver.CombineMulti(u0, -1)

        #u0 = u0*self.filter

        uker = self.create_laplacian_kernel()
        uker = CsSolver.appendmat(uker, u0.shape[3])

        self.u0 = u0

        u = numpy.copy(self.tse0)

        print('u0.shape', u0.shape)

        (xx, bb, dd) = self.make_split_variables(u)

        uf = numpy.copy(u)  # only used for ISRA, written here for generality

        murf = numpy.copy(u)  # initial values
        #    #===============================================================================
        #u_stack = numpy.empty(st['Nd']+(nBreg,),dtype=numpy.complex)
        for outer in numpy.arange(0, nBreg):
            for inner in numpy.arange(0, nInner):
                # update u
                print('iterating', [inner, outer])
                #===============================================================
                #                 update u  # simple k-space deconvolution to guess initial u
                u = self.update_u(murf, u, uker, xx, bb)

                c = numpy.max(numpy.abs(u[:]))  # Rough coefficient
                # to correct threshold of nonlinear shrink

                #===================================================================
                # # update d
                #===================================================================
                #===================================================================
                # Shrinkage: remove tiny values "in somewhere sparse!"
                # dx+bx should be sparse!
                #===================================================================
                # shrinkage
                #===================================================================
                dd = self.update_d(u, dd)

                xx = self.shrink(
                    dd, bb, c * 1.0 / LMBD / numpy.sqrt(numpy.prod(st['Nd'])))

                #===============================================================
                #===================================================================
                # # update b
                #===================================================================

                bb = self.update_b(bb, dd, xx)

#            if outer < nBreg: # do not update in the last loop
            (f, uf, murf,
             u) = self.external_update(u, f, uf, f0,
                                       u0)  # update outer Split_bregman

        u = CsSolver.Normalize(u)
        for pp in range(0, u0.shape[2]):
            matplotlib.pyplot.subplot(
                numpy.sqrt(u0.shape[2]) + 1,
                numpy.sqrt(u0.shape[2]) + 1, pp)
            matplotlib.pyplot.imshow(numpy.sum(numpy.abs(u[..., pp, :]), -1),
                                     norm=norm,
                                     interpolation='nearest')
        matplotlib.pyplot.show()
        #

        return (u, uf)