def compute(self): import numpy as np dps = self.getVal('Dims per Set') mtx_xy = self.getVal('Effective MTX XY') mtx_z = self.getVal('Effective MTX Z') numiter = self.getVal('Iterations') taper = self.getVal('Taper') kradscale = self.getVal('krad Scale') crds = self.getData('crds') inwates = self.getData('wates') mtxsz_xy = (2.*mtx_xy)+6 mtxsz_z = (2.*mtx_z)+6 sdshape = crds[...,0].shape maxi = crds.ndim - 2 npts = 1 for i in range(dps): npts *= sdshape[maxi-i] nsets = int(crds[...,0].size/npts) # Reshape crds to be 3 dimensional - # sets, # pts/set, and dimensionality (1-3) crds = np.reshape(crds.astype(np.float64),(nsets,npts,crds.shape[-1])) if self.getVal('computenow'): if inwates is not None: wates = np.copy(inwates.reshape(nsets,npts).astype(np.float64)) else: wates = np.ones((nsets,npts), dtype=np.float64) # import in thread to save namespace import core.gridding.sdc as sd for set in range(nsets): if crds.shape[-1] == 1: cmtxdim = np.array([mtxsz_xy],dtype=np.int64) sdcset = sd.oned_sdc(crds[set,:],wates[set,:],cmtxdim,numiter,taper) if crds.shape[-1] == 2: cmtxdim = np.array([mtxsz_xy,mtxsz_xy],dtype=np.int64) sdcset = sd.twod_sdc(crds[set,:],wates[set,:],cmtxdim,numiter,taper) if crds.shape[-1] == 3: cmtxdim = np.array([mtxsz_xy,mtxsz_xy,mtxsz_z],dtype=np.int64) sdcset = sd.threed_sdc(crds[set,:],wates[set,:],cmtxdim,numiter,taper,kradscale) if set == 0: sdc = np.expand_dims(sdcset,0) else: sdc = np.append(sdc,np.expand_dims(sdcset,0),axis=0) # Reshape sdc weights to match that of incoming coordinates self.setData('sdc', np.reshape(sdc,sdshape)) return(0)
def compute(self): import numpy as np from scipy import linalg self.log.node("Virtual Channels node running compute()") twoD_or_threeD = 2 # GETTING WIDGET INFO mtx_xy = self.getVal('mtx') image_ceiling = self.getVal('image ceiling') crop_left = self.getVal('crop left') crop_right = self.getVal('crop right') crop_top = self.getVal('crop top') crop_bottom = self.getVal('crop bottom') reset_compute_button = self.getVal('reset compute button each time') compute = self.getVal('compute') # number of virtual channels m m = self.getVal('virtual channels') numiter = self.getVal('SDC Iterations') # GETTING PORT INFO data = self.getData('data').astype(np.complex64, copy=False) noise = self.getData('noise') sensitivity_map_uncropped = self.getData('sensitivity map') param = self.getData('params_in') # set dimensions nr_points = data.shape[-1] nr_arms = data.shape[-2] nr_coils = data.shape[0] if data.ndim == 3: extra_dim1 = 1 extra_dim2 = 1 data.shape = [nr_coils,extra_dim2,extra_dim1,nr_arms,nr_points] elif data.ndim == 4: extra_dim1 = data.shape[-3] extra_dim2 = 1 data.shape = [nr_coils,extra_dim2,extra_dim1,nr_arms,nr_points] elif data.ndim == 5: extra_dim1 = data.shape[-3] extra_dim2 = data.shape[-4] elif data.ndim > 5: self.log.warn("Not implemented yet") print("data shape: " + str(data.shape)) if sensitivity_map_uncropped is None: # if cropping or image scaling sliders were changed then use the previously stored csm instead of calcluating a new one has_csm_been_calculated = self.getData('sum of square image') if ( (has_csm_been_calculated is not None) and ( ('crop left' in self.widgetEvents()) or ('crop right' in self.widgetEvents()) or ('crop top' in self.widgetEvents()) or ('crop bottom' in self.widgetEvents()) or ('image ceiling' in self.widgetEvents()) ) ): csm = self.getData('masked and normalized sense map') image = self.getData('sum of square image').copy() if ( (csm is None) or (image is None) ): self.log.warn("This should not happen.") return 1 csm_mtx = csm.shape[-1] else: # calculate auto-calibration B1 maps coords = self.getData('coords').astype(np.float32, copy=False) if (coords is None): self.log.warn("Either a sensitiviy map or coords to calculate one is required") return 1 import bni.gridding.Kaiser2D_utils as kaiser2D # parameters from UI UI_width = self.getVal('Autocalibration Width (%)') UI_taper = self.getVal('Autocalibration Taper (%)') UI_mask_floor = self.getVal('Mask Floor (% of max mag)') UI_average_csm = self.getVal('Dynamic data - average all dynamics for csm') csm_mtx = np.int(0.01 * UI_width * mtx_xy) if coords.shape[-3]>100: is_GoldenAngle_data = True else: is_GoldenAngle_data = False if param is not None: if 'spDYN_GOLDANGLE_ON' in param: if int(param['spDYN_GOLDANGLE_ON'][0]) == 1: is_GoldenAngle_data = True else: is_GoldenAngle_data = False print("is GoldenAngle: " + str(is_GoldenAngle_data)) if is_GoldenAngle_data: nr_arms_cms = self.getVal('# golden angle dynamics for csm') else: nr_arms_cms = nr_arms self.log.debug("nr_arms_cms: " + str(nr_arms_cms)) csm_data = data[...,0:nr_arms_cms,:] # oversampling: Oversample at the beginning and crop at the end oversampling_ratio = 2. #1.375 mtx = np.int(csm_mtx * oversampling_ratio) if mtx%2: mtx+=1 if oversampling_ratio > 1: mtx_min = np.int((mtx-csm_mtx)/2) mtx_max = mtx_min + csm_mtx else: mtx_min = 0 mtx_max = mtx # average dynamics or cardiac phases for csm if ( (extra_dim1 > 1) and UI_average_csm ): csm_data = np.sum(csm_data, axis=2) extra_dim1_csm = 1 csm_data.shape = [nr_coils, extra_dim2, extra_dim1_csm, nr_arms_cms, nr_points] else: extra_dim1_csm = extra_dim1 self.log.debug("csm_data shape: " + str(csm_data.shape)) self.log.debug("coords shape: " + str(coords.shape)) # coords dimensions: (add 1 dimension as they could have another dimension for golden angle dynamics if coords.ndim == 3: coords.shape = [1,nr_arms,nr_points,twoD_or_threeD] # create low resolution csm # cropping the data will make gridding and FFT much faster magnitude_one_interleave = np.zeros(nr_points) for x in range(nr_points): magnitude_one_interleave[x] = np.sqrt( coords[0,0,x,0]**2 + coords[0,0,x,1]**2) within_csm_width_radius = magnitude_one_interleave[:] < (0.01 * UI_width * 0.5) # for BNI spirals should be 0.45 instead of 0.5 nr_points_csm_width = within_csm_width_radius.sum() # now set the dimension lists out_dims_grid = [nr_coils, extra_dim2, extra_dim1_csm, mtx, nr_arms_cms, nr_points_csm_width] out_dims_fft = [nr_coils, extra_dim2, extra_dim1_csm, mtx, mtx] csm_data = csm_data[...,0:nr_points_csm_width] csm_coords = 1. / (0.01 * UI_width) * coords[...,0:nr_arms_cms,0:nr_points_csm_width,:] # generate SDC based on number of arms and nr of points being used for csm import core.gridding.sdc as sd #csm_weights = sd.twod_sdcsp(csm_coords.squeeze().astype(np.float64), numiter, 0.01 * UI_taper, mtx) cmtxdim = np.array([mtx,mtx],dtype=np.int64) wates = np.ones((nr_arms_cms * nr_points_csm_width), dtype=np.float64) coords_for_sdc = csm_coords.astype(np.float64) coords_for_sdc.shape = [nr_arms_cms * nr_points_csm_width, twoD_or_threeD] csm_weights = sd.twod_sdc(coords_for_sdc, wates, cmtxdim, numiter, 0.01 * UI_taper ) csm_weights.shape = [1,nr_arms_cms,nr_points_csm_width] # pre-calculate Kaiser-Bessel kernel kernel_table_size = 800 kernel = kaiser2D.kaiserbessel_kernel( kernel_table_size, oversampling_ratio) # pre-calculate the rolloff for the spatial domain roll = kaiser2D.rolloff2D(mtx, kernel) # Grid gridded_kspace = kaiser2D.grid2D(csm_data, csm_coords, csm_weights.astype(np.float32), kernel, out_dims_grid) self.setData('debug', gridded_kspace) # filter k-space - not needed anymore as SDC taper is used now. ## win = kaiser2D.window2(gridded_kspace.shape[-2:], windowpct=UI_taper, widthpct=100) ## gridded_kspace *= win # FFT image_domain = kaiser2D.fft2D(gridded_kspace, dir=0, out_dims_fft=out_dims_fft) # rolloff image_domain *= roll # crop to original matrix size csm = image_domain[...,mtx_min:mtx_max,mtx_min:mtx_max] # normalize by rms (better would be to use a whole body coil image csm_rms = np.sqrt(np.sum(np.abs(csm)**2, axis=0)) csm = csm / csm_rms # zero out points that are below mask threshold thresh = 0.01 * UI_mask_floor * csm_rms.max() csm *= csm_rms > thresh # for ROI selection use csm_rms, which still has some contrast image = csm_rms image.shape = [csm_mtx,csm_mtx] image_sos = image.copy() self.setData('sum of square image', image_sos) else: csm = sensitivity_map_uncropped csm_mtx = csm.shape[-1] # create sum-of-squares of sensitivity map to allow selection of ROI image = np.copy(csm) image = np.sqrt(np.sum(np.abs(image)**2, axis=0)) image.shape = [csm_mtx,csm_mtx] self.setData('masked and normalized sense map', csm) # display sum-of-squares of sensitivity map to allow selection of ROI data_max = image.max() data_min = image.min() image[:, crop_left-1] = data_max image[:, crop_right-1] = data_max image[crop_top-1, :] = data_max image[crop_bottom-1, :] = data_max data_range = data_max - data_min new_max = data_range * 0.01 * image_ceiling + data_min dmask = np.ones(image.shape) image = np.minimum(image,new_max*dmask) if new_max > data_min: image = 255.*(image - data_min)/(new_max-data_min) red = green = blue = np.uint8(image) alpha = 255. * np.ones(blue.shape) h, w = red.shape[:2] image1 = np.zeros((h, w, 4), dtype=np.uint8) image1[:, :, 0] = red image1[:, :, 1] = green image1[:, :, 2] = blue image1[:, :, 3] = alpha format_ = QtGui.QImage.Format_RGB32 image2 = QtGui.QImage(image1.data, w, h, format_) image2.ndarry = image1 self.setAttr('image', val=image2) # crop sensitivity map csm.shape = [nr_coils, csm_mtx, csm_mtx] sensitivity_map = csm[:,crop_top-1:crop_bottom,crop_left-1:crop_right] #self.setData('debug', np.squeeze(sensitivity_map)) # get sizes # number of channels n n = sensitivity_map.shape[-3] x_size = sensitivity_map.shape[-1] y_size = sensitivity_map.shape[-2] nr_pixels = x_size * y_size if compute: # noise covariance matrix Psi noise_cv_matrix = np.cov(noise) # Cholesky decomposition to determine T, where T Psi T_H = 1 L = np.linalg.cholesky(noise_cv_matrix) T = np.linalg.inv(L) # decorrelated sensitivity map S_hat S_hat = np.zeros([nr_pixels, n], dtype=np.complex64) for x in range(x_size): for y in range(y_size): index = y + x * y_size S_hat[index, :] = np.dot(T, sensitivity_map[:,y,x]) self.log.debug("after S_hat") # P = sum of S_hat S_hat_pseudo_inverse over all pixels P = np.zeros([n,n], dtype=np.complex64) S_hat_matrix = np.zeros([n,1], dtype=np.complex64) for index in range(nr_pixels): # pseudo inverse of S_hat S_hat_matrix[:,0] = S_hat[index,:] S_hat_pinv = np.linalg.pinv(S_hat_matrix) P = P + np.dot(S_hat_matrix, S_hat_pinv) self.log.debug("after S_hat_pinv") # singular value decomposition of P # if P is symmetric and positive definite, the SVD is P = U d U.H instead of P = U d V.H U, d, V = np.linalg.svd(P) self.log.debug("after svd") # the transformation matrix A is then given by A = C U.H T # C is diagonal matrix with 1 on the first m rows and 0 in the remaining # instead of using C, only assing mxn to A C = np.array(np.zeros([n,n]), dtype=np.float32) self.log.debug("after C") for x in range(m): C[x,x]=1. A_square = np.dot(C, np.dot(U.T.conjugate(), T)) A = A_square[0:m,:] self.log.debug("after A") # Compress the data if data.ndim == 5: out = np.zeros([m,extra_dim2,extra_dim1,nr_arms,nr_points],dtype=data.dtype) for extra2 in range(extra_dim2): for extra1 in range(extra_dim1): for arm in range(nr_arms): for point in range(nr_points): out[:,extra2,extra1,arm,point] = np.dot(A, data[:,extra2,extra1,arm,point]) # SETTING PORT INFO self.setData('compressed data', np.squeeze(out)) self.setData('A', A) self.setData('noise covariance', noise_cv_matrix) # end of compute if reset_compute_button: self.setAttr('compute', val=False) return 0
def compute(self): import bni.gridding.Kaiser2D_utils as kaiser2D self.log.debug("Start CG SENSE 2D") # get port and widget inputs data = self.getData('data').astype(np.complex64, copy=False) coords = self.getData('coords').astype(np.float32, copy=False) weights = self.getData('weights').astype(np.float32, copy=False) mtx_original = self.getVal('mtx') iterations = self.getVal('iterations') step = self.getVal('step') oversampling_ratio = self.getVal('oversampling ratio') number_threads = self.getVal('number of threads') GA = self.getVal('Golden Angle - combine dynamics before gridding') # for a single iteration step use the csm stored in the out port if step and (self.getData('oversampled CSM') is not None): csm = self.getData('oversampled CSM') else: csm = self.getData('coil sensitivity') if csm is not None: csm = csm.astype(np.complex64, copy=False) # oversampling: Oversample at the beginning and crop at the end mtx = np.int(np.around(mtx_original * oversampling_ratio)) if mtx%2: mtx+=1 if oversampling_ratio > 1: mtx_min = np.int(np.around((mtx-mtx_original)/2)) mtx_max = mtx_min + mtx_original else: mtx_min = 0 mtx_max = mtx # data dimensions nr_points = data.shape[-1] nr_arms = data.shape[-2] nr_coils = data.shape[0] if data.ndim == 3: extra_dim1 = 1 extra_dim2 = 1 data.shape = [nr_coils,extra_dim2,extra_dim1,nr_arms,nr_points] elif data.ndim == 4: extra_dim1 = data.shape[-3] extra_dim2 = 1 data.shape = [nr_coils,extra_dim2,extra_dim1,nr_arms,nr_points] elif data.ndim == 5: extra_dim1 = data.shape[-3] extra_dim2 = data.shape[-4] elif data.ndim > 5: self.log.warn("Not implemented yet") out_dims_grid = [nr_coils, extra_dim2, extra_dim1, mtx, nr_arms, nr_points] out_dims_degrid = [nr_coils, extra_dim2, extra_dim1, nr_arms, nr_points] out_dims_fft = [nr_coils, extra_dim2, extra_dim1, mtx, mtx] iterations_shape = [extra_dim2, extra_dim1, mtx, mtx] # coords dimensions: (add 1 dimension as they could have another dimension for golden angle dynamics if coords.ndim == 3: coords.shape = [1,nr_arms,nr_points,2] weights.shape = [1,nr_arms,nr_points] # output including all iterations x_iterations = np.zeros([iterations,extra_dim2,extra_dim1,mtx_original,mtx_original],dtype=np.complex64) if step and (iterations > 1): previous_iterations = self.getData('x iterations') previous_iterations.shape = [iterations-1,extra_dim2, extra_dim1, mtx_original, mtx_original] x_iterations[:-1,:,:,:,:] = previous_iterations # pre-calculate Kaiser-Bessel kernel self.log.debug("Calculate kernel") kernel_table_size = 800 kernel = kaiser2D.kaiserbessel_kernel( kernel_table_size, oversampling_ratio) # pre-calculate the rolloff for the spatial domain roll = kaiser2D.rolloff2D(mtx, kernel) # for a single iteration step use the oversampled csm and intermediate results stored in outports if step and (self.getData('d') is not None): self.log.debug("Save some time and use the previously determined csm stored in the cropped CSM outport.") elif GA: #combine data from GA dynamics before gridding, use code from VirtualChannels_GPI.py # grid images for each phase - needs to be done at some point, not really here for csm though. self.log.debug("Grid undersampled data") gridded_kspace = kaiser2D.grid2D(data, coords, weights, kernel, out_dims_grid, number_threads=number_threads) # FFT image_domain = kaiser2D.fft2D(gridded_kspace, dir=0, out_dims_fft=out_dims_fft) # rolloff image_domain *= roll twoD_or_threeD = coords.shape[-1] # parameters from UI UI_width = self.getVal('Autocalibration Width (%)') UI_taper = self.getVal('Autocalibration Taper (%)') UI_mask_floor = self.getVal('Mask Floor (% of max mag)') mask_dilation = self.getVal('Autocalibration mask dilation [pixels]') UI_average_csm = self.getVal('Dynamic data - average all dynamics for csm') numiter = self.getVal('Autocalibration SDC Iterations') original_csm_mtx = np.int(0.01 * UI_width * mtx_original) is_GoldenAngle_data = True nr_arms_csm = self.getVal('# golden angle dynamics for csm') nr_all_arms_csm = extra_dim1 * nr_arms extra_dim1_csm = 1 # coords dimensions: (add 1 dimension as they could have another dimension for golden angle dynamics if coords.ndim == 3: coords.shape = [1,nr_arms,nr_points,twoD_or_threeD] # create low resolution csm # cropping the data will make gridding and FFT much faster magnitude_one_interleave = np.zeros(nr_points) for x in range(nr_points): magnitude_one_interleave[x] = np.sqrt( coords[0,0,x,0]**2 + coords[0,0,x,1]**2) within_csm_width_radius = magnitude_one_interleave[:] < (0.01 * UI_width * 0.5) # for BNI spirals should be 0.45 instead of 0.5 nr_points_csm_width = within_csm_width_radius.sum() # in case of radial trajectory, it doesn't start at zero.. found_start_point = 0 found_end_point = 0 for x in range(nr_points): if ((not found_start_point) and (within_csm_width_radius[x])): found_start_point = 1 start_point = x if ((not found_end_point) and (found_start_point) and (not within_csm_width_radius[x])): found_end_point = 1 end_point = x if not found_end_point: end_point = nr_points self.log.node("Start and end points in interleave are: "+str(start_point)+" and "+str(end_point)+" leading to "+str(nr_points_csm_width)+" points for csm.") arm_counter = 0 extra_dim1_counter = 0 arm_with_data_counter = 0 while (arm_with_data_counter < nr_arms_csm and extra_dim1_counter < extra_dim1): if (coords[extra_dim1_counter, arm_counter,0,0] != coords[extra_dim1_counter, arm_counter,-1,0]): #only equal when no data in this interleave during resorting arm_with_data_counter += 1 arm_counter += 1 if arm_counter == nr_arms: arm_counter = 0 extra_dim1_counter += 1 self.log.node("Found "+str(arm_with_data_counter)+" arms, and was looking for "+str(nr_arms_csm)+" from a total of "+str(nr_all_arms_csm)+" arms.") csm_data = np.zeros([nr_coils,extra_dim2,extra_dim1_csm,arm_with_data_counter,nr_points_csm_width], dtype=data.dtype) csm_coords = np.zeros([1,arm_with_data_counter,nr_points_csm_width,twoD_or_threeD], dtype=coords.dtype) arm_counter = 0 extra_dim1_counter = 0 arm_with_data_counter = 0 while (arm_with_data_counter < nr_arms_csm and extra_dim1_counter < extra_dim1): if (coords[extra_dim1_counter, arm_counter,0,0] != coords[extra_dim1_counter, arm_counter,-1,0]): #only equal when no data in this interleave during resorting csm_data[:,:,0,arm_with_data_counter,:] = data[:,:,extra_dim1_counter,arm_counter,start_point:end_point] csm_coords[0,arm_with_data_counter,:,:] = coords[extra_dim1_counter,arm_counter,start_point:end_point,:] arm_with_data_counter += 1 arm_counter += 1 if arm_counter == nr_arms: arm_counter = 0 extra_dim1_counter += 1 self.log.node("Found "+str(arm_with_data_counter)+" arms, and was looking for "+str(nr_arms_csm)+" from a total of "+str(nr_all_arms_csm)+" arms.") # now set the dimension lists out_dims_grid_csm = [nr_coils, extra_dim2, extra_dim1_csm, mtx, arm_with_data_counter, nr_points_csm_width] out_dims_fft_csm = [nr_coils, extra_dim2, extra_dim1_csm, mtx, mtx] # generate SDC based on number of arms and nr of points being used for csm import core.gridding.sdc as sd #csm_weights = sd.twod_sdcsp(csm_coords.squeeze().astype(np.float64), numiter, 0.01 * UI_taper, mtx) cmtxdim = np.array([mtx,mtx],dtype=np.int64) wates = np.ones((arm_with_data_counter * nr_points_csm_width), dtype=np.float64) coords_for_sdc = csm_coords.astype(np.float64) coords_for_sdc.shape = [arm_with_data_counter * nr_points_csm_width, twoD_or_threeD] csm_weights = sd.twod_sdc(coords_for_sdc, wates, cmtxdim, numiter, 0.01 * UI_taper ) csm_weights.shape = [1,arm_with_data_counter,nr_points_csm_width] # Grid gridded_kspace_csm = kaiser2D.grid2D(csm_data, csm_coords, csm_weights.astype(np.float32), kernel, out_dims_grid_csm, number_threads=number_threads) image_domain_csm = kaiser2D.fft2D(gridded_kspace_csm, dir=0, out_dims_fft=out_dims_fft_csm) # rolloff image_domain_csm *= roll # # crop to original matrix size # csm = image_domain_csm[...,mtx_min:mtx_max,mtx_min:mtx_max] # normalize by rms (better would be to use a whole body coil image csm_rms = np.sqrt(np.sum(np.abs(image_domain_csm)**2, axis=0)) image_domain_csm = image_domain_csm / csm_rms # zero out points that are below mask threshold thresh = 0.01 * UI_mask_floor * csm_rms.max() mask = csm_rms > thresh # use scipy library to grow mask and fill holes. from scipy import ndimage mask.shape = [mtx,mtx] mask = ndimage.morphology.binary_dilation(mask, iterations=mask_dilation) mask = ndimage.binary_fill_holes(mask) image_domain_csm *= mask if extra_dim1 > 1: csm = np.zeros([nr_coils, extra_dim2, extra_dim1, mtx, mtx], dtype=image_domain_csm.dtype) for extra_dim1_counter in range(extra_dim1): csm[:,:,extra_dim1_counter,:,:]=image_domain_csm[:,:,0,:,:] else: csm = image_domain_csm self.setData('oversampled CSM', csm) self.setData('cropped CSM', csm[...,mtx_min:mtx_max,mtx_min:mtx_max]) else: # this is the normal path (not single iteration step) # grid to create images that are corrupted by # aliasing due to undersampling. If the k-space data have an # auto-calibration region, then this can be used to generate B1 maps. self.log.debug("Grid undersampled data") gridded_kspace = kaiser2D.grid2D(data, coords, weights, kernel, out_dims_grid, number_threads=number_threads) # FFT image_domain = kaiser2D.fft2D(gridded_kspace, dir=0, out_dims_fft=out_dims_fft) # rolloff image_domain *= roll # calculate auto-calibration B1 maps if csm is None: self.log.debug("Generating autocalibrated B1 maps...") # parameters from UI UI_width = self.getVal('Autocalibration Width (%)') UI_taper = self.getVal('Autocalibration Taper (%)') UI_mask_floor = self.getVal('Mask Floor (% of max mag)') UI_average_csm = self.getVal('Dynamic data - average all dynamics for csm') csm = kaiser2D.autocalibrationB1Maps2D(image_domain, taper=UI_taper, width=UI_width, mask_floor=UI_mask_floor, average_csm=UI_average_csm) else: # make sure input csm and data are the same mtx size. # Assuming the FOV was the same: zero-fill in k-space if csm.ndim != 5: self.log.debug("Reshape imported csm") csm.shape = [nr_coils,extra_dim2,extra_dim1,csm.shape[-2],csm.shape[-1]] if csm.shape[-1] != mtx: self.log.debug("Interpolate csm to oversampled matrix size") csm_oversampled_mtx = np.int(csm.shape[-1] * oversampling_ratio) if csm_oversampled_mtx%2: csm_oversampled_mtx+=1 out_dims_oversampled_image_domain = [nr_coils, extra_dim2, extra_dim1, csm_oversampled_mtx, csm_oversampled_mtx] csm = kaiser2D.fft2D(csm, dir=1, out_dims_fft=out_dims_oversampled_image_domain) csm = kaiser2D.fft2D(csm, dir=0, out_dims_fft=out_dims_fft) self.setData('oversampled CSM', csm) self.setData('cropped CSM', csm[...,mtx_min:mtx_max,mtx_min:mtx_max]) # keep a conjugate csm set on hand csm_conj = np.conj(csm) ## Iteration 1: if step and (self.getData('d') is not None): self.log.debug("\tSENSE Iteration: " + str(iterations)) # make sure the loop doesn't start if only one step is needed iterations = 0 # Get the data from the last execution of this node for an # additional single iteration. d = self.getData('d').copy() r = self.getData('r').copy() x = self.getData('x').copy() # A Ad = csm * d # add coil phase Ad *= roll # pre-rolloff for degrid convolution Ad = kaiser2D.fft2D(Ad, dir=1) Ad = kaiser2D.degrid2D(Ad, coords, kernel, out_dims_degrid, number_threads=number_threads, oversampling_ratio = oversampling_ratio) Ad = kaiser2D.grid2D(Ad, coords, weights, kernel, out_dims_grid, number_threads=number_threads) Ad = kaiser2D.fft2D(Ad, dir=0) Ad *= roll Ad = csm_conj * Ad # broadcast multiply to remove coil phase Ad = Ad.sum(axis=0) # assume the coil dim is the first else: self.log.debug("\tSENSE Iteration: 1") # calculate initial conditions # d_0 d_0 = csm_conj * image_domain # broadcast multiply to remove coil phase d_0 = d_0.sum(axis=0) # assume the coil dim is the first # Ad_0: # degrid -> grid (loop over coils) Ad_0 = csm * d_0 # add coil phase Ad_0 *= roll # pre-rolloff for degrid convolution Ad_0 = kaiser2D.fft2D(Ad_0, dir=1) Ad_0 = kaiser2D.degrid2D(Ad_0, coords, kernel, out_dims_degrid, number_threads=number_threads, oversampling_ratio = oversampling_ratio) Ad_0 = kaiser2D.grid2D(Ad_0, coords, weights, kernel, out_dims_grid, number_threads=number_threads) Ad_0 = kaiser2D.fft2D(Ad_0, dir=0) Ad_0 *= roll Ad_0 = csm_conj * Ad_0 # broadcast multiply to remove coil phase Ad_0 = Ad_0.sum(axis=0) # assume the coil dim is the first # use the initial conditions for the first iter r = d = d_0 x = np.zeros_like(d) Ad = Ad_0 # CG - iter 1 or step d_last, r_last, x_last = self.do_cg(d, r, x, Ad) current_iteration = x_last.copy() current_iteration.shape = iterations_shape if step: x_iterations[-1,:,:,:,:] = current_iteration[...,mtx_min:mtx_max,mtx_min:mtx_max] else: x_iterations[0,:,:,:,:] = current_iteration[...,mtx_min:mtx_max,mtx_min:mtx_max] ## Iterations >1: for i in range(iterations-1): self.log.debug("\tSENSE Iteration: " + str(i+2)) # input the result of the last iter d = d_last r = r_last x = x_last # A Ad = csm * d # add coil phase Ad *= roll # pre-rolloff for degrid convolution Ad = kaiser2D.fft2D(Ad, dir=1) Ad = kaiser2D.degrid2D(Ad, coords, kernel, out_dims_degrid, number_threads=number_threads, oversampling_ratio = oversampling_ratio) Ad = kaiser2D.grid2D(Ad, coords, weights, kernel, out_dims_grid, number_threads=number_threads) Ad = kaiser2D.fft2D(Ad, dir=0) Ad *= roll Ad = csm_conj * Ad # broadcast multiply to remove coil phase Ad = Ad.sum(axis=0) # assume the coil dim is the first # CG d_last, r_last, x_last = self.do_cg(d, r, x, Ad) current_iteration = x_last.copy() current_iteration.shape = iterations_shape x_iterations[i+1,:,:,:,:] = current_iteration[..., mtx_min:mtx_max, mtx_min:mtx_max] # return the final image self.setData('d', d_last) self.setData('r', r_last) self.setData('x', x_last) self.setData('out', np.squeeze(current_iteration[..., mtx_min:mtx_max, mtx_min:mtx_max])) self.setData('x iterations', np.squeeze(x_iterations)) return 0