def xformed_image_method(image, *args, **kwargs): print 'inverse transforming' util.ifft1(image.cdata, inplace=True, shift=True) util.ifft1(image.cacs_data, inplace=True, shift=True) fx = meth(image, *args, **kwargs) print 'forward transforming' util.fft1(image.cdata, inplace=True, shift=True) util.fft1(image.cacs_data, inplace=True, shift=True) if fx is not None: return fx
def run(self, image): arrays = (image.data, ) refs = (image.ref_data, ) samps = (image.n2_sampling, slice(None)) if hasattr(image, 'acs_data'): arrays += (image.acs_data, ) refs += (image.acs_ref_data, ) a, b = grappa_sampling(image.shape[-2], int(image.accel), image.n_acs) if len(b): init_acs_dir = (-1.0)**(a.tolist().index(b[0])) else: init_acs_dir = 1 polarities = (1.0, init_acs_dir) nr = image.n_ramp nf = image.n_flat if image.pslabel == 'ep2d_bold_acs_test' or image.accel > 2: acs_xleave = int(image.accel) else: acs_xleave = 1 xleaves = (1, int(acs_xleave)) for arr, n2, ref_arr, r, x in zip(arrays, samps, refs, polarities, xleaves): if arr is None: continue util.ifft1(arr, inplace=True, shift=True) # enforce 4D arrays arr.shape = (1, ) * (4 - len(arr.shape)) + arr.shape ref_arr.shape = (1, ) * (4 - len(ref_arr.shape)) + ref_arr.shape sub_samp_slicing = [slice(None)] * len(arr.shape) sub_samp_slicing[-2] = n2 Q2, Q1 = arr[sub_samp_slicing].shape[-2:] q1_ax = np.linspace(-Q1 / 2., Q1 / 2., Q1, endpoint=False) q2_pattern = r * np.power(-1.0, np.arange(Q2) / x) for v in xrange(arr.shape[0]): sub_samp_slicing[0] = v for sl in range(arr.shape[1]): sub_samp_slicing[1] = sl m = simple_unbal_phase_ramp(ref_arr[v, sl].copy(), nr, nf, image.pref_polarity, fov_lim=self.fov_lim, mask_noise=self.mask_noise) soln_pln = (m * q1_ax[None, :]) * q2_pattern[:, None] phs = np.exp(-1j * soln_pln) arr[sub_samp_slicing] *= phs # correct for flat dimensions arr.shape = tuple([d for d in arr.shape if d > 1]) util.fft1(arr, inplace=True, shift=True)
def run(self, image): arrays = (image.data,) refs = (image.ref_data,) samps = (image.n2_sampling, slice(None)) if hasattr(image, 'acs_data'): arrays += (image.acs_data,) refs += (image.acs_ref_data,) a,b = grappa_sampling(image.shape[-2], int(image.accel), image.n_acs) if len(b): init_acs_dir = (-1.0) ** (a.tolist().index(b[0])) else: init_acs_dir = 1 polarities = (1.0, init_acs_dir) nr = image.n_ramp nf = image.n_flat if image.pslabel == 'ep2d_bold_acs_test' or image.accel > 2: acs_xleave = int(image.accel) else: acs_xleave = 1 xleaves = (1, int(acs_xleave)) for arr, n2, ref_arr, r, x in zip(arrays, samps, refs, polarities, xleaves): if arr is None: continue util.ifft1(arr, inplace=True, shift=True) # enforce 4D arrays arr.shape = (1,)*(4-len(arr.shape)) + arr.shape ref_arr.shape = (1,)*(4-len(ref_arr.shape)) + ref_arr.shape sub_samp_slicing = [slice(None)]*len(arr.shape) sub_samp_slicing[-2] = n2 Q2, Q1 = arr[sub_samp_slicing].shape[-2:] q1_ax = np.linspace(-Q1/2., Q1/2., Q1, endpoint=False) q2_pattern = r*np.power(-1.0, np.arange(Q2)/x) for v in xrange(arr.shape[0]): sub_samp_slicing[0] = v for sl in range(arr.shape[1]): sub_samp_slicing[1] = sl m = simple_unbal_phase_ramp(ref_arr[v,sl].copy(), nr, nf, image.pref_polarity, fov_lim=self.fov_lim, mask_noise=self.mask_noise) soln_pln = (m * q1_ax[None,:]) * q2_pattern[:,None] phs = np.exp(-1j*soln_pln) arr[sub_samp_slicing] *= phs # correct for flat dimensions arr.shape = tuple([d for d in arr.shape if d > 1]) util.fft1(arr, inplace=True, shift=True)
def upsample(a, m): npts = a.shape[0]*m b = a.copy() # upsampe m times, stick the original ts in the middle of m samples a_up = np.zeros((npts,), a.dtype) a_up[m/2::m] = a util.fft1(a_up, inplace=True, shift=True) # LP filter to get sinc interpolation lpf = np.zeros((npts,)) bw = a.shape[0] lpf[npts/2-bw/2 : npts/2+bw/2] = 1. a_up *= lpf util.ifft1(a_up, inplace=True, shift=True) a_up *= float(m) return a_up
def run(self, image): accel = int(image.accel) sub_data = image.cdata # shape (nc, nsl, n2, n1) acs = image.cacs_data # cheap fix for new shape of potentially multi-acquisition acs if len(acs.shape) > 4: acs = acs[:, 0, :, :, :] # transpose to (nsl, nc, n2, n1) acs = acs.transpose(1, 0, 2, 3).copy() if self.ft: print "transforming readout..." util.ifft1(sub_data, inplace=True, shift=True) util.ifft1(acs, inplace=True, shift=True) n2_sampling = image.pe_sampling[:] n2_sampling.sort() for s in range(image.n_slice): N, e = grappa_coefs(acs[s], accel, self.nblocks, sliding=self.sliding, n1_window=self.n1_window, loud=self.beloud, fixed_window=not self.floating_window) # find weightings for each slide reconstruction based on the # errors of their fits (slide enumeration in axis=-2) w = find_weights(e, axis=-2) if self.beloud: print e print w.sum(axis=-2) Ssub = sub_data[:, :, s, :, :] Ssub[:] = grappa_synthesize(Ssub, N, n2_sampling, weights=w, loud=self.beloud, fixed_window=not self.floating_window) if self.ft: util.fft1(sub_data, inplace=True, shift=True) util.fft1(acs, inplace=True, shift=True) # by convention, set view to channel 0 image.use_membuffer(0)
def run(self, image): accel = int(image.accel) sub_data = image.cdata # shape (nc, nsl, n2, n1) acs = image.cacs_data # cheap fix for new shape of potentially multi-acquisition acs if len(acs.shape) > 4: acs = acs[:,0,:,:,:] # transpose to (nsl, nc, n2, n1) acs = acs.transpose(1, 0, 2, 3).copy() if self.ft: print "transforming readout..." util.ifft1(sub_data, inplace=True, shift=True) util.ifft1(acs, inplace=True, shift=True) n2_sampling = image.pe_sampling[:] n2_sampling.sort() for s in range(image.n_slice): N, e = grappa_coefs(acs[s], accel, self.nblocks, sliding=self.sliding, n1_window=self.n1_window, loud=self.beloud, fixed_window=not self.floating_window) # find weightings for each slide reconstruction based on the # errors of their fits (slide enumeration in axis=-2) w = find_weights(e, axis=-2) if self.beloud: print e print w.sum(axis=-2) Ssub = sub_data[:,:,s,:,:] Ssub[:] = grappa_synthesize(Ssub, N, n2_sampling, weights=w, loud=self.beloud, fixed_window=not self.floating_window) if self.ft: util.fft1(sub_data, inplace=True, shift=True) util.fft1(acs, inplace=True, shift=True) # by convention, set view to channel 0 image.use_membuffer(0)
def ksp_calib_hybrid_synth(image, Ny_blk, Nx_blk, sl=-1): R = int(image.accel) Nc = image.n_chan Nacs = int(image.n_acs) Nx = image.N1 Nv = image.n_vol Nfy = Nacs - (Ny_blk - 1) * R Nfx = Nx - (Nx_blk - 1) x_start = Nx_blk / 2 # lower inclusive limit for x target points x_end = x_start + Nfx - 1 # upper limit, inclusive, for x target points Npe = image.n_pe acs = image.cacs_data acs.shape = tuple([d for d in acs.shape if d > 1]) cdata = image.cdata # set up 2D neighborhood offsets xblk_offsets = np.arange(-(Nx_blk / 2), -(Nx_blk / 2) + Nx_blk) yblk_offsets = np.arange(-((Ny_blk - 1) / 2), -( (Ny_blk - 1) / 2) + Ny_blk) * R - 1 # fitting stage Ssrc = np.empty((Nfy * Nfx, Nc * Ny_blk * Nx_blk), 'F') Stgt = np.empty((Nfy * Nfx, (R - 1) * Nc), 'F') tgt_row0 = R * ((Ny_blk - 1) / 2) + 1 tgt_rows = np.arange(tgt_row0, tgt_row0 + Nfy) # transpose this array, since we will be indexing over x Wpad = np.zeros((Nx, Nc, Ny_blk, (R - 1) * Nc), 'F') Wpad_slice = [slice(None)] * len(Wpad.shape) kx0 = Nx / 2 + xblk_offsets[0] kx1 = Nx / 2 + xblk_offsets[-1] + 1 Wpad_slice[0] = slice(kx0, kx1) Wpad_slice = tuple(Wpad_slice) # synthesis stage pe_sampling = image.pe_sampling[:] pe_sampling.sort() acq_row0 = pe_sampling[0] # == 1 acq_rowf = pe_sampling[-1] + 1 # == last-sampled + 1 syn_rows = np.arange(tgt_row0 + 1, acq_rowf, R) Nu = len(syn_rows) # make Sacq with full readout points, and assume circularity in kx direction Sacq = np.empty((Nu * Nx * Nv, Nc * Ny_blk), 'F') Ssyn = np.empty((Nx, Nv * Nu, Nc * (R - 1)), 'F') sl_range = sl >= 0 and [sl] or xrange(image.n_slice) W_list = [] for s in sl_range: Dy_idx = tgt_rows[:, None] + yblk_offsets Stgt.shape = (Nfy, Nfx, (R - 1), Nc) print 'filling Stgt' inline(Stgt_fill, [ 'R', 'tgt_rows', 'Nfy', 'Nc', 'acs', 'Stgt', 'x_start', 'x_end', 's' ], type_converters=blitz) Stgt.shape = (Nfy * Nfx, (R - 1) * Nc) Ssrc.shape = (Nfy, Nfx, Nc, Ny_blk, Nx_blk) print 'filling Ssrc' inline(Ssrc_fill, [ 'Nc', 'Nfy', 'Nfx', 'Ny_blk', 'Nx_blk', 'Dy_idx', 'x_start', 'xblk_offsets', 'Ssrc', 'acs', 's' ], type_converters=blitz) Ssrc.shape = (Nfy * Nfx, Nc * Ny_blk * Nx_blk) W = np.linalg.lstsq(Ssrc, Stgt)[0] W.shape = (Nc, Ny_blk, Nx_blk, (R - 1) * Nc) W_list.append(W) util.ifft1(cdata, inplace=True, axis=-1) cdata *= Nx for W, s in zip(W_list, sl_range): # W indexes in rows as (chan, yn_idx, xn_idx) # W indexes in cols as (m, chan) Wpad[Wpad_slice] = W.transpose(2, 0, 1, 3) Wx = util.ifft1(Wpad, shift=True, inplace=False, axis=0) # Now each W(x) index in rows as (chan, yn_idx) # Now each W(x) index in cols as (m, chan) Wx.shape = (Nx, Nc * Ny_blk, (R - 1) * Nc) Wx *= Nx # want to repeatedly perform the linear combination of (Nc*Ny_blk) # points at all combinations of (Nu, Nx) # (Nu(x), Nc*Ny_blk) * W(x) Dy_idx = syn_rows[:, None] + yblk_offsets Sacq.shape = (Nx, Nv, Nu, Nc, Ny_blk) print 'filling acquisition rows, offsets', yblk_offsets inline( Sacq_fill, ['Nu', 'Nx', 'Nv', 'Nc', 'Ny_blk', 'Dy_idx', 'Sacq', 'cdata', 's'], type_converters=blitz) Sacq.shape = (Nx, Nv * Nu, Nc * Ny_blk) print 'synthesizing rows', syn_rows for xsyn, xacq, w in zip(Ssyn, Sacq, Wx): xsyn[:] = np.dot(xacq, w) Ssyn.shape = (Nx, Nv, Nu, R - 1, Nc) print 'filling synth rows' inline(Ssyn_fill, ['Nc', 'Nv', 'Nu', 'syn_rows', 'R', 'cdata', 'Ssyn', 's'], type_converters=blitz) util.fft1(cdata, inplace=True, axis=-1)
def ksp_calib_hybrid_synth(image, Ny_blk, Nx_blk, sl=-1): R = int(image.accel) Nc = image.n_chan Nacs = int(image.n_acs) Nx = image.N1 Nv = image.n_vol Nfy = Nacs - (Ny_blk-1)*R Nfx = Nx - (Nx_blk-1) x_start = Nx_blk/2 # lower inclusive limit for x target points x_end = x_start + Nfx - 1 # upper limit, inclusive, for x target points Npe = image.n_pe acs = image.cacs_data acs.shape = tuple([d for d in acs.shape if d > 1]) cdata = image.cdata # set up 2D neighborhood offsets xblk_offsets = np.arange(-(Nx_blk/2), -(Nx_blk/2)+Nx_blk) yblk_offsets = np.arange(-((Ny_blk-1)/2), -((Ny_blk-1)/2)+Ny_blk)*R - 1 # fitting stage Ssrc = np.empty((Nfy*Nfx, Nc*Ny_blk*Nx_blk), 'F') Stgt = np.empty((Nfy*Nfx, (R-1)*Nc), 'F') tgt_row0 = R * ((Ny_blk-1)/2) + 1 tgt_rows = np.arange(tgt_row0, tgt_row0 + Nfy) # transpose this array, since we will be indexing over x Wpad = np.zeros((Nx, Nc, Ny_blk, (R-1)*Nc), 'F') Wpad_slice = [slice(None)] * len(Wpad.shape) kx0 = Nx/2 + xblk_offsets[0] kx1 = Nx/2 + xblk_offsets[-1] + 1 Wpad_slice[0] = slice(kx0, kx1) Wpad_slice = tuple(Wpad_slice) # synthesis stage pe_sampling = image.pe_sampling[:] pe_sampling.sort() acq_row0 = pe_sampling[0] # == 1 acq_rowf = pe_sampling[-1]+1 # == last-sampled + 1 syn_rows = np.arange(tgt_row0+1, acq_rowf, R) Nu = len(syn_rows) # make Sacq with full readout points, and assume circularity in kx direction Sacq = np.empty((Nu*Nx*Nv, Nc*Ny_blk), 'F') Ssyn = np.empty((Nx, Nv*Nu, Nc*(R-1)), 'F') sl_range = sl>=0 and [sl] or xrange(image.n_slice) W_list = [] for s in sl_range: Dy_idx = tgt_rows[:,None] + yblk_offsets Stgt.shape = (Nfy, Nfx, (R-1), Nc) print 'filling Stgt' inline(Stgt_fill, ['R', 'tgt_rows', 'Nfy', 'Nc', 'acs', 'Stgt', 'x_start', 'x_end', 's'], type_converters=blitz) Stgt.shape = (Nfy*Nfx, (R-1)*Nc) Ssrc.shape = (Nfy, Nfx, Nc, Ny_blk, Nx_blk) print 'filling Ssrc' inline(Ssrc_fill, ['Nc', 'Nfy', 'Nfx', 'Ny_blk', 'Nx_blk', 'Dy_idx', 'x_start', 'xblk_offsets', 'Ssrc', 'acs', 's'], type_converters=blitz) Ssrc.shape = (Nfy*Nfx, Nc*Ny_blk*Nx_blk) W = np.linalg.lstsq(Ssrc, Stgt)[0] W.shape = (Nc, Ny_blk, Nx_blk, (R-1)*Nc) W_list.append(W) util.ifft1(cdata, inplace=True, axis=-1) cdata *= Nx for W, s in zip(W_list, sl_range): # W indexes in rows as (chan, yn_idx, xn_idx) # W indexes in cols as (m, chan) Wpad[Wpad_slice] = W.transpose(2, 0, 1, 3) Wx = util.ifft1(Wpad, shift=True, inplace=False, axis=0) # Now each W(x) index in rows as (chan, yn_idx) # Now each W(x) index in cols as (m, chan) Wx.shape = (Nx, Nc*Ny_blk, (R-1)*Nc) Wx *= Nx # want to repeatedly perform the linear combination of (Nc*Ny_blk) # points at all combinations of (Nu, Nx) # (Nu(x), Nc*Ny_blk) * W(x) Dy_idx = syn_rows[:,None] + yblk_offsets Sacq.shape = (Nx, Nv, Nu, Nc, Ny_blk) print 'filling acquisition rows, offsets', yblk_offsets inline(Sacq_fill, ['Nu', 'Nx', 'Nv', 'Nc', 'Ny_blk', 'Dy_idx', 'Sacq', 'cdata', 's'], type_converters=blitz) Sacq.shape = (Nx, Nv*Nu, Nc*Ny_blk) print 'synthesizing rows', syn_rows for xsyn, xacq, w in zip(Ssyn, Sacq, Wx): xsyn[:] = np.dot(xacq, w) Ssyn.shape = (Nx, Nv, Nu, R-1, Nc) print 'filling synth rows' inline(Ssyn_fill, ['Nc','Nv','Nu','syn_rows','R', 'cdata','Ssyn','s'], type_converters=blitz) util.fft1(cdata, inplace=True, axis=-1)