def create_mask(self, u0):
st = self.st
rows = u0.shape[0]
cols = u0.shape[1]
kk = numpy.arange(0, rows)
jj = numpy.arange(0, cols)
kk = CsSolver.appendmat(kk, cols)
jj = CsSolver.appendmat(jj, rows).T
st["mask"] = numpy.ones((rows, cols), dtype=numpy.float32)
# add circular mask
sp_rat = (rows ** 2 + cols ** 2) * 1.0
# for jj in numpy.arange(0,cols):
# for kk in numpy.arange(0,rows):
# if ( (kk-rows/2.0)**2+(jj-cols/2.0)**2 )/sp_rat > 1.0/8.0:
# st['mask'][kk,jj] = 0.0
if numpy.size(u0.shape) > 2:
for pp in range(2, numpy.size(u0.shape)):
st["mask"] = CsSolver.appendmat(st["mask"], u0.shape[pp])
return st
def create_mask(self, u0):
st = self.st
rows = u0.shape[0]
cols = u0.shape[1]
kk = numpy.arange(0, rows)
jj = numpy.arange(0, cols)
kk = CsSolver.appendmat(kk, cols)
jj = CsSolver.appendmat(jj, rows).T
st['mask'] = numpy.ones((rows, cols), dtype=numpy.float32)
#add circular mask
sp_rat = (rows**2 + cols**2) * 1.0
# for jj in numpy.arange(0,cols):
# for kk in numpy.arange(0,rows):
# if ( (kk-rows/2.0)**2+(jj-cols/2.0)**2 )/sp_rat > 1.0/8.0:
# st['mask'][kk,jj] = 0.0
if numpy.size(u0.shape) > 2:
for pp in range(2, numpy.size(u0.shape)):
st['mask'] = CsSolver.appendmat(st['mask'], u0.shape[pp])
return st
def solve(self): # main function of solver
u0 = numpy.empty((self.f.dim_x, self.st['Nd'][0], self.st['Nd'][1], 4))
tse = self.f.tse
tse = CsSolver.appendmat(tse, u0.shape[2])
tse = numpy.transpose(tse, (0, 1, 3, 2))
print('tse.shape', tse.shape)
#===============================================================================
# mask
#===============================================================================
self.st = self.create_mask(u0)
print('mask.shape', self.st['mask'].shape)
# for jj in range(0,16):
# matplotlib.pyplot.subplot(4,4,jj)
# matplotlib.pyplot.imshow(self.st['mask'][...,jj,0].real)
# matplotlib.pyplot.show()
#===============================================================================
#estimate sensitivity maps by divided by rms images
self.st = self.make_sense(
self.f.tse) # setting up sense map in st['sensemap']
self.st['sensemap'] = CsSolver.appendmat(self.st['sensemap'],
u0.shape[2])
self.st['sensemap'] = numpy.transpose(self.st['sensemap'],
(0, 1, 3, 2))
#self.st['sensemap'] =self.st['sensemap'] * self.st['mask']
print('self.sense.shape', self.st['sensemap'].shape)
# for jj in range(0,16):
# matplotlib.pyplot.subplot(4,4,jj)
# matplotlib.pyplot.imshow(numpy.abs(self.st['sensemap'][...,jj,0]))
# matplotlib.pyplot.show()
self.st['senseflag'] = 1 # turn-on sense, to get sensemap
(u, uf) = self.kernel(self.f.f, self.st, self.mu, self.LMBD,
self.gamma, self.nInner, self.nBreg)
self.u = u
def solve(self): # main function of solver
u0 = numpy.empty((self.f.dim_x, self.st["Nd"][0], self.st["Nd"][1], 4))
tse = self.f.tse
tse = CsSolver.appendmat(tse, u0.shape[2])
tse = numpy.transpose(tse, (0, 1, 3, 2))
print("tse.shape", tse.shape)
# ===============================================================================
# mask
# ===============================================================================
self.st = self.create_mask(u0)
print("mask.shape", self.st["mask"].shape)
# for jj in range(0,16):
# matplotlib.pyplot.subplot(4,4,jj)
# matplotlib.pyplot.imshow(self.st['mask'][...,jj,0].real)
# matplotlib.pyplot.show()
# ===============================================================================
# estimate sensitivity maps by divided by rms images
self.st = self.make_sense(self.f.tse) # setting up sense map in st['sensemap']
self.st["sensemap"] = CsSolver.appendmat(self.st["sensemap"], u0.shape[2])
self.st["sensemap"] = numpy.transpose(self.st["sensemap"], (0, 1, 3, 2))
# self.st['sensemap'] =self.st['sensemap'] * self.st['mask']
print("self.sense.shape", self.st["sensemap"].shape)
# for jj in range(0,16):
# matplotlib.pyplot.subplot(4,4,jj)
# matplotlib.pyplot.imshow(numpy.abs(self.st['sensemap'][...,jj,0]))
# matplotlib.pyplot.show()
self.st["senseflag"] = 1 # turn-on sense, to get sensemap
(u, uf) = self.kernel(self.f.f, self.st, self.mu, self.LMBD, self.gamma, self.nInner, self.nBreg)
self.u = u
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)
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)
