int main_ecaltwo(int argc, char* argv[]) { long maps = 2; // channels; struct ecalib_conf conf = ecalib_defaults; const struct opt_s opts[] = { OPT_FLOAT('c', &conf.crop, "crop_value", "Crop the sensitivities if the eigenvalue is smaller than {crop_value}."), OPT_LONG('m', &maps, "maps", "Number of maps to compute."), OPT_SET('S', &conf.softcrop, "()"), OPT_CLEAR('O', &conf.orthiter, "()"), OPT_SET('g', &conf.usegpu, "()"), }; cmdline(&argc, argv, 5, 6, usage_str, help_str, ARRAY_SIZE(opts), opts); long in_dims[DIMS]; complex float* in_data = load_cfl(argv[4], DIMS, in_dims); int channels = 0; while (in_dims[3] != (channels * (channels + 1) / 2)) channels++; debug_printf(DP_INFO, "Channels: %d\n", channels); assert(maps <= channels); long out_dims[DIMS] = { [0 ... DIMS - 1] = 1 }; long map_dims[DIMS] = { [0 ... DIMS - 1] = 1 }; out_dims[0] = atoi(argv[1]); out_dims[1] = atoi(argv[2]); out_dims[2] = atoi(argv[3]); out_dims[3] = channels; out_dims[4] = maps; assert((out_dims[0] >= in_dims[0])); assert((out_dims[1] >= in_dims[1])); assert((out_dims[2] >= in_dims[2])); for (int i = 0; i < 3; i++) map_dims[i] = out_dims[i]; map_dims[3] = 1; map_dims[4] = maps; complex float* out_data = create_cfl(argv[5], DIMS, out_dims); complex float* emaps; if (7 == argc) emaps = create_cfl(argv[6], DIMS, map_dims); else emaps = md_alloc(DIMS, map_dims, CFL_SIZE); caltwo(&conf, out_dims, out_data, emaps, in_dims, in_data, NULL, NULL); if (conf.intensity) { debug_printf(DP_DEBUG1, "Normalize...\n"); normalizel1(DIMS, COIL_FLAG, out_dims, out_data); } debug_printf(DP_DEBUG1, "Crop maps... (%.2f)\n", conf.crop); crop_sens(out_dims, out_data, conf.softcrop, conf.crop, emaps); debug_printf(DP_DEBUG1, "Fix phase...\n"); fixphase(DIMS, out_dims, COIL_DIM, out_data, out_data); debug_printf(DP_INFO, "Done.\n"); unmap_cfl(DIMS, in_dims, in_data); unmap_cfl(DIMS, out_dims, out_data); if (7 == argc) unmap_cfl(DIMS, map_dims, emaps); else md_free(emaps); exit(0); }
int main_ecaltwo(int argc, char* argv[]) { long maps = 2; // channels; struct ecalib_conf conf = ecalib_defaults; int c; while (-1 != (c = getopt(argc, argv, "OSc:m:gh"))) { switch (c) { case 'S': conf.softcrop = true; break; case 'O': conf.orthiter = false; break; case 'c': conf.crop = atof(optarg); break; case 'm': maps = atoi(optarg); break; case 'g': conf.usegpu = true; break; case 'h': usage(argv[0], stdout); help(); exit(0); default: usage(argv[0], stderr); exit(1); } } if ((argc - optind != 5) && (argc - optind != 6)) { usage(argv[0], stderr); exit(1); } long in_dims[DIMS]; complex float* in_data = load_cfl(argv[optind + 3], DIMS, in_dims); int channels = 0; while (in_dims[3] != (channels * (channels + 1) / 2)) channels++; printf("Channels: %d\n", channels); assert(maps <= channels); long out_dims[DIMS] = { [0 ... DIMS - 1] = 1 }; long map_dims[DIMS] = { [0 ... DIMS - 1] = 1 }; out_dims[0] = atoi(argv[optind + 0]); out_dims[1] = atoi(argv[optind + 1]); out_dims[2] = atoi(argv[optind + 2]); out_dims[3] = channels; out_dims[4] = maps; assert((out_dims[0] >= in_dims[0])); assert((out_dims[1] >= in_dims[1])); assert((out_dims[2] >= in_dims[2])); for (int i = 0; i < 3; i++) map_dims[i] = out_dims[i]; map_dims[3] = 1; map_dims[4] = maps; complex float* out_data = create_cfl(argv[optind + 4], DIMS, out_dims); complex float* emaps; if (6 == argc - optind) emaps = create_cfl(argv[optind + 5], DIMS, map_dims); else emaps = md_alloc(DIMS, map_dims, CFL_SIZE); caltwo(&conf, out_dims, out_data, emaps, in_dims, in_data, NULL, NULL); if (conf.intensity) { debug_printf(DP_DEBUG1, "Normalize...\n"); normalizel1(DIMS, COIL_FLAG, out_dims, out_data); } debug_printf(DP_DEBUG1, "Crop maps... (%.2f)\n", conf.crop); crop_sens(out_dims, out_data, conf.softcrop, conf.crop, emaps); debug_printf(DP_DEBUG1, "Fix phase...\n"); fixphase(DIMS, out_dims, COIL_DIM, out_data, out_data); printf("Done.\n"); unmap_cfl(DIMS, in_dims, in_data); unmap_cfl(DIMS, out_dims, out_data); if (6 == argc - optind) unmap_cfl(DIMS, map_dims, emaps); else md_free(emaps); exit(0); }
void calib2(const struct ecalib_conf* conf, const long out_dims[DIMS], complex float* out_data, complex float* eptr, unsigned int SN, float svals[SN], const long calreg_dims[DIMS], const complex float* data, const long msk_dims[3], const bool* msk) { long channels = calreg_dims[3]; long maps = out_dims[4]; assert(calreg_dims[3] == out_dims[3]); assert(maps <= channels); assert(1 == md_calc_size(DIMS - 5, out_dims + 5)); assert(1 == md_calc_size(DIMS - 5, calreg_dims + 5)); complex float rot[channels][channels]; if (conf->rotphase) { long scc_dims[DIMS] = MD_INIT_ARRAY(DIMS, 1); scc_dims[COIL_DIM] = channels; scc_dims[MAPS_DIM] = channels; scc(scc_dims, &rot[0][0], calreg_dims, data); } else { for (unsigned int i = 0; i < channels; i++) for (unsigned int j = 0; j < channels; j++) rot[i][j] = (i == j) ? 1. : 0.; } long cov_dims[4]; calone_dims(conf, cov_dims, channels); complex float* imgcov = md_alloc(4, cov_dims, CFL_SIZE); calone(conf, cov_dims, imgcov, SN, svals, calreg_dims, data); caltwo(conf, out_dims, out_data, eptr, cov_dims, imgcov, msk_dims, msk); /* Intensity and phase normalization similar as proposed * for adaptive combine (Walsh's method) in * Griswold et al., ISMRM 10:2410 (2002) */ if (conf->intensity) { debug_printf(DP_DEBUG1, "Normalize...\n"); /* I think the reason this works is because inhomogeneity usually * comes from only a few coil elements which are close. The l1-norm * is more resilient against such outliers. -- Martin */ normalizel1(DIMS, COIL_FLAG, out_dims, out_data); md_zsmul(DIMS, out_dims, out_data, out_data, sqrtf((float)channels)); } debug_printf(DP_DEBUG1, "Crop maps... (%.2f)\n", conf->crop); crop_sens(out_dims, out_data, conf->softcrop, conf->crop, eptr); debug_printf(DP_DEBUG1, "Fix phase...\n"); // rotate the the phase with respect to the first principle component fixphase2(DIMS, out_dims, COIL_DIM, rot[0], out_data, out_data); md_free(imgcov); }