#Get timepoints for SUVR window startTime = timePred[np.where(petPredD > 10)[0][0]] endTime = startTime + args.window[0] suvrTime = np.linspace(startTime, endTime, 100) #Get new basis suvrBasis = nagini.rSplineBasis(suvrTime, petKnots) #Get fits at each voxel voxX, _, _, _ = np.linalg.lstsq(petBasis, petMasked.T) #Get predictions at each voxel voxPred = np.dot(suvrBasis, voxX) #Get WB suvr image voxSum = np.sum(voxPred, axis=0) voxSum = voxSum / np.mean(voxSum) #Write out image nagini.writeMaskedImage(voxSum, mask.shape, maskData, pet.affine, pet.header, '%s_suvrSpline' % (args.out[0])) #For comparision calculate non-smoothed SUVR startFrame = np.where(petTime >= startTime)[0][0] endFrame = np.where(petTime <= endTime)[0][-1] petSum = np.sum(petMasked[:, startFrame:(endFrame + 1)], axis=1) petSum = petSum / np.mean(petSum) nagini.writeMaskedImage(petSum, mask.shape, maskData, pet.affine, pet.header, '%s_suvr' % (args.out[0]))
pet.affine, header=pet.header) #Then do the writing try: outImg.to_filename('%s.nii.gz' % (pName)) except (IOError): print 'ERROR: Cannot save image at %s.' % (pName) sys.exit() #Write out root mean square images nib.Nifti1Image(roiParams[:, -1], affine=np.identity(4)).to_filename( '%s_%s.nii.gz' % (args.out[0], paramNames[-1])) if args.noVox != 1: nagini.writeMaskedImage(voxParams[:, -1], maskData.shape, maskData, pet.affine, pet.header, '%s_%s' % (args.out[0], paramNames[-1])) #Write out chosen arguments nagini.writeArgs(args, args.out[0]) #Convergence output try: #Open file cOut = open('%s_convergence.txt' % (args.out[0]), "w") #Write out ROI data cOut.write('%i of %i\n' % (roiC, nRoi)) #Write out voxel data if necessary if args.noVox != 1:
#Calculate residual with delay fitResid = voxTac - voxFitted #Calculate normalized root mean square deviation fitRmsd = np.sqrt(np.sum(np.power(fitResid,2))/voxTac.shape[0]) / np.mean(voxTac) #Save residual fitParams[voxIdx,-1] = fitRmsd except(RuntimeError,ValueError): noC += 1 #Warn user about lack of convergence if noC > 0: print('Warning: %i of %i voxels did not converge.'%(noC,nVox)) ############# ###Output!### ############# print('Writing out results...') #Set names for model images paramNames = ['gef','kOne','kTwo','kThree','kFour','cmrGlu','alphaOne','alphaTwo','betaOne','betaTwo','netEx','influx','DV','conc','delay','nRmsd'] #Do the writing. For now, doesn't write variance images. for iIdx in range(fitParams.shape[1]-1): nagini.writeMaskedImage(fitParams[:,iIdx],maskData.shape,maskData,pet.affine,pet.header,'%s_%s'%(args.out[0],paramNames[iIdx])) nagini.writeMaskedImage(fitParams[:,-1],maskData.shape,maskData,pet.affine,pet.header,'%s_%s'%(args.out[0],paramNames[-1])) nagini.writeArgs(args,args.out[0])
#Set names for model images if args.poly is True: paramNames = ['CBF'] fitParams = voxCbf[:, np.newaxis] else: paramNames = wbLabels if args.fModel != 1: paramNames.remove('Dispersion') paramNames.remove('Delay') paramNames.append('nRmsd') #Output images for iIdx in range(fitParams.shape[1]): nagini.writeMaskedImage(fitParams[:, iIdx], brainData.shape, brainData, pet.affine, pet.header, '%s_%s' % (args.out[0], paramNames[iIdx])) #Compute extraction if necessary if args.ps is not None: if args.poly is True: voxEx = voxCbf / cbfMasked else: voxEx = 1.0 - np.exp(fitParams[:, 0] / -cbfMasked) nagini.writeMaskedImage(voxEx, brainData.shape, brainData, pet.affine, pet.header, '%s_extraction' % (args.out[0])) #Compute PSw if we used polynomial regression method if args.poly is True: voxPSw = -cbfMasked * np.log(1.0 - voxEx) nagini.writeMaskedImage(voxPSw, brainData.shape, brainData, pet.affine,
fitParams[voxIdx,4] = ((voxFit[0][0]*cbfMasked[voxIdx]*voxFit[0][2])/(voxFit[0][1]+voxFit[0][2]))*gluScale #Save parameter variances. Use delta method to get cmrGlu and k1 variance fitParams[voxIdx,5:8] = np.diag(voxFit[1]) fitParams[voxIdx,8] = voxFit[1][0][0] * np.power(cbfMasked[voxIdx],2) gluGrad = np.array([(gluScale*cbfMasked[voxIdx]*voxFit[0][2])/(voxFit[0][1]+voxFit[0][2]), (-1*voxFit[0][0]*voxFit[0][2]*gluScale*cbfMasked[voxIdx])/np.power(voxFit[0][1]+voxFit[0][2],2), (voxFit[0][0]*voxFit[0][1]*gluScale*cbfMasked[voxIdx])/np.power(voxFit[0][1]+voxFit[0][2],2)]) fitParams[voxIdx,9] = np.dot(np.dot(gluGrad.T,voxFit[1]),gluGrad) #Get normalized root mean square deviation fitResid = voxTac - voxFunc(fitX,voxFit[0][0],voxFit[0][1],voxFit[0][2]) fitRmsd = np.sqrt(np.sum(np.power(fitResid,2))/voxTac.shape[0]) fitParams[voxIdx,10] = fitRmsd / np.mean(voxTac) except(RuntimeError): noC += 1 #Warn user about lack of convergence if noC > 0: print('Warning: %i of %i voxels did not converge.'%(noC,nVox)) ############# ###Output!### ############# print('Writing out results...') #Write out two parameter model images for iIdx in range(len(imgNames)): nagini.writeMaskedImage(fitParams[:,iIdx],brain.shape,brainData,pet.affine,pet.header,'%s_%s'%(args.out[0],imgNames[iIdx]))
cbfMasked[voxIdx]) / np.power(voxFit[0][1] + voxFit[0][2], 2), (voxFit[0][0] * voxFit[0][1] * gluScale * cbfMasked[voxIdx]) / np.power(voxFit[0][1] + voxFit[0][2], 2) ]) fitParams[voxIdx, 9] = np.dot(np.dot(gluGrad.T, voxFit[1]), gluGrad) #Get normalized root mean square deviation fitResid = voxTac - voxFunc(fitX, voxFit[0][0], voxFit[0][1], voxFit[0][2]) fitRmsd = np.sqrt(np.sum(np.power(fitResid, 2)) / voxTac.shape[0]) fitParams[voxIdx, 10] = fitRmsd / np.mean(voxTac) except (RuntimeError): noC += 1 #Warn user about lack of convergence if noC > 0: print('Warning: %i of %i voxels did not converge.' % (noC, nVox)) ############# ###Output!### ############# print('Writing out results...') #Write out two parameter model images for iIdx in range(len(imgNames)): nagini.writeMaskedImage(fitParams[:, iIdx], brain.shape, brainData, pet.affine, pet.header, '%s_%s' % (args.out[0], imgNames[iIdx]))
endTime = startTime + args.window[0] suvrTime = np.linspace(startTime,endTime,100) #Get new basis suvrBasis = nagini.rSplineBasis(suvrTime,petKnots) #Get fits at each voxel voxX,_,_,_ = np.linalg.lstsq(petBasis,petMasked.T) #Get predictions at each voxel voxPred = np.dot(suvrBasis,voxX) #Get WB suvr image voxSum = np.sum(voxPred,axis=0); voxSum = voxSum / np.mean(voxSum) #Write out image nagini.writeMaskedImage(voxSum,mask.shape,maskData,pet.affine,pet.header,'%s_suvrSpline'%(args.out[0])) #For comparision calculate non-smoothed SUVR startFrame = np.where(petTime>=startTime)[0][0] endFrame = np.where(petTime<=endTime)[0][-1] petSum = np.sum(petMasked[:,startFrame:(endFrame+1)],axis=1) petSum = petSum / np.mean(petSum) nagini.writeMaskedImage(petSum,mask.shape,maskData,pet.affine,pet.header,'%s_suvr'%(args.out[0]))
#Write out polynomial matrix np.savetxt('%s_polyMat.txt'%(args.out[0]),np.hstack((polyX,cbfPred[:,np.newaxis]))) #Polynomial regression coefficients coefOut = open('%s_polyCoef.txt'%(args.out[0]), "w") coefOut.write(coefString) coefOut.close() except(IOError): print 'ERROR: Cannot write in output directory. Exiting...' sys.exit() #Don't do voxelwise estimation if user says not to if args.wbOnly == 1: sys.exit() #Integrate all the pet data petInt = np.trapz(petMasked,petTime,axis=1) #Get matrix for flow predictions petMat = np.stack((petInt,np.power(petInt,2)),axis=1) #Get flow predictions at each voxel petFlow = petMat.dot(polyCoef) #Write out fow image nagini.writeMaskedImage(petFlow,brain.shape,brainData,pet.affine,pet.header,'%s_flow'%(args.out[0]))
#Don't do voxelwise estimation if user says not to if args.wbOnly == 1: sys.exit() #Integreate pet tacs voxInt = np.trapz(petMasked,petTime,axis=1) #Create arrays for results voxOef = np.zeros_like(cbfMasked) voxOxy = np.zeros_like(cbfMasked) voxResid = np.zeros_like(cbfMasked) #Loop through voxels for voxIdx in tqdm(range(cbfMasked.shape[0])): #Make regressors for voxel voxX = ((1 - (0.835*cbfMasked[voxIdx]/lmbda))*cbfMasked[voxIdx]*aifOxyInt) - \ (0.835*cbvMasked[voxIdx]*aifOxyInterp) voxY = petMasked[voxIdx,:] + (cbfMasked[voxIdx]/lmbda*voxInt[voxIdx]) - (cbvMasked[voxIdx]*aifOxyInterp) \ - (cbvMasked[voxIdx]*cbvMasked[voxIdx]/lmbda*aifOxyInt) - (cbfMasked[voxIdx]*aifWaterInt) #Run voxelwise regression voxOef[voxIdx],voxResid[voxIdx] = opt.nnls(voxX[:,np.newaxis],voxY) #Get CMRO2 voxOxy[voxIdx] = voxOef[voxIdx] * cbfMasked[voxIdx] * oxyScale #Write out images nagini.writeMaskedImage(voxOef,brain.shape,brainData,pet.affine,pet.header,'%s_oefnn'%(args.out[0])) nagini.writeMaskedImage(voxOxy,brain.shape,brainData,pet.affine,pet.header,'%s_cmrOxynn'%(args.out[0]))
#Create aif figure try: plt.clf() fig = plt.figure(1) plt.scatter(aifTime, aifC, s=40, c="black") plt.plot(aifTime, np.dot(aifBasis, aifCoefs), linewidth=5, label='Spline Fit') plt.xlabel('Time (seconds)') plt.ylabel('Counts') plt.title('Arterial Sampled Input function') plt.legend(loc='upper right') plt.suptitle(args.out[0]) plt.savefig('%s_aifPlot.jpeg' % (args.out[0]), bbox_inches='tight') except (RuntimeError, IOError): print 'ERROR: Could not save figure. Moving on...' #Don't do voxelwise estimation if user says not to if args.wbOnly == 1: nagini.writeArgs(args, args.out[0]) sys.exit() #Calculate voxelwise CBV cbvData = petMasked * cbvScale #Write out CBV image nagini.writeMaskedImage(cbvData, brainData.shape, brainData, pet.affine, pet.header, '%s_cbv' % (args.out[0])) nagini.writeArgs(args, args.out[0])
#Write out polynomial matrix np.savetxt('%s_polyMat.txt' % (args.out[0]), np.hstack((polyX, cbfPred[:, np.newaxis]))) #Polynomial regression coefficients coefOut = open('%s_polyCoef.txt' % (args.out[0]), "w") coefOut.write(coefString) coefOut.close() except (IOError): print 'ERROR: Cannot write in output directory. Exiting...' sys.exit() #Don't do voxelwise estimation if user says not to if args.wbOnly == 1: sys.exit() #Integrate all the pet data petInt = np.trapz(petMasked, petTime, axis=1) #Get matrix for flow predictions petMat = np.stack((petInt, np.power(petInt, 2)), axis=1) #Get flow predictions at each voxel petFlow = petMat.dot(polyCoef) #Write out fow image nagini.writeMaskedImage(petFlow, brain.shape, brainData, pet.affine, pet.header, '%s_flow' % (args.out[0]))
#Load image headers pet = nagini.loadHeader(args.pet[0]) brain = nagini.loadHeader(args.brain[0]) #Check to make sure image dimensions match if pet.shape[0:3] != brain.shape[0:3]: print 'ERROR: Image dimensions do not match. Please check data...' sys.exit() #Get the image data petData = pet.get_data() brainData = brain.get_data() #Load in the idaif. idaif = nagini.loadIdaif(args.idaif[0]) #Flatten the PET images and then mask petMasked = petData.flatten()[brainData.flatten()>0] ############ ###Output### ############ #Calculate CBV in mL/hG cbvData = (petMasked * 100.0 ) / (args.r*args.d*idaif) #Write out CBV image nagini.writeMaskedImage(cbvData,brain.shape,brainData,pet.affine,pet.header,'%s_cbv'%(args.out[0]))
sys.exit() #Integreate pet tacs voxInt = np.trapz(petMasked, petTime, axis=1) #Create arrays for results voxOef = np.zeros_like(cbfMasked) voxOxy = np.zeros_like(cbfMasked) voxResid = np.zeros_like(cbfMasked) #Loop through voxels for voxIdx in tqdm(range(cbfMasked.shape[0])): #Make regressors for voxel voxX = ((1 - (0.835*cbfMasked[voxIdx]/lmbda))*cbfMasked[voxIdx]*aifOxyInt) - \ (0.835*cbvMasked[voxIdx]*aifOxyInterp) voxY = petMasked[voxIdx,:] + (cbfMasked[voxIdx]/lmbda*voxInt[voxIdx]) - (cbvMasked[voxIdx]*aifOxyInterp) \ - (cbvMasked[voxIdx]*cbvMasked[voxIdx]/lmbda*aifOxyInt) - (cbfMasked[voxIdx]*aifWaterInt) #Run voxelwise regression voxOef[voxIdx], voxResid[voxIdx] = opt.nnls(voxX[:, np.newaxis], voxY) #Get CMRO2 voxOxy[voxIdx] = voxOef[voxIdx] * cbfMasked[voxIdx] * oxyScale #Write out images nagini.writeMaskedImage(voxOef, brain.shape, brainData, pet.affine, pet.header, '%s_oefnn' % (args.out[0])) nagini.writeMaskedImage(voxOxy, brain.shape, brainData, pet.affine, pet.header, '%s_cmrOxynn' % (args.out[0]))