├── .DS_Store ├── BCS ├── demo_BCS.m └── utils │ ├── A_fhp_2d.m │ ├── At_fhp_2d.m │ ├── Eval_Vleft.m │ ├── Eval_gradUleft.m │ ├── Lsubproblem.m │ ├── RMSE.m │ ├── def_phi_phit.m │ ├── def_phi_phit_ID.m │ ├── sp_TV_eval.m │ └── t1rho_t2MapsCalc_ver2.m ├── DC_CS ├── demo_DC_CS.m └── utils │ ├── A_fhp3D.m │ ├── At_fhp3D.m │ ├── RMSE_cal.m │ ├── defDDtmodGPU.m │ ├── demon_function_dynamic_nofig.m │ ├── demon_registration_version_8f │ ├── basic_demon_example.m │ ├── basic_demon_example.m~ │ ├── compile_c_files.m │ ├── demon_reg.m │ ├── functions │ │ ├── MutualTransform.m │ │ ├── backwards2forwards.m │ │ ├── backwards2forwards_2d_double.c │ │ ├── backwards2forwards_2d_double.m │ │ ├── backwards2forwards_3d_double.c │ │ ├── backwards2forwards_3d_single.c │ │ ├── demons_energy.m │ │ ├── fminlbfgs.m │ │ ├── imgaussian.m │ │ ├── imresize3d.m │ │ ├── mutual_histogram_double.c │ │ ├── mutual_histogram_double.m │ │ ├── mutual_histogram_single.c │ │ ├── mutual_transform_2d_double.asv │ │ ├── mutual_transform_2d_double.c │ │ ├── mutual_transform_2d_double.m │ │ ├── mutual_transform_3d_double.asv │ │ ├── mutual_transform_3d_double.c │ │ ├── mutual_transform_3d_single.asv │ │ ├── mutual_transform_3d_single.c │ │ ├── showcs3.fig │ │ ├── showcs3.m │ │ ├── store_transf.m │ │ └── strain.m │ ├── functions_affine │ │ ├── affine_error_3d_double.c │ │ ├── affine_error_3d_single.c │ │ ├── affine_registration_error.m │ │ ├── affine_registration_image.m │ │ ├── affine_transform.m │ │ ├── affine_transform_2d_double.c │ │ ├── affine_transform_2d_double.m │ │ ├── affine_transform_3d_double.c │ │ ├── affine_transform_3d_single.c │ │ ├── image_difference.m │ │ ├── image_interpolation.c │ │ ├── image_interpolation.h │ │ ├── make_transformation_matrix.m │ │ ├── squared_difference_double.c │ │ ├── squared_difference_double.m │ │ └── squared_difference_single.c │ ├── functions_nonrigid │ │ ├── image_interpolation.c │ │ ├── image_interpolation.h │ │ ├── movepixels.m │ │ ├── movepixels_2d_double.c │ │ ├── movepixels_2d_double.m │ │ ├── movepixels_3d_double.c │ │ └── movepixels_3d_single.c │ ├── images │ │ ├── brain_FA.png │ │ ├── brain_FLAIR.png │ │ ├── brain_MD.png │ │ ├── brain_T1.png │ │ ├── brain_T1_wave.png │ │ ├── brain_T2.png │ │ ├── brain_T2_wave.png │ │ ├── checkboard2.png │ │ ├── checkboard3.png │ │ ├── checkboard4.png │ │ ├── get_example_data.m │ │ ├── lenag1.png │ │ ├── lenag2.png │ │ ├── lenag3.png │ │ ├── modtest1.png │ │ ├── modtest2.png │ │ ├── modtest3.png │ │ └── wave_field.mat │ ├── license.txt │ ├── literature │ │ ├── Kroon_Paper_Boston.pdf │ │ └── Kroon_Poster_Boston.pdf │ ├── register_images.m │ ├── register_speech.m │ ├── register_speech.m~ │ └── register_volumes.m │ ├── fsub_CG.m │ ├── g_motionsub_mod_boundarycorrection.m │ ├── goldenratio_samp.m │ ├── scale.m │ ├── spatialTV_lines_lam_20_4e-09.mat │ ├── spatialTV_lines_lam_24_4e-09.mat │ ├── theta_backward.m │ └── theta_forward.m ├── MUSSELS ├── demo_IRLS_MUSSELS.m └── utils │ ├── fft2.m │ ├── fft2c.m │ ├── getHankel.m │ ├── ifft2c.m │ ├── im2row.m │ ├── invHankel.m │ ├── mussels_cs.m │ ├── row2im.m │ ├── row2im_tpose.m │ ├── sos.m │ ├── unchop.m │ └── zpad.m ├── PRICE ├── demo_PRICE.m └── utils │ ├── A_fhp3Dmulticoil.m │ ├── Ah_fhp3Dmulticoil.m │ ├── L1_sat.m │ ├── README.md │ ├── Readme.pdf │ ├── computeDtD.m │ ├── giveH.m │ ├── initializeVariables.m │ ├── lefthand.m │ ├── nlm_simple2.m │ └── shrinkage_L1_sat.m ├── README.md ├── SpiralSToRM ├── @NUFFT │ ├── NUFFT.m │ ├── ctranspose.m │ ├── mtimes.m │ ├── times.m │ └── transpose.m ├── @gpuNUFFT │ ├── ctranspose.m │ ├── gpuNUFFT.m │ ├── mtimes.m │ ├── private │ │ ├── gpuNUFFT_adj.m │ │ ├── gpuNUFFT_forw.m │ │ ├── mex_gpuNUFFT_adj_atomic_f.mexa64 │ │ ├── mex_gpuNUFFT_adj_f.mexa64 │ │ ├── mex_gpuNUFFT_forw_atomic_f.mexa64 │ │ ├── mex_gpuNUFFT_forw_f.mexa64 │ │ └── mex_gpuNUFFT_precomp_f.mexa64 │ └── transpose.m ├── CUDA │ ├── CMakeLists.txt │ ├── bin │ │ ├── cvp │ │ │ ├── Gridding3D.cvp │ │ │ └── README │ │ ├── gtest_options │ │ ├── libgpuNUFFT_ATM_f.so │ │ ├── libgpuNUFFT_f.so │ │ ├── mex_gpuNUFFT_adj_atomic_f.mexa64 │ │ ├── mex_gpuNUFFT_adj_f.mexa64 │ │ ├── mex_gpuNUFFT_forw_atomic_f.mexa64 │ │ ├── mex_gpuNUFFT_forw_f.mexa64 │ │ ├── mex_gpuNUFFT_precomp_f.mexa64 │ │ ├── run_cpu_filtered_unit_test.cmd │ │ ├── run_cuda_memcheck │ │ └── run_gpu_filtered_unit_test.cmd │ ├── build │ │ ├── CMakeCache.txt │ │ ├── CMakeFiles │ │ │ ├── 2.8.12.2 │ │ │ │ ├── CMakeCCompiler.cmake │ │ │ │ ├── CMakeCXXCompiler.cmake │ │ │ │ ├── CMakeDetermineCompilerABI_C.bin │ │ │ │ ├── CMakeDetermineCompilerABI_CXX.bin │ │ │ │ ├── CMakeSystem.cmake │ │ │ │ ├── CompilerIdC │ │ │ │ │ ├── CMakeCCompilerId.c │ │ │ │ │ └── a.out │ │ │ │ └── CompilerIdCXX │ │ │ │ │ ├── CMakeCXXCompilerId.cpp │ │ │ │ │ └── a.out │ │ │ ├── CMakeDirectoryInformation.cmake │ │ │ ├── CMakeOutput.log │ │ │ ├── CMakeRuleHashes.txt │ │ │ ├── Makefile.cmake │ │ │ ├── Makefile2 │ │ │ ├── TargetDirectories.txt │ │ │ ├── cmake.check_cache │ │ │ └── progress.marks │ │ ├── Makefile │ │ ├── cmake_install.cmake │ │ ├── doc │ │ │ ├── CMakeFiles │ │ │ │ ├── CMakeDirectoryInformation.cmake │ │ │ │ ├── doc.dir │ │ │ │ │ ├── DependInfo.cmake │ │ │ │ │ ├── build.make │ │ │ │ │ ├── cmake_clean.cmake │ │ │ │ │ └── progress.make │ │ │ │ └── progress.marks │ │ │ ├── Makefile │ │ │ └── cmake_install.cmake │ │ └── src │ │ │ ├── CMakeFiles │ │ │ ├── CMakeDirectoryInformation.cmake │ │ │ └── progress.marks │ │ │ ├── Makefile │ │ │ ├── cmake_install.cmake │ │ │ └── gpu │ │ │ ├── CMakeFiles │ │ │ ├── CMakeDirectoryInformation.cmake │ │ │ └── progress.marks │ │ │ ├── Makefile │ │ │ ├── atomic │ │ │ ├── CMakeFiles │ │ │ │ ├── CMakeDirectoryInformation.cmake │ │ │ │ ├── gpuNUFFT_ATM_f.dir │ │ │ │ │ ├── CXX.includecache │ │ │ │ │ ├── DependInfo.cmake │ │ │ │ │ ├── __ │ │ │ │ │ │ ├── __ │ │ │ │ │ │ │ ├── balanced_gpuNUFFT_operator.cpp.o │ │ │ │ │ │ │ ├── balanced_texture_gpuNUFFT_operator.cpp.o │ │ │ │ │ │ │ ├── gpuNUFFT_operator.cpp.o │ │ │ │ │ │ │ ├── gpuNUFFT_operator_factory.cpp.o │ │ │ │ │ │ │ ├── gpuNUFFT_utils.cpp.o │ │ │ │ │ │ │ └── texture_gpuNUFFT_operator.cpp.o │ │ │ │ │ │ ├── gpuNUFFT_ATM_f_generated_precomp_kernels.cu.o │ │ │ │ │ │ ├── gpuNUFFT_ATM_f_generated_precomp_kernels.cu.o.cmake │ │ │ │ │ │ └── gpuNUFFT_ATM_f_generated_precomp_kernels.cu.o.depend │ │ │ │ │ ├── build.make │ │ │ │ │ ├── cmake_clean.cmake │ │ │ │ │ ├── depend.internal │ │ │ │ │ ├── depend.make │ │ │ │ │ ├── flags.make │ │ │ │ │ ├── gpuNUFFT_ATM_f_generated_atomic_gpuNUFFT.cu.o │ │ │ │ │ ├── gpuNUFFT_ATM_f_generated_atomic_gpuNUFFT.cu.o.cmake │ │ │ │ │ ├── gpuNUFFT_ATM_f_generated_atomic_gpuNUFFT.cu.o.depend │ │ │ │ │ ├── link.txt │ │ │ │ │ └── progress.make │ │ │ │ └── progress.marks │ │ │ ├── Makefile │ │ │ └── cmake_install.cmake │ │ │ ├── cmake_install.cmake │ │ │ ├── coarse │ │ │ ├── CMakeFiles │ │ │ │ ├── CMakeDirectoryInformation.cmake │ │ │ │ ├── gpuNUFFT_f.dir │ │ │ │ │ ├── CXX.includecache │ │ │ │ │ ├── DependInfo.cmake │ │ │ │ │ ├── __ │ │ │ │ │ │ ├── __ │ │ │ │ │ │ │ ├── balanced_gpuNUFFT_operator.cpp.o │ │ │ │ │ │ │ ├── balanced_texture_gpuNUFFT_operator.cpp.o │ │ │ │ │ │ │ ├── gpuNUFFT_operator.cpp.o │ │ │ │ │ │ │ ├── gpuNUFFT_operator_factory.cpp.o │ │ │ │ │ │ │ ├── gpuNUFFT_utils.cpp.o │ │ │ │ │ │ │ └── texture_gpuNUFFT_operator.cpp.o │ │ │ │ │ │ ├── gpuNUFFT_f_generated_precomp_kernels.cu.o │ │ │ │ │ │ ├── gpuNUFFT_f_generated_precomp_kernels.cu.o.cmake │ │ │ │ │ │ └── gpuNUFFT_f_generated_precomp_kernels.cu.o.depend │ │ │ │ │ ├── build.make │ │ │ │ │ ├── cmake_clean.cmake │ │ │ │ │ ├── depend.internal │ │ │ │ │ ├── depend.make │ │ │ │ │ ├── flags.make │ │ │ │ │ ├── gpuNUFFT_f_generated_coarse_gpuNUFFT.cu.o │ │ │ │ │ ├── gpuNUFFT_f_generated_coarse_gpuNUFFT.cu.o.cmake │ │ │ │ │ ├── gpuNUFFT_f_generated_coarse_gpuNUFFT.cu.o.depend │ │ │ │ │ ├── link.txt │ │ │ │ │ └── progress.make │ │ │ │ └── progress.marks │ │ │ ├── Makefile │ │ │ └── cmake_install.cmake │ │ │ └── matlab │ │ │ ├── CMakeFiles │ │ │ ├── CMakeDirectoryInformation.cmake │ │ │ ├── mex_gpuNUFFT_adj_atomic_f.dir │ │ │ │ ├── CXX.includecache │ │ │ │ ├── DependInfo.cmake │ │ │ │ ├── build.make │ │ │ │ ├── cmake_clean.cmake │ │ │ │ ├── depend.internal │ │ │ │ ├── depend.make │ │ │ │ ├── flags.make │ │ │ │ ├── gpuNUFFT_adj.cpp.o │ │ │ │ ├── gpuNUFFT_operator_matlabfactory.cpp.o │ │ │ │ ├── link.txt │ │ │ │ └── progress.make │ │ │ ├── mex_gpuNUFFT_adj_f.dir │ │ │ │ ├── CXX.includecache │ │ │ │ ├── DependInfo.cmake │ │ │ │ ├── build.make │ │ │ │ ├── cmake_clean.cmake │ │ │ │ ├── depend.internal │ │ │ │ ├── depend.make │ │ │ │ ├── flags.make │ │ │ │ ├── gpuNUFFT_adj.cpp.o │ │ │ │ ├── gpuNUFFT_operator_matlabfactory.cpp.o │ │ │ │ ├── link.txt │ │ │ │ └── progress.make │ │ │ ├── mex_gpuNUFFT_forw_atomic_f.dir │ │ │ │ ├── CXX.includecache │ │ │ │ ├── DependInfo.cmake │ │ │ │ ├── build.make │ │ │ │ ├── cmake_clean.cmake │ │ │ │ ├── depend.internal │ │ │ │ ├── depend.make │ │ │ │ ├── flags.make │ │ │ │ ├── gpuNUFFT_forw.cpp.o │ │ │ │ ├── gpuNUFFT_operator_matlabfactory.cpp.o │ │ │ │ ├── link.txt │ │ │ │ └── progress.make │ │ │ ├── mex_gpuNUFFT_forw_f.dir │ │ │ │ ├── CXX.includecache │ │ │ │ ├── DependInfo.cmake │ │ │ │ ├── build.make │ │ │ │ ├── cmake_clean.cmake │ │ │ │ ├── depend.internal │ │ │ │ ├── depend.make │ │ │ │ ├── flags.make │ │ │ │ ├── gpuNUFFT_forw.cpp.o │ │ │ │ ├── gpuNUFFT_operator_matlabfactory.cpp.o │ │ │ │ ├── link.txt │ │ │ │ └── progress.make │ │ │ └── progress.marks │ │ │ ├── Makefile │ │ │ ├── cmake_install.cmake │ │ │ └── precomputation │ │ │ ├── CMakeFiles │ │ │ ├── CMakeDirectoryInformation.cmake │ │ │ ├── mex_gpuNUFFT_precomp_f.dir │ │ │ │ ├── CXX.includecache │ │ │ │ ├── DependInfo.cmake │ │ │ │ ├── __ │ │ │ │ │ └── gpuNUFFT_operator_matlabfactory.cpp.o │ │ │ │ ├── build.make │ │ │ │ ├── cmake_clean.cmake │ │ │ │ ├── depend.internal │ │ │ │ ├── depend.make │ │ │ │ ├── flags.make │ │ │ │ ├── gpuNUFFT_precomp.cpp.o │ │ │ │ ├── link.txt │ │ │ │ └── progress.make │ │ │ └── progress.marks │ │ │ ├── Makefile │ │ │ └── cmake_install.cmake │ ├── cmake_modules │ │ └── FindGPUNUFFT.cmake │ ├── doc │ │ ├── CMakeLists.txt │ │ ├── Doxyfile │ │ └── mainpage.dox │ ├── inc │ │ ├── balanced_gpuNUFFT_operator.hpp │ │ ├── balanced_operator.hpp │ │ ├── balanced_texture_gpuNUFFT_operator.hpp │ │ ├── config.hpp │ │ ├── config.hpp.cmake │ │ ├── cuda_utils.cuh │ │ ├── cuda_utils.hpp │ │ ├── cufft_config.hpp │ │ ├── cufft_config.hpp.cmake │ │ ├── gpuNUFFT_cpu.hpp │ │ ├── gpuNUFFT_kernels.hpp │ │ ├── gpuNUFFT_operator.hpp │ │ ├── gpuNUFFT_operator_factory.hpp │ │ ├── gpuNUFFT_types.hpp │ │ ├── gpuNUFFT_utils.hpp │ │ ├── matlab_helper.h │ │ ├── precomp_kernels.hpp │ │ ├── precomp_utils.hpp │ │ └── texture_gpuNUFFT_operator.hpp │ ├── src │ │ ├── CMakeLists.txt │ │ ├── balanced_gpuNUFFT_operator.cpp │ │ ├── balanced_texture_gpuNUFFT_operator.cpp │ │ ├── cpu │ │ │ └── gpuNUFFT_cpu.cpp │ │ ├── gpu │ │ │ ├── CMakeLists.txt │ │ │ ├── atomic │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── atomic_gpuNUFFT.cu │ │ │ │ ├── atomic_gpuNUFFT_kernels.cu │ │ │ │ └── texture_gpuNUFFT_kernels.cu │ │ │ ├── coarse │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── coarse_gpuNUFFT.cu │ │ │ │ ├── gpuNUFFT_kernels.cu │ │ │ │ └── texture_gpuNUFFT_kernels.cu │ │ │ ├── matlab │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── gpuNUFFT_adj.cpp │ │ │ │ ├── gpuNUFFT_forw.cpp │ │ │ │ ├── gpuNUFFT_operator_matlabfactory.cpp │ │ │ │ ├── gpuNUFFT_operator_matlabfactory.hpp │ │ │ │ └── precomputation │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ └── gpuNUFFT_precomp.cpp │ │ │ ├── precomp_kernels.cu │ │ │ └── std_gpuNUFFT_kernels.cu │ │ ├── gpuNUFFT_operator.cpp │ │ ├── gpuNUFFT_operator_factory.cpp │ │ ├── gpuNUFFT_utils.cpp │ │ └── texture_gpuNUFFT_operator.cpp │ └── test │ │ ├── CMakeLists.txt │ │ ├── cpu │ │ ├── CMakeLists.txt │ │ ├── gpuNUFFT_kernel_tests.cpp │ │ ├── gpuNUFFT_operator_factory_tests.cpp │ │ ├── gpuNUFFT_precomputation_tests.cpp │ │ └── gpuNUFFT_tests.cpp │ │ └── gpu │ │ ├── forward │ │ └── gpuNUFFT_forward_tests.cpp │ │ ├── gpuNUFFT_2D_conv_tests.cpp │ │ ├── gpuNUFFT_conv_tests.cpp │ │ ├── gpuNUFFT_deapo_tests.cpp │ │ └── gpuNUFFT_fft_tests.cpp ├── README.md ├── Utils │ ├── AtA_LR.m │ ├── AtA_UV.m │ ├── Atb_LR.m │ ├── Atb_UV.m │ ├── SenseATA.m │ ├── coil_sens_map.m │ ├── combine_coils.m │ ├── estimateLapKernelLR.m │ ├── iterative_est_laplacian.m │ ├── l2Recont.m │ └── solveUV.m ├── csm │ ├── coil_sens_map_NUFFT.m │ ├── crop.m │ ├── dat2Kernel.m │ ├── fft2c.m │ ├── giveEspiritMaps.m │ ├── giveEspiritMapsSmall.m │ ├── im2row.m │ ├── kernelEig.m │ └── zpad.m ├── nufft_toolbox_cpu │ ├── .svn │ │ ├── all-wcprops │ │ ├── entries │ │ ├── prop-base │ │ │ ├── interp1_table_adj_mex.mexglx.svn-base │ │ │ ├── interp1_table_adj_mex.mexmaci.svn-base │ │ │ ├── interp1_table_mex.mexglx.svn-base │ │ │ ├── interp1_table_mex.mexmaci.svn-base │ │ │ ├── interp2_table_adj_mex.mexglx.svn-base │ │ │ ├── interp2_table_adj_mex.mexmaci.svn-base │ │ │ ├── interp2_table_mex.mexglx.svn-base │ │ │ ├── interp2_table_mex.mexmaci.svn-base │ │ │ ├── interp3_table_adj_mex.mexglx.svn-base │ │ │ ├── interp3_table_adj_mex.mexmaci.svn-base │ │ │ ├── interp3_table_mex.mexglx.svn-base │ │ │ ├── interp3_table_mex.mexmaci.svn-base │ │ │ ├── kaiser,m=0.mat.svn-base │ │ │ ├── kaiser,m=2.mat.svn-base │ │ │ └── nufft_gauss2.mat.svn-base │ │ └── text-base │ │ │ ├── Makefile.svn-base │ │ │ ├── col.m.svn-base │ │ │ ├── dtft.m.svn-base │ │ │ ├── dtft1.m.svn-base │ │ │ ├── dtft2.m.svn-base │ │ │ ├── dtft2_adj.m.svn-base │ │ │ ├── dtft_adj.m.svn-base │ │ │ ├── dtft_mex.m.svn-base │ │ │ ├── example_nufft1_reverse.m.svn-base │ │ │ ├── fig_taper_cos3.m.svn-base │ │ │ ├── interp1_table_adj_mex.c.svn-base │ │ │ ├── interp1_table_adj_mex.mexglx.svn-base │ │ │ ├── interp1_table_adj_mex.mexmaci.svn-base │ │ │ ├── interp1_table_mex.c.svn-base │ │ │ ├── interp1_table_mex.mexglx.svn-base │ │ │ ├── interp1_table_mex.mexmaci.svn-base │ │ │ ├── interp2_table_adj_mex.c.svn-base │ │ │ ├── interp2_table_adj_mex.mexglx.svn-base │ │ │ ├── interp2_table_adj_mex.mexmaci.svn-base │ │ │ ├── interp2_table_mex.c.svn-base │ │ │ ├── interp2_table_mex.mexglx.svn-base │ │ │ ├── interp2_table_mex.mexmaci.svn-base │ │ │ ├── interp3_table_adj_mex.c.svn-base │ │ │ ├── interp3_table_adj_mex.mexglx.svn-base │ │ │ ├── interp3_table_adj_mex.mexmaci.svn-base │ │ │ ├── interp3_table_mex.c.svn-base │ │ │ ├── interp3_table_mex.mexglx.svn-base │ │ │ ├── interp3_table_mex.mexmaci.svn-base │ │ │ ├── interp_table_test.m.svn-base │ │ │ ├── isvar.m.svn-base │ │ │ ├── kaiser,m=0.mat.svn-base │ │ │ ├── kaiser,m=2.mat.svn-base │ │ │ ├── kaiser_bessel.m.svn-base │ │ │ ├── kaiser_bessel_ft.m.svn-base │ │ │ ├── kb,notes,matej.svn-base │ │ │ ├── my_fftn.m.svn-base │ │ │ ├── nufft.m.svn-base │ │ │ ├── nufft1_err_mm.m.svn-base │ │ │ ├── nufft1_error.m.svn-base │ │ │ ├── nufft1_kernel.m.svn-base │ │ │ ├── nufft1_time.m.svn-base │ │ │ ├── nufft2_err_mm.m (a.hasib.bhati@gmail.com).svn-base │ │ │ ├── nufft2_err_mm.m.svn-base │ │ │ ├── nufft_T.m.svn-base │ │ │ ├── nufft_adj.m.svn-base │ │ │ ├── nufft_alpha.m.svn-base │ │ │ ├── nufft_alpha_kb_fit.m.svn-base │ │ │ ├── nufft_best_alpha.m.svn-base │ │ │ ├── nufft_best_gauss.m.svn-base │ │ │ ├── nufft_coef.m.svn-base │ │ │ ├── nufft_diric.m.svn-base │ │ │ ├── nufft_gauss.m.svn-base │ │ │ ├── nufft_gauss2.mat.svn-base │ │ │ ├── nufft_init.m.svn-base │ │ │ ├── nufft_interp_zn.m.svn-base │ │ │ ├── nufft_offset.m.svn-base │ │ │ ├── nufft_r.m.svn-base │ │ │ ├── nufft_scale.m.svn-base │ │ │ ├── nufft_table_adj.m (a.hasib.bhati@gmail.com).svn-base │ │ │ ├── nufft_table_adj.m.svn-base │ │ │ ├── nufft_table_init.m.svn-base │ │ │ ├── nufft_table_interp.m.svn-base │ │ │ ├── nufft_table_test.m.svn-base │ │ │ ├── nufft_tune_gauss.m.svn-base │ │ │ ├── nufft_tune_kaiser.m.svn-base │ │ │ ├── outer_sum.m.svn-base │ │ │ ├── readme.svn-base │ │ │ ├── reale.m.svn-base │ │ │ ├── spdiag.m.svn-base │ │ │ ├── streq.m.svn-base │ │ │ └── test_fft2.m.svn-base │ ├── Makefile │ ├── col.m │ ├── dtft.m │ ├── dtft1.m │ ├── dtft2.m │ ├── dtft2_adj.m │ ├── dtft_adj.m │ ├── dtft_mex.m │ ├── example_nufft1_reverse.m │ ├── fig_taper_cos3.m │ ├── interp1_table_adj_mex.c │ ├── interp1_table_adj_mex.mexglx │ ├── interp1_table_adj_mex.mexmaci │ ├── interp1_table_mex (a.hasib.bhati@gmail.com).mexglx │ ├── interp1_table_mex.c │ ├── interp1_table_mex.mexglx │ ├── interp1_table_mex.mexmaci │ ├── interp2_table_adj_mex.c │ ├── interp2_table_adj_mex.mexglx │ ├── interp2_table_adj_mex.mexmaci │ ├── interp2_table_mex.c │ ├── interp2_table_mex.mexglx │ ├── interp2_table_mex.mexmaci │ ├── interp3_table_adj_mex.c │ ├── interp3_table_adj_mex.mexglx │ ├── interp3_table_adj_mex.mexmaci │ ├── interp3_table_mex.c │ ├── interp3_table_mex.mexglx │ ├── interp3_table_mex.mexmaci │ ├── interp_table_test.m │ ├── isvar.m │ ├── kaiser,m=0.mat │ ├── kaiser,m=2.mat │ ├── kaiser_bessel.m │ ├── kaiser_bessel_ft.m │ ├── kb,notes,matej │ ├── my_fftn.m │ ├── nufft.m │ ├── nufft1_err_mm.m │ ├── nufft1_error.m │ ├── nufft1_kernel.m │ ├── nufft1_time.m │ ├── nufft2_err_mm.m │ ├── nufft_T.m │ ├── nufft_adj.m │ ├── nufft_alpha.m │ ├── nufft_alpha_kb_fit.m │ ├── nufft_best_alpha.m │ ├── nufft_best_gauss.m │ ├── nufft_coef.m │ ├── nufft_diric.m │ ├── nufft_gauss.m │ ├── nufft_gauss2.mat │ ├── nufft_init.m │ ├── nufft_interp_zn.m │ ├── nufft_offset.m │ ├── nufft_r.m │ ├── nufft_scale.m │ ├── nufft_table_adj.m │ ├── nufft_table_init.m │ ├── nufft_table_interp.m │ ├── nufft_table_test.m │ ├── nufft_tune_gauss.m │ ├── nufft_tune_kaiser.m │ ├── outer_sum.m │ ├── private │ │ ├── .svn │ │ │ ├── all-wcprops │ │ │ ├── entries │ │ │ ├── prop-base │ │ │ │ ├── kaiser,m=0.mat.svn-base │ │ │ │ ├── kaiser,m=2.mat.svn-base │ │ │ │ └── nufft_gauss2.mat.svn-base │ │ │ └── text-base │ │ │ │ ├── kaiser,m=0.mat.svn-base │ │ │ │ ├── kaiser,m=2.mat.svn-base │ │ │ │ ├── kaiser_bessel_ft.m.svn-base │ │ │ │ ├── nufft_T.m.svn-base │ │ │ │ ├── nufft_alpha.m.svn-base │ │ │ │ ├── nufft_coef.m.svn-base │ │ │ │ ├── nufft_gauss2.mat.svn-base │ │ │ │ ├── nufft_interp_zn.m.svn-base │ │ │ │ ├── nufft_offset.m.svn-base │ │ │ │ └── nufft_r.m.svn-base │ │ ├── kaiser,m=0.mat │ │ ├── kaiser,m=2.mat │ │ ├── kaiser_bessel_ft.m │ │ ├── nufft_T.m │ │ ├── nufft_alpha.m │ │ ├── nufft_coef.m │ │ ├── nufft_gauss2.mat │ │ ├── nufft_interp_zn.m │ │ ├── nufft_offset.m │ │ └── nufft_r.m │ ├── readme │ ├── reale.m │ ├── spdiag.m │ ├── streq.m │ └── test_fft2.m ├── spiralStorm_iterative.m └── spiralStorm_navigator.m └── ktSLR ├── demo_ktslr_mcoil.m └── utils ├── A_fhp3D.m ├── A_fhp3D_mcoil.m ├── At_fhp3D.m ├── At_fhp3D_mcoil.m ├── CG_solver.m ├── RMSE.m ├── defDDt.m ├── givefastSVD.m ├── ismrm_estimate_csm_walsh_modified.m ├── ismrm_rss.m ├── minSNandTV.m └── strucrand.m /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/.DS_Store -------------------------------------------------------------------------------- /BCS/utils/A_fhp_2d.m: -------------------------------------------------------------------------------- 1 | % Forward Fourier transform sampling operator 2 | 3 | function y = A_fhp_2d(x, s, OMEGA,n,nc) 4 | 5 | s=(s); 6 | 7 | x=reshape(x,n(1),n(2),n(3)); 8 | y=zeros(size(OMEGA,1),nc); 9 | 10 | for ii=1:nc, 11 | yc = (1/sqrt(n(1)*n(2)))*fft2(squeeze(s(:,:,ii,:)).*x); 12 | y(:,ii) = yc(OMEGA); 13 | end 14 | 15 | 16 | -------------------------------------------------------------------------------- /BCS/utils/At_fhp_2d.m: -------------------------------------------------------------------------------- 1 | % Backward Fourier transform sampling operator 2 | 3 | function x = At_fhp_2d(y,s, OMEGA,n) 4 | s=(s); 5 | 6 | nc = n(3); 7 | x = zeros(n(1),n(2),n(4)); 8 | OMEGA=double(OMEGA); 9 | 10 | for ii=1:nc, 11 | fx = zeros(n(1),n(2),n(4)); 12 | fx(OMEGA) = y(:,ii); 13 | x = x + (sqrt(n(1)*n(2))*ifft2(fx).*conj(squeeze(s(:,:,ii,:)))); 14 | end 15 | 16 | x=reshape(x, n(1)*n(2),n(4)); 17 | -------------------------------------------------------------------------------- /BCS/utils/Eval_Vleft.m: -------------------------------------------------------------------------------- 1 | function out=Eval_Vleft(V,A,At,U,opts) 2 | 3 | V=reshape(V,opts.r,opts.n3); 4 | out=2*(U'*At(A(U*V)))+opts.beta2*V; 5 | out=out(:); 6 | end -------------------------------------------------------------------------------- /BCS/utils/Eval_gradUleft.m: -------------------------------------------------------------------------------- 1 | function left = Eval_gradUleft(U,A,At,phi, phit, V,opts) 2 | 3 | U=reshape(U, opts.n1*opts.n2,opts.r); 4 | left = At(A(U*V))*V' + (opts.lambda1*opts.beta1/2)*phit(phi(U)); 5 | left = left(:); 6 | -------------------------------------------------------------------------------- /BCS/utils/Lsubproblem.m: -------------------------------------------------------------------------------- 1 | % Shrinkage function 2 | 3 | function L = Lsubproblem(opts, phi, U) 4 | if strcmp(opts.phi, 'TV'); 5 | phifwd = phi(U); 6 | TV = sqrt(abs(phifwd{1}).^2 + abs(phifwd{2}).^2) ; 7 | TV(TV==0) = 1; 8 | TV = max(TV - (1/opts.beta1), 0)./TV; 9 | L{1} = double(phifwd{1}.*TV); 10 | L{2} = double(phifwd{2}.*TV); 11 | elseif strcmp(opts.phi, 'l1'); 12 | Z = U; 13 | L_1 = (abs(Z)-1/opts.beta1); 14 | L_1 = L_1.*(L_1>0); 15 | L_2 = abs(Z)+(abs(Z)<1e-12); 16 | L = L_1.*Z./L_2; 17 | L=(L); 18 | 19 | elseif strcmp(opts.phi,'lp') 20 | Z = U ; 21 | L_1 = (abs(Z)-1/opts.beta1*((abs(Z)+0.00001).^(opts.p-1))); 22 | L_1 = L_1.*(L_1>0); 23 | L_2 = abs(Z)+(abs(Z)<1e-12); 24 | L = L_1.*Z./L_2; 25 | L=double(L); 26 | end 27 | -------------------------------------------------------------------------------- /BCS/utils/RMSE.m: -------------------------------------------------------------------------------- 1 | function[Error,U]= RMSE(U,I) 2 | U = abs(U); I = abs(I); 3 | for ii=1:size(U,3) 4 | alpha = sum(dot(U(:,:,ii),I(:,:,ii)))/(sum(dot(U(:,:,ii),U(:,:,ii)))); 5 | 6 | U(:,:,ii)=(alpha)*U(:,:,ii); 7 | 8 | E=sum(sum(abs((I(:,:,ii)-U(:,:,ii))).^2)); 9 | 10 | E=E*1/(sum(sum(abs((I(:,:,ii))).^2))); 11 | 12 | Error(ii)=(E); 13 | end 14 | 15 | 16 | Error=mean((Error)); 17 | -------------------------------------------------------------------------------- /BCS/utils/def_phi_phit_ID.m: -------------------------------------------------------------------------------- 1 | function [phi,phit] = def_phi_phit_ID 2 | 3 | 4 | phi = @(U) ((U));warning off all; 5 | phit = @(DU) ((DU)); 6 | end -------------------------------------------------------------------------------- /BCS/utils/sp_TV_eval.m: -------------------------------------------------------------------------------- 1 | % evaluates total variation (TV) norm 2 | 3 | function [out]= sp_TV_eval(z) 4 | tv_sp = sqrt(abs(z{1}).^2 + abs(z{2}).^2); 5 | out = sum(abs(tv_sp(:))); 6 | end -------------------------------------------------------------------------------- /DC_CS/utils/A_fhp3D.m: -------------------------------------------------------------------------------- 1 | function A = A_fhp3D(z, S) 2 | z=double(z); S=double(S); 3 | [n1,n2,n3] = size(z); 4 | %A = zeros(n1,n2,n3); 5 | p=1/sqrt(n1*n2)*fft2(z); 6 | A = p(S) ; 7 | -------------------------------------------------------------------------------- /DC_CS/utils/At_fhp3D.m: -------------------------------------------------------------------------------- 1 | function At = At_fhp3D(z, S, n1,n2,n3) 2 | z=double(z); S= double(S); 3 | p=zeros(n1,n2,n3); 4 | p(S)=z; 5 | At=double(sqrt(n1*n2)*ifft2(p)); 6 | -------------------------------------------------------------------------------- /DC_CS/utils/RMSE_cal.m: -------------------------------------------------------------------------------- 1 | 2 | function [U,rmse]= RMSE_cal(ideal, recon) 3 | x = ideal; x_init = recon; 4 | 5 | I=double(abs(x));U=(double(abs(x_init))); 6 | 7 | for ii=1:size(U,3) 8 | alpha = sum(dot(U(:,:,ii),I(:,:,ii)))/(sum(dot(U(:,:,ii),U(:,:,ii)))); 9 | 10 | U(:,:,ii)=(alpha)*U(:,:,ii); 11 | 12 | E=sum(sum(abs((I(:,:,ii)-U(:,:,ii))).^2)); 13 | 14 | E=E*1/(sum(sum(abs((I(:,:,ii))).^2))); 15 | 16 | Error(ii)=(E); 17 | end 18 | 19 | rmse=mean((Error)) -------------------------------------------------------------------------------- /DC_CS/utils/demon_registration_version_8f/compile_c_files.m: -------------------------------------------------------------------------------- 1 | % This script will compile all the C files of the registration methods 2 | cd('functions_nonrigid'); 3 | files=dir('*.c'); 4 | for i=1:length(files) 5 | filename=[files(i).name]; 6 | if(length(filename)<19||(~strcmpi(filename(1:19),'image_interpolation'))) 7 | disp(['compiling : ' filename]); 8 | mex(filename,'image_interpolation.c'); 9 | end 10 | end 11 | cd('..'); 12 | 13 | cd('functions_affine'); 14 | files=dir('*.c'); 15 | for i=1:length(files) 16 | filename=[files(i).name]; 17 | if(length(filename)<19||(~strcmpi(filename(1:19),'image_interpolation'))) 18 | disp(['compiling : ' filename]); 19 | mex(filename,'image_interpolation.c'); 20 | end 21 | end 22 | cd('..'); 23 | 24 | cd('functions') 25 | files=dir('*.c'); 26 | for i=1:length(files) 27 | filename=[files(i).name]; 28 | disp(['compiling : ' filename]); 29 | mex(filename); 30 | end 31 | cd('..'); 32 | 33 | 34 | -------------------------------------------------------------------------------- /DC_CS/utils/demon_registration_version_8f/demon_reg.m: -------------------------------------------------------------------------------- 1 | function [ M ] = demon_reg( S,M ) 2 | %DEMON_REG Summary of this function goes here 3 | % Detailed explanation goes here 4 | 5 | % Set static and moving image 6 | 7 | I2=S; 8 | I1=M; 9 | 10 | % Alpha (noise) constant 11 | alpha=4.5; 12 | 13 | % Velocity field smoothing kernel 14 | Hsmooth=fspecial('gaussian',[60 60],10); 15 | 16 | % The transformation fields 17 | Tx=zeros(size(M)); Ty=zeros(size(M)); 18 | 19 | [Sy,Sx] = gradient(S); 20 | for itt=1:200 21 | % Difference image between moving and static image 22 | Idiff=M-S; 23 | 24 | % Default demon force, (Thirion 1998) 25 | %Ux = -(Idiff.*Sx)./((Sx.^2+Sy.^2)+Idiff.^2); 26 | %Uy = -(Idiff.*Sy)./((Sx.^2+Sy.^2)+Idiff.^2); 27 | 28 | % Extended demon force. With forces from the gradients from both 29 | % moving as static image. (Cachier 1999, He Wang 2005) 30 | [My,Mx] = gradient(M); 31 | Ux = -Idiff.* ((Sx./((Sx.^2+Sy.^2)+alpha^2*Idiff.^2))+(Mx./((Mx.^2+My.^2)+alpha^2*Idiff.^2))); 32 | Uy = -Idiff.* ((Sy./((Sx.^2+Sy.^2)+alpha^2*Idiff.^2))+(My./((Mx.^2+My.^2)+alpha^2*Idiff.^2))); 33 | 34 | % When divided by zero 35 | Ux(isnan(Ux))=0; Uy(isnan(Uy))=0; 36 | 37 | % Smooth the transformation field 38 | Uxs=3*imfilter(Ux,Hsmooth); 39 | Uys=3*imfilter(Uy,Hsmooth); 40 | 41 | % Add the new transformation field to the total transformation field. 42 | Tx=Tx+Uxs; 43 | Ty=Ty+Uys; 44 | M=movepixels(I1,Tx,Ty); 45 | end 46 | 47 | end 48 | 49 | -------------------------------------------------------------------------------- /DC_CS/utils/demon_registration_version_8f/functions/fminlbfgs.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/DC_CS/utils/demon_registration_version_8f/functions/fminlbfgs.m -------------------------------------------------------------------------------- /DC_CS/utils/demon_registration_version_8f/functions/imresize3d.m: -------------------------------------------------------------------------------- 1 | function A=imresize3d(V,scale,tsize,ntype,npad) 2 | % This function resizes a 3D image volume to new dimensions 3 | % Vnew = imresize3d(V,scale,nsize,ntype,npad); 4 | % 5 | % inputs, 6 | % V: The input image volume 7 | % scale: scaling factor, when used set tsize to []; 8 | % nsize: new dimensions, when used set scale to []; 9 | % ntype: Type of interpolation ('nearest', 'linear', or 'cubic') 10 | % npad: Boundary condition ('replicate', 'symmetric', 'circular', 'fill', or 'bound') 11 | % 12 | % outputs, 13 | % Vnew: The resized image volume 14 | % 15 | % example, 16 | % load('mri','D'); D=squeeze(D); 17 | % Dnew = imresize3d(D,[],[80 80 40],'nearest','bound'); 18 | % 19 | % This function is written by D.Kroon University of Twente (July 2008) 20 | 21 | % Check the inputs 22 | if(exist('ntype', 'var') == 0), ntype='nearest'; end 23 | if(exist('npad', 'var') == 0), npad='bound'; end 24 | if(exist('scale', 'var')&&~isempty(scale)), tsize=round(size(V)*scale); end 25 | if(exist('tsize', 'var')&&~isempty(tsize)), scale=(tsize./size(V)); end 26 | 27 | % Make transformation structure 28 | T = makehgtform('scale',scale); 29 | tform = maketform('affine', T); 30 | 31 | % Specify resampler 32 | R = makeresampler(ntype, npad); 33 | 34 | % Resize the image volueme 35 | A = tformarray(V, tform, R, [1 2 3], [1 2 3], tsize, [], 0); 36 | 37 | -------------------------------------------------------------------------------- /DC_CS/utils/demon_registration_version_8f/functions/showcs3.fig: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/DC_CS/utils/demon_registration_version_8f/functions/showcs3.fig -------------------------------------------------------------------------------- /DC_CS/utils/demon_registration_version_8f/functions/store_transf.m: -------------------------------------------------------------------------------- 1 | function stop=store_transf(x,optimValues,state) 2 | % This function STORE_TRANSF is needed by the demon energy optimizer. 3 | % It stores the Transformation field of an itteration in a global variable, needed to calculate 4 | % transformation update energy in the next itteration. 5 | global last_transformation_field updatemovie; 6 | switch state 7 | case 'iter' 8 | last_transformation_field=x; 9 | case 'interrupt' 10 | clear('last_transformation_field'); 11 | case 'init' 12 | last_transformation_field=x; 13 | case 'done' 14 | clear('last_transformation_field'); 15 | otherwise 16 | end 17 | %updatemovie=true; 18 | updatemovie=false; 19 | stop=false; 20 | 21 | -------------------------------------------------------------------------------- /DC_CS/utils/demon_registration_version_8f/functions_affine/affine_transform.m: -------------------------------------------------------------------------------- 1 | function Iout=affine_transform(Iin,M,mode) 2 | % Function affine_transform, is a wrapper of the (mex) functions 3 | % affine_transform_2d_double and affine_transform_3d mex functions 4 | % 5 | % Iout = affine_transform(Iin,M,mode) 6 | % 7 | % inputs, 8 | % Iin : Input image. 9 | % M : Transformation matrix 10 | % mode: If 0: linear interpolation and outside pixels set to nearest pixel 11 | % 1: linear interpolation and outside pixels set to zero 12 | % 2: cubic interpolation and outsite pixels set to nearest pixel 13 | % 3: cubic interpolation and outside pixels set to zero 14 | % 15 | % 16 | % outputs, 17 | % Iout: Output image 18 | % 19 | % Function is written by D.Kroon University of Twente (September 2008) 20 | 21 | if(~exist('mode','var')), mode=0; end 22 | if(size(Iin,3)<4) 23 | if(~isa(Iin,'double')), Iin=im2double(Iin); end 24 | Iout=affine_transform_2d_double(double(Iin),double(M),double(mode)); 25 | else 26 | if(isa(Iin,'double')) 27 | Iout=affine_transform_3d_double(double(Iin),double(M),double(mode)); 28 | else 29 | Iout=affine_transform_3d_single(single(Iin),single(M),single(mode)); 30 | end 31 | end 32 | -------------------------------------------------------------------------------- /DC_CS/utils/demon_registration_version_8f/functions_affine/squared_difference_double.c: -------------------------------------------------------------------------------- 1 | #include "mex.h" 2 | #include "math.h" 3 | 4 | /* squared pixel difference */ 5 | 6 | /* The matlab mex function */ 7 | void mexFunction( int nlhs, mxArray *plhs[], 8 | int nrhs, const mxArray *prhs[] ) 9 | { 10 | double *I1, *I2, *Ierror; 11 | 12 | /* Size of input image */ 13 | const mwSize *idims; 14 | /* Dimensions */ 15 | int nsubs; 16 | /* number of pixels */ 17 | int npixels=1; 18 | /* Loop variable */ 19 | int i; 20 | /* Size of output */ 21 | int odims2[2]={1,1}; 22 | /* Total squared error */ 23 | double ierror=0; 24 | 25 | /* Connect inputs */ 26 | I1=(double *)mxGetData(prhs[0]); 27 | I2=(double *)mxGetData(prhs[1]); 28 | 29 | /* Initialize output array */ 30 | plhs[0] = mxCreateNumericArray(2, odims2, mxDOUBLE_CLASS, mxREAL); 31 | Ierror=(double *)mxGetData(plhs[0]); 32 | 33 | /* Get the number of dimensions */ 34 | nsubs = mxGetNumberOfDimensions(prhs[0]); 35 | /* Get the sizes of the grid */ 36 | idims = mxGetDimensions(prhs[0]); 37 | for (i=0; i0; 28 | 29 | %% IRLS MUSSELS Recon 30 | 31 | tic; 32 | %[rec] =mussels_cs(kdata,csm,mask,[6,6],10,8,.005,1,0); 33 | [rec] =mussels_cs(kdata,csm,mask,[4,4],5,5,.005,1,0); % faster 34 | toc; 35 | 36 | dwi(:,:,ph)=sos(ifft2c(rec)); 37 | figure();imagesc(cat(2,rot90(sos(ifft2c(sum(kdata,4))),1),rot90(dwi(:,:,ph),1)));colormap(gray);title(['without phase compensation ',' MUSSELS Recon']) 38 | 39 | 40 | end 41 | 42 | -------------------------------------------------------------------------------- /MUSSELS/utils/fft2.m: -------------------------------------------------------------------------------- 1 | function f = fft2(x, mrows, ncols) 2 | %FFT2 Two-dimensional discrete Fourier Transform. 3 | % FFT2(X) returns the two-dimensional Fourier transform of matrix X. 4 | % If X is a vector, the result will have the same orientation. 5 | % 6 | % FFT2(X,MROWS,NCOLS) pads matrix X with zeros to size MROWS-by-NCOLS 7 | % before transforming. 8 | % 9 | % Class support for input X: 10 | % float: double, single 11 | % 12 | % See also FFT, FFTN, FFTSHIFT, FFTW, IFFT, IFFT2, IFFTN. 13 | 14 | % Copyright 1984-2010 The MathWorks, Inc. 15 | 16 | if ismatrix(x) 17 | if nargin==1 18 | f = fftn(x); 19 | else 20 | f = fftn(x,[mrows ncols]); 21 | end 22 | else 23 | if nargin==1 24 | f = fft(fft(x,[],2),[],1); 25 | else 26 | f = fft(fft(x,ncols,2),mrows,1); 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /MUSSELS/utils/fft2c.m: -------------------------------------------------------------------------------- 1 | function res = fft2c(x) 2 | 3 | S = size(x); 4 | fctr = S(1)*S(2); 5 | 6 | x = reshape(x,S(1),S(2),prod(S(3:end))); 7 | 8 | res = zeros(size(x)); 9 | for n=1:size(x,3) 10 | res(:,:,n) = 1/sqrt(fctr)*fftshift(fft2(ifftshift(x(:,:,n)))); 11 | end 12 | 13 | res = reshape(res,S); 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /MUSSELS/utils/getHankel.m: -------------------------------------------------------------------------------- 1 | function [ H ] = getHankel( img,ncalib ) 2 | %UNTITLED5 Summary of this function goes here 3 | % Detailed explanation goes here 4 | 5 | 6 | tmp=im2row(img,ncalib); [tsx,tsy,tsz] = size(tmp); 7 | % H=reshape(permute(tmp,[2,3,1]),tsy*tsz,tsx); 8 | %H = (reshape(tmp,tsx,tsy*tsz)); 9 | H = (reshape(tmp,tsx,tsy*tsz)); 10 | 11 | end 12 | 13 | -------------------------------------------------------------------------------- /MUSSELS/utils/ifft2c.m: -------------------------------------------------------------------------------- 1 | function res = ifft2c(x) 2 | 3 | S = size(x); 4 | fctr = S(1)*S(2); 5 | 6 | x = reshape(x,S(1),S(2),prod(S(3:end))); 7 | 8 | res = zeros(size(x)); 9 | for n=1:size(x,3) 10 | res(:,:,n) = sqrt(fctr)*fftshift(ifft2(ifftshift(x(:,:,n)))); 11 | end 12 | 13 | 14 | res = reshape(res,S); 15 | 16 | -------------------------------------------------------------------------------- /MUSSELS/utils/im2row.m: -------------------------------------------------------------------------------- 1 | function res = im2row(im, winSize) 2 | %res = im2row(im, winSize) 3 | [sx,sy,sz] = size(im); 4 | 5 | res = zeros((sx-winSize(1)+1)*(sy-winSize(2)+1),prod(winSize),sz); 6 | count=0; 7 | for y=1:winSize(2) 8 | for x=1:winSize(1) 9 | count = count+1; 10 | res(:,count,:) = reshape(im(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:),... 11 | (sx-winSize(1)+1)*(sy-winSize(2)+1),1,sz); 12 | end 13 | end 14 | -------------------------------------------------------------------------------- /MUSSELS/utils/invHankel.m: -------------------------------------------------------------------------------- 1 | function [ img ] = invHankel( H,sx,sy,nc,ksize ) 2 | %UNTITLED5 Summary of this function goes here 3 | % Detailed explanation goes here 4 | % H1=transpose(H); 5 | tsx=size(H,1); 6 | tsy=size(H,2)/nc; 7 | H2 = reshape(H,tsx,tsy,nc); 8 | % tsx=size(H,2); 9 | % tsy=size(H,1)/nc; 10 | % H = reshape(permute(H,[2,1]),tsx,tsy,nc); 11 | 12 | img = row2im_tpose(H2,[sx,sy,nc],ksize); 13 | end 14 | 15 | -------------------------------------------------------------------------------- /MUSSELS/utils/row2im.m: -------------------------------------------------------------------------------- 1 | function [res,W] = row2im(mtx,imSize, winSize) 2 | %[res,W] = row2im(mtx,imSize, winSize); 3 | 4 | sz = size(mtx,3); 5 | sx = imSize(1); sy = imSize(2); 6 | res = zeros(imSize(1),imSize(2),sz); 7 | W = res; 8 | 9 | 10 | 11 | count=0; 12 | for y=1:winSize(2) 13 | for x=1:winSize(1) 14 | count = count+1; 15 | res(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:) = res(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:) + reshape(mtx(:,count,:),(sx-winSize(1)+1),(sy-winSize(2)+1),sz); 16 | W(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:) = W(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:)+1; 17 | end 18 | end 19 | 20 | res = res./W; 21 | -------------------------------------------------------------------------------- /MUSSELS/utils/row2im_tpose.m: -------------------------------------------------------------------------------- 1 | function [res,W] = row2im_tpose(mtx,imSize, winSize) 2 | %[res,W] = row2im(mtx,imSize, winSize); 3 | 4 | sz = size(mtx,3); 5 | sx = imSize(1); sy = imSize(2); 6 | res = zeros(imSize(1),imSize(2),sz); 7 | W = res; 8 | 9 | 10 | 11 | count=0; 12 | for y=1:winSize(2) 13 | for x=1:winSize(1) 14 | count = count+1; 15 | res(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:) = res(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:) + reshape(mtx(:,count,:),(sx-winSize(1)+1),(sy-winSize(2)+1),sz); 16 | W(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:) = W(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:)+1; 17 | end 18 | end 19 | 20 | % res = res./W; 21 | -------------------------------------------------------------------------------- /MUSSELS/utils/sos.m: -------------------------------------------------------------------------------- 1 | function res = sos(x ,dim, pnorm) 2 | % res = sos(x [,dim, pnorm]) 3 | % 4 | % function computes the square root of sum of squares along dimension dim. 5 | % If dim is not specified, it computes it along the last dimension. 6 | % 7 | % (c) Michael Lustig 2009 8 | 9 | if nargin < 2 10 | dim = size(size(x),2); 11 | end 12 | 13 | if nargin < 3 14 | pnorm = 2; 15 | end 16 | 17 | 18 | res = (sum(abs(x.^pnorm),dim)).^(1/pnorm); 19 | -------------------------------------------------------------------------------- /MUSSELS/utils/unchop.m: -------------------------------------------------------------------------------- 1 | function kdata=unchop(x); 2 | 3 | S = size(x); 4 | x = reshape(x,S(1),S(2),prod(S(3:end))); 5 | 6 | % x(1:2:end,:,:)=x(1:2:end,:,:)*-1; 7 | 8 | x(:,1:2:end,:)=x(:,1:2:end,:)*-1; 9 | 10 | kdata = reshape(x,S); 11 | -------------------------------------------------------------------------------- /MUSSELS/utils/zpad.m: -------------------------------------------------------------------------------- 1 | function res = zpad(x,sx,sy,sz,st) 2 | % res = zpad(x,sx,sy) 3 | % Zero pads a 2D matrix around its center. 4 | % 5 | % 6 | % res = zpad(x,sx,sy,sz,st) 7 | % Zero pads a 4D matrix around its center 8 | % 9 | % 10 | % res = zpad(x,[sx,sy,sz,st]) 11 | % same as the previous example 12 | % 13 | % 14 | % (c) Michael Lustig 2007 15 | 16 | if nargin < 2 17 | error('must have a target size') 18 | end 19 | 20 | if nargin == 2 21 | s = sx; 22 | end 23 | 24 | if nargin == 3 25 | s = [sx,sy]; 26 | end 27 | 28 | if nargin == 4 29 | s = [sx,sy,sz]; 30 | end 31 | 32 | if nargin == 5 33 | s = [sx,sy,sz,st]; 34 | end 35 | 36 | m = size(x); 37 | if length(m) < length(s) 38 | m = [m, ones(1,length(s)-length(m))]; 39 | end 40 | 41 | if sum(m==s)==length(m) 42 | res = x; 43 | return; 44 | end 45 | 46 | res = zeros(s); 47 | 48 | for n=1:length(s) 49 | idx{n} = floor(s(n)/2)+1+ceil(-m(n)/2) : floor(s(n)/2)+ceil(m(n)/2); 50 | end 51 | 52 | % % this is a dirty ugly trick 53 | % cmd = 'res(idx{1}'; 54 | % for n=2:length(s) 55 | % cmd = sprintf('%s,idx{%d}',cmd,n); 56 | % end 57 | % cmd = sprintf('%s)=x;',cmd); 58 | % eval(cmd); 59 | 60 | if(n<3) 61 | res(idx{1},idx{2})=x; 62 | elseif(n==3) 63 | res(idx{1},idx{2},idx{3})=x; 64 | elseif(n==4) 65 | res(idx{1},idx{2},idx{3},idx{4})=x; 66 | end 67 | 68 | 69 | -------------------------------------------------------------------------------- /PRICE/utils/A_fhp3Dmulticoil.m: -------------------------------------------------------------------------------- 1 | function A = A_fhp3Dmulticoil(z, S,n1,n2,n3,n4,coil_sens) 2 | %-------------------------------------- 3 | % This function Defines the forward operator A 4 | % 5 | % input - 6 | % z - input matrix/vector 7 | % S - Sampling indices 8 | % n1,n2,n3,n4 - data size 9 | % coil_sens - coil sensetivities map 10 | % 11 | % output - 12 | % A - forward operator A applied on z: A(z) 13 | % 14 | % Please see : Y. Mohsin, S.G Lingala, E. DiBella, M.Jacob, 15 | % Accelerated dynamic MRI Using Patch Regularization for Implicit motion CompEnsation (PRICE), 16 | % Magnetic Resonance in Medicine, 2016 17 | % 18 | % Last Edit: 11/27/2016 19 | % Contact: Y. Mohsin (yasir-mohsin@uiowa.edu) 20 | % M. Jacob (mathews-jacob@uiowa.edu) 21 | % 22 | % Copyright 2016, CBIG Lab, College of Engineering, The University of Iowa. 23 | % https://research.engineering.uiowa.edu/cbig/content/price 24 | %-------------------------------------- 25 | 26 | z=double(z); S = double(S); 27 | z = reshape(z,n1,n2,n3); 28 | A =double(zeros(n1,n2,n3,n4)); 29 | for nc =1:n4 30 | A(:,:,:,nc) = (1/sqrt(n1*n2))*fft2(z.*coil_sens(:,:,:,nc)); 31 | 32 | end 33 | A= A(S); 34 | -------------------------------------------------------------------------------- /PRICE/utils/Ah_fhp3Dmulticoil.m: -------------------------------------------------------------------------------- 1 | function At = Ah_fhp3Dmulticoil(z, S, n1,n2,n3,n4,coil_sens) 2 | %-------------------------------------- 3 | % This function Defines the backward operator Atranspose (At) 4 | % 5 | % input - 6 | % z - input matrix/vector 7 | % S - Sampling indices 8 | % n1,n2,n3,n4 - data size 9 | % coil_sens - coil sensetivities map 10 | % 11 | % output - 12 | % At - backword operator At applied on z: At(z) 13 | % 14 | % Please see : Y. Mohsin, S.G Lingala, E. DiBella, M.Jacob, 15 | % Accelerated dynamic MRI Using Patch Regularization for Implicit motion CompEnsation (PRICE), 16 | % Magnetic Resonance in Medicine, 2016. 17 | % 18 | % Last Edit: 11/27/2016 19 | % Contact: Y. Mohsin (yasir-mohsin@uiowa.edu) 20 | % M. Jacob (mathews-jacob@uiowa.edu) 21 | % 22 | % Copyright 2016, CBIG Lab, College of Engineering, The University of Iowa. 23 | % https://research.engineering.uiowa.edu/cbig/content/price 24 | %-------------------------------------- 25 | 26 | z=double(z); S = double(S); 27 | p=double(zeros(n1,n2,n3,n4)); 28 | p(S)=z; 29 | for nc = 1:n4 30 | p(:,:,:,nc) = sqrt(n1*n2)*ifft2(p(:,:,:,nc)).*conj(coil_sens(:,:,:,nc)); 31 | end 32 | At = sum(p,4); -------------------------------------------------------------------------------- /PRICE/utils/L1_sat.m: -------------------------------------------------------------------------------- 1 | function out = L1_sat(in,T,input) 2 | %-------------------------------------- 3 | % This function provides the result obtained by applying 4 | % the l_p threshold function to in 5 | % input - 6 | % in - input matrix/vector 7 | % T - threshold parameter 8 | % input.p - p-value for the l_p penalty (input is a struct) 9 | % 10 | % output - 11 | % out - thresholded matrix/vector 12 | % 13 | % Please see : Y. Mohsin, S.G Lingala, E. DiBella, M.Jacob, 14 | % Accelerated dynamic MRI Using Patch Regularization for Implicit motion CompEnsation (PRICE), 15 | % Magnetic Resonance in Medicine, 2016. 16 | % 17 | % Last Edit: 11/27/2016 18 | % Contact: Y. Mohsin (yasir-mohsin@uiowa.edu) 19 | % M. Jacob (mathews-jacob@uiowa.edu) 20 | % 21 | % Copyright 2016, CBIG Lab, College of Engineering, The University of Iowa. 22 | % https://research.engineering.uiowa.edu/cbig/content/price 23 | %-------------------------------------- 24 | 25 | out = abs(in).^(input.p); 26 | out = out.*(out < T); 27 | end 28 | -------------------------------------------------------------------------------- /PRICE/utils/README.md: -------------------------------------------------------------------------------- 1 | # PRICE 2 | Accelerated dynamic MRI Using Patch Regularization for Implicit motion CompEnsation (PRICE) 3 | Framework: We introduce a fast and an efficient patch smoothness regularization scheme, which implicitly compensates for interframe motion, to recover dynamic MRI data from highly undersampled measurements. The regularization prior is a sum of distances between each rectangular patch in the dataset with other patches in the dataset using a saturating distance metric. Unlike current motion estimation and motion compensation (ME-MC) methods, the proposed scheme does not require explicit prior information such as reference frames or motion model. The proposed algorithm, which alternates between inter-patch shrinkage step and conjugate gradient algorithm, is considerably more computationally efficient than ME-MC methods. The reconstructions obtained using the proposed algorithm is compared against stateof-the-art methods using free-breathing cardiac cine and myocardial perfusion datasets, using retrospective and prospective multi-channel experiments 4 | -------------------------------------------------------------------------------- /PRICE/utils/Readme.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/PRICE/utils/Readme.pdf -------------------------------------------------------------------------------- /PRICE/utils/computeDtD.m: -------------------------------------------------------------------------------- 1 | function DtD = computeDtD(ipStruct) 2 | %-------------------------------------- 3 | % %This function computes the finite difference operator of the Dirac function. 4 | % input - 5 | % ipStruct - input is a struct 6 | % 7 | % output - 8 | % DTD - finite difference operator. 9 | % 10 | % Please see : Y. Mohsin, S.G Lingala, E. DiBella, M.Jacob, 11 | % Accelerated dynamic MRI Using Patch Regularization for Implicit motion CompEnsation (PRICE), 12 | % Magnetic Resonance in Medicine, 2016 13 | % 14 | % Last Edit: 11/27/2016 15 | % Contact: Y. Mohsin (yasir-mohsin@uiowa.edu) 16 | % M. Jacob (mathews-jacob@uiowa.edu) 17 | % 18 | % Copyright 2016, CBIG Lab, College of Engineering, The University of Iowa. 19 | % https://research.engineering.uiowa.edu/cbig/content/price 20 | %-------------------------------------- 21 | 22 | DtD = zeros(ipStruct.nx,ipStruct.ny,ipStruct.nz); 23 | Dirac = zeros(ipStruct.nx,ipStruct.ny,ipStruct.nz); 24 | Dirac(1,1,1) = 1; 25 | %% Calculating DtD 26 | for k = ipStruct.Wint, 27 | for i=ipStruct.Winx, 28 | for j=ipStruct.Winy, 29 | if i==0&&j==0 30 | w=10; 31 | 32 | else 33 | w=ipStruct.w; 34 | end 35 | DDirac = circshift(Dirac,[i,j,k])-Dirac; 36 | DDtDirac = DDirac-circshift(DDirac,[-i,-j,-k]); 37 | DtD = DtD + DDtDirac*w; 38 | end 39 | end 40 | end 41 | -------------------------------------------------------------------------------- /PRICE/utils/lefthand.m: -------------------------------------------------------------------------------- 1 | function Acc = lefthand(out,input,DtD) 2 | %-------------------------------------- 3 | % This fucntion solves the left hand side of the PRICE scheme. 4 | % input - 5 | % out - input matrix/vector 6 | % DtD - finite difference operator of the Dirac function 7 | % input - input is a struct 8 | % output - 9 | % Acc - output matrix/vector 10 | % 11 | % Please see : Y. Mohsin, S.G Lingala, E. DiBella, M.Jacob, 12 | % Accelerated dynamic MRI Using Patch Regularization for Implicit motion CompEnsation (PRICE), 13 | % Magnetic Resonance in Medicine, 2016. 14 | % 15 | % Last Edit: 11/27/2016 16 | % Contact: Y. Mohsin (yasir-mohsin@uiowa.edu) 17 | % M. Jacob (mathews-jacob@uiowa.edu) 18 | % 19 | % Copyright 2016, CBIG Lab, College of Engineering, The University of Iowa. 20 | % https://research.engineering.uiowa.edu/cbig/content/price 21 | %-------------------------------------- 22 | 23 | out = reshape(out,input.nx,input.ny,input.nz); 24 | AtAf = input.At(input.A(out)); 25 | DTDf = ifftn(fftn(DtD).*fftn(out)); 26 | Acc = 2*AtAf-input.lambeta*DTDf; 27 | Acc = Acc(:); 28 | end -------------------------------------------------------------------------------- /PRICE/utils/shrinkage_L1_sat.m: -------------------------------------------------------------------------------- 1 | function out = shrinkage_L1_sat(in,input,T) 2 | %-------------------------------------- 3 | % This function solves the shrinkage part of the scheme and provides the result obtained by applying 4 | % the l_p threshold to in 5 | % input - 6 | % in - input matrix/vector 7 | % T - threshold parameter 8 | % input.p - p-value for the l_p penalty (input is a struct) 9 | % 10 | % output - 11 | % out - thresholded matrix/vector 12 | % 13 | % Please see : Y. Mohsin, S.G Lingala, E. DiBella, M.Jacob, 14 | % Accelerated dynamic MRI Using Patch Regularization for Implicit motion CompEnsation (PRICE), 15 | % Magnetic Resonance in Medicine, 2016 16 | % 17 | % Last Edit: 11/27/2016 18 | % Contact: Y. Mohsin (yasir-mohsin@uiowa.edu) 19 | % M. Jacob (mathews-jacob@uiowa.edu) 20 | % 21 | % Copyright 2016, CBIG Lab, College of Engineering, The University of Iowa. 22 | % https://research.engineering.uiowa.edu/cbig/content/price 23 | %-------------------------------------- 24 | 25 | mask = abs(in) < T; 26 | wt = max(abs(in) - (1/input.beta).*((abs(in)).^(input.p-1)),0)./(abs(in)+(in==0)); 27 | out = wt.*mask + not(mask); 28 | end 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | -------------------------------------------------------------------------------- /SpiralSToRM/@NUFFT/ctranspose.m: -------------------------------------------------------------------------------- 1 | function res = ctranspose(a) 2 | a.adjoint = xor(a.adjoint,1); 3 | res = a; 4 | 5 | -------------------------------------------------------------------------------- /SpiralSToRM/@NUFFT/mtimes.m: -------------------------------------------------------------------------------- 1 | function ress = mtimes(a,bb) 2 | % performs the normal nufft 3 | nf=size(bb,3); 4 | for n=1:nf 5 | b = bb(:,:,n); 6 | if a.adjoint 7 | b = b(:).*a.w(:); 8 | if size(a.st)==1 9 | res = nufft_adj(b, a.st{1})/sqrt(prod(a.imSize)); 10 | else 11 | res = nufft_adj(b, a.st{n})/sqrt(prod(a.imSize)); 12 | end 13 | res = reshape(res, a.imSize(1), a.imSize(2)); 14 | % res = res.*conj(a.phase); 15 | % if a.mode==1 16 | % res = real(res); 17 | % end 18 | 19 | else 20 | b = reshape(b,a.imSize(1),a.imSize(2)); 21 | % if a.mode==1 22 | % b = real(b); 23 | % end 24 | % b = b.*a.phase; 25 | if size(a.st)==1 26 | res = nufft(b, a.st{1})/sqrt(prod(a.imSize)); 27 | else 28 | res = nufft(b, a.st{n})/sqrt(prod(a.imSize)); 29 | end 30 | res = reshape(res,a.dataSize(1),a.dataSize(2)); 31 | end 32 | ress(:,:,n) = res; 33 | end 34 | 35 | -------------------------------------------------------------------------------- /SpiralSToRM/@NUFFT/times.m: -------------------------------------------------------------------------------- 1 | function ress = mtimes(a,bb) 2 | % performs only interpolation nufft 3 | 4 | for n=1:size(bb,3) 5 | b = bb(:,:,n); 6 | if a.adjoint 7 | b = b(:).*a.w(:); 8 | res = nufft_adj(b, a.st)/sqrt(prod(a.imSize));; 9 | res = reshape(res, a.imSize(1), a.imSize(2)); 10 | res = fft2c(res); 11 | else 12 | b = reshape(b,a.imSize(1),a.imSize(2)); 13 | b = ifft2c(b); 14 | res = nufft(b, a.st)/sqrt(prod(a.imSize)); 15 | res = reshape(res,a.dataSize(1),a.dataSize(2)); 16 | end 17 | ress(:,:,n) = res; 18 | end 19 | 20 | -------------------------------------------------------------------------------- /SpiralSToRM/@NUFFT/transpose.m: -------------------------------------------------------------------------------- 1 | function res = ctranspose(a) 2 | a.adjoint = xor(a.adjoint,1); 3 | res = a; 4 | 5 | -------------------------------------------------------------------------------- /SpiralSToRM/@gpuNUFFT/ctranspose.m: -------------------------------------------------------------------------------- 1 | function res = ctranspose(a) 2 | a.adjoint = xor(a.adjoint,1); 3 | res = a; 4 | 5 | -------------------------------------------------------------------------------- /SpiralSToRM/@gpuNUFFT/mtimes.m: -------------------------------------------------------------------------------- 1 | function res = mtimes(a,bb) 2 | if (a.adjoint) 3 | res = gpuNUFFT_adj(a.op,bb); 4 | else 5 | res = gpuNUFFT_forw(a.op,bb); 6 | end -------------------------------------------------------------------------------- /SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_adj_atomic_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_adj_atomic_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_adj_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_adj_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_forw_atomic_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_forw_atomic_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_forw_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_forw_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_precomp_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/@gpuNUFFT/private/mex_gpuNUFFT_precomp_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/@gpuNUFFT/transpose.m: -------------------------------------------------------------------------------- 1 | function res = ctranspose(a) 2 | a.adjoint = xor(a.adjoint,1); 3 | res = a; 4 | 5 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/cvp/README: -------------------------------------------------------------------------------- 1 | USAGE of CUDA Visual Profiler under LINUX 2 | 3 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/computeprof/bin 4 | 5 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/gtest_options: -------------------------------------------------------------------------------- 1 | repeat tests: --gtest_repeat=n --gtest_break_on_failure 2 | select single tests, filter: --gtest_filter=TestGridding.GPUTest_8SectorsKernel3nDataw32 3 | write output to xml file: --gtest_output="xml:" 4 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/libgpuNUFFT_ATM_f.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/bin/libgpuNUFFT_ATM_f.so -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/libgpuNUFFT_f.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/bin/libgpuNUFFT_f.so -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/mex_gpuNUFFT_adj_atomic_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/bin/mex_gpuNUFFT_adj_atomic_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/mex_gpuNUFFT_adj_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/bin/mex_gpuNUFFT_adj_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/mex_gpuNUFFT_forw_atomic_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/bin/mex_gpuNUFFT_forw_atomic_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/mex_gpuNUFFT_forw_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/bin/mex_gpuNUFFT_forw_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/mex_gpuNUFFT_precomp_f.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/bin/mex_gpuNUFFT_precomp_f.mexa64 -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/run_cpu_filtered_unit_test.cmd: -------------------------------------------------------------------------------- 1 | runUnitTests.exe --gtest_filter=TestGridding.CPUTest_8SectorsKernel3nDataw32 --gtest_repeat=100 --gtest_break_on_failure 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/run_cuda_memcheck: -------------------------------------------------------------------------------- 1 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64; 2 | 3 | /usr/local/cuda/bin/cuda-memcheck runGPUUnitTests 4 | 5 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/bin/run_gpu_filtered_unit_test.cmd: -------------------------------------------------------------------------------- 1 | runGPUUnitTests.exe --gtest_filter=TestGridding.GPUTest_8SectorsKernel3nDataw32 --gtest_repeat=100 --gtest_break_on_failure 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CMakeDetermineCompilerABI_C.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CMakeDetermineCompilerABI_C.bin -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CMakeDetermineCompilerABI_CXX.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CMakeDetermineCompilerABI_CXX.bin -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CMakeSystem.cmake: -------------------------------------------------------------------------------- 1 | set(CMAKE_HOST_SYSTEM "Linux-3.10.0-693.17.1.el7.x86_64") 2 | set(CMAKE_HOST_SYSTEM_NAME "Linux") 3 | set(CMAKE_HOST_SYSTEM_VERSION "3.10.0-693.17.1.el7.x86_64") 4 | set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") 5 | 6 | 7 | 8 | set(CMAKE_SYSTEM "Linux-3.10.0-693.17.1.el7.x86_64") 9 | set(CMAKE_SYSTEM_NAME "Linux") 10 | set(CMAKE_SYSTEM_VERSION "3.10.0-693.17.1.el7.x86_64") 11 | set(CMAKE_SYSTEM_PROCESSOR "x86_64") 12 | 13 | set(CMAKE_CROSSCOMPILING "FALSE") 14 | 15 | set(CMAKE_SYSTEM_LOADED 1) 16 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CompilerIdC/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CompilerIdC/a.out -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CompilerIdCXX/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/CMakeFiles/2.8.12.2/CompilerIdCXX/a.out -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/CMakeDirectoryInformation.cmake: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # Relative path conversion top directories. 5 | SET(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA") 6 | SET(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build") 7 | 8 | # Force unix paths in dependencies. 9 | SET(CMAKE_FORCE_UNIX_PATHS 1) 10 | 11 | 12 | # The C and CXX include file regular expressions for this directory. 13 | SET(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") 14 | SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") 15 | SET(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) 16 | SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/CMakeRuleHashes.txt: -------------------------------------------------------------------------------- 1 | # Hashes of file build rules. 2 | 43fc537daf521fe726d933709ee8b947 doc/CMakeFiles/doc 3 | 28dd87b22f0f77c29a1d745624fa9a23 src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/./gpuNUFFT_ATM_f_generated_atomic_gpuNUFFT.cu.o 4 | 12af3e0ace31dc8c65b90a572648a0df src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/./gpuNUFFT_ATM_f_generated_precomp_kernels.cu.o 5 | 6d82c6ff69849fc7d19a1245c1153118 src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/./gpuNUFFT_f_generated_coarse_gpuNUFFT.cu.o 6 | c0fba4cf08c16758c2c9716abbaef3ae src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/./gpuNUFFT_f_generated_precomp_kernels.cu.o 7 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/TargetDirectories.txt: -------------------------------------------------------------------------------- 1 | /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/doc/CMakeFiles/doc.dir 2 | /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir 3 | /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir 4 | /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir 5 | /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir 6 | /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir 7 | /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir 8 | /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/cmake.check_cache: -------------------------------------------------------------------------------- 1 | # This file is generated by cmake for dependency checking of the CMakeCache.txt file 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/CMakeFiles/progress.marks: -------------------------------------------------------------------------------- 1 | 26 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/doc/CMakeFiles/CMakeDirectoryInformation.cmake: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # Relative path conversion top directories. 5 | SET(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA") 6 | SET(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build") 7 | 8 | # Force unix paths in dependencies. 9 | SET(CMAKE_FORCE_UNIX_PATHS 1) 10 | 11 | 12 | # The C and CXX include file regular expressions for this directory. 13 | SET(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") 14 | SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") 15 | SET(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) 16 | SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/doc/CMakeFiles/doc.dir/DependInfo.cmake: -------------------------------------------------------------------------------- 1 | # The set of languages for which implicit dependencies are needed: 2 | SET(CMAKE_DEPENDS_LANGUAGES 3 | ) 4 | # The set of files for implicit dependencies of each language: 5 | 6 | # Targets to which this target links. 7 | SET(CMAKE_TARGET_LINKED_INFO_FILES 8 | ) 9 | 10 | # The include file search paths: 11 | SET(CMAKE_C_TARGET_INCLUDE_PATH 12 | "../inc" 13 | ) 14 | SET(CMAKE_CXX_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 15 | SET(CMAKE_Fortran_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 16 | SET(CMAKE_ASM_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/doc/CMakeFiles/doc.dir/cmake_clean.cmake: -------------------------------------------------------------------------------- 1 | FILE(REMOVE_RECURSE 2 | "CMakeFiles/doc" 3 | ) 4 | 5 | # Per-language clean rules from dependency scanning. 6 | FOREACH(lang) 7 | INCLUDE(CMakeFiles/doc.dir/cmake_clean_${lang}.cmake OPTIONAL) 8 | ENDFOREACH(lang) 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/doc/CMakeFiles/doc.dir/progress.make: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/doc/CMakeFiles/progress.marks: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/doc/cmake_install.cmake: -------------------------------------------------------------------------------- 1 | # Install script for directory: /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/doc 2 | 3 | # Set the install prefix 4 | IF(NOT DEFINED CMAKE_INSTALL_PREFIX) 5 | SET(CMAKE_INSTALL_PREFIX "/usr/local") 6 | ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX) 7 | STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") 8 | 9 | # Set the install configuration name. 10 | IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 11 | IF(BUILD_TYPE) 12 | STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" "" 13 | CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") 14 | ELSE(BUILD_TYPE) 15 | SET(CMAKE_INSTALL_CONFIG_NAME "") 16 | ENDIF(BUILD_TYPE) 17 | MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") 18 | ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 19 | 20 | # Set the component getting installed. 21 | IF(NOT CMAKE_INSTALL_COMPONENT) 22 | IF(COMPONENT) 23 | MESSAGE(STATUS "Install component: \"${COMPONENT}\"") 24 | SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}") 25 | ELSE(COMPONENT) 26 | SET(CMAKE_INSTALL_COMPONENT) 27 | ENDIF(COMPONENT) 28 | ENDIF(NOT CMAKE_INSTALL_COMPONENT) 29 | 30 | # Install shared libraries without execute permission? 31 | IF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 32 | SET(CMAKE_INSTALL_SO_NO_EXE "0") 33 | ENDIF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 34 | 35 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/CMakeFiles/CMakeDirectoryInformation.cmake: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # Relative path conversion top directories. 5 | SET(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA") 6 | SET(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build") 7 | 8 | # Force unix paths in dependencies. 9 | SET(CMAKE_FORCE_UNIX_PATHS 1) 10 | 11 | 12 | # The C and CXX include file regular expressions for this directory. 13 | SET(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") 14 | SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") 15 | SET(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) 16 | SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/CMakeFiles/progress.marks: -------------------------------------------------------------------------------- 1 | 26 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/cmake_install.cmake: -------------------------------------------------------------------------------- 1 | # Install script for directory: /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src 2 | 3 | # Set the install prefix 4 | IF(NOT DEFINED CMAKE_INSTALL_PREFIX) 5 | SET(CMAKE_INSTALL_PREFIX "/usr/local") 6 | ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX) 7 | STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") 8 | 9 | # Set the install configuration name. 10 | IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 11 | IF(BUILD_TYPE) 12 | STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" "" 13 | CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") 14 | ELSE(BUILD_TYPE) 15 | SET(CMAKE_INSTALL_CONFIG_NAME "") 16 | ENDIF(BUILD_TYPE) 17 | MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") 18 | ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 19 | 20 | # Set the component getting installed. 21 | IF(NOT CMAKE_INSTALL_COMPONENT) 22 | IF(COMPONENT) 23 | MESSAGE(STATUS "Install component: \"${COMPONENT}\"") 24 | SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}") 25 | ELSE(COMPONENT) 26 | SET(CMAKE_INSTALL_COMPONENT) 27 | ENDIF(COMPONENT) 28 | ENDIF(NOT CMAKE_INSTALL_COMPONENT) 29 | 30 | # Install shared libraries without execute permission? 31 | IF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 32 | SET(CMAKE_INSTALL_SO_NO_EXE "0") 33 | ENDIF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 34 | 35 | IF(NOT CMAKE_INSTALL_LOCAL_ONLY) 36 | # Include the install script for each subdirectory. 37 | INCLUDE("/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/cmake_install.cmake") 38 | 39 | ENDIF(NOT CMAKE_INSTALL_LOCAL_ONLY) 40 | 41 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/CMakeFiles/CMakeDirectoryInformation.cmake: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # Relative path conversion top directories. 5 | SET(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA") 6 | SET(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build") 7 | 8 | # Force unix paths in dependencies. 9 | SET(CMAKE_FORCE_UNIX_PATHS 1) 10 | 11 | 12 | # The C and CXX include file regular expressions for this directory. 13 | SET(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") 14 | SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") 15 | SET(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) 16 | SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/CMakeFiles/progress.marks: -------------------------------------------------------------------------------- 1 | 26 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/CMakeDirectoryInformation.cmake: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # Relative path conversion top directories. 5 | SET(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA") 6 | SET(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build") 7 | 8 | # Force unix paths in dependencies. 9 | SET(CMAKE_FORCE_UNIX_PATHS 1) 10 | 11 | 12 | # The C and CXX include file regular expressions for this directory. 13 | SET(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") 14 | SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") 15 | SET(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) 16 | SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/balanced_gpuNUFFT_operator.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/balanced_gpuNUFFT_operator.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/balanced_texture_gpuNUFFT_operator.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/balanced_texture_gpuNUFFT_operator.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_operator.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_operator.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_operator_factory.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_operator_factory.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_utils.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_utils.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/texture_gpuNUFFT_operator.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/texture_gpuNUFFT_operator.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/gpuNUFFT_ATM_f_generated_precomp_kernels.cu.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/__/gpuNUFFT_ATM_f_generated_precomp_kernels.cu.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/cmake_clean.cmake: -------------------------------------------------------------------------------- 1 | FILE(REMOVE_RECURSE 2 | "CMakeFiles/gpuNUFFT_ATM_f.dir/./gpuNUFFT_ATM_f_generated_atomic_gpuNUFFT.cu.o" 3 | "CMakeFiles/gpuNUFFT_ATM_f.dir/__/./gpuNUFFT_ATM_f_generated_precomp_kernels.cu.o" 4 | "CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_utils.cpp.o" 5 | "CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_operator_factory.cpp.o" 6 | "CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_operator.cpp.o" 7 | "CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/texture_gpuNUFFT_operator.cpp.o" 8 | "CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/balanced_gpuNUFFT_operator.cpp.o" 9 | "CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/balanced_texture_gpuNUFFT_operator.cpp.o" 10 | "../../../../bin/libgpuNUFFT_ATM_f.pdb" 11 | "../../../../bin/libgpuNUFFT_ATM_f.so" 12 | ) 13 | 14 | # Per-language clean rules from dependency scanning. 15 | FOREACH(lang CXX) 16 | INCLUDE(CMakeFiles/gpuNUFFT_ATM_f.dir/cmake_clean_${lang}.cmake OPTIONAL) 17 | ENDFOREACH(lang) 18 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/flags.make: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # compile CXX with /usr/bin/c++ 5 | CXX_FLAGS = -fPIC -I/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/inc -I/opt/apps/cuda/9.1.85.2/include 6 | 7 | CXX_DEFINES = -DgpuNUFFT_ATM_f_EXPORTS 8 | 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/gpuNUFFT_ATM_f_generated_atomic_gpuNUFFT.cu.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/gpuNUFFT_ATM_f_generated_atomic_gpuNUFFT.cu.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/link.txt: -------------------------------------------------------------------------------- 1 | /usr/bin/c++ -fPIC -shared -Wl,-soname,libgpuNUFFT_ATM_f.so -o ../../../../bin/libgpuNUFFT_ATM_f.so CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_utils.cpp.o CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_operator_factory.cpp.o CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/gpuNUFFT_operator.cpp.o CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/texture_gpuNUFFT_operator.cpp.o CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/balanced_gpuNUFFT_operator.cpp.o CMakeFiles/gpuNUFFT_ATM_f.dir/__/__/balanced_texture_gpuNUFFT_operator.cpp.o CMakeFiles/gpuNUFFT_ATM_f.dir/./gpuNUFFT_ATM_f_generated_atomic_gpuNUFFT.cu.o CMakeFiles/gpuNUFFT_ATM_f.dir/__/./gpuNUFFT_ATM_f_generated_precomp_kernels.cu.o -lcudart -lcufft -lcublas 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/progress.make: -------------------------------------------------------------------------------- 1 | CMAKE_PROGRESS_1 = 1 2 | CMAKE_PROGRESS_2 = 2 3 | CMAKE_PROGRESS_3 = 3 4 | CMAKE_PROGRESS_4 = 4 5 | CMAKE_PROGRESS_5 = 5 6 | CMAKE_PROGRESS_6 = 6 7 | CMAKE_PROGRESS_7 = 7 8 | CMAKE_PROGRESS_8 = 8 9 | 10 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/CMakeFiles/progress.marks: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/atomic/cmake_install.cmake: -------------------------------------------------------------------------------- 1 | # Install script for directory: /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/atomic 2 | 3 | # Set the install prefix 4 | IF(NOT DEFINED CMAKE_INSTALL_PREFIX) 5 | SET(CMAKE_INSTALL_PREFIX "/usr/local") 6 | ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX) 7 | STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") 8 | 9 | # Set the install configuration name. 10 | IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 11 | IF(BUILD_TYPE) 12 | STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" "" 13 | CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") 14 | ELSE(BUILD_TYPE) 15 | SET(CMAKE_INSTALL_CONFIG_NAME "") 16 | ENDIF(BUILD_TYPE) 17 | MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") 18 | ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 19 | 20 | # Set the component getting installed. 21 | IF(NOT CMAKE_INSTALL_COMPONENT) 22 | IF(COMPONENT) 23 | MESSAGE(STATUS "Install component: \"${COMPONENT}\"") 24 | SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}") 25 | ELSE(COMPONENT) 26 | SET(CMAKE_INSTALL_COMPONENT) 27 | ENDIF(COMPONENT) 28 | ENDIF(NOT CMAKE_INSTALL_COMPONENT) 29 | 30 | # Install shared libraries without execute permission? 31 | IF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 32 | SET(CMAKE_INSTALL_SO_NO_EXE "0") 33 | ENDIF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 34 | 35 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/CMakeDirectoryInformation.cmake: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # Relative path conversion top directories. 5 | SET(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA") 6 | SET(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build") 7 | 8 | # Force unix paths in dependencies. 9 | SET(CMAKE_FORCE_UNIX_PATHS 1) 10 | 11 | 12 | # The C and CXX include file regular expressions for this directory. 13 | SET(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") 14 | SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") 15 | SET(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) 16 | SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/balanced_gpuNUFFT_operator.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/balanced_gpuNUFFT_operator.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/balanced_texture_gpuNUFFT_operator.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/balanced_texture_gpuNUFFT_operator.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_operator.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_operator.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_operator_factory.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_operator_factory.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_utils.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_utils.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/texture_gpuNUFFT_operator.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/__/texture_gpuNUFFT_operator.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/gpuNUFFT_f_generated_precomp_kernels.cu.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/__/gpuNUFFT_f_generated_precomp_kernels.cu.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/cmake_clean.cmake: -------------------------------------------------------------------------------- 1 | FILE(REMOVE_RECURSE 2 | "CMakeFiles/gpuNUFFT_f.dir/./gpuNUFFT_f_generated_coarse_gpuNUFFT.cu.o" 3 | "CMakeFiles/gpuNUFFT_f.dir/__/./gpuNUFFT_f_generated_precomp_kernels.cu.o" 4 | "CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_utils.cpp.o" 5 | "CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_operator_factory.cpp.o" 6 | "CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_operator.cpp.o" 7 | "CMakeFiles/gpuNUFFT_f.dir/__/__/texture_gpuNUFFT_operator.cpp.o" 8 | "CMakeFiles/gpuNUFFT_f.dir/__/__/balanced_gpuNUFFT_operator.cpp.o" 9 | "CMakeFiles/gpuNUFFT_f.dir/__/__/balanced_texture_gpuNUFFT_operator.cpp.o" 10 | "../../../../bin/libgpuNUFFT_f.pdb" 11 | "../../../../bin/libgpuNUFFT_f.so" 12 | ) 13 | 14 | # Per-language clean rules from dependency scanning. 15 | FOREACH(lang CXX) 16 | INCLUDE(CMakeFiles/gpuNUFFT_f.dir/cmake_clean_${lang}.cmake OPTIONAL) 17 | ENDFOREACH(lang) 18 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/flags.make: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # compile CXX with /usr/bin/c++ 5 | CXX_FLAGS = -fPIC -I/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/inc -I/opt/apps/cuda/9.1.85.2/include 6 | 7 | CXX_DEFINES = -DgpuNUFFT_f_EXPORTS 8 | 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/gpuNUFFT_f_generated_coarse_gpuNUFFT.cu.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/gpuNUFFT_f_generated_coarse_gpuNUFFT.cu.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/link.txt: -------------------------------------------------------------------------------- 1 | /usr/bin/c++ -fPIC -shared -Wl,-soname,libgpuNUFFT_f.so -o ../../../../bin/libgpuNUFFT_f.so CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_utils.cpp.o CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_operator_factory.cpp.o CMakeFiles/gpuNUFFT_f.dir/__/__/gpuNUFFT_operator.cpp.o CMakeFiles/gpuNUFFT_f.dir/__/__/texture_gpuNUFFT_operator.cpp.o CMakeFiles/gpuNUFFT_f.dir/__/__/balanced_gpuNUFFT_operator.cpp.o CMakeFiles/gpuNUFFT_f.dir/__/__/balanced_texture_gpuNUFFT_operator.cpp.o CMakeFiles/gpuNUFFT_f.dir/./gpuNUFFT_f_generated_coarse_gpuNUFFT.cu.o CMakeFiles/gpuNUFFT_f.dir/__/./gpuNUFFT_f_generated_precomp_kernels.cu.o -lcudart -lcufft -lcublas 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/progress.make: -------------------------------------------------------------------------------- 1 | CMAKE_PROGRESS_1 = 9 2 | CMAKE_PROGRESS_2 = 10 3 | CMAKE_PROGRESS_3 = 11 4 | CMAKE_PROGRESS_4 = 12 5 | CMAKE_PROGRESS_5 = 13 6 | CMAKE_PROGRESS_6 = 14 7 | CMAKE_PROGRESS_7 = 15 8 | CMAKE_PROGRESS_8 = 16 9 | 10 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/CMakeFiles/progress.marks: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/coarse/cmake_install.cmake: -------------------------------------------------------------------------------- 1 | # Install script for directory: /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/coarse 2 | 3 | # Set the install prefix 4 | IF(NOT DEFINED CMAKE_INSTALL_PREFIX) 5 | SET(CMAKE_INSTALL_PREFIX "/usr/local") 6 | ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX) 7 | STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") 8 | 9 | # Set the install configuration name. 10 | IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 11 | IF(BUILD_TYPE) 12 | STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" "" 13 | CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") 14 | ELSE(BUILD_TYPE) 15 | SET(CMAKE_INSTALL_CONFIG_NAME "") 16 | ENDIF(BUILD_TYPE) 17 | MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") 18 | ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 19 | 20 | # Set the component getting installed. 21 | IF(NOT CMAKE_INSTALL_COMPONENT) 22 | IF(COMPONENT) 23 | MESSAGE(STATUS "Install component: \"${COMPONENT}\"") 24 | SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}") 25 | ELSE(COMPONENT) 26 | SET(CMAKE_INSTALL_COMPONENT) 27 | ENDIF(COMPONENT) 28 | ENDIF(NOT CMAKE_INSTALL_COMPONENT) 29 | 30 | # Install shared libraries without execute permission? 31 | IF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 32 | SET(CMAKE_INSTALL_SO_NO_EXE "0") 33 | ENDIF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 34 | 35 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/CMakeDirectoryInformation.cmake: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # Relative path conversion top directories. 5 | SET(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA") 6 | SET(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build") 7 | 8 | # Force unix paths in dependencies. 9 | SET(CMAKE_FORCE_UNIX_PATHS 1) 10 | 11 | 12 | # The C and CXX include file regular expressions for this directory. 13 | SET(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") 14 | SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") 15 | SET(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) 16 | SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/DependInfo.cmake: -------------------------------------------------------------------------------- 1 | # The set of languages for which implicit dependencies are needed: 2 | SET(CMAKE_DEPENDS_LANGUAGES 3 | "CXX" 4 | ) 5 | # The set of files for implicit dependencies of each language: 6 | SET(CMAKE_DEPENDS_CHECK_CXX 7 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_adj.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_adj.cpp.o" 8 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_operator_matlabfactory.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o" 9 | ) 10 | SET(CMAKE_CXX_COMPILER_ID "GNU") 11 | 12 | # Targets to which this target links. 13 | SET(CMAKE_TARGET_LINKED_INFO_FILES 14 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/DependInfo.cmake" 15 | ) 16 | 17 | # The include file search paths: 18 | SET(CMAKE_C_TARGET_INCLUDE_PATH 19 | "../inc" 20 | "/opt/apps/matlab/R2016b/extern/include" 21 | "/opt/apps/cuda/9.1.85.2/include" 22 | ) 23 | SET(CMAKE_CXX_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 24 | SET(CMAKE_Fortran_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 25 | SET(CMAKE_ASM_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 26 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/cmake_clean.cmake: -------------------------------------------------------------------------------- 1 | FILE(REMOVE_RECURSE 2 | "CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_adj.cpp.o" 3 | "CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o" 4 | "../../../../bin/mex_gpuNUFFT_adj_atomic_f.pdb" 5 | "../../../../bin/mex_gpuNUFFT_adj_atomic_f.mexa64" 6 | ) 7 | 8 | # Per-language clean rules from dependency scanning. 9 | FOREACH(lang CXX) 10 | INCLUDE(CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/cmake_clean_${lang}.cmake OPTIONAL) 11 | ENDFOREACH(lang) 12 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/flags.make: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # compile CXX with /usr/bin/c++ 5 | CXX_FLAGS = -fPIC -I/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/inc -I/opt/apps/matlab/R2016b/extern/include -I/opt/apps/cuda/9.1.85.2/include 6 | 7 | CXX_DEFINES = -Dmex_gpuNUFFT_adj_atomic_f_EXPORTS 8 | 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_adj.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_adj.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/link.txt: -------------------------------------------------------------------------------- 1 | /usr/bin/c++ -fPIC -shared -Wl,-soname,mex_gpuNUFFT_adj_atomic_f.mexa64 -o ../../../../bin/mex_gpuNUFFT_adj_atomic_f.mexa64 CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_adj.cpp.o CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o -L/opt/apps/matlab/R2016b/bin/glnxa64 -lcudart -lmex -lmx -lcudart ../../../../bin/libgpuNUFFT_ATM_f.so -lcudart -lcufft -lcublas -Wl,-rpath,/opt/apps/matlab/R2016b/bin/glnxa64:/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/bin 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_atomic_f.dir/progress.make: -------------------------------------------------------------------------------- 1 | CMAKE_PROGRESS_1 = 17 2 | CMAKE_PROGRESS_2 = 18 3 | 4 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/DependInfo.cmake: -------------------------------------------------------------------------------- 1 | # The set of languages for which implicit dependencies are needed: 2 | SET(CMAKE_DEPENDS_LANGUAGES 3 | "CXX" 4 | ) 5 | # The set of files for implicit dependencies of each language: 6 | SET(CMAKE_DEPENDS_CHECK_CXX 7 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_adj.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_adj.cpp.o" 8 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_operator_matlabfactory.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o" 9 | ) 10 | SET(CMAKE_CXX_COMPILER_ID "GNU") 11 | 12 | # Targets to which this target links. 13 | SET(CMAKE_TARGET_LINKED_INFO_FILES 14 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/DependInfo.cmake" 15 | ) 16 | 17 | # The include file search paths: 18 | SET(CMAKE_C_TARGET_INCLUDE_PATH 19 | "../inc" 20 | "/opt/apps/matlab/R2016b/extern/include" 21 | "/opt/apps/cuda/9.1.85.2/include" 22 | ) 23 | SET(CMAKE_CXX_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 24 | SET(CMAKE_Fortran_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 25 | SET(CMAKE_ASM_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 26 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/cmake_clean.cmake: -------------------------------------------------------------------------------- 1 | FILE(REMOVE_RECURSE 2 | "CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_adj.cpp.o" 3 | "CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o" 4 | "../../../../bin/mex_gpuNUFFT_adj_f.pdb" 5 | "../../../../bin/mex_gpuNUFFT_adj_f.mexa64" 6 | ) 7 | 8 | # Per-language clean rules from dependency scanning. 9 | FOREACH(lang CXX) 10 | INCLUDE(CMakeFiles/mex_gpuNUFFT_adj_f.dir/cmake_clean_${lang}.cmake OPTIONAL) 11 | ENDFOREACH(lang) 12 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/flags.make: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # compile CXX with /usr/bin/c++ 5 | CXX_FLAGS = -fPIC -I/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/inc -I/opt/apps/matlab/R2016b/extern/include -I/opt/apps/cuda/9.1.85.2/include 6 | 7 | CXX_DEFINES = -Dmex_gpuNUFFT_adj_f_EXPORTS 8 | 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_adj.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_adj.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/link.txt: -------------------------------------------------------------------------------- 1 | /usr/bin/c++ -fPIC -shared -Wl,-soname,mex_gpuNUFFT_adj_f.mexa64 -o ../../../../bin/mex_gpuNUFFT_adj_f.mexa64 CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_adj.cpp.o CMakeFiles/mex_gpuNUFFT_adj_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o -L/opt/apps/matlab/R2016b/bin/glnxa64 -lcudart -lmex -lmx -lcudart ../../../../bin/libgpuNUFFT_f.so -lcudart -lcufft -lcublas -Wl,-rpath,/opt/apps/matlab/R2016b/bin/glnxa64:/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/bin 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_adj_f.dir/progress.make: -------------------------------------------------------------------------------- 1 | CMAKE_PROGRESS_1 = 19 2 | CMAKE_PROGRESS_2 = 20 3 | 4 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/DependInfo.cmake: -------------------------------------------------------------------------------- 1 | # The set of languages for which implicit dependencies are needed: 2 | SET(CMAKE_DEPENDS_LANGUAGES 3 | "CXX" 4 | ) 5 | # The set of files for implicit dependencies of each language: 6 | SET(CMAKE_DEPENDS_CHECK_CXX 7 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_forw.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_forw.cpp.o" 8 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_operator_matlabfactory.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o" 9 | ) 10 | SET(CMAKE_CXX_COMPILER_ID "GNU") 11 | 12 | # Targets to which this target links. 13 | SET(CMAKE_TARGET_LINKED_INFO_FILES 14 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/atomic/CMakeFiles/gpuNUFFT_ATM_f.dir/DependInfo.cmake" 15 | ) 16 | 17 | # The include file search paths: 18 | SET(CMAKE_C_TARGET_INCLUDE_PATH 19 | "../inc" 20 | "/opt/apps/matlab/R2016b/extern/include" 21 | "/opt/apps/cuda/9.1.85.2/include" 22 | ) 23 | SET(CMAKE_CXX_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 24 | SET(CMAKE_Fortran_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 25 | SET(CMAKE_ASM_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 26 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/cmake_clean.cmake: -------------------------------------------------------------------------------- 1 | FILE(REMOVE_RECURSE 2 | "CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_forw.cpp.o" 3 | "CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o" 4 | "../../../../bin/mex_gpuNUFFT_forw_atomic_f.pdb" 5 | "../../../../bin/mex_gpuNUFFT_forw_atomic_f.mexa64" 6 | ) 7 | 8 | # Per-language clean rules from dependency scanning. 9 | FOREACH(lang CXX) 10 | INCLUDE(CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/cmake_clean_${lang}.cmake OPTIONAL) 11 | ENDFOREACH(lang) 12 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/flags.make: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # compile CXX with /usr/bin/c++ 5 | CXX_FLAGS = -fPIC -I/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/inc -I/opt/apps/matlab/R2016b/extern/include -I/opt/apps/cuda/9.1.85.2/include 6 | 7 | CXX_DEFINES = -Dmex_gpuNUFFT_forw_atomic_f_EXPORTS 8 | 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_forw.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_forw.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/link.txt: -------------------------------------------------------------------------------- 1 | /usr/bin/c++ -fPIC -shared -Wl,-soname,mex_gpuNUFFT_forw_atomic_f.mexa64 -o ../../../../bin/mex_gpuNUFFT_forw_atomic_f.mexa64 CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_forw.cpp.o CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o -L/opt/apps/matlab/R2016b/bin/glnxa64 -lcudart -lmex -lmx -lcudart ../../../../bin/libgpuNUFFT_ATM_f.so -lcudart -lcufft -lcublas -Wl,-rpath,/opt/apps/matlab/R2016b/bin/glnxa64:/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/bin 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_atomic_f.dir/progress.make: -------------------------------------------------------------------------------- 1 | CMAKE_PROGRESS_1 = 21 2 | CMAKE_PROGRESS_2 = 22 3 | 4 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/DependInfo.cmake: -------------------------------------------------------------------------------- 1 | # The set of languages for which implicit dependencies are needed: 2 | SET(CMAKE_DEPENDS_LANGUAGES 3 | "CXX" 4 | ) 5 | # The set of files for implicit dependencies of each language: 6 | SET(CMAKE_DEPENDS_CHECK_CXX 7 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_forw.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_forw.cpp.o" 8 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_operator_matlabfactory.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o" 9 | ) 10 | SET(CMAKE_CXX_COMPILER_ID "GNU") 11 | 12 | # Targets to which this target links. 13 | SET(CMAKE_TARGET_LINKED_INFO_FILES 14 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/DependInfo.cmake" 15 | ) 16 | 17 | # The include file search paths: 18 | SET(CMAKE_C_TARGET_INCLUDE_PATH 19 | "../inc" 20 | "/opt/apps/matlab/R2016b/extern/include" 21 | "/opt/apps/cuda/9.1.85.2/include" 22 | ) 23 | SET(CMAKE_CXX_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 24 | SET(CMAKE_Fortran_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 25 | SET(CMAKE_ASM_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 26 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/cmake_clean.cmake: -------------------------------------------------------------------------------- 1 | FILE(REMOVE_RECURSE 2 | "CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_forw.cpp.o" 3 | "CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o" 4 | "../../../../bin/mex_gpuNUFFT_forw_f.pdb" 5 | "../../../../bin/mex_gpuNUFFT_forw_f.mexa64" 6 | ) 7 | 8 | # Per-language clean rules from dependency scanning. 9 | FOREACH(lang CXX) 10 | INCLUDE(CMakeFiles/mex_gpuNUFFT_forw_f.dir/cmake_clean_${lang}.cmake OPTIONAL) 11 | ENDFOREACH(lang) 12 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/flags.make: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # compile CXX with /usr/bin/c++ 5 | CXX_FLAGS = -fPIC -I/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/inc -I/opt/apps/matlab/R2016b/extern/include -I/opt/apps/cuda/9.1.85.2/include 6 | 7 | CXX_DEFINES = -Dmex_gpuNUFFT_forw_f_EXPORTS 8 | 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_forw.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_forw.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/link.txt: -------------------------------------------------------------------------------- 1 | /usr/bin/c++ -fPIC -shared -Wl,-soname,mex_gpuNUFFT_forw_f.mexa64 -o ../../../../bin/mex_gpuNUFFT_forw_f.mexa64 CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_forw.cpp.o CMakeFiles/mex_gpuNUFFT_forw_f.dir/gpuNUFFT_operator_matlabfactory.cpp.o -L/opt/apps/matlab/R2016b/bin/glnxa64 -lcudart -lmex -lmx -lcudart ../../../../bin/libgpuNUFFT_f.so -lcudart -lcufft -lcublas -Wl,-rpath,/opt/apps/matlab/R2016b/bin/glnxa64:/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/bin 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/mex_gpuNUFFT_forw_f.dir/progress.make: -------------------------------------------------------------------------------- 1 | CMAKE_PROGRESS_1 = 23 2 | CMAKE_PROGRESS_2 = 24 3 | 4 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/CMakeFiles/progress.marks: -------------------------------------------------------------------------------- 1 | 26 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/cmake_install.cmake: -------------------------------------------------------------------------------- 1 | # Install script for directory: /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab 2 | 3 | # Set the install prefix 4 | IF(NOT DEFINED CMAKE_INSTALL_PREFIX) 5 | SET(CMAKE_INSTALL_PREFIX "/usr/local") 6 | ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX) 7 | STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") 8 | 9 | # Set the install configuration name. 10 | IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 11 | IF(BUILD_TYPE) 12 | STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" "" 13 | CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") 14 | ELSE(BUILD_TYPE) 15 | SET(CMAKE_INSTALL_CONFIG_NAME "") 16 | ENDIF(BUILD_TYPE) 17 | MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") 18 | ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 19 | 20 | # Set the component getting installed. 21 | IF(NOT CMAKE_INSTALL_COMPONENT) 22 | IF(COMPONENT) 23 | MESSAGE(STATUS "Install component: \"${COMPONENT}\"") 24 | SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}") 25 | ELSE(COMPONENT) 26 | SET(CMAKE_INSTALL_COMPONENT) 27 | ENDIF(COMPONENT) 28 | ENDIF(NOT CMAKE_INSTALL_COMPONENT) 29 | 30 | # Install shared libraries without execute permission? 31 | IF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 32 | SET(CMAKE_INSTALL_SO_NO_EXE "0") 33 | ENDIF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 34 | 35 | IF(NOT CMAKE_INSTALL_LOCAL_ONLY) 36 | # Include the install script for each subdirectory. 37 | INCLUDE("/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/precomputation/cmake_install.cmake") 38 | 39 | ENDIF(NOT CMAKE_INSTALL_LOCAL_ONLY) 40 | 41 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/CMakeDirectoryInformation.cmake: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # Relative path conversion top directories. 5 | SET(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA") 6 | SET(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build") 7 | 8 | # Force unix paths in dependencies. 9 | SET(CMAKE_FORCE_UNIX_PATHS 1) 10 | 11 | 12 | # The C and CXX include file regular expressions for this directory. 13 | SET(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") 14 | SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") 15 | SET(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) 16 | SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/DependInfo.cmake: -------------------------------------------------------------------------------- 1 | # The set of languages for which implicit dependencies are needed: 2 | SET(CMAKE_DEPENDS_LANGUAGES 3 | "CXX" 4 | ) 5 | # The set of files for implicit dependencies of each language: 6 | SET(CMAKE_DEPENDS_CHECK_CXX 7 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/gpuNUFFT_operator_matlabfactory.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/__/gpuNUFFT_operator_matlabfactory.cpp.o" 8 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/precomputation/gpuNUFFT_precomp.cpp" "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/gpuNUFFT_precomp.cpp.o" 9 | ) 10 | SET(CMAKE_CXX_COMPILER_ID "GNU") 11 | 12 | # Targets to which this target links. 13 | SET(CMAKE_TARGET_LINKED_INFO_FILES 14 | "/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/build/src/gpu/coarse/CMakeFiles/gpuNUFFT_f.dir/DependInfo.cmake" 15 | ) 16 | 17 | # The include file search paths: 18 | SET(CMAKE_C_TARGET_INCLUDE_PATH 19 | "../inc" 20 | "/opt/apps/matlab/R2016b/extern/include" 21 | "/opt/apps/cuda/9.1.85.2/include" 22 | ) 23 | SET(CMAKE_CXX_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 24 | SET(CMAKE_Fortran_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 25 | SET(CMAKE_ASM_TARGET_INCLUDE_PATH ${CMAKE_C_TARGET_INCLUDE_PATH}) 26 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/__/gpuNUFFT_operator_matlabfactory.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/__/gpuNUFFT_operator_matlabfactory.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/cmake_clean.cmake: -------------------------------------------------------------------------------- 1 | FILE(REMOVE_RECURSE 2 | "CMakeFiles/mex_gpuNUFFT_precomp_f.dir/gpuNUFFT_precomp.cpp.o" 3 | "CMakeFiles/mex_gpuNUFFT_precomp_f.dir/__/gpuNUFFT_operator_matlabfactory.cpp.o" 4 | "../../../../../bin/mex_gpuNUFFT_precomp_f.pdb" 5 | "../../../../../bin/mex_gpuNUFFT_precomp_f.mexa64" 6 | ) 7 | 8 | # Per-language clean rules from dependency scanning. 9 | FOREACH(lang CXX) 10 | INCLUDE(CMakeFiles/mex_gpuNUFFT_precomp_f.dir/cmake_clean_${lang}.cmake OPTIONAL) 11 | ENDFOREACH(lang) 12 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/flags.make: -------------------------------------------------------------------------------- 1 | # CMAKE generated file: DO NOT EDIT! 2 | # Generated by "Unix Makefiles" Generator, CMake Version 2.8 3 | 4 | # compile CXX with /usr/bin/c++ 5 | CXX_FLAGS = -fPIC -I/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/inc -I/opt/apps/matlab/R2016b/extern/include -I/opt/apps/cuda/9.1.85.2/include 6 | 7 | CXX_DEFINES = -Dmex_gpuNUFFT_precomp_f_EXPORTS 8 | 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/gpuNUFFT_precomp.cpp.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/gpuNUFFT_precomp.cpp.o -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/link.txt: -------------------------------------------------------------------------------- 1 | /usr/bin/c++ -fPIC -shared -Wl,-soname,mex_gpuNUFFT_precomp_f.mexa64 -o ../../../../../bin/mex_gpuNUFFT_precomp_f.mexa64 CMakeFiles/mex_gpuNUFFT_precomp_f.dir/gpuNUFFT_precomp.cpp.o CMakeFiles/mex_gpuNUFFT_precomp_f.dir/__/gpuNUFFT_operator_matlabfactory.cpp.o -L/opt/apps/matlab/R2016b/bin/glnxa64 -lcudart -lmex -lmx -lcudart ../../../../../bin/libgpuNUFFT_f.so -lcudart -lcufft -lcublas -Wl,-rpath,/opt/apps/matlab/R2016b/bin/glnxa64:/Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/bin 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/mex_gpuNUFFT_precomp_f.dir/progress.make: -------------------------------------------------------------------------------- 1 | CMAKE_PROGRESS_1 = 25 2 | CMAKE_PROGRESS_2 = 26 3 | 4 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/CMakeFiles/progress.marks: -------------------------------------------------------------------------------- 1 | 10 2 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/build/src/gpu/matlab/precomputation/cmake_install.cmake: -------------------------------------------------------------------------------- 1 | # Install script for directory: /Users/ahhmed/Downloads/gpuNUFFT-master/CUDA/src/gpu/matlab/precomputation 2 | 3 | # Set the install prefix 4 | IF(NOT DEFINED CMAKE_INSTALL_PREFIX) 5 | SET(CMAKE_INSTALL_PREFIX "/usr/local") 6 | ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX) 7 | STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") 8 | 9 | # Set the install configuration name. 10 | IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 11 | IF(BUILD_TYPE) 12 | STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" "" 13 | CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") 14 | ELSE(BUILD_TYPE) 15 | SET(CMAKE_INSTALL_CONFIG_NAME "") 16 | ENDIF(BUILD_TYPE) 17 | MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") 18 | ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 19 | 20 | # Set the component getting installed. 21 | IF(NOT CMAKE_INSTALL_COMPONENT) 22 | IF(COMPONENT) 23 | MESSAGE(STATUS "Install component: \"${COMPONENT}\"") 24 | SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}") 25 | ELSE(COMPONENT) 26 | SET(CMAKE_INSTALL_COMPONENT) 27 | ENDIF(COMPONENT) 28 | ENDIF(NOT CMAKE_INSTALL_COMPONENT) 29 | 30 | # Install shared libraries without execute permission? 31 | IF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 32 | SET(CMAKE_INSTALL_SO_NO_EXE "0") 33 | ENDIF(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) 34 | 35 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/cmake_modules/FindGPUNUFFT.cmake: -------------------------------------------------------------------------------- 1 | INCLUDE(FindPackageHandleStandardArgs) 2 | 3 | IF (NOT DEFINED GPUNUFFT_ROOT_DIR) 4 | MESSAGE(FATAL_ERROR "GPUNUFFT_ROOT_DIR not defined!") 5 | ELSE() 6 | MESSAGE("Searching for GPUNUFFT in ${GPUNUFFT_ROOT_DIR}") 7 | 8 | SET(GPUNUFFT_IncludeSearchPaths ${GPUNUFFT_ROOT_DIR}/CUDA/inc ${GPUNUFFT_ROOT_DIR}/inc) #/usr/local/include 9 | SET(GPUNUFFT_LibrarySearchPaths ${GPUNUFFT_ROOT_DIR}/CUDA/bin ${GPUNUFFT_ROOT_DIR}/bin) #/usr/local/lib 10 | 11 | FIND_PATH(GPUNUFFT_INCLUDE_DIRS NAMES gpuNUFFT_operator_factory.hpp PATHS ${GPUNUFFT_IncludeSearchPaths}) 12 | 13 | FIND_LIBRARY(GPUNUFFT_LIBRARIES NAMES gpuNUFFT gpuNUFFT_ATM_f gpuNUFFT_f PATHS ${GPUNUFFT_LibrarySearchPaths}) 14 | 15 | #Handle the REQUIRED argument and set the < UPPERCASED_NAME > _FOUND variable 16 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(GPUNUFFT "Could NOT find GPUNUFFT." GPUNUFFT_LIBRARIES GPUNUFFT_INCLUDE_DIRS) 17 | IF(GPUNUFFT_FOUND) 18 | FIND_PACKAGE_MESSAGE( 19 | GPUNUFFT 20 | "Found GPUNUFFT ${GPUNUFFT_LIBRARIES}" 21 | "[${GPUNUFFT_LIBRARIES}][${GPUNUFFT_INCLUDE_DIRS}]") 22 | ENDIF(GPUNUFFT_FOUND) 23 | MARK_AS_ADVANCED(GPUNUFFT_INCLUDE_DIRS GPUNUFFT_LIBRARIES) 24 | ENDIF() 25 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/doc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | find_package(Doxygen) 2 | 3 | if (DOXYGEN_FOUND) 4 | add_custom_target (doc ${DOXYGEN_EXECUTABLE} "${CMAKE_SOURCE_DIR}/doc/Doxyfile" 5 | WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/src) 6 | endif() 7 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/inc/balanced_operator.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BALANCED_OPERATOR_H_INCLUDED 2 | #define BALANCED_OPERATOR_H_INCLUDED 3 | 4 | #include "gpuNUFFT_types.hpp" 5 | 6 | namespace gpuNUFFT 7 | { 8 | /** 9 | * \brief Interface defined for balanced gpuNUFFT Operators 10 | * 11 | * Adds sector processing order getter and setter. 12 | */ 13 | class BalancedOperator 14 | { 15 | public: 16 | // Getter and Setter for Processing Order 17 | virtual Array getSectorProcessingOrder() = 0; 18 | virtual void 19 | setSectorProcessingOrder(Array sectorProcessingOrder) = 0; 20 | }; 21 | } 22 | #endif // BALANCED_OPERATOR_H_INCLUDED 23 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/inc/config.hpp: -------------------------------------------------------------------------------- 1 | /* WARNING: Automatically generated file. Please do not modify this file. */ 2 | 3 | #ifndef CONFIG_H 4 | #define CONFIG_H 5 | #include "cufft.h" 6 | 7 | /** 8 | * @file 9 | * \brief Definition of types used in gpuNUFFT 10 | * 11 | * Depends on CMAKE build parameters MATLAB_DEBUG, DEBUG, GPU_DOUBLE_PREC 12 | * 13 | */ 14 | 15 | #define MATLAB_DEBUG false 16 | #define DEBUG false 17 | 18 | /* #undef GPU_DOUBLE_PREC */ 19 | 20 | #ifdef GPU_DOUBLE_PREC 21 | typedef double DType; 22 | typedef double2 DType2; 23 | typedef double3 DType3; 24 | typedef cufftDoubleComplex CufftType; 25 | #else 26 | typedef float DType; 27 | typedef float2 DType2; 28 | typedef float3 DType3; 29 | typedef cufftComplex CufftType; 30 | #endif 31 | 32 | typedef unsigned int IndType; 33 | 34 | /** \brief Combined 2-tuple (x,y) of IndType */ 35 | typedef struct IndType2 36 | { 37 | IndType x; 38 | IndType y; 39 | IndType2() 40 | { 41 | } 42 | IndType2(IndType x, IndType y) : x(x), y(y) 43 | { 44 | } 45 | } IndType2; 46 | 47 | /** \brief Combined 3-tuple (x,y,z) of IndType */ 48 | typedef struct IndType3 49 | { 50 | IndType x; 51 | IndType y; 52 | IndType z; 53 | // IndType3(){} 54 | // IndType3(IndType x, IndType y, IndType z): x(x),y(y),z(z){} 55 | } IndType3; 56 | 57 | #endif // CONFIG_H 58 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/inc/config.hpp.cmake: -------------------------------------------------------------------------------- 1 | @WARNING@ 2 | 3 | #ifndef CONFIG_H 4 | #define CONFIG_H 5 | #include "cufft.h" 6 | 7 | /** 8 | * @file 9 | * \brief Definition of types used in gpuNUFFT 10 | * 11 | * Depends on CMAKE build parameters MATLAB_DEBUG, DEBUG, GPU_DOUBLE_PREC 12 | * 13 | */ 14 | 15 | #define MATLAB_DEBUG @MATLAB_DEBUG@ 16 | #define DEBUG @DEBUG@ 17 | 18 | #cmakedefine GPU_DOUBLE_PREC 19 | 20 | #ifdef GPU_DOUBLE_PREC 21 | typedef double DType; 22 | typedef double2 DType2; 23 | typedef double3 DType3; 24 | typedef cufftDoubleComplex CufftType; 25 | #else 26 | typedef float DType; 27 | typedef float2 DType2; 28 | typedef float3 DType3; 29 | typedef cufftComplex CufftType; 30 | #endif 31 | 32 | typedef unsigned int IndType; 33 | 34 | /** \brief Combined 2-tuple (x,y) of IndType */ 35 | typedef struct IndType2 36 | { 37 | IndType x; 38 | IndType y; 39 | IndType2() 40 | { 41 | } 42 | IndType2(IndType x, IndType y) : x(x), y(y) 43 | { 44 | } 45 | } IndType2; 46 | 47 | /** \brief Combined 3-tuple (x,y,z) of IndType */ 48 | typedef struct IndType3 49 | { 50 | IndType x; 51 | IndType y; 52 | IndType z; 53 | // IndType3(){} 54 | // IndType3(IndType x, IndType y, IndType z): x(x),y(y),z(z){} 55 | } IndType3; 56 | 57 | #endif // CONFIG_H 58 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/inc/cufft_config.hpp: -------------------------------------------------------------------------------- 1 | /* WARNING: Automatically generated file. Please do not modify this file. */ 2 | #ifndef CUFFT_CONFIG_H 3 | #define CUFFT_CONFIG_H 4 | #include "config.hpp" 5 | #include "cufft.h" 6 | 7 | /** 8 | * @file 9 | * \brief Definition of types and function pointers used for CUFFT calls. 10 | * 11 | * Depends on CMAKE build parameter GPU_DOUBLE_PREC 12 | * 13 | */ 14 | 15 | #ifdef GPU_DOUBLE_PREC 16 | static cufftType_t CufftTransformType = CUFFT_Z2Z; 17 | 18 | #ifdef WIN32 19 | static cufftResult(__stdcall *pt2CufftExec)(cufftHandle, cufftDoubleComplex *, 20 | cufftDoubleComplex *, 21 | int) = &cufftExecZ2Z; 22 | #else 23 | static cufftResult (*pt2CufftExec)(cufftHandle, cufftDoubleComplex *, 24 | cufftDoubleComplex *, int) = &cufftExecZ2Z; 25 | #endif 26 | #else 27 | static cufftType_t CufftTransformType = CUFFT_C2C; 28 | 29 | #ifdef WIN32 30 | static cufftResult(__stdcall *pt2CufftExec)(cufftHandle, cufftComplex *, 31 | cufftComplex *, 32 | int) = &cufftExecC2C; 33 | #else 34 | static cufftResult (*pt2CufftExec)(cufftHandle, cufftComplex *, cufftComplex *, 35 | int) = &cufftExecC2C; 36 | #endif 37 | #endif 38 | 39 | #endif // CUFFT_CONFIG_H 40 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/inc/cufft_config.hpp.cmake: -------------------------------------------------------------------------------- 1 | @WARNING@ 2 | #ifndef CUFFT_CONFIG_H 3 | #define CUFFT_CONFIG_H 4 | #include "config.hpp" 5 | #include "cufft.h" 6 | 7 | /** 8 | * @file 9 | * \brief Definition of types and function pointers used for CUFFT calls. 10 | * 11 | * Depends on CMAKE build parameter GPU_DOUBLE_PREC 12 | * 13 | */ 14 | 15 | #ifdef GPU_DOUBLE_PREC 16 | static cufftType_t CufftTransformType = CUFFT_Z2Z; 17 | 18 | #ifdef WIN32 19 | static cufftResult(__stdcall *pt2CufftExec)(cufftHandle, cufftDoubleComplex *, 20 | cufftDoubleComplex *, 21 | int) = &cufftExecZ2Z; 22 | #else 23 | static cufftResult (*pt2CufftExec)(cufftHandle, cufftDoubleComplex *, 24 | cufftDoubleComplex *, int) = &cufftExecZ2Z; 25 | #endif 26 | #else 27 | static cufftType_t CufftTransformType = CUFFT_C2C; 28 | 29 | #ifdef WIN32 30 | static cufftResult(__stdcall *pt2CufftExec)(cufftHandle, cufftComplex *, 31 | cufftComplex *, 32 | int) = &cufftExecC2C; 33 | #else 34 | static cufftResult (*pt2CufftExec)(cufftHandle, cufftComplex *, cufftComplex *, 35 | int) = &cufftExecC2C; 36 | #endif 37 | #endif 38 | 39 | #endif // CUFFT_CONFIG_H 40 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/inc/gpuNUFFT_cpu.hpp: -------------------------------------------------------------------------------- 1 | #ifndef GPUNUFFT_CPU_H_ 2 | #define GPUNUFFT_CPU_H_ 3 | 4 | #include "gpuNUFFT_utils.hpp" 5 | 6 | /** \brief CPU implementation of gridding */ 7 | void gpuNUFFT_cpu(DType *data, DType *crds, DType *gdata, DType *kernel, 8 | int *sectors, int sector_count, int *sector_centers, 9 | int sector_width, int kernel_width, int kernel_count, 10 | int width); 11 | 12 | #endif // GPUNUFFT_CPU_H_ 13 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | MESSAGE("------start creating libraries-------") 2 | 3 | SET(GPUNUFFT_SRC_DIR ${CMAKE_SOURCE_DIR}/src) 4 | SET(GPUNUFFT_SOURCES ${GPUNUFFT_SRC_DIR}/gpuNUFFT_utils.cpp 5 | ${GPUNUFFT_SRC_DIR}/gpuNUFFT_operator_factory.cpp 6 | ${GPUNUFFT_SRC_DIR}/gpuNUFFT_operator.cpp 7 | ${GPUNUFFT_SRC_DIR}/texture_gpuNUFFT_operator.cpp 8 | ${GPUNUFFT_SRC_DIR}/balanced_gpuNUFFT_operator.cpp 9 | ${GPUNUFFT_SRC_DIR}/balanced_texture_gpuNUFFT_operator.cpp) 10 | 11 | ADD_SUBDIRECTORY(gpu) 12 | 13 | #cpu not necessary 14 | #ADD_SUBDIRECTORY(cpu) 15 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/src/gpu/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | SET (GPU_GPUNUFFT_SOURCES ${GPUNUFFT_SOURCES} 2 | ${CMAKE_CURRENT_SOURCE_DIR}/precomp_kernels.cu) 3 | 4 | ADD_SUBDIRECTORY(coarse) 5 | if(GEN_ATOMIC) 6 | ADD_SUBDIRECTORY(atomic) 7 | endif() 8 | ADD_SUBDIRECTORY(matlab) 9 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/src/gpu/atomic/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | MESSAGE("Atomic GPU GpuNUFFT Library") 2 | #add exe to build from gpuNUFFT 3 | 4 | include_directories(${GPUNUFFT_INC_DIR}) 5 | 6 | cuda_include_directories(${GPUNUFFT_INC_DIR}) 7 | 8 | set(GPU_CU_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/atomic_gpuNUFFT.cu 9 | #${CMAKE_CURRENT_SOURCE_DIR}/atomic_gpuNUFFT_kernels.cu 10 | #${CMAKE_CURRENT_SOURCE_DIR}/texture_gpuNUFFT_kernels.cu 11 | #${CMAKE_CURRENT_SOURCE_DIR}/../std_gpuNUFFT_kernels.cu 12 | ) 13 | if(WIN32) 14 | CUDA_ADD_LIBRARY(${GRID_LIB_ATM_NAME} ${GPU_CU_SOURCES} ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE}) 15 | else(WIN32) 16 | CUDA_ADD_LIBRARY(${GRID_LIB_ATM_NAME} ${GPU_CU_SOURCES} ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE} SHARED) 17 | endif(WIN32) 18 | 19 | CUDA_ADD_CUFFT_TO_TARGET(${GRID_LIB_ATM_NAME}) 20 | CUDA_ADD_CUBLAS_TO_TARGET(${GRID_LIB_ATM_NAME}) 21 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/src/gpu/atomic/atomic_gpuNUFFT.cu: -------------------------------------------------------------------------------- 1 | #include "atomic_gpuNUFFT_kernels.cu" 2 | #include "texture_gpuNUFFT_kernels.cu" 3 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/src/gpu/coarse/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | MESSAGE("Coarse GPU GpuNUFFT Library") 2 | #add exe to build from gpuNUFFT 3 | 4 | include_directories(${GPUNUFFT_INC_DIR}) 5 | 6 | cuda_include_directories(${GPUNUFFT_INC_DIR}) 7 | 8 | set(GPU_CU_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/coarse_gpuNUFFT.cu 9 | #${CMAKE_CURRENT_SOURCE_DIR}/gpuNUFFT_kernels.cu 10 | #${CMAKE_CURRENT_SOURCE_DIR}/../std_gpuNUFFT_kernels.cu 11 | ) 12 | 13 | if (NOT GEN_ATOMIC) 14 | if(CMAKE_BUILD_TYPE MATCHES Debug) 15 | SET(CUDA_NVCC_FLAGS "-arch;sm_11;--ptxas-options=-v") 16 | else(CMAKE_BUILD_TYPE) 17 | SET(CUDA_NVCC_FLAGS "-arch;sm_11;") 18 | endif() 19 | endif(NOT GEN_ATOMIC) 20 | 21 | if(WIN32) 22 | CUDA_ADD_LIBRARY(${GRID_LIB_NAME} ${GPU_CU_SOURCES} ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE} ${GPUNUFFT_INC_DIR}/cufft_config.hpp) 23 | else(WIN32) 24 | CUDA_ADD_LIBRARY(${GRID_LIB_NAME} ${GPU_CU_SOURCES} ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE} ${GPUNUFFT_INC_DIR}/cufft_config.hpp SHARED) 25 | endif(WIN32) 26 | 27 | CUDA_ADD_CUFFT_TO_TARGET(${GRID_LIB_NAME}) 28 | CUDA_ADD_CUBLAS_TO_TARGET(${GRID_LIB_NAME}) 29 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/src/gpu/coarse/coarse_gpuNUFFT.cu: -------------------------------------------------------------------------------- 1 | #include "gpuNUFFT_kernels.cu" 2 | #include "texture_gpuNUFFT_kernels.cu" 3 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/src/gpu/matlab/precomputation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | MESSAGE("Generate precomputation MEX file") 2 | 3 | set(PRECOMP_MEX_FILE gpuNUFFT_precomp.cpp ${MATLAB_SOURCES}) 4 | 5 | CUDA_COMPILE(mex_gpuNUFFT_precomp_generated ${PRECOMP_MEX_FILE} SHARED) 6 | 7 | CUDA_ADD_LIBRARY(${GRID_MEX_PRECOMP_NAME} SHARED ${mex_gpuNUFFT_precomp_generated} ${PRECOMP_MEX_FILE}) 8 | TARGET_LINK_LIBRARIES(${GRID_MEX_PRECOMP_NAME} ${MATLAB_MEX_LIBRARY} ${MATLAB_MX_LIBRARY} ${CUDA_LIBRARIES} ${GRID_LIB_NAME}) 9 | SET_TARGET_PROPERTIES(${GRID_MEX_PRECOMP_NAME} PROPERTIES PREFIX "" LINKER_LANGUAGE CXX) 10 | 11 | if(WIN32) 12 | SET_TARGET_PROPERTIES(${GRID_MEX_PRECOMP_NAME} PROPERTIES 13 | SUFFIX ${MEX_SUFFIX} 14 | LINK_FLAGS /export:mexFunction) 15 | else(UNIX) 16 | SET_TARGET_PROPERTIES(${GRID_MEX_PRECOMP_NAME} PROPERTIES SUFFIX ${MEX_SUFFIX}) 17 | endif() 18 | 19 | exportMex(${GRID_MEX_PRECOMP_NAME}) -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/test/cpu/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | #setup testframework 2 | MESSAGE("------ generating cpu tests -------") 3 | 4 | #cpu test sources 5 | set(CPU_SOURCES gpuNUFFT_tests.cpp 6 | gpuNUFFT_kernel_tests.cpp 7 | gpuNUFFT_precomputation_tests.cpp 8 | gpuNUFFT_operator_factory_tests.cpp 9 | ../../src/gpuNUFFT_utils.cpp 10 | ../../src/cpu/gpuNUFFT_cpu.cpp) 11 | 12 | include_directories(${CUDA_INCLUDE_DIRS}) 13 | #add source dir 14 | add_executable(runUnitTests ${CPU_SOURCES} ${GPUNUFFT_SOURCES} ../../inc/gpuNUFFT_cpu.hpp ../../inc/gpuNUFFT_utils.hpp ../../inc/gpuNUFFT_operator_factory.hpp ../../inc/gpuNUFFT_operator.hpp ../../inc/gpuNUFFT_kernels.hpp) 15 | target_link_libraries(runUnitTests ${GRID_LIB_NAME} ${GTEST_LIB} ${GTESTMAIN_LIB}) 16 | set_target_properties(runUnitTests PROPERTIES LINK_FLAGS -lpthread) 17 | -------------------------------------------------------------------------------- /SpiralSToRM/CUDA/test/cpu/gpuNUFFT_kernel_tests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "gpuNUFFT_cpu.hpp" 3 | 4 | #include "gtest/gtest.h" 5 | 6 | #define epsilon 0.0001f 7 | 8 | TEST(TestKernel, LoadKernel) { 9 | if (DEBUG) 10 | printf("start creating kernel...\n"); 11 | long kernel_entries = calculateGrid3KernelSize(); 12 | 13 | assert(kernel_entries > 0); 14 | 15 | DType *kern = (DType*) calloc(kernel_entries,sizeof(DType)); 16 | if (kern != NULL) 17 | { 18 | loadGrid3Kernel(kern,kernel_entries); 19 | EXPECT_EQ(1.0f,kern[0]); 20 | EXPECT_LT(0.9940f-kern[1],epsilon); 21 | EXPECT_LT(0.0621f-kern[401],epsilon); 22 | EXPECT_LT(0.0041f-kern[665],epsilon); 23 | EXPECT_EQ(0.0f,kern[kernel_entries-1]); 24 | free(kern); 25 | } 26 | EXPECT_EQ(1, 1); 27 | } -------------------------------------------------------------------------------- /SpiralSToRM/Utils/AtA_LR.m: -------------------------------------------------------------------------------- 1 | function y = AtA_LR(FT,x,csm,nf,N) 2 | %UNTITLED Summary of this function goes here 3 | % Detailed explanation goes here 4 | 5 | [~,~,nChannelsToChoose] = size(csm); 6 | x = reshape(x,[N,N,nf]); 7 | y = zeros(N,N,nf); 8 | 9 | for j=1:nChannelsToChoose 10 | temp = FT'*(FT*(bsxfun(@times,x,csm(:,:,j)))); 11 | y = y + bsxfun(@times,temp,conj(csm(:,:,j))); 12 | end 13 | 14 | y = y(:); 15 | 16 | end 17 | 18 | -------------------------------------------------------------------------------- /SpiralSToRM/Utils/AtA_UV.m: -------------------------------------------------------------------------------- 1 | function y = AtA_UV(FT,x,V,csm,N,NsamplesPerFrame) 2 | %UNTITLED Summary of this function goes here 3 | % Detailed explanation goes here 4 | 5 | [~,~,nChannelsToChoose] = size(csm); 6 | [nFrames,nBasis] = size(V); 7 | x = reshape(x,[N,N,nBasis]); 8 | 9 | y = zeros(N,N,nBasis); 10 | 11 | for j=1:nChannelsToChoose 12 | virtualKspace = zeros(NsamplesPerFrame,nFrames); 13 | for i=1:nBasis 14 | temp = FT*(x(:,:,i).*csm(:,:,j)); 15 | virtualKspace = virtualKspace + reshape(temp,[NsamplesPerFrame,nFrames])*diag(V(:,i)); 16 | end 17 | for i=1:nBasis 18 | temp = virtualKspace*diag(V(:,i)); 19 | y(:,:,i) = y(:,:,i) + (FT'*temp(:)).*conj(csm(:,:,j)); 20 | end 21 | end 22 | 23 | y = y(:); 24 | 25 | end 26 | 27 | -------------------------------------------------------------------------------- /SpiralSToRM/Utils/Atb_LR.m: -------------------------------------------------------------------------------- 1 | function Atb = Atb_LR(FT,kdata,csm,useGPU) 2 | %UNTITLED Summary of this function goes here 3 | % Detailed explanation goes here 4 | 5 | [N,~,nChannelsToChoose] = size(csm); 6 | nf = size(kdata,3); 7 | Atb = zeros(N,N,nf); 8 | 9 | 10 | if(useGPU) 11 | for j=1:nChannelsToChoose 12 | Atb = Atb + bsxfun(@times,(FT'*kdata(:,:,:,j)),conj(csm(:,:,j))); 13 | end 14 | end 15 | 16 | -------------------------------------------------------------------------------- /SpiralSToRM/Utils/Atb_UV.m: -------------------------------------------------------------------------------- 1 | function Atb = Atb_UV(FT,kdata,V,csm,N,useGPU) 2 | %UNTITLED Summary of this function goes here 3 | % Detailed explanation goes here 4 | 5 | [~,~,nChannelsToChoose] = size(csm); 6 | nBasis = size(V,2); 7 | Atb = zeros(N,N,nBasis); 8 | 9 | 10 | if(useGPU) 11 | for i=1:nBasis 12 | for j=1:nChannelsToChoose 13 | temp = squeeze(kdata(:,:,j))*diag(V(:,i)); 14 | Atb(:,:,i) = Atb(:,:,i) + (FT'*temp(:)).*conj(csm(:,:,j)); 15 | end 16 | end 17 | else 18 | for i=1:nBasis 19 | for j=1:nChannelsToChoose 20 | temp = squeeze(kdata(:,:,j))*diag(V(:,i)); 21 | %temp=reshape(temp,[2496,4,450]); 22 | Atb(:,:,i) = Atb(:,:,i) + (FT'*temp).*conj(csm(:,:,j)); 23 | end 24 | end 25 | 26 | end 27 | 28 | -------------------------------------------------------------------------------- /SpiralSToRM/Utils/SenseATA.m: -------------------------------------------------------------------------------- 1 | function out = SenseATA(x,FT,csm,N,nFrames,nCh) 2 | 3 | x = reshape(x,[N,N,nFrames]); 4 | out = zeros(N,N,nFrames); 5 | for ii=1:nCh, 6 | xnew = FT'*(FT*bsxfun(@times,x,csm(:,:,ii))); 7 | out = out + bsxfun(@times,xnew,conj(csm(:,:,ii))); 8 | end 9 | out = out(:); 10 | 11 | end -------------------------------------------------------------------------------- /SpiralSToRM/Utils/coil_sens_map.m: -------------------------------------------------------------------------------- 1 | function [csm,coilimages] = coil_sens_map(kdat,k,w,N) 2 | numFramesforcsm=100; 3 | kdata=kdat(:,:,1:numFramesforcsm,:); 4 | [n,nint,nf,nCh]=size(kdata); 5 | coilimages=zeros(N,N,nCh); 6 | 7 | w = w(:,:,1:numFramesforcsm); 8 | k=k(:,:,1:numFramesforcsm); 9 | kdata=reshape(kdata,[n*nint*nf,nCh]); 10 | [A1,B1] = creatA(1.5*transpose(k(:)),N); 11 | At_DFT = @(x) INFT_new(x,A1,B1,sqrt(w(:))); 12 | 13 | for i=1:nCh 14 | coilimages(:,:,i)=double(At_DFT(kdata(:,i).*sqrt(w(:)))); 15 | end 16 | 17 | [A2, B2] = creatA_zeropadded(transpose(k(:)),N,2*N); 18 | Q = ifftshift(fft2(fftshift(INFT_new(ones(n*nint*nf,1),A2,B2,(w(:)))/N^2))); 19 | M=@(u)AhA(reshape(u,[size(coilimages,1), size(coilimages,2), nCh]),Q,N,nCh); 20 | coilImages = pcg(M,coilimages(:),1e-6,100); 21 | 22 | csm=giveEspiritMaps(reshape(coilimages,[size(coilimages,1), size(coilimages,2), nCh])); 23 | csm=fftshift(fftshift(csm,1),2); 24 | end 25 | 26 | function res= AhA(X,Q,n,nc) 27 | 28 | res = zeros(n,n,nc); 29 | tmp = zeros(2*n,2*n); 30 | 31 | for k=1:nc 32 | tmp(n/2+1:end-n/2,n/2+1:end-n/2)=X(:,:,k); 33 | tmp1=ifftshift(fft2(fftshift(tmp))).*Q; 34 | tmp1 = ifftshift(ifft2(fftshift(tmp1))); 35 | res(:,:,k)=tmp1(n/2+1:end-n/2,n/2+1:end-n/2); 36 | tmp(:)=0; 37 | end 38 | 39 | 40 | res = res(:); 41 | end -------------------------------------------------------------------------------- /SpiralSToRM/Utils/combine_coils.m: -------------------------------------------------------------------------------- 1 | function [vKSpaceData] = combine_coils(kSpaceData,threshold) 2 | 3 | %temp = permute(kSpaceData,[1,3,2]); 4 | %temp = reshape(temp,param.n*param.nf*param.lines_per_SG_block,param.NcoilSelect); 5 | %[N,~,NcoilSelect]=size(coilimages); 6 | temp=kSpaceData; 7 | Rs = real(temp'*temp); 8 | 9 | 10 | [v,s] = eig(Rs); 11 | s = diag(s);[s,i] = sort(s,'descend'); 12 | v = v(:,i); 13 | s=s./sum(s);s = cumsum(s); 14 | nvchannels = min(find(s>threshold)); 15 | 16 | vKSpaceData = temp*v(:,1:nvchannels); 17 | 18 | %vCoilImages = reshape(coilimages,N^2,NcoilSelect)*v(:,1:nvchannels); 19 | %vCoilImages = reshape(vCoilImages,N,N,nvchannels); 20 | % vKSpaceData = reshape(vKSpaceData,[param.n,param.lines_per_SG_block*param.nf,nvchannels]); 21 | % vKSpaceData = permute(vKSpaceData,[1,3,2]); -------------------------------------------------------------------------------- /SpiralSToRM/Utils/estimateLapKernelLR.m: -------------------------------------------------------------------------------- 1 | 2 | function [K, X, A] = estimateLapKernelLR(nav, sigSq, lambda) 3 | 4 | nf = size(nav,2); 5 | nav=double(nav); 6 | 7 | p = 1; 8 | q = 1-p/2; 9 | eta = 2; 10 | 11 | X2 = double(sum(nav.*conj(nav),1)); 12 | X3 = (nav')*nav; 13 | dsq = abs(repmat(X2,nf,1)+repmat(X2',1,nf)-2*real(X3)); 14 | 15 | % Changes 16 | %============ 17 | medvalue = median(dsq(:)); 18 | maxvalue = medvalue;%./sigSq; 19 | nav = nav./sqrt(maxvalue); 20 | dsq = dsq./maxvalue; 21 | %============ 22 | tt=dsq/sigSq; 23 | K = exp(-tt); 24 | 25 | [V,S,~] = svd(K); 26 | gamma = 100; 27 | 28 | for i=1:70 29 | W = V*((S+gamma*eye(nf))^(-q))*V'; 30 | 31 | A = W.*K; 32 | A = -diag(sum(A))+A; 33 | 34 | X = nav*inv(eye(nf) + (lambda)*A); 35 | % X = nav*(eye(nf) + lambda*A); 36 | 37 | 38 | gamma = gamma/eta; 39 | 40 | X2 = sum(X.*conj(X),1); 41 | X3 = (X')*X; 42 | dsq = abs(repmat(X2,nf,1)+repmat(X2',1,nf)-2*real(X3)); 43 | K = exp(-dsq/sigSq); 44 | 45 | [V,S,~] = svd(K); 46 | 47 | end 48 | 49 | -------------------------------------------------------------------------------- /SpiralSToRM/Utils/iterative_est_laplacian.m: -------------------------------------------------------------------------------- 1 | 2 | function [ X, A] = iterative_est_laplacian(A,FT,kdata,csm_lowRes,N1, sigSq, lam) 3 | %function [ X, A] = iterative_est_laplacian(A,FT,kdata,csm_lowRes,N1, sigSq, lam) 4 | % 5 | % Arguments: 6 | % A Laplacian matrix [nf nf] complex 7 | % FT Fourier operator 8 | % kdata [np nv nf nc] complex 9 | % csm_lowRes coil sens map 10 | % lam threshold 11 | % N1 reconstucted image size 12 | % sigSq Sigma to control standard deviation 13 | 14 | % 15 | % 16 | % Outputs: 17 | % X [N N Nf] low res images 18 | % A [Nf Nf] improved laplacian matrix 19 | % 20 | % Ahmed, Abdul Haseeb 21 | 22 | nf = size(kdata,3); 23 | W=(circshift(eye(nf),[0,1])+circshift(eye(nf),[1,0])); 24 | W=(W+W')/2; 25 | Lnn = (diag(sum(W,1))-W); 26 | lambda2=0.0001; 27 | Xpre=zeros(N1*N1,nf); 28 | 29 | for i=1:30 30 | 31 | Atb = Atb_LR(FT,kdata,csm_lowRes,true); 32 | lambda1=lam*max(abs(Atb(:))); 33 | Reg1 = @(x) reshape(reshape(x,[N1*N1,nf])*(lambda1*A+lambda2*Lnn),[N1*N1*nf,1]); 34 | AtA = @(x) AtA_LR(FT,x,csm_lowRes,nf,N1)+Reg1(x); 35 | tic; [x1,~,~,it,res] = pcg(AtA,Atb(:),9e-4,50,[],[],Xpre(:));toc;%dataset virg 9e-4; 36 | X =(reshape(x1,[N1*N1,nf])); 37 | 38 | [~,~,A]=estimateLapKernelLR(X,sigSq,lam); 39 | 40 | if (norm(X(:)-Xpre(:))<1e-10) 41 | break; 42 | end 43 | Xpre=reshape(X,[N1*N1,nf]); 44 | end 45 | end 46 | 47 | -------------------------------------------------------------------------------- /SpiralSToRM/Utils/l2Recont.m: -------------------------------------------------------------------------------- 1 | function data = l2Recont(kdata,FT,csm,lambda,N) 2 | %function data = l2Recont(kdata,FT,csm,lambda,N) 3 | % 4 | % Arguments: 5 | % kdata [np nv nf nc] complex 6 | % FT Fourier operator 7 | % csm coil sens map 8 | % lambda threshold 9 | % N reconstucted image size 10 | % 11 | % Optional Arguments: 12 | 13 | % 14 | % Outputs: 15 | % data [N N N Nt] complex 16 | % 17 | % Ahmed, Abdul Haseeb 18 | 19 | [~,~,nFrames,nCh] = size(kdata); 20 | Atb = zeros(N,N,nFrames); 21 | 22 | for ii=1:nCh 23 | Atb = Atb + bsxfun(@times,FT'*kdata(:,:,:,ii),conj(csm(:,:,ii))); 24 | end 25 | lambda=max(abs(Atb(:)))*lambda; 26 | 27 | ATA = @(x) SenseATA(x,FT,csm,N,nFrames,nCh) + lambda*x; 28 | data = pcg(ATA,Atb(:),1e-5,60); 29 | data = reshape(data,[N,N,nFrames]); 30 | 31 | end -------------------------------------------------------------------------------- /SpiralSToRM/Utils/solveUV.m: -------------------------------------------------------------------------------- 1 | function x = solveUV(ktraj,kdata,csm, V, N, nIterations,SBasis,useGPU) 2 | %UNTITLED Summary of this function goes here 3 | % Detailed explanation goes here 4 | 5 | [nSamplesPerFrame,numFrames,~,~] = size(kdata); 6 | [~,nbasis] = size(V); 7 | 8 | if(useGPU) 9 | osf = 2; wg = 3; sw = 8; 10 | w=ones(nSamplesPerFrame*numFrames,1); 11 | %w=repmat(dcf,[1 5*numFrames]); 12 | ktraj_gpu = [real(ktraj(:)),imag(ktraj(:))]'; 13 | FT = gpuNUFFT(ktraj_gpu/N,w(:),osf,wg,sw,[N,N],[],true); 14 | Atb = Atb_UV(FT,kdata,V,csm,N,true); 15 | Reg = @(x) reshape(reshape(x,[N*N,nbasis])*SBasis,[N*N*nbasis,1]); 16 | AtA = @(x) AtA_UV(FT,x,V,csm,N,nSamplesPerFrame) + Reg(x); 17 | else 18 | FT= NUFFT(ktraj/N,1,0,0,[N,N]); 19 | Atb = Atb_UV(FT,kdata,V,csm,N,false); 20 | Reg = @(x) reshape(reshape(x,[N*N,nbasis])*SBasis,[N*N*nbasis,1]); 21 | AtA = @(x) AtA_UV(FT,x,V,csm,nSamplesPerFrame)+Reg(x); 22 | end 23 | 24 | x = pcg(AtA,Atb(:),1e-5,nIterations); 25 | x = reshape(x,[N,N,nbasis]); 26 | 27 | end 28 | 29 | -------------------------------------------------------------------------------- /SpiralSToRM/csm/coil_sens_map_NUFFT.m: -------------------------------------------------------------------------------- 1 | function [coilimages] = coil_sens_map_NUFFT(kdata,trajectory,N,useGPU) 2 | 3 | [nReadouts,nInterleaves,nFrames,nCh] = size(kdata); 4 | coilimages=zeros(N,N,nCh); 5 | 6 | if(useGPU) 7 | osf = 2; wg = 3; sw = 8; 8 | %w=ones(nReadouts*nInterleaves*nFrames,1); 9 | %w=repmat(dcf,[1 nInterleaves*nFrames]); 10 | ktraj_gpu = [real(trajectory(:)),imag(trajectory(:))]'; 11 | FT = gpuNUFFT(ktraj_gpu/N,ones(nReadouts*nInterleaves*nFrames,1),osf,wg,sw,[N,N],[],true); 12 | else 13 | 14 | %w=repmat(dcf,[1 nInterleaves]); 15 | FT= NUFFT(trajectory(:)/N,ones(nReadouts*nInterleaves*nFrames,1),0,0,[N,N]); 16 | %Atb = Atb_UV(FT,kdata,V,csm,false); 17 | %AtA = @(x) AtA_UV(FT,x,V,csm,nFreqEncoding*ninterleavesPerFrame); 18 | end 19 | 20 | ATA = @(x) reshape(FT'*(FT*reshape(x,[N,N,1])),[N*N,1]); 21 | 22 | kdata = reshape(kdata,[nReadouts*nInterleaves*nFrames,nCh]); 23 | for i=1:nCh 24 | temp = FT'*kdata(:,i); 25 | coilimages(:,:,i)= reshape(pcg(ATA,temp(:),1e-6,70),[N,N]); 26 | end 27 | %csm=giveEspiritMaps(reshape(coilimages,[size(coilimages,1), size(coilimages,2), nCh])); 28 | 29 | end -------------------------------------------------------------------------------- /SpiralSToRM/csm/crop.m: -------------------------------------------------------------------------------- 1 | function res = crop(x,sx,sy,sz,st) 2 | % res = crop(x,sx,sy) 3 | % crops a 2D matrix around its center. 4 | % 5 | % 6 | % res = crop(x,sx,sy,sz,st) 7 | % crops a 4D matrix around its center 8 | % 9 | % 10 | % res = crop(x,[sx,sy,sz,st]) 11 | % same as the previous example 12 | % 13 | % 14 | % 15 | % 16 | % (c) Michael Lustig 2007 17 | 18 | if nargin < 2 19 | error('must have a target size') 20 | end 21 | 22 | if nargin == 2 23 | s = sx; 24 | end 25 | 26 | if nargin == 3 27 | s = [sx,sy]; 28 | end 29 | 30 | if nargin == 4 31 | s = [sx,sy,sz]; 32 | end 33 | 34 | if nargin == 5 35 | s = [sx,sy,sz,st]; 36 | end 37 | 38 | m = size(x); 39 | if length(s) < length(m) 40 | s = [s, ones(1,length(m)-length(s))]; 41 | end 42 | 43 | if sum(m==s)==length(m) 44 | res = x; 45 | return; 46 | end 47 | 48 | 49 | for n=1:length(s) 50 | idx{n} = floor(m(n)/2)+1+ceil(-s(n)/2) : floor(m(n)/2)+ceil(s(n)/2); 51 | end 52 | 53 | % this is a dirty ugly trick 54 | cmd = 'res = x(idx{1}'; 55 | for n=2:length(s) 56 | cmd = sprintf('%s,idx{%d}',cmd,n); 57 | end 58 | cmd = sprintf('%s);',cmd); 59 | eval(cmd); 60 | 61 | 62 | 63 | 64 | 65 | -------------------------------------------------------------------------------- /SpiralSToRM/csm/dat2Kernel.m: -------------------------------------------------------------------------------- 1 | function [kernel, S] = dat2Kernel(data, kSize) 2 | % kernel = dat2Kernel(data, kSize,thresh) 3 | % 4 | % Function to perform k-space calibration step for ESPIRiT and create 5 | % k-space kernels. Only works for 2D multi-coil images for now. 6 | % 7 | % Inputs: 8 | % data - calibration data [kx,ky,coils] 9 | % kSize - size of kernel (for example kSize=[6,6]) 10 | % 11 | % Outputs: 12 | % kernel - k-space kernels matrix (not cropped), which correspond to 13 | % the basis vectors of overlapping blocks in k-space 14 | % S - (Optional parameter) The singular vectors of the 15 | % calibration matrix 16 | % 17 | % 18 | % See also: 19 | % kernelEig 20 | % 21 | % (c) Michael Lustig 2013 22 | 23 | 24 | 25 | [sx,sy,nc] = size(data); 26 | imSize = [sx,sy] ; 27 | 28 | tmp = im2row(data,kSize); [tsx,tsy,tsz] = size(tmp); 29 | A = reshape(tmp,tsx,tsy*tsz); 30 | 31 | [U,S,V] = svd(A,'econ'); 32 | 33 | kernel = reshape(V,kSize(1),kSize(2),nc,size(V,2)); 34 | S = diag(S);S = S(:); 35 | -------------------------------------------------------------------------------- /SpiralSToRM/csm/fft2c.m: -------------------------------------------------------------------------------- 1 | function res = fft2c(x) 2 | 3 | S = size(x); 4 | fctr = S(1)*S(2); 5 | 6 | x = reshape(x,S(1),S(2),prod(S(3:end))); 7 | 8 | res = zeros(size(x)); 9 | for n=1:size(x,3) 10 | res(:,:,n) = 1/sqrt(fctr)*fftshift(fft2(ifftshift(x(:,:,n)))); 11 | end 12 | 13 | res = reshape(res,S); 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /SpiralSToRM/csm/giveEspiritMaps.m: -------------------------------------------------------------------------------- 1 | function maps = giveEspiritMaps(coilimages,eigThresh_1) 2 | 3 | coilimages = fftshift(fftshift(coilimages,1),2); 4 | DATA = fftshift(fftshift(fft2(coilimages),1),2); 5 | 6 | [sx,sy,Nc] = size(DATA); 7 | %DATA=DATA(:,:,1); 8 | ncalib = 64; 9 | ksize = [4,4]; 10 | 11 | 12 | % Threshold for picking singular vercors of the calibration matrix 13 | % (relative to largest singlular value. 14 | 15 | %eigThresh_1 = 0.02%0.01;%0.005 16 | 17 | % threshold of eigen vector decomposition in image space. 18 | eigThresh_2 = 0.95; 19 | 20 | % crop a calibration area 21 | calib = crop(DATA,[ncalib,ncalib],Nc); 22 | 23 | 24 | %% Compute ESPIRiT EigenVectors 25 | % Here we perform calibration in k-space followed by an eigen-decomposition 26 | % in image space to produce the EigenMaps. 27 | 28 | 29 | % compute Calibration matrix, perform 1st SVD and convert singular vectors 30 | % into k-space kernels 31 | 32 | [k,S] = dat2Kernel(calib,ksize); 33 | idx = max(find(S >= S(1)*eigThresh_1)); 34 | 35 | 36 | %% 37 | % crop kernels and compute eigen-value decomposition in image space to get 38 | % maps 39 | [M,W] = kernelEig(k(:,:,:,1:idx),[sx,sy]); 40 | 41 | % crop sensitivity maps 42 | maps = M(:,:,:,end).*repmat(W(:,:,end)>eigThresh_2,[1,1,Nc]); 43 | -------------------------------------------------------------------------------- /SpiralSToRM/csm/giveEspiritMapsSmall.m: -------------------------------------------------------------------------------- 1 | function maps = giveEspiritMapsSmall(coilimages,sx,sy) 2 | 3 | coilimages = fftshift(fftshift(coilimages,1),2); 4 | DATA = fftshift(fftshift(fft2(coilimages),1),2); 5 | 6 | [~,~,Nc] = size(DATA); 7 | ncalib = 64; 8 | ksize = [4,4]; 9 | 10 | 11 | % Threshold for picking singular vercors of the calibration matrix 12 | % (relative to largest singlular value. 13 | 14 | eigThresh_1 = 0.02; 15 | 16 | % threshold of eigen vector decomposition in image space. 17 | eigThresh_2 = 0.95; 18 | 19 | % crop a calibration area 20 | calib = crop(DATA,[ncalib,ncalib],Nc); 21 | 22 | 23 | %% Compute ESPIRiT EigenVectors 24 | % Here we perform calibration in k-space followed by an eigen-decomposition 25 | % in image space to produce the EigenMaps. 26 | 27 | 28 | % compute Calibration matrix, perform 1st SVD and convert singular vectors 29 | % into k-space kernels 30 | 31 | [k,S] = dat2Kernel(calib,ksize); 32 | idx = max(find(S >= S(1)*eigThresh_1)); 33 | 34 | 35 | %% 36 | % crop kernels and compute eigen-value decomposition in image space to get 37 | % maps 38 | [M,W] = kernelEig(k(:,:,:,1:idx),[sx,sy]); 39 | 40 | % crop sensitivity maps 41 | maps = M(:,:,:,end).*repmat(W(:,:,end)>eigThresh_2,[1,1,Nc]); 42 | -------------------------------------------------------------------------------- /SpiralSToRM/csm/im2row.m: -------------------------------------------------------------------------------- 1 | function res = im2row(im, winSize) 2 | %res = im2row(im, winSize) 3 | [sx,sy,sz] = size(im); 4 | 5 | res = zeros((sx-winSize(1)+1)*(sy-winSize(2)+1),prod(winSize),sz); 6 | count=0; 7 | for y=1:winSize(2) 8 | for x=1:winSize(1) 9 | count = count+1; 10 | res(:,count,:) = reshape(im(x:sx-winSize(1)+x,y:sy-winSize(2)+y,:),... 11 | (sx-winSize(1)+1)*(sy-winSize(2)+1),1,sz); 12 | end 13 | end 14 | -------------------------------------------------------------------------------- /SpiralSToRM/csm/zpad.m: -------------------------------------------------------------------------------- 1 | function res = zpad(x,sx,sy,sz,st) 2 | % res = zpad(x,sx,sy) 3 | % Zero pads a 2D matrix around its center. 4 | % 5 | % 6 | % res = zpad(x,sx,sy,sz,st) 7 | % Zero pads a 4D matrix around its center 8 | % 9 | % 10 | % res = zpad(x,[sx,sy,sz,st]) 11 | % same as the previous example 12 | % 13 | % 14 | % (c) Michael Lustig 2007 15 | 16 | if nargin < 2 17 | error('must have a target size') 18 | end 19 | 20 | if nargin == 2 21 | s = sx; 22 | end 23 | 24 | if nargin == 3 25 | s = [sx,sy]; 26 | end 27 | 28 | if nargin == 4 29 | s = [sx,sy,sz]; 30 | end 31 | 32 | if nargin == 5 33 | s = [sx,sy,sz,st]; 34 | end 35 | 36 | m = size(x); 37 | if length(m) < length(s) 38 | m = [m, ones(1,length(s)-length(m))]; 39 | end 40 | 41 | if sum(m==s)==length(m) 42 | res = x; 43 | return; 44 | end 45 | 46 | res = zeros(s); 47 | 48 | for n=1:length(s) 49 | idx{n} = floor(s(n)/2)+1+ceil(-m(n)/2) : floor(s(n)/2)+ceil(m(n)/2); 50 | end 51 | 52 | % this is a dirty ugly trick 53 | cmd = 'res(idx{1}'; 54 | for n=2:length(s) 55 | cmd = sprintf('%s,idx{%d}',cmd,n); 56 | end 57 | cmd = sprintf('%s)=x;',cmd); 58 | eval(cmd); 59 | 60 | 61 | 62 | 63 | 64 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp1_table_adj_mex.mexglx.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp1_table_adj_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp1_table_mex.mexglx.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp1_table_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp2_table_adj_mex.mexglx.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp2_table_adj_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp2_table_mex.mexglx.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp2_table_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp3_table_adj_mex.mexglx.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp3_table_adj_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp3_table_mex.mexglx.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/interp3_table_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- 1 | K 14 2 | svn:executable 3 | V 1 4 | * 5 | K 13 6 | svn:mime-type 7 | V 24 8 | application/octet-stream 9 | END 10 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/kaiser,m=0.mat.svn-base: -------------------------------------------------------------------------------- 1 | K 13 2 | svn:mime-type 3 | V 24 4 | application/octet-stream 5 | END 6 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/kaiser,m=2.mat.svn-base: -------------------------------------------------------------------------------- 1 | K 13 2 | svn:mime-type 3 | V 24 4 | application/octet-stream 5 | END 6 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/prop-base/nufft_gauss2.mat.svn-base: -------------------------------------------------------------------------------- 1 | K 13 2 | svn:mime-type 3 | V 24 4 | application/octet-stream 5 | END 6 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/Makefile.svn-base: -------------------------------------------------------------------------------- 1 | # Makefile 2 | # one can reduce time by compiling the initialization routine 3 | 4 | suf = mexglx 5 | goal: \ 6 | interp1_table_mex.$(suf) \ 7 | interp2_table_mex.$(suf) \ 8 | interp3_table_mex.$(suf) \ 9 | interp1_table_adj_mex.$(suf) \ 10 | interp2_table_adj_mex.$(suf) \ 11 | interp3_table_adj_mex.$(suf) 12 | 13 | CFLAGS = -ansi -Wall -Wshadow -Wpointer-arith -W -Werror 14 | mex = mex CFLAGS='$(CFLAGS)' 15 | 16 | interp1_table_mex.$(suf): interp1_table_mex.c 17 | $(mex) $? 18 | 19 | interp2_table_mex.$(suf): interp2_table_mex.c 20 | $(mex) $? 21 | 22 | interp3_table_mex.$(suf): interp3_table_mex.c 23 | $(mex) $? 24 | 25 | interp1_table_adj_mex.$(suf): interp1_table_adj_mex.c 26 | $(mex) $? 27 | 28 | interp2_table_adj_mex.$(suf): interp2_table_adj_mex.c 29 | $(mex) $? 30 | 31 | interp3_table_adj_mex.$(suf): interp3_table_adj_mex.c 32 | $(mex) $? 33 | 34 | mat = /users/apps/matlab5.3/toolbox/matlab 35 | mfile = \ 36 | $(mat)/datatypes/ndgrid.m \ 37 | $(mat)/elfun/mod.m \ 38 | $(mat)/ops/kron.m 39 | 40 | goal = nufft2_init.mexaxp 41 | main = nufft2_init.m 42 | 43 | $(goal): $(main) $(mfile) 44 | mcc -x -h $(main) $(mfile) 45 | 46 | reset: 47 | rm -i $(goal) 48 | 49 | 50 | #plist = nufft2.m nufft2_init.m nufft_diric.m nufft_R.m 51 | plist = *.m 52 | en7=print,code 53 | comm=$(en7) `linesplit $? | sort`; lpq; touch $@ 54 | .print: $(plist) 55 | $(comm) 56 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/col.m.svn-base: -------------------------------------------------------------------------------- 1 | function x = col(x) 2 | %function x = col(x) 3 | % "colon" function 4 | x = x(:); 5 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/dtft1.m.svn-base: -------------------------------------------------------------------------------- 1 | function X = dtft1(x, omega, n_shift) 2 | %function X = dtft1(x, omega, n_shift) 3 | % Compute DTFT of 1D signal x at frequency locations wx 4 | % In 5 | % x [N,ncol] signal values 6 | % omega [M,1] frequency locations 7 | % n_shift [1,1] use [0:(N-1)]-n_shift indices 8 | % Out 9 | % X [M,ncol] DTFT values 10 | % 11 | % This needs enough memory to store M * N size matrices 12 | % Copyright 2000-1-9 Jeff Fessler The University of Michigan 13 | 14 | % 15 | % if no arguments, then run a simple test 16 | % 17 | if nargin < 2 18 | N = 4; 19 | x = [[1:N]', [1 1 2 2]']; % two test signal 20 | omega = 2*pi*[0:(N-1)]'/N; % test with uniform frequency locations 21 | Xd = dtft1(x, omega); 22 | Xf = fft(x); 23 | % disp([Xd Xf]) 24 | help(mfilename) 25 | disp(sprintf('max %% difference = %g', max_percent_diff(Xf,Xd))) 26 | return 27 | end 28 | 29 | N = size(x,1); 30 | if ~isvar('n_shift') | isempty(n_shift), n_shift = 0; end 31 | nn = [0:(N-1)] - n_shift; 32 | 33 | X = exp(-i*omega*nn) * x; % compute 1D DTFT 34 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/dtft_mex.m.svn-base: -------------------------------------------------------------------------------- 1 | function X = dtft_mex(varargin) 2 | 3 | disp('This dtft_mex.m is a dummy m-file that is included to provide') 4 | disp('a reminder that you must have the Mex file "dtft_mex.mex???" that') 5 | disp('is appropriate for your system. For pc-linux, the mex file is') 6 | disp('called "dtft_mex.mexglx", which is provided in the "mfile"') 7 | disp('subdirectory. For a sun, the name is "dtft_mex.mexsol", which') 8 | disp('may or may not be provided. If you have another OS, then you may') 9 | disp('be out of luck, or you may be able to cajole Jeff into compiling a') 10 | disp('mex file for your OS.') 11 | error 'no appropriate mex file!?' 12 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/fig_taper_cos3.m.svn-base: -------------------------------------------------------------------------------- 1 | % fig_taper_cos3 2 | % compare 3 different interpolation kernels: 3 | % min-max kernel with uniform scaling factors 4 | % min-max kernel with optimized scaling factors 5 | % cos^3-tapered dirichlet kernel of magnusson 6 | 7 | J = 6; 8 | N = 1000; 9 | K = 2 * N; 10 | k = linspace(-J/2,J/2,101)'; 11 | fm = diric(2*pi*k/J, J) .* cos((2*pi*k/J)/2).^3; % tapered 12 | fn = nufft1_kernel(k, N, J, K, 1, 0); % min-max unif 13 | fo = nufft1_kernel(k, N, J, K, 'best'); 14 | fo = fo / max(fo); 15 | 16 | %fm = 0*fm; 17 | %fn = nufft1_kernel(k, N, J, 9*N, 1, 0); 18 | %fo = nufft1_kernel(k, N, J, 2*N, 1, 0); 19 | 20 | plot(k, fn, '-', k, fm, '--', k, fo, '-.') 21 | axisy(-0.3,1.1) 22 | legend('min-max', 'Magnusson', 'optimized') 23 | title(sprintf('J=%d K/N=%g', J, K/N)) 24 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp1_table_adj_mex.mexglx.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp1_table_adj_mex.mexglx.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp1_table_adj_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp1_table_adj_mex.mexmaci.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp1_table_mex.mexglx.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp1_table_mex.mexglx.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp1_table_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp1_table_mex.mexmaci.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp2_table_adj_mex.mexglx.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp2_table_adj_mex.mexglx.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp2_table_adj_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp2_table_adj_mex.mexmaci.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp2_table_mex.mexglx.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp2_table_mex.mexglx.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp2_table_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp2_table_mex.mexmaci.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp3_table_adj_mex.mexglx.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp3_table_adj_mex.mexglx.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp3_table_adj_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp3_table_adj_mex.mexmaci.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp3_table_mex.mexglx.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp3_table_mex.mexglx.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp3_table_mex.mexmaci.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/interp3_table_mex.mexmaci.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/isvar.m.svn-base: -------------------------------------------------------------------------------- 1 | function tf = isvar(name) 2 | %function tf = isvar(name) 3 | % determine if "name" is a variable in the caller's workspace 4 | 5 | if nargin < 1 6 | help isvar 7 | error arg 8 | end 9 | 10 | tf = logical(1); 11 | evalin('caller', [name ';'], 'tf=logical(0);') 12 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/kaiser,m=0.mat.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/kaiser,m=0.mat.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/kaiser,m=2.mat.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/kaiser,m=2.mat.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/my_fftn.m.svn-base: -------------------------------------------------------------------------------- 1 | function X = my_fftn(x) 2 | 3 | X = fft(x); 4 | dd = ndims(x); 5 | for id=2:dd 6 | ord = 1:dd; 7 | ord([1 id]) = [id 1]; 8 | x = permute(X, ord); 9 | X = fft(x); 10 | X = ipermute(X, ord); 11 | end 12 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft1_kernel.m.svn-base: -------------------------------------------------------------------------------- 1 | function kern = nufft1_kernel(klist, N, J, K, alpha, beta) 2 | %function kern = nufft1_kernel(klist, N, J, K, alpha, beta) 3 | % compute equivalent interpolation kernel (real part) 4 | % at points in klist 5 | 6 | if nargin < 4 7 | help(mfilename) 8 | J = 7; N = 100; K = 2*N; 9 | k = linspace(-J/2-1,J/2+1,201)'; % fine sampling for display 10 | ker = nufft1_kernel(k, N, J, K, 1, 0); 11 | plot(k, ker), axis tight 12 | return 13 | end 14 | 15 | if ~isvar('alpha') | isempty(alpha), alpha = 1; end 16 | if ~isvar('beta') | isempty(beta), beta = 0.5; end 17 | [alpha beta] = nufft_alpha(N, J, K, alpha, beta); 18 | 19 | n_shift1 = 0; 20 | 21 | gam = 2*pi/K; 22 | 23 | st = nufft_init(gam*klist, N, J, K, n_shift1, 'minmax:user', {alpha}, {beta}); 24 | 25 | kern = full(st.p(:,1)); 26 | 27 | % 28 | % undo phase to make it real 29 | % 30 | om = st.om; 31 | if 0 32 | koff = nufft_offset(om, J, K); % [M,1] 33 | jj = 0 - nufft_offset(om, J, K); % effective j 34 | oarg = om - gam * (koff + jj); 35 | else 36 | oarg = gam * klist; 37 | end 38 | 39 | kern = kern .* exp(i * oarg * (N-1)/2); 40 | kern = reale(kern); 41 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft1_time.m.svn-base: -------------------------------------------------------------------------------- 1 | % nufft1_time.m 2 | % examine time spent in nufft1 sub-routines 3 | 4 | if 1 5 | N1 = 1024 * 128; 6 | J1 = 6; 7 | 8 | n_shift = 0; 9 | Nlist = 2 .^ [8]; 10 | Jlist = [8]; 11 | 12 | [NN,JJ] = ndgrid(Nlist, Jlist); 13 | 14 | for ii=1:length(NN(:)) 15 | N1 = NN(ii); 16 | J1 = JJ(ii); 17 | K1 = 2*N1; 18 | 19 | x = [1:N1]'; % test signal 20 | x = x(:,ones(1,1000)); 21 | 22 | gam = 2*pi/K1; 23 | o1 = linspace(0,gam,N1)'; 24 | 25 | %profile clear 26 | %profile on -detail operator 27 | %profile on -detail builtin 28 | tic 29 | sb = nufft1_init(o1, N1, J1, K1, n_shift, 'best'); 30 | printf('init time = %g', toc) 31 | %profile on -detail builtin 32 | [Xn, times] = nufft1(x, sb); 33 | %profile report 34 | %profile off 35 | 36 | printf('time fft=%g other=%g overhead=%g', ... 37 | times(1), times(2), times(2)/times(1)*100) 38 | end 39 | return 40 | end 41 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_alpha.m.svn-base: -------------------------------------------------------------------------------- 1 | function [alpha, beta, ok] = nufft_alpha(N, J, K, alpha, beta) 2 | % Determine alpha and beta, as associated with the scaling factors 3 | % for min-max interpolation, from arguments. 4 | % in 5 | % alpha [L,1] Fourier series coefficients of scaling factors 6 | % or a string (see below) 7 | % beta scale gamma=2pi/K by this in Fourier series 8 | % typically is K/N (me) or 0.5 (Liu) 9 | % out 10 | % alpha,beta 11 | % 12 | % Copyright 2001-3-30 Jeff Fessler The University of Michigan 13 | 14 | % if no arguments 15 | if nargin < 3 16 | help(mfilename) 17 | error(mfilename) 18 | return 19 | end 20 | 21 | if ~isvar('alpha') | isempty(alpha) 22 | alpha = [1]; % default Fourier series coefficients of scaling factors 23 | end 24 | if ~isvar('beta') | isempty(beta) 25 | beta = 0.5; % default is Liu version for now 26 | end 27 | 28 | 29 | % 30 | % see if 'best' alpha is desired 31 | % 32 | if ischar(alpha) 33 | if streq(alpha, 'uniform') 34 | alpha = [1]; 35 | beta = 0.5; 36 | else 37 | if streq(alpha, 'best') 38 | L = 0; 39 | elseif streq(alpha, 'best,L=1') 40 | L = 1; 41 | elseif streq(alpha, 'best,L=2') 42 | L = 2; 43 | else 44 | error 'unknown alpha argument' 45 | end 46 | [alpha, beta, ok] = nufft_best_alpha(J, L, K/N); 47 | if ~ok 48 | tmp = 'optimal alpha unknown for J=%d, K/N=%g, L=%d'; 49 | warning(sprintf(tmp, J, K/N, L)) 50 | end 51 | end 52 | end 53 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_alpha_kb_fit.m.svn-base: -------------------------------------------------------------------------------- 1 | function [alphas, beta] = nufft_alpha_kb_fit(N, J, K, L, beta, chat) 2 | % 3 | % return the alpha and beta corresponding to LS fit of L components 4 | % to optimized Kaiser-Bessel scaling factors (m=0, alpha=2.34J). 5 | % This is the best method I know currently for choosing alpha! 6 | % 7 | % Copyright 2002-7-16, Jeff Fessler, The University of Michigan 8 | 9 | if nargin < 3, help(mfilename), error(mfilename), end 10 | if ~isvar('L') | isempty(L) 11 | if N > 40 12 | L = 13; % empirically found to be reasonable 13 | else 14 | L = ceil(N/3); % a kludge to avoid "rank deficient" complaints 15 | end 16 | end 17 | if ~isvar('beta') | isempty(beta), beta = 1; end 18 | if ~isvar('chat') | isempty(chat), chat = 0; end 19 | 20 | kb_alf = 2.34 * J; % KB shape parameter 21 | kb_m = 0; % KB order 22 | 23 | [tmp, sn_kaiser] = nufft1_error(0, N, J, K, 'kaiser', 'ft'); 24 | sn_kaiser = reale(sn_kaiser); 25 | 26 | % 27 | % use regression to match NUFFT with BEST kaiser scaling's 28 | % 29 | gam = 2*pi/K; 30 | nlist = [0:(N-1)]' - (N-1)/2; 31 | X = cos(beta*gam*nlist*[0:L]); % [N,L] 32 | coef = (X \ sn_kaiser)'; % regress(sn_kaiser, X)'; 33 | alphas = [reale(coef(1)) coef(2:end)/2]; 34 | 35 | if chat 36 | printf('cond # for LS fit to KB scale factors: %g', cond(X)) 37 | end 38 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_best_gauss.m.svn-base: -------------------------------------------------------------------------------- 1 | function [sig, kernel, kernel_ft] = nufft_best_gauss(J, K_N, sn_type) 2 | %function [sig, kernel, kernel_ft] = nufft_best_gauss(J, K_N, sn_type) 3 | % Return "sigma" of best (truncated) gaussian for NUFFT 4 | % with previously numerically-optimized width 5 | % in 6 | % K_N K/N 7 | % J # of neighbors used per frequency location 8 | % sn_type 'zn' or 'ft' (latter recommended) 9 | % out 10 | % sig best sigma 11 | % kernel string for inline kernel function, args (k,J) 12 | % kernel_ft string for Fourier transform function, arg: (t) 13 | % 14 | % Copyright 2002-4-11 Jeff Fessler The University of Michigan 15 | 16 | if nargin < 1 17 | help(mfilename) 18 | [sig, kernel, kernel_ft] = nufft_best_gauss(6) 19 | error(mfilename) 20 | end 21 | 22 | if nargin < 2, K_N = 2; end 23 | if nargin < 3, sn_type = 'ft'; end 24 | 25 | if K_N ~= 2, error 'only K/N=2 done', end 26 | s = load('private/nufft_gauss2'); 27 | ii = find(J == s.Jgauss2); 28 | if length(ii) ~= 1 29 | disp(s.Jgauss2(:)') 30 | error 'only above J values done' 31 | end 32 | if streq(sn_type, 'ft') 33 | sig = s.Sgauss2.ft(find(J == s.Jgauss2)); 34 | elseif streq(sn_type, 'zn') 35 | sig = s.Sgauss2.zn(find(J == s.Jgauss2)); 36 | else 37 | error 'bad sn_type' 38 | end 39 | [kernel, kernel_ft] = nufft_gauss('string', J, sig); 40 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_coef.m.svn-base: -------------------------------------------------------------------------------- 1 | function [coef, arg] = nufft_coef(om, J, K, kernel) 2 | %function [coef, arg] = nufft_coef(om, J, K, kernel) 3 | % Make NUFFT interpolation coefficient vector given kernel function. 4 | % in: 5 | % om [M,1] digital frequency omega in radians 6 | % J # of neighbors used per frequency location 7 | % K FFT size (should be >= N, the signal_length) 8 | % kernel kernel function (inline or handle) 9 | % out: 10 | % coef [J,M] coef vector for each frequency 11 | % arg [J,M] kernel argument 12 | % 13 | % Copyright 2002-4-11, Jeff Fessler, The University of Michigan 14 | 15 | if nargin < 4, help(mfilename), error(mfilename), end 16 | 17 | M = length(om); 18 | gam = 2*pi/K; 19 | dk = om / gam - nufft_offset(om, J, K); % [M,1] 20 | arg = outer_sum(-[1:J]', dk'); % [J,M] kernel arg 21 | 22 | coef = feval(kernel, arg, J); % [J,M] 23 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_gauss2.mat.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_gauss2.mat.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_offset.m.svn-base: -------------------------------------------------------------------------------- 1 | function k0 = nufft_offset(om, J, K) 2 | %function k0 = nufft_offset(om, J, K) 3 | % offset for NUFFT 4 | % om [...] omega in [-pi, pi) (not essential!) 5 | % J # of neighbors used 6 | % K FFT size 7 | % out: 8 | % k0 [...] prepare to use mod(k0 + [1:J], K) + 1 9 | % the extra "+1" up here -^ is because matlab counts from 1, not 0 10 | % Copyright 2000-1-9, Jeff Fessler, The University of Michigan 11 | 12 | if nargin < 3, help(mfilename), error args, end 13 | 14 | if mod(J,2) % odd J 15 | k0 = round(om / (2*pi/K)) - (J+1)/2; 16 | 17 | else % even J 18 | k0 = floor(om / (2*pi/K)) - J/2; 19 | end 20 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_scale.m.svn-base: -------------------------------------------------------------------------------- 1 | function sn = nufft_scale(N, K, alpha, gamma_scale) 2 | %function sn = nufft_scale(N, K, alpha, gamma_scale) 3 | % Compute scaling factors for 1D NUFFT 4 | % in: 5 | % N,K 6 | % alpha 7 | % gamma_scale 8 | % out: 9 | % sn [N] scaling factors 10 | % 11 | % Copyright 2001-10-4 Jeff Fessler The University of Michigan 12 | 13 | % 14 | % if no arguments, then run a simple test 15 | % 16 | if nargin < 4 17 | help(mfilename) 18 | 19 | N = 100; 20 | K = 2*N; 21 | alpha = [1.0 -0.0 -0.2]; 22 | sn = nufft_scale(N, K, alpha, 1); 23 | clf, plot(1:N, real(sn), 'y-', 1:N, imag(sn), 'g-') 24 | legend('sn real', 'sn imag') 25 | clear sn 26 | return 27 | end 28 | 29 | 30 | if ~isreal(alpha(1)), error 'need real alpha_0', end 31 | L = length(alpha) - 1; 32 | 33 | % 34 | % compute scaling factors from Fourier coefficients 35 | % 36 | if L > 0 37 | sn = zeros(N,1); 38 | n = [0:(N-1)]'; 39 | i_gam_n_n0 = i * (2*pi/K) * (n - (N-1)/2) * gamma_scale; 40 | 41 | for l1=-L:L 42 | alf = alpha(abs(l1)+1); 43 | if l1 < 0, alf = conj(alf); end 44 | sn = sn + alf * exp(i_gam_n_n0 * l1); 45 | end 46 | 47 | else 48 | sn = alpha * ones(N,1); 49 | end 50 | 51 | if 0 52 | printf('range real(sn) = %g,%g', min(real(sn)), max(real(sn))) 53 | printf('range imag(sn) = %g,%g', min(imag(sn)), max(imag(sn))) 54 | end 55 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_table_adj.m (a.hasib.bhati@gmail.com).svn-base: -------------------------------------------------------------------------------- 1 | function Xk = nufft_table_adj(st, X) 2 | %function Xk = nufft_table_adj(st, X) 3 | % adjoint of table-based nufft interpolation. 4 | % in 5 | % st structure from nufft_init 6 | % X [M,?] DTFT values 7 | % out 8 | % Xk [*Kd,?] DFT coefficients 9 | % Copyright 2004-3-30, Jeff Fessler and Yingying Zhang, University of Michigan 10 | 11 | dd = length(st.Kd); 12 | 13 | % t = omega / gamma 14 | tm = zeros(size(st.om)); 15 | for id=1:dd 16 | gam = 2*pi / st.Kd(id); 17 | tm(:,id) = st.om(:,id) / gam; 18 | end 19 | 20 | if size(X,1) ~= st.M 21 | error 'X size problem' 22 | end 23 | 24 | % adjoint of phase shift 25 | if isvar('st.phase_shift') & ~isempty(st.phase_shift) 26 | X = X .* conj(st.phase_shift); 27 | end 28 | 29 | if isreal(X) 30 | X = complexify(X); 31 | end 32 | 33 | if dd == 1 34 | Xk = interp1_table_adj_mex(X, st.h{1}, ... 35 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd(1))); 36 | 37 | elseif dd==2 38 | Xk = interp2_table_adj_mex(X, st.h{1}, st.h{2}, ... 39 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd)); 40 | 41 | elseif dd==3 42 | Xk = interp3_table_adj_mex(X, st.h{1}, st.h{2}, st.h{3}, ... 43 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd)); 44 | 45 | else 46 | error '> 3d not done' 47 | end 48 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_table_adj.m.svn-base: -------------------------------------------------------------------------------- 1 | function Xk = nufft_table_adj(st, X) 2 | %function Xk = nufft_table_adj(st, X) 3 | % adjoint of table-based nufft interpolation. 4 | % in 5 | % st structure from nufft_init 6 | % X [M,?] DTFT values 7 | % out 8 | % Xk [*Kd,?] DFT coefficients 9 | % Copyright 2004-3-30, Jeff Fessler and Yingying Zhang, University of Michigan 10 | 11 | dd = length(st.Kd); 12 | 13 | % t = omega / gamma 14 | tm = zeros(size(st.om)); 15 | for id=1:dd 16 | gam = 2*pi / st.Kd(id); 17 | tm(:,id) = st.om(:,id) / gam; 18 | end 19 | 20 | if size(X,1) ~= st.M 21 | error 'X size problem' 22 | end 23 | 24 | % adjoint of phase shift 25 | if isvar('st.phase_shift') & ~isempty(st.phase_shift) 26 | X = X .* conj(st.phase_shift); 27 | end 28 | 29 | if isreal(X) 30 | X = complexify(X); 31 | end 32 | 33 | if dd == 1 34 | Xk = interp1_table_adj_mex(X, st.h{1}, ... 35 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd(1))); 36 | 37 | elseif dd==2 38 | Xk = interp2_table_adj_mex(X, st.h{1}, st.h{2}, ... 39 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd)); 40 | 41 | elseif dd==3 42 | Xk = interp3_table_adj_mex(X, st.h{1}, st.h{2}, st.h{3}, ... 43 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd)); 44 | 45 | else 46 | error '> 3d not done' 47 | end 48 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/nufft_table_interp.m.svn-base: -------------------------------------------------------------------------------- 1 | function X = nufft_table_interp(st, Xk) 2 | %function X = nufft_table_interp(st, Xk) 3 | % table-based 1D and 2D nufft 4 | % in 5 | % st structure formed by nufft_init (through nufft_init_table) 6 | % Xk [*Kd,L] over-sampled DFT coefficients 7 | % out 8 | % X [M,L] NUFFT values 9 | % Copyright 2004-3-30, Jeff Fessler and Yingying Zhang, University of Michigan 10 | 11 | dd = length(st.Kd); 12 | 13 | % t = omega / gamma 14 | tm = zeros(size(st.om)); 15 | for id=1:dd 16 | gam = 2*pi / st.Kd(id); 17 | tm(:,id) = st.om(:,id) / gam; 18 | end 19 | 20 | if size(Xk,1) ~= prod(st.Kd), error 'Xk size problem', end 21 | 22 | % force Xk to be complex, since this is needed for pointers in the mex files. 23 | if isreal(Xk), Xk = complex(Xk); end 24 | 25 | if dd == 1 26 | X = interp1_table_mex(Xk, st.h{1}, ... 27 | int32(st.Jd), int32(st.Ld), tm); 28 | 29 | elseif dd==2 30 | Xk = reshape(Xk, st.Kd); 31 | X = interp2_table_mex(Xk, st.h{1}, st.h{2}, ... 32 | int32(st.Jd), int32(st.Ld), tm); 33 | 34 | elseif dd==3 35 | Xk = reshape(Xk, st.Kd); 36 | X = interp3_table_mex(Xk, st.h{1}, st.h{2}, st.h{3}, ... 37 | int32(st.Jd), int32(st.Ld), tm); 38 | 39 | else 40 | error '> 3d not done' 41 | end 42 | 43 | % apply phase shift 44 | if isvar('st.phase_shift') & ~isempty(st.phase_shift) 45 | X = X .* st.phase_shift; 46 | end 47 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/outer_sum.m.svn-base: -------------------------------------------------------------------------------- 1 | function ss = outer_sum(xx,yy) 2 | %function ss = outer_sum(xx,yy) 3 | % compute an "outer sum" x + y' 4 | % that is analogous to the "outer product" x * y' 5 | % Input 6 | % xx [nx,1] 7 | % yy [1,ny] 8 | % Output 9 | % ss [nx,ny] ss(i,j) = xx(i) + yy(j) 10 | if ~nargin, help outer_sum, end 11 | 12 | xx = xx(:); 13 | yy = yy(:)'; 14 | nx = length(xx); 15 | ny = length(yy); 16 | xx = xx(:, ones(1,ny)); 17 | yy = yy(ones(1,nx),:); 18 | % [xx, yy] = ndgrid(xx, yy); 19 | ss = xx + yy; 20 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/reale.m.svn-base: -------------------------------------------------------------------------------- 1 | function y = reale(x, arg2) 2 | %function y = reale(x) 3 | %function y = reale(x, tol) 4 | %function y = reale(x, 'warn') 5 | %function y = reale(x, 'error') 6 | %function y = reale(x, 'report') 7 | %function y = reale(x, 'disp') 8 | % return real part of complex data (with error checking). 9 | % checks that imaginary part is negligible (or warning etc. if not) 10 | % Copyright Jeff Fessler, The University of Michigan 11 | 12 | com = 'error'; 13 | tol = 1e-13; 14 | if nargin > 1 15 | if ischar(arg2) 16 | com = arg2; 17 | elseif isnumeric(arg2) 18 | tol = arg2; 19 | end 20 | end 21 | 22 | if streq(com, 'disp') 23 | ; 24 | elseif streq(com, 'warn') 25 | onlywarn = 1; 26 | elseif streq(com, 'error') 27 | onlywarn = 0; 28 | elseif streq(com, 'report') 29 | ; 30 | else 31 | error(sprintf('bad argument %s', com)) 32 | end 33 | 34 | if max(abs(x(:))) == 0 35 | if any(imag(x(:)) ~= 0) 36 | error 'max real 0, but imaginary!' 37 | else 38 | y = real(x); 39 | return 40 | end 41 | end 42 | 43 | frac = max(abs(imag(x(:)))) / max(abs(x(:))); 44 | if streq(com, 'report') 45 | printf('imaginary part %g%%', frac * 100) 46 | return 47 | end 48 | 49 | if frac > tol 50 | t = sprintf('%s: imaginary fraction %g', mfilename, frac); 51 | if streq(com, 'disp') 52 | disp(t) 53 | elseif onlywarn 54 | disp(t) 55 | else 56 | error(t) 57 | end 58 | end 59 | y = real(x); 60 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/spdiag.m.svn-base: -------------------------------------------------------------------------------- 1 | function b = spdiag(a) 2 | %function b = spdiag(a) 3 | % create a sparse matrix with diagonal given by a 4 | 5 | a = a(:); 6 | b = spdiags(a, 0, length(a), length(a)); 7 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/streq.m.svn-base: -------------------------------------------------------------------------------- 1 | function tf = streq(a,b,n) 2 | %function tf = streq(a, b [,n]) 3 | % return 1 if two strings are equal (optionally only up to 1st n chars) 4 | if nargin == 2 5 | tf = strcmp(a,b); 6 | elseif nargin == 3 7 | tf = strncmp(a,b,n); 8 | else 9 | help(mfilename), error(mfilename) 10 | end 11 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/.svn/text-base/test_fft2.m.svn-base: -------------------------------------------------------------------------------- 1 | % test_fft2.m 2 | % compare fft2 vs fft(fft()) 3 | % 4 | % results on G5: 5 | % fftn 0.147631 6 | % fft2 0.133448 7 | % fft1 0.130262 8 | % fft0 0.0802386 9 | % 10 | % results on ir7: 11 | % fftn 0.184001 12 | % fft2 0.184357 13 | % fft1 0.192388 14 | % fft0 0.177634 15 | 16 | N = 2^9; 17 | M = 5; 18 | rand('state', 0) 19 | x = rand(N); 20 | 21 | tic 22 | for m=1:M, X1 = fftn(x); end 23 | printf('fftn %g', toc/M) 24 | 25 | tic 26 | for m=1:M, Xm = my_fftn(x); end 27 | printf('fftm %g', toc/M) 28 | 29 | tic 30 | for m=1:M, X4 = fft(fft(x).').'; end 31 | printf('fft0 %g', toc/M) 32 | 33 | tic 34 | for m=1:M, X2 = fft2(x); end 35 | printf('fft2 %g', toc/M) 36 | 37 | tic 38 | for m=1:M, X3 = fft(fft(x,[],2),[],1); end 39 | printf('fft1 %g', toc/M) 40 | 41 | [max_percent_diff(X1,X2) max_percent_diff(X1,X3) ... 42 | max_percent_diff(X1,X4) max_percent_diff(X1,Xm)] 43 | 44 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/Makefile: -------------------------------------------------------------------------------- 1 | # Makefile 2 | # one can reduce time by compiling the initialization routine 3 | 4 | suf = mexglx 5 | goal: \ 6 | interp1_table_mex.$(suf) \ 7 | interp2_table_mex.$(suf) \ 8 | interp3_table_mex.$(suf) \ 9 | interp1_table_adj_mex.$(suf) \ 10 | interp2_table_adj_mex.$(suf) \ 11 | interp3_table_adj_mex.$(suf) 12 | 13 | CFLAGS = -ansi -Wall -Wshadow -Wpointer-arith -W -Werror 14 | mex = mex CFLAGS='$(CFLAGS)' 15 | 16 | interp1_table_mex.$(suf): interp1_table_mex.c 17 | $(mex) $? 18 | 19 | interp2_table_mex.$(suf): interp2_table_mex.c 20 | $(mex) $? 21 | 22 | interp3_table_mex.$(suf): interp3_table_mex.c 23 | $(mex) $? 24 | 25 | interp1_table_adj_mex.$(suf): interp1_table_adj_mex.c 26 | $(mex) $? 27 | 28 | interp2_table_adj_mex.$(suf): interp2_table_adj_mex.c 29 | $(mex) $? 30 | 31 | interp3_table_adj_mex.$(suf): interp3_table_adj_mex.c 32 | $(mex) $? 33 | 34 | mat = /users/apps/matlab5.3/toolbox/matlab 35 | mfile = \ 36 | $(mat)/datatypes/ndgrid.m \ 37 | $(mat)/elfun/mod.m \ 38 | $(mat)/ops/kron.m 39 | 40 | goal = nufft2_init.mexaxp 41 | main = nufft2_init.m 42 | 43 | $(goal): $(main) $(mfile) 44 | mcc -x -h $(main) $(mfile) 45 | 46 | reset: 47 | rm -i $(goal) 48 | 49 | 50 | #plist = nufft2.m nufft2_init.m nufft_diric.m nufft_R.m 51 | plist = *.m 52 | en7=print,code 53 | comm=$(en7) `linesplit $? | sort`; lpq; touch $@ 54 | .print: $(plist) 55 | $(comm) 56 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/col.m: -------------------------------------------------------------------------------- 1 | function x = col(x) 2 | %function x = col(x) 3 | % "colon" function 4 | x = x(:); 5 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/dtft1.m: -------------------------------------------------------------------------------- 1 | function X = dtft1(x, omega, n_shift) 2 | %function X = dtft1(x, omega, n_shift) 3 | % Compute DTFT of 1D signal x at frequency locations wx 4 | % In 5 | % x [N,ncol] signal values 6 | % omega [M,1] frequency locations 7 | % n_shift [1,1] use [0:(N-1)]-n_shift indices 8 | % Out 9 | % X [M,ncol] DTFT values 10 | % 11 | % This needs enough memory to store M * N size matrices 12 | % Copyright 2000-1-9 Jeff Fessler The University of Michigan 13 | 14 | % 15 | % if no arguments, then run a simple test 16 | % 17 | if nargin < 2 18 | N = 4; 19 | x = [[1:N]', [1 1 2 2]']; % two test signal 20 | omega = 2*pi*[0:(N-1)]'/N; % test with uniform frequency locations 21 | Xd = dtft1(x, omega); 22 | Xf = fft(x); 23 | % disp([Xd Xf]) 24 | help(mfilename) 25 | disp(sprintf('max %% difference = %g', max_percent_diff(Xf,Xd))) 26 | return 27 | end 28 | 29 | N = size(x,1); 30 | if ~isvar('n_shift') | isempty(n_shift), n_shift = 0; end 31 | nn = [0:(N-1)] - n_shift; 32 | 33 | X = exp(-i*omega*nn) * x; % compute 1D DTFT 34 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/dtft_mex.m: -------------------------------------------------------------------------------- 1 | function X = dtft_mex(varargin) 2 | 3 | disp('This dtft_mex.m is a dummy m-file that is included to provide') 4 | disp('a reminder that you must have the Mex file "dtft_mex.mex???" that') 5 | disp('is appropriate for your system. For pc-linux, the mex file is') 6 | disp('called "dtft_mex.mexglx", which is provided in the "mfile"') 7 | disp('subdirectory. For a sun, the name is "dtft_mex.mexsol", which') 8 | disp('may or may not be provided. If you have another OS, then you may') 9 | disp('be out of luck, or you may be able to cajole Jeff into compiling a') 10 | disp('mex file for your OS.') 11 | error 'no appropriate mex file!?' 12 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/fig_taper_cos3.m: -------------------------------------------------------------------------------- 1 | % fig_taper_cos3 2 | % compare 3 different interpolation kernels: 3 | % min-max kernel with uniform scaling factors 4 | % min-max kernel with optimized scaling factors 5 | % cos^3-tapered dirichlet kernel of magnusson 6 | 7 | J = 6; 8 | N = 1000; 9 | K = 2 * N; 10 | k = linspace(-J/2,J/2,101)'; 11 | fm = diric(2*pi*k/J, J) .* cos((2*pi*k/J)/2).^3; % tapered 12 | fn = nufft1_kernel(k, N, J, K, 1, 0); % min-max unif 13 | fo = nufft1_kernel(k, N, J, K, 'best'); 14 | fo = fo / max(fo); 15 | 16 | %fm = 0*fm; 17 | %fn = nufft1_kernel(k, N, J, 9*N, 1, 0); 18 | %fo = nufft1_kernel(k, N, J, 2*N, 1, 0); 19 | 20 | plot(k, fn, '-', k, fm, '--', k, fo, '-.') 21 | axisy(-0.3,1.1) 22 | legend('min-max', 'Magnusson', 'optimized') 23 | title(sprintf('J=%d K/N=%g', J, K/N)) 24 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp1_table_adj_mex.mexglx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp1_table_adj_mex.mexglx -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp1_table_adj_mex.mexmaci: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp1_table_adj_mex.mexmaci -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp1_table_mex (a.hasib.bhati@gmail.com).mexglx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp1_table_mex (a.hasib.bhati@gmail.com).mexglx -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp1_table_mex.mexglx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp1_table_mex.mexglx -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp1_table_mex.mexmaci: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp1_table_mex.mexmaci -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp2_table_adj_mex.mexglx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp2_table_adj_mex.mexglx -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp2_table_adj_mex.mexmaci: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp2_table_adj_mex.mexmaci -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp2_table_mex.mexglx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp2_table_mex.mexglx -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp2_table_mex.mexmaci: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp2_table_mex.mexmaci -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp3_table_adj_mex.mexglx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp3_table_adj_mex.mexglx -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp3_table_adj_mex.mexmaci: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp3_table_adj_mex.mexmaci -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp3_table_mex.mexglx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp3_table_mex.mexglx -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/interp3_table_mex.mexmaci: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/interp3_table_mex.mexmaci -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/isvar.m: -------------------------------------------------------------------------------- 1 | function tf = isvar(name) 2 | %function tf = isvar(name) 3 | % determine if "name" is a variable in the caller's workspace 4 | 5 | if nargin < 1 6 | help isvar 7 | error arg 8 | end 9 | 10 | tf = logical(1); 11 | evalin('caller', [name ';'], 'tf=logical(0);') 12 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/kaiser,m=0.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/kaiser,m=0.mat -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/kaiser,m=2.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/kaiser,m=2.mat -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/my_fftn.m: -------------------------------------------------------------------------------- 1 | function X = my_fftn(x) 2 | 3 | X = fft(x); 4 | dd = ndims(x); 5 | for id=2:dd 6 | ord = 1:dd; 7 | ord([1 id]) = [id 1]; 8 | x = permute(X, ord); 9 | X = fft(x); 10 | X = ipermute(X, ord); 11 | end 12 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft1_kernel.m: -------------------------------------------------------------------------------- 1 | function kern = nufft1_kernel(klist, N, J, K, alpha, beta) 2 | %function kern = nufft1_kernel(klist, N, J, K, alpha, beta) 3 | % compute equivalent interpolation kernel (real part) 4 | % at points in klist 5 | 6 | if nargin < 4 7 | help(mfilename) 8 | J = 7; N = 100; K = 2*N; 9 | k = linspace(-J/2-1,J/2+1,201)'; % fine sampling for display 10 | ker = nufft1_kernel(k, N, J, K, 1, 0); 11 | plot(k, ker), axis tight 12 | return 13 | end 14 | 15 | if ~isvar('alpha') | isempty(alpha), alpha = 1; end 16 | if ~isvar('beta') | isempty(beta), beta = 0.5; end 17 | [alpha beta] = nufft_alpha(N, J, K, alpha, beta); 18 | 19 | n_shift1 = 0; 20 | 21 | gam = 2*pi/K; 22 | 23 | st = nufft_init(gam*klist, N, J, K, n_shift1, 'minmax:user', {alpha}, {beta}); 24 | 25 | kern = full(st.p(:,1)); 26 | 27 | % 28 | % undo phase to make it real 29 | % 30 | om = st.om; 31 | if 0 32 | koff = nufft_offset(om, J, K); % [M,1] 33 | jj = 0 - nufft_offset(om, J, K); % effective j 34 | oarg = om - gam * (koff + jj); 35 | else 36 | oarg = gam * klist; 37 | end 38 | 39 | kern = kern .* exp(i * oarg * (N-1)/2); 40 | kern = reale(kern); 41 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft1_time.m: -------------------------------------------------------------------------------- 1 | % nufft1_time.m 2 | % examine time spent in nufft1 sub-routines 3 | 4 | if 1 5 | N1 = 1024 * 128; 6 | J1 = 6; 7 | 8 | n_shift = 0; 9 | Nlist = 2 .^ [8]; 10 | Jlist = [8]; 11 | 12 | [NN,JJ] = ndgrid(Nlist, Jlist); 13 | 14 | for ii=1:length(NN(:)) 15 | N1 = NN(ii); 16 | J1 = JJ(ii); 17 | K1 = 2*N1; 18 | 19 | x = [1:N1]'; % test signal 20 | x = x(:,ones(1,1000)); 21 | 22 | gam = 2*pi/K1; 23 | o1 = linspace(0,gam,N1)'; 24 | 25 | %profile clear 26 | %profile on -detail operator 27 | %profile on -detail builtin 28 | tic 29 | sb = nufft1_init(o1, N1, J1, K1, n_shift, 'best'); 30 | printf('init time = %g', toc) 31 | %profile on -detail builtin 32 | [Xn, times] = nufft1(x, sb); 33 | %profile report 34 | %profile off 35 | 36 | printf('time fft=%g other=%g overhead=%g', ... 37 | times(1), times(2), times(2)/times(1)*100) 38 | end 39 | return 40 | end 41 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_alpha.m: -------------------------------------------------------------------------------- 1 | function [alpha, beta, ok] = nufft_alpha(N, J, K, alpha, beta) 2 | % Determine alpha and beta, as associated with the scaling factors 3 | % for min-max interpolation, from arguments. 4 | % in 5 | % alpha [L,1] Fourier series coefficients of scaling factors 6 | % or a string (see below) 7 | % beta scale gamma=2pi/K by this in Fourier series 8 | % typically is K/N (me) or 0.5 (Liu) 9 | % out 10 | % alpha,beta 11 | % 12 | % Copyright 2001-3-30 Jeff Fessler The University of Michigan 13 | 14 | % if no arguments 15 | if nargin < 3 16 | help(mfilename) 17 | error(mfilename) 18 | return 19 | end 20 | 21 | if ~isvar('alpha') | isempty(alpha) 22 | alpha = [1]; % default Fourier series coefficients of scaling factors 23 | end 24 | if ~isvar('beta') | isempty(beta) 25 | beta = 0.5; % default is Liu version for now 26 | end 27 | 28 | 29 | % 30 | % see if 'best' alpha is desired 31 | % 32 | if ischar(alpha) 33 | if streq(alpha, 'uniform') 34 | alpha = [1]; 35 | beta = 0.5; 36 | else 37 | if streq(alpha, 'best') 38 | L = 0; 39 | elseif streq(alpha, 'best,L=1') 40 | L = 1; 41 | elseif streq(alpha, 'best,L=2') 42 | L = 2; 43 | else 44 | error 'unknown alpha argument' 45 | end 46 | [alpha, beta, ok] = nufft_best_alpha(J, L, K/N); 47 | if ~ok 48 | tmp = 'optimal alpha unknown for J=%d, K/N=%g, L=%d'; 49 | warning(sprintf(tmp, J, K/N, L)) 50 | end 51 | end 52 | end 53 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_alpha_kb_fit.m: -------------------------------------------------------------------------------- 1 | function [alphas, beta] = nufft_alpha_kb_fit(N, J, K, L, beta, chat) 2 | % 3 | % return the alpha and beta corresponding to LS fit of L components 4 | % to optimized Kaiser-Bessel scaling factors (m=0, alpha=2.34J). 5 | % This is the best method I know currently for choosing alpha! 6 | % 7 | % Copyright 2002-7-16, Jeff Fessler, The University of Michigan 8 | 9 | if nargin < 3, help(mfilename), error(mfilename), end 10 | if ~isvar('L') | isempty(L) 11 | if N > 40 12 | L = 13; % empirically found to be reasonable 13 | else 14 | L = ceil(N/3); % a kludge to avoid "rank deficient" complaints 15 | end 16 | end 17 | if ~isvar('beta') | isempty(beta), beta = 1; end 18 | if ~isvar('chat') | isempty(chat), chat = 0; end 19 | 20 | kb_alf = 2.34 * J; % KB shape parameter 21 | kb_m = 0; % KB order 22 | 23 | [tmp, sn_kaiser] = nufft1_error(0, N, J, K, 'kaiser', 'ft'); 24 | sn_kaiser = reale(sn_kaiser); 25 | 26 | % 27 | % use regression to match NUFFT with BEST kaiser scaling's 28 | % 29 | gam = 2*pi/K; 30 | nlist = [0:(N-1)]' - (N-1)/2; 31 | X = cos(beta*gam*nlist*[0:L]); % [N,L] 32 | coef = (X \ sn_kaiser)'; % regress(sn_kaiser, X)'; 33 | alphas = [reale(coef(1)) coef(2:end)/2]; 34 | 35 | if chat 36 | printf('cond # for LS fit to KB scale factors: %g', cond(X)) 37 | end 38 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_best_gauss.m: -------------------------------------------------------------------------------- 1 | function [sig, kernel, kernel_ft] = nufft_best_gauss(J, K_N, sn_type) 2 | %function [sig, kernel, kernel_ft] = nufft_best_gauss(J, K_N, sn_type) 3 | % Return "sigma" of best (truncated) gaussian for NUFFT 4 | % with previously numerically-optimized width 5 | % in 6 | % K_N K/N 7 | % J # of neighbors used per frequency location 8 | % sn_type 'zn' or 'ft' (latter recommended) 9 | % out 10 | % sig best sigma 11 | % kernel string for inline kernel function, args (k,J) 12 | % kernel_ft string for Fourier transform function, arg: (t) 13 | % 14 | % Copyright 2002-4-11 Jeff Fessler The University of Michigan 15 | 16 | if nargin < 1 17 | help(mfilename) 18 | [sig, kernel, kernel_ft] = nufft_best_gauss(6) 19 | error(mfilename) 20 | end 21 | 22 | if nargin < 2, K_N = 2; end 23 | if nargin < 3, sn_type = 'ft'; end 24 | 25 | if K_N ~= 2, error 'only K/N=2 done', end 26 | s = load('private/nufft_gauss2'); 27 | ii = find(J == s.Jgauss2); 28 | if length(ii) ~= 1 29 | disp(s.Jgauss2(:)') 30 | error 'only above J values done' 31 | end 32 | if streq(sn_type, 'ft') 33 | sig = s.Sgauss2.ft(find(J == s.Jgauss2)); 34 | elseif streq(sn_type, 'zn') 35 | sig = s.Sgauss2.zn(find(J == s.Jgauss2)); 36 | else 37 | error 'bad sn_type' 38 | end 39 | [kernel, kernel_ft] = nufft_gauss('string', J, sig); 40 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_coef.m: -------------------------------------------------------------------------------- 1 | function [coef, arg] = nufft_coef(om, J, K, kernel) 2 | %function [coef, arg] = nufft_coef(om, J, K, kernel) 3 | % Make NUFFT interpolation coefficient vector given kernel function. 4 | % in: 5 | % om [M,1] digital frequency omega in radians 6 | % J # of neighbors used per frequency location 7 | % K FFT size (should be >= N, the signal_length) 8 | % kernel kernel function (inline or handle) 9 | % out: 10 | % coef [J,M] coef vector for each frequency 11 | % arg [J,M] kernel argument 12 | % 13 | % Copyright 2002-4-11, Jeff Fessler, The University of Michigan 14 | 15 | if nargin < 4, help(mfilename), error(mfilename), end 16 | 17 | M = length(om); 18 | gam = 2*pi/K; 19 | dk = om / gam - nufft_offset(om, J, K); % [M,1] 20 | arg = outer_sum(-[1:J]', dk'); % [J,M] kernel arg 21 | 22 | coef = feval(kernel, arg, J); % [J,M] 23 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_gauss2.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/nufft_gauss2.mat -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_offset.m: -------------------------------------------------------------------------------- 1 | function k0 = nufft_offset(om, J, K) 2 | %function k0 = nufft_offset(om, J, K) 3 | % offset for NUFFT 4 | % om [...] omega in [-pi, pi) (not essential!) 5 | % J # of neighbors used 6 | % K FFT size 7 | % out: 8 | % k0 [...] prepare to use mod(k0 + [1:J], K) + 1 9 | % the extra "+1" up here -^ is because matlab counts from 1, not 0 10 | % Copyright 2000-1-9, Jeff Fessler, The University of Michigan 11 | 12 | if nargin < 3, help(mfilename), error args, end 13 | 14 | if mod(J,2) % odd J 15 | k0 = round(om / (2*pi/K)) - (J+1)/2; 16 | 17 | else % even J 18 | k0 = floor(om / (2*pi/K)) - J/2; 19 | end 20 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_scale.m: -------------------------------------------------------------------------------- 1 | function sn = nufft_scale(N, K, alpha, gamma_scale) 2 | %function sn = nufft_scale(N, K, alpha, gamma_scale) 3 | % Compute scaling factors for 1D NUFFT 4 | % in: 5 | % N,K 6 | % alpha 7 | % gamma_scale 8 | % out: 9 | % sn [N] scaling factors 10 | % 11 | % Copyright 2001-10-4 Jeff Fessler The University of Michigan 12 | 13 | % 14 | % if no arguments, then run a simple test 15 | % 16 | if nargin < 4 17 | help(mfilename) 18 | 19 | N = 100; 20 | K = 2*N; 21 | alpha = [1.0 -0.0 -0.2]; 22 | sn = nufft_scale(N, K, alpha, 1); 23 | clf, plot(1:N, real(sn), 'y-', 1:N, imag(sn), 'g-') 24 | legend('sn real', 'sn imag') 25 | clear sn 26 | return 27 | end 28 | 29 | 30 | if ~isreal(alpha(1)), error 'need real alpha_0', end 31 | L = length(alpha) - 1; 32 | 33 | % 34 | % compute scaling factors from Fourier coefficients 35 | % 36 | if L > 0 37 | sn = zeros(N,1); 38 | n = [0:(N-1)]'; 39 | i_gam_n_n0 = i * (2*pi/K) * (n - (N-1)/2) * gamma_scale; 40 | 41 | for l1=-L:L 42 | alf = alpha(abs(l1)+1); 43 | if l1 < 0, alf = conj(alf); end 44 | sn = sn + alf * exp(i_gam_n_n0 * l1); 45 | end 46 | 47 | else 48 | sn = alpha * ones(N,1); 49 | end 50 | 51 | if 0 52 | printf('range real(sn) = %g,%g', min(real(sn)), max(real(sn))) 53 | printf('range imag(sn) = %g,%g', min(imag(sn)), max(imag(sn))) 54 | end 55 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_table_adj.m: -------------------------------------------------------------------------------- 1 | function Xk = nufft_table_adj(st, X) 2 | %function Xk = nufft_table_adj(st, X) 3 | % adjoint of table-based nufft interpolation. 4 | % in 5 | % st structure from nufft_init 6 | % X [M,?] DTFT values 7 | % out 8 | % Xk [*Kd,?] DFT coefficients 9 | % Copyright 2004-3-30, Jeff Fessler and Yingying Zhang, University of Michigan 10 | 11 | dd = length(st.Kd); 12 | 13 | % t = omega / gamma 14 | tm = zeros(size(st.om)); 15 | for id=1:dd 16 | gam = 2*pi / st.Kd(id); 17 | tm(:,id) = st.om(:,id) / gam; 18 | end 19 | 20 | if size(X,1) ~= st.M 21 | error 'X size problem' 22 | end 23 | 24 | % adjoint of phase shift 25 | if isvar('st.phase_shift') & ~isempty(st.phase_shift) 26 | X = X .* conj(st.phase_shift); 27 | end 28 | 29 | if isreal(X) 30 | X = complexify(X); 31 | end 32 | 33 | if dd == 1 34 | Xk = interp1_table_adj_mex(X, st.h{1}, ... 35 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd(1))); 36 | 37 | elseif dd==2 38 | Xk = interp2_table_adj_mex(X, st.h{1}, st.h{2}, ... 39 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd)); 40 | 41 | elseif dd==3 42 | Xk = interp3_table_adj_mex(X, st.h{1}, st.h{2}, st.h{3}, ... 43 | int32(st.Jd), int32(st.Ld), tm, int32(st.Kd)); 44 | 45 | else 46 | error '> 3d not done' 47 | end 48 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/nufft_table_interp.m: -------------------------------------------------------------------------------- 1 | function X = nufft_table_interp(st, Xk) 2 | %function X = nufft_table_interp(st, Xk) 3 | % table-based 1D and 2D nufft 4 | % in 5 | % st structure formed by nufft_init (through nufft_init_table) 6 | % Xk [*Kd,L] over-sampled DFT coefficients 7 | % out 8 | % X [M,L] NUFFT values 9 | % Copyright 2004-3-30, Jeff Fessler and Yingying Zhang, University of Michigan 10 | 11 | dd = length(st.Kd); 12 | 13 | % t = omega / gamma 14 | tm = zeros(size(st.om)); 15 | for id=1:dd 16 | gam = 2*pi / st.Kd(id); 17 | tm(:,id) = st.om(:,id) / gam; 18 | end 19 | 20 | if size(Xk,1) ~= prod(st.Kd), error 'Xk size problem', end 21 | 22 | % force Xk to be complex, since this is needed for pointers in the mex files. 23 | if isreal(Xk), Xk = complex(Xk); end 24 | 25 | if dd == 1 26 | X = interp1_table_mex(Xk, st.h{1}, ... 27 | int32(st.Jd), int32(st.Ld), tm); 28 | 29 | elseif dd==2 30 | Xk = reshape(Xk, st.Kd); 31 | X = interp2_table_mex(Xk, st.h{1}, st.h{2}, ... 32 | int32(st.Jd), int32(st.Ld), tm); 33 | 34 | elseif dd==3 35 | Xk = reshape(Xk, st.Kd); 36 | X = interp3_table_mex(Xk, st.h{1}, st.h{2}, st.h{3}, ... 37 | int32(st.Jd), int32(st.Ld), tm); 38 | 39 | else 40 | error '> 3d not done' 41 | end 42 | 43 | % apply phase shift 44 | if isvar('st.phase_shift') & ~isempty(st.phase_shift) 45 | X = X .* st.phase_shift; 46 | end 47 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/outer_sum.m: -------------------------------------------------------------------------------- 1 | function ss = outer_sum(xx,yy) 2 | %function ss = outer_sum(xx,yy) 3 | % compute an "outer sum" x + y' 4 | % that is analogous to the "outer product" x * y' 5 | % Input 6 | % xx [nx,1] 7 | % yy [1,ny] 8 | % Output 9 | % ss [nx,ny] ss(i,j) = xx(i) + yy(j) 10 | if ~nargin, help outer_sum, end 11 | 12 | xx = xx(:); 13 | yy = yy(:)'; 14 | nx = length(xx); 15 | ny = length(yy); 16 | xx = xx(:, ones(1,ny)); 17 | yy = yy(ones(1,nx),:); 18 | % [xx, yy] = ndgrid(xx, yy); 19 | ss = xx + yy; 20 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/all-wcprops: -------------------------------------------------------------------------------- 1 | K 25 2 | svn:wc:ra_dav:version-url 3 | V 48 4 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private 5 | END 6 | kaiser_bessel_ft.m 7 | K 25 8 | svn:wc:ra_dav:version-url 9 | V 67 10 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/kaiser_bessel_ft.m 11 | END 12 | nufft_T.m 13 | K 25 14 | svn:wc:ra_dav:version-url 15 | V 58 16 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/nufft_T.m 17 | END 18 | nufft_alpha.m 19 | K 25 20 | svn:wc:ra_dav:version-url 21 | V 62 22 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/nufft_alpha.m 23 | END 24 | nufft_offset.m 25 | K 25 26 | svn:wc:ra_dav:version-url 27 | V 63 28 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/nufft_offset.m 29 | END 30 | kaiser,m=0.mat 31 | K 25 32 | svn:wc:ra_dav:version-url 33 | V 63 34 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/kaiser,m=0.mat 35 | END 36 | nufft_interp_zn.m 37 | K 25 38 | svn:wc:ra_dav:version-url 39 | V 66 40 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/nufft_interp_zn.m 41 | END 42 | kaiser,m=2.mat 43 | K 25 44 | svn:wc:ra_dav:version-url 45 | V 63 46 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/kaiser,m=2.mat 47 | END 48 | nufft_gauss2.mat 49 | K 25 50 | svn:wc:ra_dav:version-url 51 | V 65 52 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/nufft_gauss2.mat 53 | END 54 | nufft_coef.m 55 | K 25 56 | svn:wc:ra_dav:version-url 57 | V 61 58 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/nufft_coef.m 59 | END 60 | nufft_r.m 61 | K 25 62 | svn:wc:ra_dav:version-url 63 | V 58 64 | /svn/SPIRiT/!svn/ver/6/trunk/nufft_files/private/nufft_r.m 65 | END 66 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/prop-base/kaiser,m=0.mat.svn-base: -------------------------------------------------------------------------------- 1 | K 13 2 | svn:mime-type 3 | V 24 4 | application/octet-stream 5 | END 6 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/prop-base/kaiser,m=2.mat.svn-base: -------------------------------------------------------------------------------- 1 | K 13 2 | svn:mime-type 3 | V 24 4 | application/octet-stream 5 | END 6 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/prop-base/nufft_gauss2.mat.svn-base: -------------------------------------------------------------------------------- 1 | K 13 2 | svn:mime-type 3 | V 24 4 | application/octet-stream 5 | END 6 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/kaiser,m=0.mat.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/kaiser,m=0.mat.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/kaiser,m=2.mat.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/kaiser,m=2.mat.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/nufft_alpha.m.svn-base: -------------------------------------------------------------------------------- 1 | function [alpha, beta, ok] = nufft_alpha(N, J, K, alpha, beta) 2 | % Determine alpha and beta, as associated with the scaling factors 3 | % for min-max interpolation, from arguments. 4 | % in 5 | % alpha [L,1] Fourier series coefficients of scaling factors 6 | % or a string (see below) 7 | % beta scale gamma=2pi/K by this in Fourier series 8 | % typically is K/N (me) or 0.5 (Liu) 9 | % out 10 | % alpha,beta 11 | % 12 | % Copyright 2001-3-30 Jeff Fessler The University of Michigan 13 | 14 | % if no arguments 15 | if nargin < 3 16 | help(mfilename) 17 | error(mfilename) 18 | return 19 | end 20 | 21 | if ~isvar('alpha') | isempty(alpha) 22 | alpha = [1]; % default Fourier series coefficients of scaling factors 23 | end 24 | if ~isvar('beta') | isempty(beta) 25 | beta = 0.5; % default is Liu version for now 26 | end 27 | 28 | 29 | % 30 | % see if 'best' alpha is desired 31 | % 32 | if ischar(alpha) 33 | if streq(alpha, 'uniform') 34 | alpha = [1]; 35 | beta = 0.5; 36 | else 37 | if streq(alpha, 'best') 38 | L = 0; 39 | elseif streq(alpha, 'best,L=1') 40 | L = 1; 41 | elseif streq(alpha, 'best,L=2') 42 | L = 2; 43 | else 44 | error 'unknown alpha argument' 45 | end 46 | [alpha, beta, ok] = nufft_best_alpha(J, L, K/N); 47 | if ~ok 48 | tmp = 'optimal alpha unknown for J=%d, K/N=%g, L=%d'; 49 | warning(sprintf(tmp, J, K/N, L)) 50 | end 51 | end 52 | end 53 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/nufft_coef.m.svn-base: -------------------------------------------------------------------------------- 1 | function [coef, arg] = nufft_coef(om, J, K, kernel) 2 | %function [coef, arg] = nufft_coef(om, J, K, kernel) 3 | % Make NUFFT interpolation coefficient vector given kernel function. 4 | % in: 5 | % om [M,1] digital frequency omega in radians 6 | % J # of neighbors used per frequency location 7 | % K FFT size (should be >= N, the signal_length) 8 | % kernel kernel function (inline or handle) 9 | % out: 10 | % coef [J,M] coef vector for each frequency 11 | % arg [J,M] kernel argument 12 | % 13 | % Copyright 2002-4-11, Jeff Fessler, The University of Michigan 14 | 15 | if nargin < 4, help(mfilename), error(mfilename), end 16 | 17 | M = length(om); 18 | gam = 2*pi/K; 19 | dk = om / gam - nufft_offset(om, J, K); % [M,1] 20 | arg = outer_sum(-[1:J]', dk'); % [J,M] kernel arg 21 | 22 | coef = feval(kernel, arg, J); % [J,M] 23 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/nufft_gauss2.mat.svn-base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/nufft_gauss2.mat.svn-base -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/.svn/text-base/nufft_offset.m.svn-base: -------------------------------------------------------------------------------- 1 | function k0 = nufft_offset(om, J, K) 2 | %function k0 = nufft_offset(om, J, K) 3 | % offset for NUFFT 4 | % om [...] omega in [-pi, pi) (not essential!) 5 | % J # of neighbors used 6 | % K FFT size 7 | % out: 8 | % k0 [...] prepare to use mod(k0 + [1:J], K) + 1 9 | % the extra "+1" up here -^ is because matlab counts from 1, not 0 10 | % Copyright 2000-1-9, Jeff Fessler, The University of Michigan 11 | 12 | if nargin < 3, help(mfilename), error args, end 13 | 14 | if mod(J,2) % odd J 15 | k0 = round(om / (2*pi/K)) - (J+1)/2; 16 | 17 | else % even J 18 | k0 = floor(om / (2*pi/K)) - J/2; 19 | end 20 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/kaiser,m=0.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/private/kaiser,m=0.mat -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/kaiser,m=2.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/private/kaiser,m=2.mat -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/nufft_alpha.m: -------------------------------------------------------------------------------- 1 | function [alpha, beta, ok] = nufft_alpha(N, J, K, alpha, beta) 2 | % Determine alpha and beta, as associated with the scaling factors 3 | % for min-max interpolation, from arguments. 4 | % in 5 | % alpha [L,1] Fourier series coefficients of scaling factors 6 | % or a string (see below) 7 | % beta scale gamma=2pi/K by this in Fourier series 8 | % typically is K/N (me) or 0.5 (Liu) 9 | % out 10 | % alpha,beta 11 | % 12 | % Copyright 2001-3-30 Jeff Fessler The University of Michigan 13 | 14 | % if no arguments 15 | if nargin < 3 16 | help(mfilename) 17 | error(mfilename) 18 | return 19 | end 20 | 21 | if ~isvar('alpha') | isempty(alpha) 22 | alpha = [1]; % default Fourier series coefficients of scaling factors 23 | end 24 | if ~isvar('beta') | isempty(beta) 25 | beta = 0.5; % default is Liu version for now 26 | end 27 | 28 | 29 | % 30 | % see if 'best' alpha is desired 31 | % 32 | if ischar(alpha) 33 | if streq(alpha, 'uniform') 34 | alpha = [1]; 35 | beta = 0.5; 36 | else 37 | if streq(alpha, 'best') 38 | L = 0; 39 | elseif streq(alpha, 'best,L=1') 40 | L = 1; 41 | elseif streq(alpha, 'best,L=2') 42 | L = 2; 43 | else 44 | error 'unknown alpha argument' 45 | end 46 | [alpha, beta, ok] = nufft_best_alpha(J, L, K/N); 47 | if ~ok 48 | tmp = 'optimal alpha unknown for J=%d, K/N=%g, L=%d'; 49 | warning(sprintf(tmp, J, K/N, L)) 50 | end 51 | end 52 | end 53 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/nufft_coef.m: -------------------------------------------------------------------------------- 1 | function [coef, arg] = nufft_coef(om, J, K, kernel) 2 | %function [coef, arg] = nufft_coef(om, J, K, kernel) 3 | % Make NUFFT interpolation coefficient vector given kernel function. 4 | % in: 5 | % om [M,1] digital frequency omega in radians 6 | % J # of neighbors used per frequency location 7 | % K FFT size (should be >= N, the signal_length) 8 | % kernel kernel function (inline or handle) 9 | % out: 10 | % coef [J,M] coef vector for each frequency 11 | % arg [J,M] kernel argument 12 | % 13 | % Copyright 2002-4-11, Jeff Fessler, The University of Michigan 14 | 15 | if nargin < 4, help(mfilename), error(mfilename), end 16 | 17 | M = length(om); 18 | gam = 2*pi/K; 19 | dk = om / gam - nufft_offset(om, J, K); % [M,1] 20 | arg = outer_sum(-[1:J]', dk'); % [J,M] kernel arg 21 | 22 | coef = feval(kernel, arg, J); % [J,M] 23 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/nufft_gauss2.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sajanglingala/data_adaptive_recon_MRI/07fcf294ace66db48719bca5c7365646dfa0453d/SpiralSToRM/nufft_toolbox_cpu/private/nufft_gauss2.mat -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/private/nufft_offset.m: -------------------------------------------------------------------------------- 1 | function k0 = nufft_offset(om, J, K) 2 | %function k0 = nufft_offset(om, J, K) 3 | % offset for NUFFT 4 | % om [...] omega in [-pi, pi) (not essential!) 5 | % J # of neighbors used 6 | % K FFT size 7 | % out: 8 | % k0 [...] prepare to use mod(k0 + [1:J], K) + 1 9 | % the extra "+1" up here -^ is because matlab counts from 1, not 0 10 | % Copyright 2000-1-9, Jeff Fessler, The University of Michigan 11 | 12 | if nargin < 3, help(mfilename), error args, end 13 | 14 | if mod(J,2) % odd J 15 | k0 = round(om / (2*pi/K)) - (J+1)/2; 16 | 17 | else % even J 18 | k0 = floor(om / (2*pi/K)) - J/2; 19 | end 20 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/reale.m: -------------------------------------------------------------------------------- 1 | function y = reale(x, arg2) 2 | %function y = reale(x) 3 | %function y = reale(x, tol) 4 | %function y = reale(x, 'warn') 5 | %function y = reale(x, 'error') 6 | %function y = reale(x, 'report') 7 | %function y = reale(x, 'disp') 8 | % return real part of complex data (with error checking). 9 | % checks that imaginary part is negligible (or warning etc. if not) 10 | % Copyright Jeff Fessler, The University of Michigan 11 | 12 | com = 'error'; 13 | tol = 1e-13; 14 | if nargin > 1 15 | if ischar(arg2) 16 | com = arg2; 17 | elseif isnumeric(arg2) 18 | tol = arg2; 19 | end 20 | end 21 | 22 | if streq(com, 'disp') 23 | ; 24 | elseif streq(com, 'warn') 25 | onlywarn = 1; 26 | elseif streq(com, 'error') 27 | onlywarn = 0; 28 | elseif streq(com, 'report') 29 | ; 30 | else 31 | error(sprintf('bad argument %s', com)) 32 | end 33 | 34 | if max(abs(x(:))) == 0 35 | if any(imag(x(:)) ~= 0) 36 | error 'max real 0, but imaginary!' 37 | else 38 | y = real(x); 39 | return 40 | end 41 | end 42 | 43 | frac = max(abs(imag(x(:)))) / max(abs(x(:))); 44 | if streq(com, 'report') 45 | printf('imaginary part %g%%', frac * 100) 46 | return 47 | end 48 | 49 | if frac > tol 50 | t = sprintf('%s: imaginary fraction %g', mfilename, frac); 51 | if streq(com, 'disp') 52 | disp(t) 53 | elseif onlywarn 54 | disp(t) 55 | else 56 | error(t) 57 | end 58 | end 59 | y = real(x); 60 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/spdiag.m: -------------------------------------------------------------------------------- 1 | function b = spdiag(a) 2 | %function b = spdiag(a) 3 | % create a sparse matrix with diagonal given by a 4 | 5 | a = a(:); 6 | b = spdiags(a, 0, length(a), length(a)); 7 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/streq.m: -------------------------------------------------------------------------------- 1 | function tf = streq(a,b,n) 2 | %function tf = streq(a, b [,n]) 3 | % return 1 if two strings are equal (optionally only up to 1st n chars) 4 | if nargin == 2 5 | tf = strcmp(a,b); 6 | elseif nargin == 3 7 | tf = strncmp(a,b,n); 8 | else 9 | help(mfilename), error(mfilename) 10 | end 11 | -------------------------------------------------------------------------------- /SpiralSToRM/nufft_toolbox_cpu/test_fft2.m: -------------------------------------------------------------------------------- 1 | % test_fft2.m 2 | % compare fft2 vs fft(fft()) 3 | % 4 | % results on G5: 5 | % fftn 0.147631 6 | % fft2 0.133448 7 | % fft1 0.130262 8 | % fft0 0.0802386 9 | % 10 | % results on ir7: 11 | % fftn 0.184001 12 | % fft2 0.184357 13 | % fft1 0.192388 14 | % fft0 0.177634 15 | 16 | N = 2^9; 17 | M = 5; 18 | rand('state', 0) 19 | x = rand(N); 20 | 21 | tic 22 | for m=1:M, X1 = fftn(x); end 23 | printf('fftn %g', toc/M) 24 | 25 | tic 26 | for m=1:M, Xm = my_fftn(x); end 27 | printf('fftm %g', toc/M) 28 | 29 | tic 30 | for m=1:M, X4 = fft(fft(x).').'; end 31 | printf('fft0 %g', toc/M) 32 | 33 | tic 34 | for m=1:M, X2 = fft2(x); end 35 | printf('fft2 %g', toc/M) 36 | 37 | tic 38 | for m=1:M, X3 = fft(fft(x,[],2),[],1); end 39 | printf('fft1 %g', toc/M) 40 | 41 | [max_percent_diff(X1,X2) max_percent_diff(X1,X3) ... 42 | max_percent_diff(X1,X4) max_percent_diff(X1,Xm)] 43 | 44 | -------------------------------------------------------------------------------- /ktSLR/utils/A_fhp3D.m: -------------------------------------------------------------------------------- 1 | function A = A_fhp3D(z, S) 2 | z=double(z); S = single(S); 3 | [n1,n2,n3] = size(z); 4 | A = zeros(n1,n2,n3); 5 | p=1/sqrt(n1*n2)*fft2(z) ; 6 | A(S) = p(S); 7 | -------------------------------------------------------------------------------- /ktSLR/utils/A_fhp3D_mcoil.m: -------------------------------------------------------------------------------- 1 | function A = A_fhp3D_mcoil(z, S,n1,n2,n3,n4,smaps) 2 | z=double(z); S = double(S); 3 | %[n1,n2,n3] = size(z); 4 | p = zeros(n1,n2,n3,n4); 5 | for i = 1: n4, 6 | p(:,:,:,i)=1/sqrt(n1*n2)*fft2(z.*smaps(:,:,:,i)); 7 | end 8 | A = p(S); 9 | -------------------------------------------------------------------------------- /ktSLR/utils/At_fhp3D.m: -------------------------------------------------------------------------------- 1 | function At = At_fhp3D(z, S, n1,n2,n3) 2 | z=double(z); S = single(S); 3 | p=zeros(n1,n2,n3); 4 | p(S)=z(S); 5 | 6 | At=sqrt(n1*n2)*ifft2(p); 7 | -------------------------------------------------------------------------------- /ktSLR/utils/At_fhp3D_mcoil.m: -------------------------------------------------------------------------------- 1 | function At = At_fhp3D_mcoil(z, S, n1,n2,n3,n4,smaps) 2 | 3 | z=double(z); S = double(S); 4 | 5 | p=zeros(n1,n2,n3,n4); 6 | p(S)=z; 7 | 8 | for nc = 1:n4 9 | 10 | p(:,:,:,nc)= sqrt(n1*n2)*ifft2(squeeze(p(:,:,:,nc))).*conj(squeeze(smaps(:,:,:,nc))); 11 | 12 | end 13 | 14 | At = squeeze(sum(p,4)); 15 | -------------------------------------------------------------------------------- /ktSLR/utils/RMSE.m: -------------------------------------------------------------------------------- 1 | function[Error,U]= RMSE(U,I) 2 | U = (U); I = (I); 3 | for ii=1:size(U,3) 4 | alpha = sum(dot(U(:,:,ii),I(:,:,ii)))/(sum(dot(U(:,:,ii),U(:,:,ii)))); 5 | 6 | U(:,:,ii)=(alpha)*U(:,:,ii); 7 | 8 | E=sum(sum(abs((I(:,:,ii)-U(:,:,ii))).^2)); 9 | 10 | E=E*1/(sum(sum(abs((I(:,:,ii))).^2))); 11 | 12 | Error(ii)=(E); 13 | end 14 | 15 | 16 | Error=mean((Error)); 17 | -------------------------------------------------------------------------------- /ktSLR/utils/givefastSVD.m: -------------------------------------------------------------------------------- 1 | function [u,s,v] = givefastSVD(X); 2 | 3 | [v,s] = eig(X'*X);s = sqrt(abs(s)); 4 | 5 | s = diag(s); 6 | index = find(s >1e-6*max(s)); 7 | v = v(:,index); 8 | s = diag(s(index)); 9 | u = X*v; 10 | 11 | for i=1:size(s,2), 12 | u(:,i) = u(:,i)./sqrt(sum(abs(u(:,i)).^2)); 13 | end 14 | 15 | -------------------------------------------------------------------------------- /ktSLR/utils/ismrm_rss.m: -------------------------------------------------------------------------------- 1 | function y = ismrm_rss(x,dim) 2 | % 3 | % [mag] = ismrm_rss(samples, dim) 4 | % 5 | % Computes root-sum-of-squares along a single dimension. 6 | % 7 | % 8 | % INPUT: 9 | % - x : multi-dimensional array of samples 10 | % - dim : dimension of reduction; defaults to last dimension 11 | % 12 | % OUTPUT: 13 | % 14 | % - y : root sum of squares result 15 | % 16 | % 17 | % Code made available for the ISMRM 2013 Sunrise Educational Course 18 | % 19 | % Michael S. Hansen (michael.hansen@nih.gov) 20 | % Philip J. Beatty (philip.beatty@sri.utoronto.ca) 21 | % 22 | 23 | 24 | if nargin==1 25 | dim=ndims(x); 26 | else 27 | if isempty(dim); dim=ndims(x); end 28 | end 29 | 30 | y = squeeze(sqrt(sum(real(x).^2 + imag(x).^2,dim))); 31 | --------------------------------------------------------------------------------