def gen_kspace(self,imouse=0): rcvrelems = nonzero(self.inputAcq.rcvrmouse_mapping==imouse)[0] if (len(rcvrelems)==0): print("Requested reconstruction for mouse %d, which is not in receiver map"%imouse, self.inputAcq.rcvrmouse_mapping) raise SystemExit nreps = rgf.get_dict_value(self.inputAcq.method_param_dict,"PVM_NRepetitions",1) self.kspace = empty([len(rcvrelems),nreps*self.inputAcq.ni*self.inputAcq.nfid,self.inputAcq.nf,self.inputAcq.nro],complex) for j,ircvr in enumerate(rcvrelems): self.kspace[j] = rgf.gen_kspace_simple(self.inputAcq,ircvr) self.kspace.shape = tuple([x for x in self.kspace.shape if x>1]) if self.options.cen_out_pe1: self.kspace=rgf.centre_out_reordering(self.kspace,-2) if self.options.cen_out_pe2: self.kspace=rgf.centre_out_reordering(self.kspace,-3) if self.options.petable_pe1: self.kspace = rgf.petable_reordering(self.kspace,axis=-2,petable_array='t1',petable_name=self.petable_name) if self.options.petable_pe2: self.kspace = rgf.petable_reordering(self.kspace,axis=-3,petable_array='t2',petable_name=self.petable_name) if self.options.petable_ordered_pairs: self.kspace = rgf.petable_orderedpair_reordering(self.kspace,petable_arrays=('t1','t2'),petable_name=self.petable_name,\ matrix=(self.inputAcq.npe,self.inputAcq.npe2)) self.kspace = rgf.fov_adjustment(self.kspace,self.options,self.inputAcq,imouse) if ((self.inputAcq.platform=="Bruker") and (self.inputAcq.nD==2)): print("Reordering multislice experiment...") slice_order = rgf.get_dict_value(self.inputAcq.method_param_dict,"PVM_OjbOrderList",arange(self.inputAcq.nslices)) self.kspace[...,:,:,:] = self.kspace[...,slice_order,:,:] if self.options.dcshiftcorr: #do we use this? self.kspace,dcoff = rgf.DCartcorr(self.kspace,self.param_dict) if self.options.fermi_ellipse: self.kspace = rgf.fermi_ellipse_filter(self.kspace) elif self.options.fermi_pecirc: self.kspace = rgf.fermi_pecircle_filter(self.kspace)
def gen_kspace(self, imouse=0): rcvrelems = nonzero(self.inputAcq.rcvrmouse_mapping == imouse)[0] if (len(rcvrelems) == 0): print( "Requested reconstruction for mouse %d, which is not in receiver map" % imouse, self.inputAcq.rcvrmouse_mapping) raise SystemExit nTRs = len(parse_petable_file(self.petable_name, 't1')) self.inputAcq.nf = nTRs self.inputAcq.ni_perchan = 1 nreps = rgf.get_dict_value(self.inputAcq.method_param_dict, "PVM_NRepetitions", 1) self.kspace = empty([ nreps, len(rcvrelems), self.inputAcq.ni_perchan, self.inputAcq.nf, self.inputAcq.nro ], complex) for j, ircvr in enumerate(rcvrelems): self.kspace[:, j, ...] = gen_kspace_local(self.inputAcq, ircvr, nTRs=nTRs) #self.kspace.shape = tuple([x for x in self.kspace.shape if x>1]) if self.options.petable_ordered_pairs: self.kspace = rgf.petable_orderedpair_reordering(self.kspace,petable_arrays=('t1','t2'),petable_name=self.petable_name,\ matrix=(self.inputAcq.npe,self.inputAcq.npe2)) print(self.kspace.shape) elif self.options.petable_pe1: self.kspace = rgf.petable_reordering( self.kspace, axis=-2, petable_array='t1', petable_name=self.petable_name) elif self.options.petable_pe2: self.kspace = rgf.petable_reordering( self.kspace, axis=-3, petable_array='t2', petable_name=self.petable_name) self.kspace = rgf.fov_adjustment(self.kspace, self.options, self.inputAcq, imouse) if (rgf.get_dict_value(self.inputAcq.method_param_dict, 'PVM_EncPft', [1.0, 1.0, 1.0])[0] > 1.0005): #first: zero-pad k-space nrofull = rgf.get_dict_value(self.inputAcq.method_param_dict, 'PVM_Matrix', [1, 1, 1])[0] nroacq = rgf.get_dict_value(self.inputAcq.method_param_dict, 'PVM_EncMatrix', [1, 1, 1])[0] npad = nrofull - nroacq self.kspace = append(zeros(self.kspace.shape[0:-1] + (npad, ), complex), self.kspace, axis=-1) self.inputAcq.data_shape[-1] = nrofull self.Pftacq = True if self.options.fermi_ellipse: self.kspace = rgf.fermi_ellipse_filter(self.kspace)
def recon(self): if ((self.Pftacq == True) and (not self.options.nofft)): #recon centre of k-space (with apodization) and obtain normed conjugate print("Partial fourier recon in the read direction...") nrofull = rgf.get_dict_value(self.inputAcq.method_param_dict, 'PVM_Matrix', [1, 1, 1])[0] nroacq = rgf.get_dict_value(self.inputAcq.method_param_dict, 'PVM_EncMatrix', [1, 1, 1])[0] filt = 1.0 / ( 1.0 + exp(-(nroacq - arange(nrofull)) / self.options.apowidth)) k_sym = self.kspace * filt img_sym = rgf.recon_3d(k_sym) del k_sym Pmult = exp( -1.j * angle(img_sym)) #conjugate(img_sym)/where(abs(img_sym)) #multiply kspace by window function Kweight = 1.0/(1.0+exp((nrofull-nroacq-arange(nrofull))/self.options.apowidth))+ \ 1.0/(1.0+exp((nroacq-arange(nrofull))/self.options.apowidth)) weighted_image = rgf.recon_3d(self.kspace * Kweight).astype(complex) self.image_data = (weighted_image * Pmult).real else: rgf.default_recon(self) if ((self.options.complexavg) and (len(self.inputAcq.data_shape) > 4)): thresh = percentile(abs(self.image_data).flat, 75.0) nstep = 8 g_coord = mgrid[0:self.image_data.shape[-3]:nstep, 0:self.image_data.shape[-2]:nstep, 0:self.image_data.shape[-1]:nstep] pts_log = (abs(self.image_data[0,0,ravel(g_coord[0]),ravel(g_coord[1]),ravel(g_coord[2])])>thresh)* \ (abs(self.image_data[0,1,ravel(g_coord[0]),ravel(g_coord[1]),ravel(g_coord[2])])>thresh) Ainds = reshape(g_coord, (3, len(pts_log)))[:, pts_log] Ivals1 = mean(self.image_data[:, 0, Ainds[0, :], Ainds[1, :], Ainds[2, :]], axis=0) Ivals2 = mean(self.image_data[:, 1, Ainds[0, :], Ainds[1, :], Ainds[2, :]], axis=0) Cvals = Ivals1 * conj(Ivals2) Elem_phase_diff = arctan2(Cvals.imag, Cvals.real) pfit = Phase_shift_cal(Elem_phase_diff, Ainds) fullphaseimg = fullphasemap(pfit, self.image_data.shape) self.image_data = self.image_data[:, 0, :, :, :] + self.image_data[:, 1, :, :, :] * exp( 1.j * fullphaseimg ) self.image_data.shape = (self.image_data.shape[0], 1, self.image_data.shape[-3], self.image_data.shape[-2], self.image_data.shape[-1]) if (not self.options.outputreps): print("Averaging repetitions...") self.image_data = mean(abs(self.image_data), axis=0)
def add_scanparams_to_mncheader(inputAcq, filename, imouse): print("Adding scan header to minc header...") nmice = inputAcq.nmice if (inputAcq.platform == "Varian"): dparamlist = [ 'sw', 'tr', 'np', 'nv', 'nv2', 'nv_lores', 'nv2_lores', 'ni', 'nf', 'ne', 'etl', 'lro', 'lpe', 'lpe2', 'thk', 'ns', 'phi', 'psi', 'theta', 'fn', 'fn1', 'fn2', 'nmice', 'arrayelements', 'arraydim', 'nD', 'nleaf', 'nfid', 'npetables', 'frac_kx', 'esp', 'sfrq', 'te', 'ti', 'nt', 'ngainlo', 'gainlo', 'gainhi', 'gain', 'pss', 'mm_pro', 'mm_ppe', 'mm_ppe2', 'ppe', 'ppe2', 'pro' ] sparamlist = [ 'array', 'seqfil', 'pslabel', 'orient', 'rfcoil', 'time_submitted', 'petable', 'rcvrs', 'seqcon', 'vrgain', 'acqtype', 'username', 'datestr', 'mmconf', 'dp', 'console', 'console_rev', 'tn', 'protocols' ] image_param = inputAcq.param_dict platform_str = "vnmr" elif (inputAcq.platform == "Bruker"): dparamlist = [ 'PVM_EchoTime', 'PVM_RepetitionTime', 'PVM_NAverages', 'PVM_EffSWh', 'PVM_AcquisitionTime', 'PVM_SliceThick' ] sparamlist = [ 'Method', 'OWNER', 'PVM_ScanTimeStr', 'PVM_Matrix', 'PVM_Fov', 'PVM_SPackArrSliceOrient', 'PVM_SPackArrReadOrient', 'PVM_SPackArrReadOffset', 'PVM_SPackArrPhase1Offset', 'PVM_SPackArrPhase2Offset', 'PVM_SPackArrSliceOffset', 'PVM_SPackArrSliceGap', 'PVM_SPackArrSliceDistance' ] image_param = inputAcq.method_param_dict platform_str = "brkr" for ckey in dparamlist: cval = get_dict_value(image_param, ckey, 0.0) if (hasattr(cval, '__len__')): if ((len(cval) == nmice) or (ckey == "mm_ppe") or (ckey == "mm_ppe2") or (ckey == "mm_pro")): cval = cval[imouse] else: cval = cval[0] cmdstr = 'minc_modify_header -dinsert %s:%s=%f %s > /dev/null' \ % (platform_str,ckey,cval,filename) os.system(cmdstr) cmdstr = 'minc_modify_header -dinsert %s:coil=%f %s > /dev/null' \ % (platform_str,imouse+1,filename) os.system(cmdstr) for ckey in sparamlist: cval = str(get_dict_value(image_param, ckey, "NA")) cmdstr = 'minc_modify_header -sinsert %s:%s="%s" %s > /dev/null' \ % (platform_str,ckey,cval,filename) os.system(cmdstr)
def get_sg_data(inputAcq, imouse): print("Retrieving self-gate data...") sgpts = get_dict_value(inputAcq.param_dict, 'np', 1) / 2 - get_dict_value( inputAcq.param_dict, 'nro', 1) if (sgpts < 1): return 0 sg_fids, data_error = inputAcq.getdatafids( 0, product(inputAcq.data_shape[0:-1]) / inputAcq.nrcvrs, rcvrnum=imouse, nrcvrs=inputAcq.nrcvrs, startpt=0, endpt=sgpts) return sg_fids
def gen_kspace_local(inputAcq, ircvr, nTRs=None): print("Reading k-space data...") nrcvrs = inputAcq.nrcvrs no_ro = inputAcq.nro if ((no_ro <= 0) or (no_ro > inputAcq.data_shape[-1])): no_ro = inputAcq.data_shape[-1] #np #if (len(inputAcq.data_shape)>2) and (inputAcq.data_shape[-3]>0): # npe2 = inputAcq.data_shape[-3] #else: # npe2 = 1 #npe1 = inputAcq.data_shape[-2] if (inputAcq.platform == "Varian"): print("Not setup for Varian acquisition...") raise SystemExit elif (inputAcq.platform == "Bruker" ): #force Bruker to artificial Varian format nf = nTRs nreps = rgf.get_dict_value(inputAcq.method_param_dict, "PVM_NRepetitions", 1) else: print("Input format not recognized.") raw_imgdata = zeros((nreps, 1, nf, no_ro), complex) for k in range(nreps): print("%d / %d" % (k, nreps)) fid_start = k * nf fid_end = (k + 1) * nf fid_data, data_error = inputAcq.getdatafids(fid_start, fid_end, rcvrnum=ircvr) raw_imgdata[k, 0, :, :] = fid_data[:, -no_ro:] if (data_error): data_fraction = float(data_error + fid_start) / float(nf * nreps) print('Error at %f%% through data set' % (100.0 * data_fraction)) break return raw_imgdata
def __init__(self, inputAcq, options, outputfile): self.options = options self.inputAcq = inputAcq self.outputfile = outputfile if ((self.options.petable == '') and (inputAcq.platform == "Varian")): self.petable_name = rgf.get_dict_value(inputAcq.param_dict, 'petable', 'petable') elif ((self.options.petable == '') and (inputAcq.platform == "Bruker")): self.petable_name = rgf.get_dict_value(inputAcq.method_param_dict, 'MICe_InputPetablePath', 'petable') else: self.petable_name = self.options.petable self.kspace = None self.image_data = None self.Pftacq = False
def __init__(self,inputAcq,options,outputfile): self.options=options self.inputAcq=inputAcq self.outputfile=outputfile if ((self.options.petable=='') and (inputAcq.platform=="Varian")): self.petable_name=rgf.get_dict_value(inputAcq.param_dict,'petable','petable') else: self.petable_name=self.options.petable self.kspace=None self.image_data=None
def gen_kspace(self, imouse=0): sgflag = rgf.get_dict_value(self.inputAcq.param_dict, 'sgflag', 'n') if (sgflag == 'y') and self.options.self_resp_gate: sg_fids = rsg.get_sg_data(self.inputAcq, imouse) #from pylab import plot,show #plot(sg_fids[:,3].real) #plot(sg_fids[:,3].imag) #show() tr = rgf.get_dict_value(self.inputAcq.param_dict, 'tr', 0.05) resp_dur = 0.2 resp_gate_sig, resp_sig = rsg.self_resp_gate(sg_fids, tr, resp_dur) else: resp_gate_sig = None resp_sig = None if (self.options.petable_ordered_pairs): grappafov = int( rgf.get_dict_value(self.inputAcq.param_dict, 'grappafov', 1)) self.kspace = rsg.gen_kspace_sg_orderedpairtable( self.inputAcq, resp_gate_sig, resp_sig, imouse, gate_resp=self.options.self_resp_gate, petable=self.petable_name, grappafov=grappafov, kpts_offset=self.options.grappa_kpts_offset, outputreps=self.options.outputreps, phasecorr=self.phasedriftcorr, dcpl_info=self.dcpl_info) elif (sgflag == 'y'): self.kspace = rsg.gen_kspace_sg(self.inputAcq, resp_gate_sig, resp_sig, imouse) else: #sgflag='n' and no petable_ordered_pairs self.kspace = rgf.gen_kspace_simple(self.inputAcq, imouse) self.kspace = rgf.fov_adjustment(self.kspace, self.options, self.inputAcq, imouse) if self.options.fermi_ellipse: self.kspace = rgf.fermi_ellipse_filter(self.kspace) elif self.options.fermi_pecirc: self.kspace = rgf.fermi_pecircle_filter(self.kspace)
def __init__(self, inputAcq, options, outputfile): self.options = options self.inputAcq = inputAcq self.outputfile = outputfile if ((self.options.petable == '') and (inputAcq.platform == "Varian")): self.petable_name = rgf.get_dict_value(inputAcq.param_dict, 'petable', 'petable') else: self.petable_name = self.options.petable self.kspace = None self.image_data = None if (not self.options.dcplppeadj_string): self.dcplppeadj = None else: self.dcplppeadj = [ float(x) for x in self.options.dcplppeadj_string.split(',') ]
def gen_kspace_sg(inputAcq, resp_gate_sig, resp_sig, mousenum, gate_resp=True): print("Generating gated k-space data...") no_ro = inputAcq.data_shape[-1] if (get_dict_value(inputAcq.param_dict, 'sgflag', 'n') == 'y'): no_ro = get_dict_value(inputAcq.param_dict, 'nro', 0) nechoes = get_dict_value(inputAcq.param_dict, 'etl', 1) nfid_pts = inputAcq.data_shape[-1] no_inner_loop = 1 #int(get_dict_value(method_param_dict,'$PVM_NMovieFrames',1)) no_middle_loop = 1 #int(get_dict_value(image_param_dict,'no_middle_loop','1')) no_outer_loop = int(get_dict_value(inputAcq.param_dict, 'nreps', 1)) nexpt = no_inner_loop * no_middle_loop * no_outer_loop if (len(inputAcq.data_shape) > 2): n_slowpe = inputAcq.data_shape[-3] else: n_slowpe = 1 n_fastpe = inputAcq.data_shape[-2] if (nechoes > 1): raw_imgdata = N.zeros((nechoes, n_slowpe, n_fastpe, no_ro), N.complex) else: raw_imgdata = N.zeros((n_slowpe, n_fastpe, no_ro), N.complex) traces_per_file = n_slowpe * n_fastpe * nexpt traces_per_slowpe = n_fastpe * no_inner_loop * no_middle_loop traces_per_fastpe = no_inner_loop #timing for echo locations sgpts = inputAcq.data_shape[-1] - get_dict_value(inputAcq.param_dict, 'nro', 1) start_pt = sgpts end_pt = inputAcq.data_shape[-1] nacq_pts = end_pt - start_pt if (nechoes > 1 ): #need to get this setup so that it finds or reads pts automatically #start_pt=[194,895]; end_pt=[578,1279]; nacq_pts=[384,384]; start_pt = [61, 405] end_pt = [317, 661] nacq_pts = [256, 256] #[68,426] [324,682] [256,256] nrcvrs = inputAcq.nrcvrs #start_pt = int(0.5 + start_time*sw*1e-3*ro_oversample) #nacq_pts = int(0.45+no_ro*fracacqwindow/imgacqwindow) #end_pt = int(start_pt + ro_oversample*nacq_pts) #(echotimes+acqwindow/2.0)*sw*1e-3*ro_oversample for j in range(n_slowpe): print("%d / %d" % (j, n_slowpe)) fid_data = zeros( (traces_per_slowpe * no_outer_loop, inputAcq.data_shape[-1]), complex) resp_flag = zeros((traces_per_slowpe * no_outer_loop, ), float) resp_curr_sig = zeros((traces_per_slowpe * no_outer_loop, ), float) for k in range(no_outer_loop): #range(no_outer_loop) fid_start = j * traces_per_slowpe + k * traces_per_slowpe * n_slowpe fid_end = ( j + 1) * traces_per_slowpe + k * traces_per_slowpe * n_slowpe fid_data_temp, data_error = inputAcq.getdatafids(fid_start, fid_end, rcvrnum=mousenum) if (data_error): data_fraction = float(j) / float(n_slowpe) print('Error at %f%% through data set' % (100.0 * data_fraction)) break fid_data[k * traces_per_slowpe:(k + 1) * traces_per_slowpe, :] = fid_data_temp if (gate_resp): resp_flag[k * traces_per_slowpe:(k + 1) * traces_per_slowpe] = resp_gate_sig[ fid_start:fid_end].astype(N.float) resp_curr_sig[k * traces_per_slowpe:(k + 1) * traces_per_slowpe] = resp_sig[ fid_start:fid_end].astype(N.float) else: resp_flag[k * traces_per_slowpe:(k + 1) * traces_per_slowpe] = N.ones((traces_per_slowpe, ), N.float) fid_shape = (no_outer_loop * no_middle_loop, n_fastpe, traces_per_fastpe, inputAcq.data_shape[-1]) resp_flag = N.reshape(resp_flag, fid_shape[:-1]) resp_curr_sig = N.reshape(resp_curr_sig, fid_shape[:-1]) fid_data = N.reshape(fid_data, fid_shape) norm_val = N.sum(N.sum(resp_flag, axis=0), axis=1) zero_inds = N.nonzero(norm_val == 0)[0] for index in zero_inds: print("|") best_index = argmin(ravel(resp_curr_sig[:, index, :])) resp_flag[best_index / traces_per_fastpe, index, best_index % traces_per_fastpe] = 1 norm_val = N.sum(N.sum(resp_flag, axis=0), axis=1) if (nechoes <= 1): raw_imgdata[j,:,-nacq_pts:] = ( N.sum(N.sum( fid_data[:,:,:,start_pt:end_pt]* \ resp_flag[:,:,N.newaxis] \ ,axis=0),axis=1)/norm_val[:,N.newaxis]).astype(N.complex) else: for k in range(nechoes): raw_imgdata[k,j,:,-nacq_pts[k]:] = ( N.sum(N.sum( fid_data[:,:,:,start_pt[k]:end_pt[k]]* \ resp_flag[:,:,N.newaxis] \ ,axis=0),axis=1)/norm_val[:,N.newaxis]).astype(N.complex) return raw_imgdata
def gen_kspace_sg_orderedpairtable(inputAcq, resp_gate_sig, resp_sig, mousenum, gate_resp=True, petable=None, petable_arrays=('t1', 't2'), grappafov=1, kpts_offset=0, outputreps=False, phasecorr=None, dcpl_info=None): print("Generating gated k-space data...") no_ro = inputAcq.data_shape[-1] if (get_dict_value(inputAcq.param_dict, 'sgflag', 'n') == 'y'): no_ro = get_dict_value(inputAcq.param_dict, 'nro', 0) nechoes = get_dict_value(inputAcq.param_dict, 'etl', 1) nfid_pts = inputAcq.data_shape[-1] nv = int(get_dict_value(inputAcq.param_dict, 'nv', 1)) nv2 = int(get_dict_value(inputAcq.param_dict, 'nv2', 1)) if (petable): t1array = parse_petable_file(petable, petable_arrays[0]) t2array = parse_petable_file(petable, petable_arrays[1]) else: t1array = (N.arange(nv * nv2) % nv) - nv // 2 + 1 t2array = (N.arange(nv * nv2) // nv) - nv2 // 2 + 1 if (outputreps): gate_resp = False #only makes sense to output reps without retrospective gating noutreps = int( mode( array( collections.Counter( t1array + nv // 2 - 1 + nv * (t2array + nv2 // 2 - 1)).most_common())[:, 1])[0] [0]) #count from table rather than looking in procpar else: noutreps = 1 if (nechoes * noutreps > 1): raw_imgdata = N.zeros((nechoes * noutreps, nv2, nv, no_ro), N.complex) else: raw_imgdata = N.zeros((nv2, nv, no_ro), N.complex) #timing for echo locations needs to be improved if (dcpl_info == None): start_pt = [inputAcq.data_shape[-1] - no_ro] end_pt = [inputAcq.data_shape[-1]] else: start_pt = [dcpl_info.rok0index - no_ro // 2] #[0] end_pt = [] for this_start_pt in start_pt: end_pt += [this_start_pt + no_ro] nacq_pts = [end_pt[0] - start_pt[0]] if (nechoes > 1 ): #need to get this setup so that it finds or reads pts automatically #start_pt=[194,895]; end_pt=[578,1279]; nacq_pts=[384,384]; print('Warning: echo timing needs to be setup properly...') start_pt = [61, 405] end_pt = [317, 661] nacq_pts = [256, 256] #[68,426] [324,682] [256,256] nrcvrs = inputAcq.nrcvrs #start_pt = int(0.5 + start_time*sw*1e-3*ro_oversample) #nacq_pts = int(0.45+no_ro*fracacqwindow/imgacqwindow) #end_pt = int(start_pt + ro_oversample*nacq_pts) #(echotimes+acqwindow/2.0)*sw*1e-3*ro_oversample for j in range(nv2): print("%d / %d" % (j, nv2)) for k in range(nv): fidinds = N.nonzero((t2array == ( (j - nv2 // 2 + 1) * grappafov + kpts_offset)) & (t1array == ( (k - nv // 2 + 1) * grappafov + kpts_offset)))[0] #print "gen_kspace_sg_orderedpairtable: ",len(fidinds) if (len(fidinds) == 0): continue nreps = len(fidinds) fid_data = zeros((nreps, inputAcq.data_shape[-1]), complex) #no_ro for q in range(nreps): #fid_data[q,:],data_error = get_vnmr_datafids(vnmrfidfilelist,fidinds[q],fidinds[q]+1, # header_info,startpt=start_pt[0],endpt=end_pt[0],mouse_num=mousenum,nrcvrs=nrcvrs) fid_data[q, :] = get_corrected_datafids(inputAcq, fidinds[q], fidinds[q] + 1, mouse_num=mousenum, phasecorr=phasecorr, dcpl_info=dcpl_info, dcpl_ppe_index=k - nv / 2 + 1) if (gate_resp): resp_flag = resp_gate_sig[fidinds].astype(N.int) resp_curr_sig = resp_sig[fidinds].astype(N.float) else: resp_flag = N.ones((nreps, ), bool) norm_val = N.sum(resp_flag) if (norm_val == 0): print("|") best_index = argmin(resp_curr_sig) resp_flag[best_index] = 1 norm_val = 1 if (nechoes * noutreps <= 1): raw_imgdata[j,k,-nacq_pts[0]:] = N.sum( fid_data[:,start_pt[0]:end_pt[0]]*resp_flag[:,N.newaxis] \ ,axis=0)/norm_val else: repstep = nreps // noutreps rstarts = arange(noutreps) * repstep rends = (1 + arange(noutreps)) * repstep rends = where(rends == rstarts, rstarts + 1, rends) rends[-1] = len(fidinds) for cr in range(noutreps): for q in range(nechoes): raw_imgdata[cr*nechoes+q,j,k,-nacq_pts[q]:] = N.sum( fid_data[rstarts[cr]:rends[cr], start_pt[q]:end_pt[q]]*resp_flag[rstarts[cr]:rends[cr],N.newaxis] \ ,axis=0)/N.sum(resp_flag[rstarts[cr]:rends[cr]]) return raw_imgdata
def write_to_mnc_file(filename, data, inputAcq, options, manstarts=None, mansteps=None, imouse=0, mincversion=2): #output type nrcvrs_per_mouse = len(N.nonzero(inputAcq.rcvrmouse_mapping == imouse)[0]) if options.real: if (data.dtype == complex): out_im = data.real else: out_im = data vType = [options.vType, "short"][options.vType == None] elif options.imag: out_im = data.imag vType = [options.vType, "short"][options.vType == None] elif options.phase: out_im = N.arctan2(data.imag, data.real) vType = [options.vType, "short"][options.vType == None] elif (nrcvrs_per_mouse > 1): print("Sum of squares reconstruction on multiple coils...") if ((inputAcq.nD == 3) or ((inputAcq.nD == 2) and (inputAcq.nslices > 1))): rcvraxis = -4 elif ((inputAcq.nD == 2) and (inputAcq.nslices == 1)): rcvraxis = -3 elif (len(data.shape) > 3): rcvraxis = -4 else: rcvraxis = 0 if (len(data.shape) > inputAcq.nD): out_im = N.sqrt(N.sum(abs(data)**2, axis=rcvraxis)) else: #assume only one coil has been received and that nD==ndims out_im = abs(data) vType = [options.vType, "ushort"][options.vType == None] else: out_im = abs(data) vType = [options.vType, "ushort"][options.vType == None] #dimensions (number and sizes) if (len(out_im.shape) > 4): out_im.shape = (N.prod(out_im.shape[0:(len(out_im.shape) - 3)]), out_im.shape[-3], out_im.shape[-2], out_im.shape[-1]) dim_sizes = out_im.shape nD = len(dim_sizes) if (nD == 2): nout_files = 1 dim_sizes = (1, dim_sizes[0], dim_sizes[1]) out_im.shape = dim_sizes elif (nD < 4): nout_files = 1 else: nout_files = dim_sizes[0] nD = 3 if (inputAcq.platform == "Varian"): #fov and step size fov_array = [ 10.0 * float(get_dict_value(inputAcq.param_dict, x, 1.0)) for x in ['lpe2', 'lpe', 'lro'] ] (fov_ro, fov_pe, fov_pe2) = (fov_array[-1], fov_array[-2], fov_array[-3]) #step & direction step_list = [ fov_pe2 / dim_sizes[-3], fov_pe / dim_sizes[-2], fov_ro / dim_sizes[-1], 1, 1 ] [psi, phi, theta] = [ get_dict_value(inputAcq.param_dict, x, 0) for x in ['psi', 'phi', 'theta'] ] Emat = Eulermat(psi * N.pi / 180, phi * N.pi / 180, theta * N.pi / 180) #did this end up Varian specific?? dim_names = ['zspace', 'yspace', 'xspace'] #default for j in range(3): dim_names[-1 - j] = ['xspace', 'yspace', 'zspace'][N.argmax(abs(Emat[:, j]))] if (Emat[N.argmax(abs(Emat[:, j])), j] < 0): step_list[2 - j] = step_list[2 - j] * (-1) #start point mm_pro = 10.0 * get_dict_value( inputAcq.param_dict, 'mm_pro', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) mm_ppe = 10.0 * get_dict_value( inputAcq.param_dict, 'mm_ppe', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) mm_ppe2 = 10.0 * get_dict_value( inputAcq.param_dict, 'mm_ppe2', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) start_list = [ N.sign(step_list[0]) * mm_ppe2[imouse] - step_list[0] * (0.5 * dim_sizes[-3] - 0.5), N.sign(step_list[1]) * mm_ppe[imouse] - step_list[1] * (0.5 * dim_sizes[-2] - 0.5), N.sign(step_list[2]) * mm_pro[imouse] - step_list[2] * (0.5 * dim_sizes[-1] - 0.5), 0, 0 ] elif (inputAcq.platform == "Bruker"): #fov and step size fov_array = (get_dict_value(inputAcq.method_param_dict, "PVM_Fov", N.array([20.0, 20.0, 20.0], float)).astype(float))[::-1] (fov_ro, fov_pe) = (fov_array[-1], fov_array[-2]) if (inputAcq.nD == 3): fov_pe2 = fov_array[-3] elif (inputAcq.nD == 2): fov_pe2 = get_dict_value( inputAcq.method_param_dict, "PVM_SPackArrSliceDistance", N.array([1.0, 1.0, 1.0], float))[0] * inputAcq.nslices #step & direction dim_names = ['zspace', 'yspace', 'xspace'] stepdirec = N.ones(3) Gmatrix_parse_row = lambda x: (['xspace', 'yspace', 'zspace'][N.argmax( abs(x))], [1, -1][x[N.argmax(abs(x))] < 0]) dim_names[0], stepdirec[0] = Gmatrix_parse_row(inputAcq.gmatrix[2]) dim_names[1], stepdirec[1] = Gmatrix_parse_row(inputAcq.gmatrix[1]) dim_names[2], stepdirec[2] = Gmatrix_parse_row(inputAcq.gmatrix[0]) #dim_names=['zspace','yspace','xspace'] #default #sliceorient=get_dict_value(inputAcq.method_param_dict,'PVM_SPackArrSliceOrient',['axial'])[0] #dim_names[0]={'sagittal': 'xspace', 'coronal': 'yspace', 'axial': 'zspace'}[sliceorient] #readorient=get_dict_value(inputAcq.method_param_dict,'PVM_SPackArrReadOrient',['H_F'])[0] #dim_names[2]={'H_F': 'zspace','L_R': 'xspace', 'D_V': 'yspace'}[readorient] #what is yspace flag??? can we have F_H??? #dim_names[1]=list(set(['zspace','yspace','xspace'])-set([dim_names[0],dim_names[2]]))[0] step_list = [ fov_pe2 * stepdirec[-3] / dim_sizes[-3], fov_pe * stepdirec[-2] / dim_sizes[-2], fov_ro * stepdirec[-1] / dim_sizes[-1], 1, 1 ] #start point mm_pro = get_dict_value(inputAcq.method_param_dict, 'MICe_ReadOffset', N.array([0.0, 0.0, 0.0, 0.0], float)) mm_ppe = get_dict_value(inputAcq.method_param_dict, 'MICe_Phase1Offset', N.array([0.0, 0.0, 0.0, 0.0], float)) if (inputAcq.nD == 3): #mm_ppe2 = get_dict_value(inputAcq.method_param_dict,'MICe_Phase2Offset',N.array([0.0,0.0,0.0,0.0],float)) mm_ppe2 = get_dict_value(inputAcq.method_param_dict, 'MICe_SliceOffset', N.array([0.0, 0.0, 0.0, 0.0], float)) elif (inputAcq.nD == 2): mm_ppe2 = get_dict_value(inputAcq.method_param_dict, 'MICe_SliceOffset', N.array([0.0, 0.0, 0.0, 0.0], float)) else: mm_ppe2 = N.array([0.0, 0.0, 0.0, 0.0], float) start_list = [ N.sign(step_list[0]) * mm_ppe2[imouse] - step_list[0] * (0.5 * dim_sizes[-3] - 0.5), N.sign(step_list[1]) * mm_ppe[imouse] - step_list[1] * (0.5 * dim_sizes[-2] - 0.5), N.sign(step_list[2]) * mm_pro[imouse] - step_list[2] * (0.5 * dim_sizes[-1] - 0.5), 0, 0 ] else: print("Platform not recognized as Varian or Bruker") if (options.fft2d): #loop order: slice,pe1,ro if (inputAcq.platform == "Varian"): slice_sep = float(get_dict_value( inputAcq.param_dict, 'thk', 1.0)) #this isn't strictly the right parameter to use... elif (inputAcq.platform == "Bruker"): slice_sep = float( get_dict_value(inputAcq.method_param_dict, 'PVM_SPackArrSliceDistance', [0.0])[0]) start_list[0] = -dim_sizes[ -3] * slice_sep / 2.0 #this is not set up properly for 2D imaging yet... step_list[0] = slice_sep elif (options.nofft): #nofft if (fov_pe2 > 1e-6): steppe2 = 1.0 / fov_pe2 startpe2 = -dim_sizes[-3] * steppe2 / 2 else: steppe2 = 1.0 startpe2 = 0 step_list = [steppe2, 1.0 / fov_pe, 1.0 / fov_ro, 1, 1] start_list = [ startpe2, -dim_sizes[-2] / fov_pe, -dim_sizes[-1] / fov_ro ] #intensity scaling if (options.image_range_max - options.image_range_min > 1e-4): print("Using user-input intensity range...") (Imin, Imax) = (options.image_range_min, options.image_range_max) for j in range(dim_sizes[0]): out_im[j] = N.where(N.greater(out_im[j], options.image_range_max), options.image_range_max, out_im[j]).astype(float) out_im[j] = N.where(N.less(out_im[j], options.image_range_min), options.image_range_min, out_im[j]).astype(float) else: N_voxels = N.size(out_im) flat_out = N.reshape(out_im, (N_voxels, )) Imin = min(flat_out) if options.max_range: Imax = max(flat_out) else: plane_maxima = N.ravel(N.maximum.reduce(out_im, axis=-1)) plane_maxima = medfilt(plane_maxima, 11) Imax = 1.1 * N.maximum.reduce(plane_maxima) indices = N.nonzero(N.greater(flat_out, Imax)) N.put(flat_out, indices, Imax) #override of starts and steps if (manstarts != None): start_list = list(manstarts) if (mansteps != None): step_list = list(mansteps) #loop over output files for j in range(nout_files): #index output (for multiple echoes, repetitions, phases, etc) if (nout_files == 1): outfile_name = filename imgshape = dim_sizes else: outfile_name = filename[:-4] + '_' + str(j) + '.mnc' imgshape = dim_sizes[1:] print("Writing to output file %s..." % outfile_name) #minc1 or minc2 output if (mincversion != 2): print("Sorry, minc1 isn't an option.") spatDim = 3 #print outfile_name,dim_names,imgshape,tuple(start_list[0:spatDim]),tuple(step_list[0:spatDim]),vType,out_im.dtype,out_im.shape mnc_vol = volumeFromDescription(outfile_name, dim_names, imgshape, tuple(start_list[0:spatDim]), tuple(step_list[0:spatDim]), volumeType=vType, dtype=out_im.dtype) if (nout_files == 1): mnc_vol.setdata(out_im) else: mnc_vol.setdata(out_im[j]) mnc_vol.writeFile() mnc_vol.closeVolume() #add scan params to mnc header add_scanparams_to_mncheader(inputAcq, outfile_name, imouse) return nout_files