int main(int argc, char *argv[]) { char **av, *out_fname, *in_fname ; int ac, nargs ; MRI_SURFACE *mris ; MRI *mri_interior, *mri_template = NULL, *mri_buffer = NULL; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mris_fill.c,v 1.6 2011/03/02 00:04:32 nicks Exp $", "$Name: $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_fill.c,v 1.6 2011/03/02 00:04:32 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc != 3) usage_exit() ; in_fname = argv[1] ; out_fname = argv[2] ; fprintf(stderr, "reading surface from %s...\n", in_fname) ; mris = MRISread(in_fname) ; if (template)
int main(int argc, char *argv[]) { tesselation_parms *parms; MRIS **mris_table, *mris,*mris_corrected; MRI *mri; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mri_mc.c,v 1.22 2011/03/02 00:04:23 nicks Exp $", "$Name: stable5 $", cmdline); Progname=argv[0]; if (argc > 1 && (stricmp(argv[1], "-d") == 0)) { downsample = atoi(argv[2]) ; argc -= 2; argv += 2 ; printf("downsampling input volume %d times\n", downsample) ; } if (argc < 4) { fprintf(stderr,"\n\nUSAGE: mri_mc input_volume " "label_value output_surface [connectivity]"); fprintf(stderr, "\noption connectivity: 1=6+,2=18,3=6,4=26 (default=1)\n\n"); exit(-1); } parms=(tesselation_parms*)calloc(1,sizeof(tesselation_parms)); if (!parms) ErrorExit(ERROR_NOMEMORY, "tesselation parms\n") ; mri=MRIread(argv[1]); if (downsample > 0) { MRI *mri_tmp ; mri_tmp = MRIdownsample2(mri, NULL) ; MRIfree(&mri) ; mri = mri_tmp ; } { MRI *mri_tmp ; mri_tmp = MRIalloc(mri->width+2, mri->height+2, mri->depth+2, mri->type) ; MRIextractInto(mri, mri_tmp, 0, 0, 0, mri->width, mri->height, mri->depth, 1, 1, 1) ; MRIfree(&mri) ; mri = mri_tmp ; } MRIreInitCache(mri); if (mri->type != MRI_UCHAR) { MRI *mri_tmp ; float min_val, max_val ; MRIvalRange(mri, &min_val, &max_val) ; if (min_val < 0 || max_val > 255) ErrorExit (ERROR_UNSUPPORTED, "%s: input volume (val range [%2.1f %2.1f]) must be " "convertible to UCHAR", Progname, min_val, max_val) ; printf("changing type of input volume to 8 bits/voxel...\n") ; mri_tmp = MRIchangeType(mri, MRI_UCHAR, 0.0, 0.999, TRUE) ; MRIfree(&mri) ; mri = mri_tmp ; } parms->mri=mri; parms->number_of_labels=1; //only one single label parms->label_values=(int*)malloc(sizeof(int)); parms->label_values[0]=atoi(argv[2]);//label; parms->ind=0; mris_table=(MRIS**)malloc(sizeof(MRIS*)); //final surface information parms->mris_table=mris_table; if ((!parms->label_values) || (!mris_table)) ErrorExit(ERROR_NOMEMORY, "labels/surfaces tables\n") ; if (argc==5) parms->connectivity=atoi(argv[4]);//connectivity; else parms->connectivity=1; initTesselationParms(parms); generateMCtesselation(parms); free(parms->label_values); mris=parms->mris_table[0]; free(parms->mris_table); freeTesselationParms(&parms); { float dist,max_e=0.0; int n,p,vn0,vn2; VERTEX *v,*vp; fprintf(stderr,"computing the maximum edge length..."); for (n = 0 ; n < mris->nvertices ; n++) { v=&mris->vertices[n]; for (p = 0 ; p < v->vnum ; p++) { vp = &mris->vertices[v->v[p]]; dist=SQR(vp->x-v->x)+SQR(vp->y-v->y)+SQR(vp->z-v->z); if (dist>max_e) max_e=dist; } } fprintf(stderr,"%f mm",sqrt(max_e)); fprintf(stderr,"\nreversing orientation of faces..."); for (n = 0 ; n < mris->nfaces ; n++) { vn0=mris->faces[n].v[0]; vn2=mris->faces[n].v[2]; /* vertex 0 becomes vertex 2 */ v=&mris->vertices[vn0]; for (p = 0 ; p < v->num ; p++) if (v->f[p]==n) v->n[p]=2; mris->faces[n].v[2]=vn0; /* vertex 2 becomes vertex 0 */ v=&mris->vertices[vn2]; for (p = 0 ; p < v->num ; p++) if (v->f[p]==n) v->n[p]=0; mris->faces[n].v[0]=vn2; } } fprintf(stderr,"\nchecking orientation of surface..."); MRISmarkOrientationChanges(mris); mris_corrected=MRISextractMainComponent(mris,0,1,0); MRISfree(&mris); fprintf(stderr,"\nwriting out surface..."); MRISaddCommandLine(mris_corrected, cmdline) ; if (mriConformed(mri) == 0) { printf("input volume is not conformed - using useRealRAS=1\n") ; mris_corrected->useRealRAS = 1 ; } // getVolGeom(mri, &mris_corrected->vg); MRISwrite(mris_corrected,argv[3]); fprintf(stderr,"done\n"); MRIfree(&mri); MRISfree(&mris_corrected); return 0; }
int main(int argc, char *argv[]) { char *in_fname, *out_fname, **av, *xform_fname, fname[STRLEN] ; MRI *mri_in, *mri_tmp ; int ac, nargs, msec, minutes, seconds; int input, ninputs ; struct timeb start ; TRANSFORM *transform = NULL ; char cmdline[CMD_LINE_LEN], line[STRLEN], *cp, subject[STRLEN], sdir[STRLEN], base_name[STRLEN] ; FILE *fp ; make_cmd_version_string (argc, argv, "$Id: mri_fuse_intensity_images.c,v 1.2 2011/06/02 14:05:10 fischl Exp $", "$Name: $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_fuse_intensity_images.c,v 1.2 2011/06/02 14:05:10 fischl Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; setRandomSeed(-1L) ; Progname = argv[0] ; DiagInit(NULL, NULL, NULL) ; ErrorInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 5) ErrorExit (ERROR_BADPARM, "usage: %s [<options>] <longitudinal time point file> <in vol> <transform file> <out vol> \n", Progname) ; in_fname = argv[2] ; xform_fname = argv[3] ; out_fname = argv[4] ; transform = TransformRead(xform_fname) ; if (transform == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read transform from %s", Progname, xform_fname) ; TimerStart(&start) ; FileNamePath(argv[1], sdir) ; cp = strrchr(sdir, '/') ; if (cp) { strcpy(base_name, cp+1) ; *cp = 0 ; // remove last component of path, which is base subject name } ninputs = 0 ; fp = fopen(argv[1], "r") ; if (fp == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read time point file %s", Progname, argv[1]) ; do { cp = fgetl(line, STRLEN-1, fp) ; if (cp != NULL && strlen(cp) > 0) { subjects[ninputs] = (char *)calloc(strlen(cp)+1, sizeof(char)) ; strcpy(subjects[ninputs], cp) ; ninputs++ ; } } while (cp != NULL && strlen(cp) > 0) ; fclose(fp) ; printf("processing %d timepoints in SUBJECTS_DIR %s...\n", ninputs, sdir) ; for (input = 0 ; input < ninputs ; input++) { sprintf(subject, "%s.long.%s", subjects[input], base_name) ; printf("reading subject %s - %d of %d\n", subject, input+1, ninputs) ; sprintf(fname, "%s/%s/mri/%s", sdir, subject, in_fname) ; mri_tmp = MRIread(fname) ; if (!mri_tmp) ErrorExit(ERROR_NOFILE, "%s: could not read input MR volume from %s", Progname, fname) ; MRImakePositive(mri_tmp, mri_tmp) ; if (input == 0) { mri_in = MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth, mri_tmp->type, ninputs) ; if (!mri_in) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate input volume %dx%dx%dx%d", mri_tmp->width,mri_tmp->height,mri_tmp->depth,ninputs) ; MRIcopyHeader(mri_tmp, mri_in) ; } if (mask_fname) { int i ; MRI *mri_mask ; mri_mask = MRIread(mask_fname) ; if (!mri_mask) ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n", Progname, mask_fname) ; for (i = 1 ; i < WM_MIN_VAL ; i++) MRIreplaceValues(mri_mask, mri_mask, i, 0) ; MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ; MRIfree(&mri_mask) ; } MRIcopyFrame(mri_tmp, mri_in, 0, input) ; MRIfree(&mri_tmp) ; } MRIaddCommandLine(mri_in, cmdline) ; // try to bring the images closer to each other at each voxel where they seem to come from the same distribution { MRI *mri_frame1, *mri_frame2 ; double rms_after ; mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ; mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ; rms_after = MRIrmsDiff(mri_frame1, mri_frame2) ; printf("RMS before intensity cohering = %2.2f\n", rms_after) ; MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ; if (0) normalize_timepoints(mri_in, 2.0, cross_time_sigma) ; else normalize_timepoints_with_parzen_window(mri_in, cross_time_sigma) ; mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ; mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ; rms_after = MRIrmsDiff(mri_frame1, mri_frame2) ; MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ; printf("RMS after intensity cohering = %2.2f (sigma=%2.2f)\n", rms_after, cross_time_sigma) ; } for (input = 0 ; input < ninputs ; input++) { sprintf(fname, "%s/%s.long.%s/mri/%s", sdir, subjects[input], base_name, out_fname) ; printf("writing normalized volume to %s...\n", fname) ; if (MRIwriteFrame(mri_in, fname, input) != NO_ERROR) ErrorExit(ERROR_BADFILE, "%s: could not write normalized volume to %s",Progname, fname); } MRIfree(&mri_in) ; printf("done.\n") ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf("normalization took %d minutes and %d seconds.\n", minutes, seconds) ; if (diag_fp) fclose(diag_fp) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char **av, *in_surf_fname, *out_fname, fname[STRLEN], *cp ; int ac, nargs, msec, err ; MRI_SURFACE *mris ; struct timeb then ; float max_dim ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mris_sphere.c,v 1.57 2011/03/02 00:04:34 nicks Exp $", "$Name: stable5 $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_sphere.c,v 1.57 2011/03/02 00:04:34 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; #ifdef FS_CUDA /* print GPU device info */ MRISCdeviceInfo(); #endif // FS_CUDA TimerStart(&then) ; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; memset(&parms, 0, sizeof(parms)) ; parms.dt = .05 ; parms.projection = PROJECT_ELLIPSOID ; parms.tol = .5 /*1e-1*/ ; parms.n_averages = 1024 ; parms.min_averages = 0 ; parms.l_angle = 0.0 /* L_ANGLE */ ; parms.l_area = 0.0 /* L_AREA */ ; parms.l_neg = 0.0 ; parms.l_dist = 1.0 ; parms.l_spring = 0.0 ; parms.l_area = 1.0 ; parms.l_boundary = 0.0 ; parms.l_curv = 0.0 ; parms.niterations = 25 ; parms.write_iterations = 1000 ; parms.a = parms.b = parms.c = 0.0f ; /* ellipsoid parameters */ parms.dt_increase = 1.01 /* DT_INCREASE */; parms.dt_decrease = 0.99 /* DT_DECREASE*/ ; parms.error_ratio = 1.03 /*ERROR_RATIO */; parms.integration_type = INTEGRATE_LINE_MINIMIZE ; parms.momentum = 0.9 ; parms.desired_rms_height = -1.0 ; parms.base_name[0] = 0 ; parms.Hdesired = 0.0 ; /* a flat surface */ parms.nbhd_size = 7 ; parms.max_nbrs = 8 ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } parms.scale = scale ; if (argc != 3) // catches args beyond the expected two { usage_exit() ; } parms.base_dt = base_dt_scale * parms.dt ; in_surf_fname = argv[1] ; out_fname = argv[2] ; printf("%s\n",vcid); printf(" %s\n",MRISurfSrcVersion()); fflush(stdout); if (parms.base_name[0] == 0) { FileNameOnly(out_fname, fname) ; cp = strchr(fname, '.') ; if (cp) { strcpy(parms.base_name, cp+1) ; } else { strcpy(parms.base_name, "sphere") ; } } mris = MRISread(in_surf_fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, in_surf_fname) ; MRISaddCommandLine(mris, cmdline) ; fprintf(stderr, "reading original vertex positions...\n") ; if (!FZERO(disturb)) { mrisDisturbVertices(mris, disturb) ; } if (quick == 0) { // don't need original properties unless preserving metric err = MRISreadOriginalProperties(mris, orig_name) ; if(err) { exit(1); } } if (smooth_avgs > 0) { MRISsaveVertexPositions(mris, TMP_VERTICES) ; MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ; MRISaverageVertexPositions(mris, smooth_avgs) ; MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; MRISrestoreVertexPositions(mris, TMP_VERTICES) ; } if (!FZERO(ralpha) || !FZERO(rbeta) || !FZERO(rgamma)) { MRISrotate(mris,mris,RADIANS(ralpha),RADIANS(rbeta),RADIANS(rgamma)) ; // if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) MRISwrite(mris, "rot") ; } fprintf(stderr, "unfolding cortex into spherical form...\n"); if (talairach) { MRIStalairachTransform(mris, mris) ; MRISwrite(mris, "tal") ; } if (xform_fname) { LTA *lta ; MRI *mri ; TRANSFORM transform ; lta = LTAread(xform_fname) ; if (lta == NULL) { ErrorExit(ERROR_NOFILE, "%s: could not load %s", xform_fname) ; } mri = MRIread(vol_fname) ; if (mri == NULL) { ErrorExit(ERROR_NOFILE, "%s: could not load %s", vol_fname) ; } transform.type = lta->type ; transform.xform = (void *)lta ; MRIStransform(mris, mri, &transform, mri) ; MRIfree(&mri) ; LTAfree(<a) ; MRISwrite(mris, "xfm") ; } #if 0 max_dim = MAX(abs(mris->xlo), abs(mris->xhi)) ; max_dim = MAX(abs(max_dim), abs(mris->ylo)) ; max_dim = MAX(abs(max_dim), abs(mris->yhi)) ; max_dim = MAX(abs(max_dim), abs(mris->zlo)) ; max_dim = MAX(abs(max_dim), abs(mris->zhi)) ; #else max_dim = MAX(abs(mris->xhi-mris->xlo), abs(mris->yhi-mris->ylo)) ; max_dim = MAX(max_dim,abs(mris->zhi-mris->zlo)) ; #endif if (max_dim > .75*DEFAULT_RADIUS) { float ratio = .75*DEFAULT_RADIUS / (max_dim) ; printf("scaling brain by %2.3f...\n", ratio) ; MRISscaleBrain(mris, mris, ratio) ; } if (target_radius < 0) { target_radius = sqrt(mris->total_area / (4*M_PI)) ; printf("setting target radius to be %2.3f to match surface areas\n", target_radius) ; } // MRISsampleAtEachDistance(mris, parms.nbhd_size, parms.max_nbrs) ; if (!load && inflate) { INTEGRATION_PARMS inflation_parms ; MRIScenter(mris, mris) ; memset(&inflation_parms, 0, sizeof(INTEGRATION_PARMS)) ; strcpy(inflation_parms.base_name, parms.base_name) ; inflation_parms.write_iterations = parms.write_iterations ; inflation_parms.niterations = inflate_iterations ; inflation_parms.l_spring_norm = l_spring_norm ; inflation_parms.l_spring = inflate_spring ; inflation_parms.l_nlarea = inflate_nlarea ; inflation_parms.l_area = inflate_area ; inflation_parms.n_averages = inflate_avgs ; inflation_parms.l_expand = l_expand ; inflation_parms.l_tspring = inflate_tspring ; inflation_parms.l_sphere = l_sphere ; inflation_parms.l_convex = l_convex ; #define SCALE_UP 2 inflation_parms.a = SCALE_UP*DEFAULT_RADIUS ; inflation_parms.tol = inflate_tol ; inflation_parms.integration_type = INTEGRATE_MOMENTUM ; inflation_parms.momentum = 0.9 ; inflation_parms.dt = inflate_dt ; /* store the inflated positions in the v->c? field so that they can be used in the repulsive term. */ /* inflation_parms.l_repulse_ratio = .1 ;*/ MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ; if (l_expand > 0) { MRISexpandSurface(mris, target_radius/2, &inflation_parms, 0, 1) ; l_expand = parms.l_expand = 0 ; } MRIScenter(mris, mris) ; mris->x0 = mris->xctr ; mris->y0 = mris->yctr ; mris->z0 = mris->zctr ; MRISinflateToSphere(mris, &inflation_parms) ; if (inflation_parms.l_expand > 0) { inflation_parms.l_expand = 0 ; inflation_parms.niterations += (inflate_iterations*.1) ; MRISinflateToSphere(mris, &inflation_parms) ; } MRISscaleBrain(mris, mris, target_radius/(DEFAULT_RADIUS*SCALE_UP)) ; parms.start_t = inflation_parms.start_t ; MRISresetNeighborhoodSize(mris, nbrs) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRISwrite(mris, "before") ; } MRISprojectOntoSphere(mris, mris, target_radius) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRISwrite(mris, "after") ; } fprintf(stderr,"surface projected - minimizing metric distortion...\n"); MRISsetNeighborhoodSize(mris, nbrs) ; if (quick) { if (!load) { #if 0 parms.n_averages = 32 ; parms.tol = .1 ; parms.l_parea = parms.l_dist = 0.0 ; parms.l_nlarea = 1 ; #endif MRISprintTessellationStats(mris, stderr) ; MRISquickSphere(mris, &parms, max_passes) ; } } else { MRISunfold(mris, &parms, max_passes) ; } if (remove_negative) { parms.niterations = 1000 ; MRISremoveOverlapWithSmoothing(mris,&parms) ; } if (!load) { fprintf(stderr, "writing spherical brain to %s\n", out_fname) ; MRISwrite(mris, out_fname) ; } msec = TimerStop(&then) ; fprintf(stderr, "spherical transformation took %2.2f hours\n", (float)msec/(1000.0f*60.0f*60.0f)); exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { char **av ; int ac, nargs, n ; MRI *mri_src, *mri_dst = NULL, *mri_bias, *mri_orig, *mri_aseg = NULL ; char *in_fname, *out_fname ; int msec, minutes, seconds ; struct timeb start ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mri_normalize.c,v 1.80 2012/10/16 21:38:35 nicks Exp $", "$Name: $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_normalize.c,v 1.80 2012/10/16 21:38:35 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; mni.max_gradient = MAX_GRADIENT ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) { usage_exit(0) ; } if (argc < 1) { ErrorExit(ERROR_BADPARM, "%s: no input name specified", Progname) ; } in_fname = argv[1] ; if (argc < 2) { ErrorExit(ERROR_BADPARM, "%s: no output name specified", Progname) ; } out_fname = argv[2] ; if(verbose) { printf( "reading from %s...\n", in_fname) ; } mri_src = MRIread(in_fname) ; if (!mri_src) ErrorExit(ERROR_NO_FILE, "%s: could not open source file %s", Progname, in_fname) ; MRIaddCommandLine(mri_src, cmdline) ; if(nsurfs > 0) { MRI_SURFACE *mris ; MRI *mri_dist=NULL, *mri_dist_sup=NULL, *mri_ctrl, *mri_dist_one ; LTA *lta= NULL ; int i ; TRANSFORM *surface_xform ; if (control_point_fname) // do one pass with only file control points first { MRI3dUseFileControlPoints(mri_src, control_point_fname) ; mri_dst = MRI3dGentleNormalize(mri_src, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, NULL, intensity_above, intensity_below/2,1, bias_sigma, mri_not_control); } else { mri_dst = MRIcopy(mri_src, NULL) ; } for (i = 0 ; i < nsurfs ; i++) { mris = MRISread(surface_fnames[i]) ; if (mris == NULL) ErrorExit(ERROR_NOFILE,"%s: could not surface %s", Progname,surface_fnames[i]); surface_xform = surface_xforms[i] ; TransformInvert(surface_xform, NULL) ; if (surface_xform->type == MNI_TRANSFORM_TYPE || surface_xform->type == TRANSFORM_ARRAY_TYPE || surface_xform->type == REGISTER_DAT) { lta = (LTA *)(surface_xform->xform) ; #if 0 if (invert) { VOL_GEOM vgtmp; LT *lt; MATRIX *m_tmp = lta->xforms[0].m_L ; lta->xforms[0].m_L = MatrixInverse(lta->xforms[0].m_L, NULL) ; MatrixFree(&m_tmp) ; lt = <a->xforms[0]; if (lt->dst.valid == 0 || lt->src.valid == 0) { printf( "WARNING:***************************************************************\n"); printf( "WARNING:dst volume infor is invalid. Most likely produce wrong inverse.\n"); printf( "WARNING:***************************************************************\n"); } copyVolGeom(<->dst, &vgtmp); copyVolGeom(<->src, <->dst); copyVolGeom(&vgtmp, <->src); } #endif } if (stricmp(surface_xform_fnames[i], "identity.nofile") != 0) { MRIStransform(mris, NULL, surface_xform, NULL) ; } mri_dist_one = MRIcloneDifferentType(mri_dst, MRI_FLOAT) ; printf("computing distance transform\n") ; MRIScomputeDistanceToSurface(mris, mri_dist_one, mri_dist_one->xsize) ; if (i == 0) { mri_dist = MRIcopy(mri_dist_one, NULL) ; } else { MRIcombineDistanceTransforms(mri_dist_one, mri_dist, mri_dist) ; } // MRIminAbs(mri_dist_one, mri_dist, mri_dist) ; MRIfree(&mri_dist_one) ; } MRIscalarMul(mri_dist, mri_dist, -1) ; if (nonmax_suppress) { printf("computing nonmaximum suppression\n") ; mri_dist_sup = MRInonMaxSuppress(mri_dist, NULL, 0, 1) ; mri_ctrl = MRIcloneDifferentType(mri_dist_sup, MRI_UCHAR) ; MRIbinarize(mri_dist_sup, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; } else if (erode) { int i ; mri_ctrl = MRIcloneDifferentType(mri_dist, MRI_UCHAR) ; MRIbinarize(mri_dist, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; for (i = 0 ; i < erode ; i++) { MRIerode(mri_ctrl, mri_ctrl) ; } } else { mri_ctrl = MRIcloneDifferentType(mri_dist, MRI_UCHAR) ; MRIbinarize(mri_dist, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; } if (control_point_fname) { MRInormAddFileControlPoints(mri_ctrl, CONTROL_MARKED) ; } if (mask_sigma > 0) { MRI *mri_smooth, *mri_mag, *mri_grad ; mri_smooth = MRIgaussianSmooth(mri_dst, mask_sigma, 1, NULL) ; mri_mag = MRIcloneDifferentType(mri_dst, MRI_FLOAT) ; mri_grad = MRIsobel(mri_smooth, NULL, mri_mag) ; MRIbinarize(mri_mag, mri_mag, mask_thresh, 1, 0) ; MRImask(mri_ctrl, mri_mag, mri_ctrl, 0, CONTROL_NONE) ; MRIfree(&mri_grad) ; MRIfree(&mri_mag) ; MRIfree(&mri_smooth) ; } if (mask_orig_fname) { MRI *mri_orig ; mri_orig = MRIread(mask_orig_fname) ; MRIbinarize(mri_orig, mri_orig, mask_orig_thresh, 0, 1) ; MRImask(mri_ctrl, mri_orig, mri_ctrl, 0, CONTROL_NONE) ; MRIfree(&mri_orig) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_dist, "d.mgz"); MRIwrite(mri_dist_sup, "dm.mgz"); MRIwrite(mri_ctrl, "c.mgz"); } MRIeraseBorderPlanes(mri_ctrl, 4) ; if (aseg_fname) { mri_aseg = MRIread(aseg_fname) ; if (mri_aseg == NULL) { ErrorExit(ERROR_NOFILE, "%s: could not load aseg from %s", Progname, aseg_fname) ; } remove_nonwm_voxels(mri_ctrl, mri_aseg, mri_ctrl) ; MRIfree(&mri_aseg) ; } else { remove_surface_outliers(mri_ctrl, mri_dist, mri_dst, mri_ctrl) ; } mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; if (mri_dist) { MRIfree(&mri_dist) ; } if (mri_dist_sup) { MRIfree(&mri_dist_sup) ; } if (bias_sigma> 0) { MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_bias, "b.mgz") ; } printf("smoothing bias field\n") ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_bias, "bs.mgz") ; } MRIfree(&mri_kernel); } MRIfree(&mri_ctrl) ; mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; printf("writing normalized volume to %s\n", out_fname) ; MRIwrite(mri_dst, out_fname) ; exit(0) ; } // end if(surface_fname) if (!mriConformed(mri_src) && conform > 0) { printf("unconformed source detected - conforming...\n") ; mri_src = MRIconform(mri_src) ; } if (mask_fname) { MRI *mri_mask ; mri_mask = MRIread(mask_fname) ; if (!mri_mask) ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n", Progname, mask_fname) ; MRImask(mri_src, mri_mask, mri_src, 0, 0) ; MRIfree(&mri_mask) ; } if (read_flag) { MRI *mri_ctrl ; double scale ; mri_bias = MRIread(bias_volume_fname) ; if (!mri_bias) ErrorExit (ERROR_BADPARM, "%s: could not read bias volume %s", Progname, bias_volume_fname) ; mri_ctrl = MRIread(control_volume_fname) ; if (!mri_ctrl) ErrorExit (ERROR_BADPARM, "%s: could not read control volume %s", Progname, control_volume_fname) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, 0, 128) ; mri_dst = MRImultiply(mri_bias, mri_src, NULL) ; scale = MRImeanInLabel(mri_dst, mri_ctrl, 128) ; printf("mean in wm is %2.0f, scaling by %2.2f\n", scale, 110/scale) ; scale = 110/scale ; MRIscalarMul(mri_dst, mri_dst, scale) ; MRIwrite(mri_dst, out_fname) ; exit(0) ; } if(long_flag) { MRI *mri_ctrl ; double scale ; mri_bias = MRIread(long_bias_volume_fname) ; if (!mri_bias) ErrorExit (ERROR_BADPARM, "%s: could not read bias volume %s", Progname, long_bias_volume_fname) ; mri_ctrl = MRIread(long_control_volume_fname) ; if (!mri_ctrl) ErrorExit (ERROR_BADPARM, "%s: could not read control volume %s", Progname, long_control_volume_fname) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, 0, CONTROL_MARKED) ; if (mri_ctrl->type != MRI_UCHAR) { MRI *mri_tmp ; mri_tmp = MRIchangeType(mri_ctrl, MRI_UCHAR, 0, 1,1); MRIfree(&mri_ctrl) ; mri_ctrl = mri_tmp ; } scale = MRImeanInLabel(mri_src, mri_ctrl, CONTROL_MARKED) ; printf("mean in wm is %2.0f, scaling by %2.2f\n", scale, 110/scale) ; scale = DEFAULT_DESIRED_WHITE_MATTER_VALUE/scale ; mri_dst = MRIscalarMul(mri_src, NULL, scale) ; MRIremoveWMOutliers(mri_dst, mri_ctrl, mri_ctrl, intensity_below/2) ; mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; MRIsoapBubble(mri_bias, mri_ctrl, mri_bias, 50, 1) ; MRIapplyBiasCorrectionSameGeometry(mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE); // MRIwrite(mri_dst, out_fname) ; // exit(0) ; } // end if(long_flag) if (grad_thresh > 0) { float thresh ; MRI *mri_mag, *mri_grad, *mri_smooth ; MRI *mri_kernel = MRIgaussian1d(.5, -1) ; mri_not_control = MRIcloneDifferentType(mri_src, MRI_UCHAR) ; switch (scan_type) { case MRI_MGH_MPRAGE: thresh = 15 ; break ; case MRI_WASHU_MPRAGE: thresh = 20 ; break ; case MRI_UNKNOWN: default: thresh = 12 ; break ; } mri_smooth = MRIconvolveGaussian(mri_src, NULL, mri_kernel) ; thresh = grad_thresh ; mri_mag = MRIcloneDifferentType(mri_src, MRI_FLOAT) ; mri_grad = MRIsobel(mri_smooth, NULL, mri_mag) ; MRIwrite(mri_mag, "m.mgz") ; MRIbinarize(mri_mag, mri_not_control, thresh, 0, 1) ; MRIwrite(mri_not_control, "nc.mgz") ; MRIfree(&mri_mag) ; MRIfree(&mri_grad) ; MRIfree(&mri_smooth) ; MRIfree(&mri_kernel) ; } #if 0 #if 0 if ((mri_src->type != MRI_UCHAR) || (!(mri_src->xsize == 1 && mri_src->ysize == 1 && mri_src->zsize == 1))) #else if (conform || (mri_src->type != MRI_UCHAR && conform > 0)) #endif { MRI *mri_tmp ; fprintf (stderr, "downsampling to 8 bits and scaling to isotropic voxels...\n") ; mri_tmp = MRIconform(mri_src) ; mri_src = mri_tmp ; } #endif if(aseg_fname) { printf("Reading aseg %s\n",aseg_fname); mri_aseg = MRIread(aseg_fname) ; if (mri_aseg == NULL) ErrorExit (ERROR_NOFILE, "%s: could not read aseg from file %s", Progname, aseg_fname) ; if (!mriConformed(mri_aseg)) { ErrorExit(ERROR_UNSUPPORTED, "%s: aseg volume %s must be conformed", Progname, aseg_fname) ; } } else { mri_aseg = NULL ; } if(verbose) { printf( "normalizing image...\n") ; } fflush(stdout); fflush(stderr); TimerStart(&start) ; if (control_point_fname) { MRI3dUseFileControlPoints(mri_src, control_point_fname) ; } // this just setup writing control-point volume saving if(control_volume_fname) { MRI3dWriteControlPoints(control_volume_fname) ; } /* first do a gentle normalization to get things in the right intensity range */ if(long_flag == 0) // if long, then this will already have been done with base control points { if(control_point_fname != NULL) /* do one pass with only file control points first */ mri_dst = MRI3dGentleNormalize(mri_src, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, NULL, intensity_above, intensity_below/2,1, bias_sigma, mri_not_control); else { mri_dst = MRIcopy(mri_src, NULL) ; } } fflush(stdout); fflush(stderr); if(mri_aseg) { MRI *mri_ctrl, *mri_bias ; int i ; printf("processing with aseg\n"); mri_ctrl = MRIclone(mri_aseg, NULL) ; for (i = 0 ; i < NWM_LABELS ; i++) { MRIcopyLabel(mri_aseg, mri_ctrl, aseg_wm_labels[i]) ; } printf("removing outliers in the aseg WM...\n") ; MRIremoveWMOutliersAndRetainMedialSurface(mri_dst, mri_ctrl, mri_ctrl, intensity_below) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, CONTROL_NONE, CONTROL_MARKED) ; MRInormAddFileControlPoints(mri_ctrl, CONTROL_MARKED) ; if (interior_fname1) { MRIS *mris_interior1, *mris_interior2 ; mris_interior1 = MRISread(interior_fname1) ; if (mris_interior1 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname1) ; mris_interior2 = MRISread(interior_fname2) ; if (mris_interior2 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname2) ; add_interior_points(mri_ctrl, mri_dst, intensity_above, 1.25*intensity_below, mris_interior1, mris_interior2, mri_aseg, mri_ctrl) ; MRISfree(&mris_interior1) ; MRISfree(&mris_interior2) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_ctrl, "norm_ctrl.mgz") ; } printf("Building bias image\n"); fflush(stdout); fflush(stderr); mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; fflush(stdout); fflush(stderr); if (bias_sigma> 0) { printf("Smoothing with sigma %g\n",bias_sigma); MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; MRIfree(&mri_kernel); fflush(stdout); fflush(stderr); } MRIfree(&mri_ctrl) ; MRIfree(&mri_aseg) ; printf("Applying bias correction\n"); mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_dst, "norm_1.mgz") ; } fflush(stdout); fflush(stderr); } // if(mri_aseg) else { printf("processing without aseg, no1d=%d\n",no1d); if (!no1d) { printf("MRInormInit(): \n"); MRInormInit(mri_src, &mni, 0, 0, 0, 0, 0.0f) ; printf("MRInormalize(): \n"); mri_dst = MRInormalize(mri_src, NULL, &mni) ; if (!mri_dst) { no1d = 1 ; printf("1d normalization failed - trying no1d...\n") ; // ErrorExit(ERROR_BADPARM, "%s: normalization failed", Progname) ; } } if(no1d) { if ((file_only && nosnr) || ((gentle_flag != 0) && (control_point_fname != NULL))) { if (mri_dst == NULL) { mri_dst = MRIcopy(mri_src, NULL) ; } } else { if (nosnr) { if (interior_fname1) { MRIS *mris_interior1, *mris_interior2 ; MRI *mri_ctrl ; printf("computing initial normalization using surface interiors\n"); mri_ctrl = MRIcloneDifferentType(mri_src, MRI_UCHAR) ; mris_interior1 = MRISread(interior_fname1) ; if (mris_interior1 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname1) ; mris_interior2 = MRISread(interior_fname2) ; if (mris_interior2 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname2) ; add_interior_points(mri_ctrl, mri_dst, intensity_above, 1.25*intensity_below, mris_interior1, mris_interior2, mri_aseg, mri_ctrl) ; MRISfree(&mris_interior1) ; MRISfree(&mris_interior2) ; mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; if (bias_sigma> 0) { MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; MRIfree(&mri_kernel); } mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_src, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; MRIfree(&mri_ctrl) ; } else if (long_flag == 0) // no initial normalization specified { mri_dst = MRIcopy(mri_src, NULL) ; } } else { printf("computing initial normalization using SNR...\n") ; mri_dst = MRInormalizeHighSignalLowStd (mri_src, mri_dst, bias_sigma, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; } } if (!mri_dst) ErrorExit (ERROR_BADPARM, "%s: could not allocate volume", Progname) ; } } // else (not using aseg) fflush(stdout); fflush(stderr); if (file_only == 0) MRI3dGentleNormalize(mri_dst, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above, intensity_below/2, file_only, bias_sigma, mri_not_control); mri_orig = MRIcopy(mri_dst, NULL) ; printf("\n"); printf("Iterating %d times\n",num_3d_iter); for (n = 0 ; n < num_3d_iter ; n++) { if(file_only) { break ; } printf( "---------------------------------\n"); printf( "3d normalization pass %d of %d\n", n+1, num_3d_iter) ; if (gentle_flag) MRI3dGentleNormalize(mri_dst, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above/2, intensity_below/2, file_only, bias_sigma, mri_not_control); else MRI3dNormalize(mri_orig, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above, intensity_below, file_only, prune, bias_sigma, scan_type, mri_not_control); } printf( "Done iterating ---------------------------------\n"); // this just setup writing control-point volume saving if(control_volume_fname) { MRI3dWriteControlPoints(control_volume_fname) ; } if(bias_volume_fname) { mri_bias = compute_bias(mri_src, mri_dst, NULL) ; printf("writing bias field to %s....\n", bias_volume_fname) ; MRIwrite(mri_bias, bias_volume_fname) ; MRIfree(&mri_bias) ; } if (verbose) { printf("writing output to %s\n", out_fname) ; } MRIwrite(mri_dst, out_fname) ; msec = TimerStop(&start) ; MRIfree(&mri_src); MRIfree(&mri_dst); seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf( "3D bias adjustment took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char *gca_fname, *in_fname, *out_fname, **av, *xform_fname, fname[STRLEN] ; MRI *mri_in, *mri_norm = NULL, *mri_tmp, *mri_ctrl = NULL ; GCA *gca ; int ac, nargs, nsamples, msec, minutes, seconds; int i, struct_samples, norm_samples = 0, n, input, ninputs ; struct timeb start ; GCA_SAMPLE *gcas, *gcas_norm = NULL, *gcas_struct ; TRANSFORM *transform = NULL ; char cmdline[CMD_LINE_LEN], line[STRLEN], *cp, subject[STRLEN], sdir[STRLEN], base_name[STRLEN] ; FILE *fp ; make_cmd_version_string (argc, argv, "$Id: mri_cal_normalize.c,v 1.2.2.1 2011/08/31 00:32:41 nicks Exp $", "$Name: stable5 $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_cal_normalize.c,v 1.2.2.1 2011/08/31 00:32:41 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; setRandomSeed(-1L) ; Progname = argv[0] ; DiagInit(NULL, NULL, NULL) ; ErrorInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 6) ErrorExit (ERROR_BADPARM, "usage: %s [<options>] <longitudinal time point file> <in vol> <atlas> <transform file> <out vol> \n", Progname) ; in_fname = argv[2] ; gca_fname = argv[3] ; xform_fname = argv[4] ; out_fname = argv[5] ; transform = TransformRead(xform_fname) ; if (transform == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read transform from %s", Progname, xform_fname) ; if (read_ctrl_point_fname) { mri_ctrl = MRIread(read_ctrl_point_fname) ; if (mri_ctrl == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read precomputed control points from %s", Progname, read_ctrl_point_fname) ; } TimerStart(&start) ; printf("reading atlas from '%s'...\n", gca_fname) ; fflush(stdout) ; gca = GCAread(gca_fname) ; if (gca == NULL) ErrorExit(ERROR_NOFILE, "%s: could not open GCA %s.\n",Progname, gca_fname) ; GCAregularizeConditionalDensities(gca, .5) ; FileNamePath(argv[1], sdir) ; cp = strrchr(sdir, '/') ; if (cp) { strcpy(base_name, cp+1) ; *cp = 0 ; // remove last component of path, which is base subject name } ninputs = 0 ; fp = fopen(argv[1], "r") ; if (fp == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read time point file %s", argv[1]) ; do { cp = fgetl(line, STRLEN-1, fp) ; if (cp != NULL && strlen(cp) > 0) { subjects[ninputs] = (char *)calloc(strlen(cp)+1, sizeof(char)) ; strcpy(subjects[ninputs], cp) ; ninputs++ ; } } while (cp != NULL && strlen(cp) > 0) ; fclose(fp) ; printf("processing %d timepoints in SUBJECTS_DIR %s...\n", ninputs, sdir) ; for (input = 0 ; input < ninputs ; input++) { sprintf(subject, "%s.long.%s", subjects[input], base_name) ; printf("reading subject %s - %d of %d\n", subject, input+1, ninputs) ; sprintf(fname, "%s/%s/mri/%s", sdir, subject, in_fname) ; mri_tmp = MRIread(fname) ; if (!mri_tmp) ErrorExit(ERROR_NOFILE, "%s: could not read input MR volume from %s", Progname, fname) ; MRImakePositive(mri_tmp, mri_tmp) ; if (mri_tmp && ctrl_point_fname && !mri_ctrl) { mri_ctrl = MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,MRI_FLOAT, nregions*2) ; // labels and means MRIcopyHeader(mri_tmp, mri_ctrl) ; } if (input == 0) { mri_in = MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth, mri_tmp->type, ninputs) ; if (!mri_in) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate input volume %dx%dx%dx%d", mri_tmp->width,mri_tmp->height,mri_tmp->depth,ninputs) ; MRIcopyHeader(mri_tmp, mri_in) ; } if (mask_fname) { int i ; MRI *mri_mask ; mri_mask = MRIread(mask_fname) ; if (!mri_mask) ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n", Progname, mask_fname) ; for (i = 1 ; i < WM_MIN_VAL ; i++) MRIreplaceValues(mri_mask, mri_mask, i, 0) ; MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ; MRIfree(&mri_mask) ; } MRIcopyFrame(mri_tmp, mri_in, 0, input) ; MRIfree(&mri_tmp) ; } MRIaddCommandLine(mri_in, cmdline) ; GCAhistoScaleImageIntensitiesLongitudinal(gca, mri_in, 1) ; { int j ; gcas = GCAfindAllSamples(gca, &nsamples, NULL, 1) ; printf("using %d sample points...\n", nsamples) ; GCAcomputeSampleCoords(gca, mri_in, gcas, nsamples, transform) ; if (sample_fname) GCAtransformAndWriteSamples (gca, mri_in, gcas, nsamples, sample_fname, transform) ; for (j = 0 ; j < 1 ; j++) { for (n = 1 ; n <= nregions ; n++) { for (norm_samples = i = 0 ; i < NSTRUCTURES ; i++) { if (normalization_structures[i] == Gdiag_no) DiagBreak() ; printf("finding control points in %s....\n", cma_label_to_name(normalization_structures[i])) ; gcas_struct = find_control_points(gca, gcas, nsamples, &struct_samples, n, normalization_structures[i], mri_in, transform, min_prior, ctl_point_pct) ; discard_unlikely_control_points(gca, gcas_struct, struct_samples, mri_in, transform, cma_label_to_name(normalization_structures[i])) ; if (mri_ctrl && ctrl_point_fname) // store the samples copy_ctrl_points_to_volume(gcas_struct, struct_samples, mri_ctrl, n-1) ; if (i) { GCA_SAMPLE *gcas_tmp ; gcas_tmp = gcas_concatenate(gcas_norm, gcas_struct, norm_samples, struct_samples) ; free(gcas_norm) ; norm_samples += struct_samples ; gcas_norm = gcas_tmp ; } else { gcas_norm = gcas_struct ; norm_samples = struct_samples ; } } printf("using %d total control points " "for intensity normalization...\n", norm_samples) ; if (normalized_transformed_sample_fname) GCAtransformAndWriteSamples(gca, mri_in, gcas_norm, norm_samples, normalized_transformed_sample_fname, transform) ; mri_norm = GCAnormalizeSamplesAllChannels(mri_in, gca, gcas_norm, file_only ? 0 :norm_samples, transform, ctl_point_fname, bias_sigma) ; if (Gdiag & DIAG_WRITE) { char fname[STRLEN] ; sprintf(fname, "norm%d.mgz", n) ; printf("writing normalized volume to %s...\n", fname) ; MRIwrite(mri_norm, fname) ; sprintf(fname, "norm_samples%d.mgz", n) ; GCAtransformAndWriteSamples(gca, mri_in, gcas_norm, norm_samples, fname, transform) ; } MRIcopy(mri_norm, mri_in) ; /* for next pass through */ MRIfree(&mri_norm) ; } } } // now do cross-time normalization to bring each timepoint closer to the mean at each location { MRI *mri_frame1, *mri_frame2, *mri_tmp ; double rms_before, rms_after ; int i ; mri_tmp = MRIcopy(mri_in, NULL) ; mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ; mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ; rms_before = MRIrmsDiff(mri_frame1, mri_frame2) ; printf("RMS before = %2.2f\n", rms_before) ; MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ; for (i = 50 ; i <= 50 ; i += 25) { MRIcopy(mri_tmp, mri_in) ; normalize_timepoints_with_samples(mri_in, gcas_norm, norm_samples, i) ; mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ; mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ; rms_after = MRIrmsDiff(mri_frame1, mri_frame2) ; MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ; printf("RMS after (%d) = %2.2f\n", i, rms_after) ; } } { MRI *mri_frame1, *mri_frame2 ; double rms_after ; int i ; mri_tmp = MRIcopy(mri_in, NULL) ; for (i = 10 ; i <= 10 ; i += 10) { MRIcopy(mri_tmp, mri_in) ; normalize_timepoints(mri_in, 2.0, i) ; mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ; mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ; rms_after = MRIrmsDiff(mri_frame1, mri_frame2) ; MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ; printf("RMS after intensity cohering = %2.2f\n", rms_after) ; } } for (input = 0 ; input < ninputs ; input++) { sprintf(fname, "%s/%s.long.%s/mri/%s", sdir, subjects[input], base_name, out_fname) ; printf("writing normalized volume to %s...\n", fname) ; if (MRIwriteFrame(mri_in, fname, input) != NO_ERROR) ErrorExit(ERROR_BADFILE, "%s: could not write normalized volume to %s",Progname, fname); } if (ctrl_point_fname) { printf("writing control points to %s\n", ctrl_point_fname) ; MRIwrite(mri_ctrl, ctrl_point_fname) ; MRIfree(&mri_ctrl) ; } MRIfree(&mri_in) ; printf("freeing GCA...") ; if (gca) GCAfree(&gca) ; printf("done.\n") ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf("normalization took %d minutes and %d seconds.\n", minutes, seconds) ; if (diag_fp) fclose(diag_fp) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char **av, *surf_fname, *template_fname, *out_fname, fname[STRLEN],*cp; int ac, nargs,err, msec ; MRI_SURFACE *mris ; MRI_SP *mrisp_template ; char cmdline[CMD_LINE_LEN] ; struct timeb start ; make_cmd_version_string (argc, argv, "$Id: mris_register.c,v 1.59 2011/03/02 00:04:33 nicks Exp $", "$Name: stable5 $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_register.c,v 1.59 2011/03/02 00:04:33 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; TimerStart(&start) ; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; memset(&parms, 0, sizeof(parms)) ; parms.projection = PROJECT_SPHERE ; parms.flags |= IP_USE_CURVATURE ; parms.tol = 0.5 ; // was 1e-0*2.5 parms.min_averages = 0 ; parms.l_area = 0.0 ; parms.l_parea = 0.1f ; // used to be 0.2 parms.l_dist = 5.0 ; // used to be 0.5, and before that 0.1 parms.l_corr = 1.0f ; parms.l_nlarea = 1 ; parms.l_pcorr = 0.0f ; parms.niterations = 25 ; parms.n_averages = 1024 ; // used to be 256 parms.write_iterations = 100 ; parms.dt_increase = 1.01 /* DT_INCREASE */; parms.dt_decrease = 0.99 /* DT_DECREASE*/ ; parms.error_ratio = 1.03 /*ERROR_RATIO */; parms.dt_increase = 1.0 ; parms.dt_decrease = 1.0 ; parms.l_external = 10000 ; /* in case manual label is specified */ parms.error_ratio = 1.1 /*ERROR_RATIO */; parms.integration_type = INTEGRATE_ADAPTIVE ; parms.integration_type = INTEGRATE_MOMENTUM /*INTEGRATE_LINE_MINIMIZE*/ ; parms.integration_type = INTEGRATE_LINE_MINIMIZE ; parms.dt = 0.9 ; parms.momentum = 0.95 ; parms.desired_rms_height = -1.0 ; parms.nbhd_size = -10 ; parms.max_nbrs = 10 ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (nsigmas > 0) { MRISsetRegistrationSigmas(sigmas, nsigmas) ; } parms.which_norm = which_norm ; if (argc < 4) { usage_exit() ; } printf("%s\n", vcid) ; printf(" %s\n",MRISurfSrcVersion()); fflush(stdout); surf_fname = argv[1] ; template_fname = argv[2] ; out_fname = argv[3] ; if (parms.base_name[0] == 0) { FileNameOnly(out_fname, fname) ; cp = strchr(fname, '.') ; if (cp) { strcpy(parms.base_name, cp+1) ; } else { strcpy(parms.base_name, "sphere") ; } } fprintf(stderr, "reading surface from %s...\n", surf_fname) ; mris = MRISread(surf_fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, surf_fname) ; if (parms.var_smoothness) { parms.vsmoothness = (float *)calloc(mris->nvertices, sizeof(float)) ; if (parms.vsmoothness == NULL) { ErrorExit(ERROR_NOMEMORY, "%s: could not allocate vsmoothness array", Progname) ; } parms.dist_error = (float *)calloc(mris->nvertices, sizeof(float)) ; if (parms.dist_error == NULL) { ErrorExit(ERROR_NOMEMORY, "%s: could not allocate dist_error array", Progname) ; } parms.area_error = (float *)calloc(mris->nvertices, sizeof(float)) ; if (parms.area_error == NULL) { ErrorExit(ERROR_NOMEMORY, "%s: could not allocate area_error array", Progname) ; } parms.geometry_error = (float *)calloc(mris->nvertices, sizeof(float)) ; if (parms.geometry_error == NULL) { ErrorExit(ERROR_NOMEMORY, "%s: could not allocate geometry_error array", Progname) ; } } MRISresetNeighborhoodSize(mris, 1) ; if (annot_name) { if (MRISreadAnnotation(mris, annot_name) != NO_ERROR) ErrorExit(ERROR_BADPARM, "%s: could not read annot file %s", Progname, annot_name) ; MRISripMedialWall(mris) ; } MRISsaveVertexPositions(mris, TMP2_VERTICES) ; MRISaddCommandLine(mris, cmdline) ; if (!FZERO(dalpha) || !FZERO(dbeta) || !FZERO(dgamma)) MRISrotate(mris, mris, RADIANS(dalpha), RADIANS(dbeta), RADIANS(dgamma)) ; if (curvature_fname[0]) { fprintf(stderr, "reading source curvature from %s\n",curvature_fname) ; MRISreadCurvatureFile(mris, curvature_fname) ; } if (single_surf) { char fname[STRLEN], *cp, surf_dir[STRLEN], hemi[10] ; MRI_SURFACE *mris_template ; int sno, tnbrs=3 ; FileNamePath(template_fname, surf_dir) ; cp = strrchr(template_fname, '/') ; if (cp == NULL) // no path - start from beginning of file name { cp = template_fname ; } cp = strchr(cp, '.') ; if (cp == NULL) ErrorExit(ERROR_NOFILE, "%s: could no scan hemi from %s", Progname, template_fname) ; strncpy(hemi, cp-2, 2) ; hemi[2] = 0 ; fprintf(stderr, "reading spherical surface %s...\n", template_fname) ; mris_template = MRISread(template_fname) ; if (mris_template == NULL) { ErrorExit(ERROR_NOFILE, "") ; } #if 0 if (reverse_flag) { MRISreverse(mris_template, REVERSE_X, 1) ; } #endif MRISsaveVertexPositions(mris_template, CANONICAL_VERTICES) ; MRIScomputeMetricProperties(mris_template) ; MRISstoreMetricProperties(mris_template) ; if (noverlays > 0) { mrisp_template = MRISPalloc(scale, IMAGES_PER_SURFACE*noverlays); for (sno = 0; sno < noverlays ; sno++) { sprintf(fname, "%s/../label/%s.%s", surf_dir, hemi, overlays[sno]) ; if (MRISreadValues(mris_template, fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read overlay from %s", Progname, fname) ; MRIScopyValuesToCurvature(mris_template) ; MRISaverageCurvatures(mris_template, navgs) ; MRISnormalizeCurvature(mris_template, which_norm) ; fprintf(stderr, "computing parameterization for overlay %s...\n", fname); MRIStoParameterization(mris_template, mrisp_template, scale, sno*3) ; MRISPsetFrameVal(mrisp_template, sno*3+1, 1.0) ; } } else { mrisp_template = MRISPalloc(scale, PARAM_IMAGES); for (sno = 0; sno < SURFACES ; sno++) { if (curvature_names[sno]) /* read in precomputed curvature file */ { sprintf(fname, "%s/%s.%s", surf_dir, hemi, curvature_names[sno]) ; if (MRISreadCurvatureFile(mris_template, fname) != NO_ERROR) ErrorExit(Gerror, "%s: could not read curvature file '%s'\n", Progname, fname) ; /* the two next lines were not in the original code */ MRISaverageCurvatures(mris_template, navgs) ; MRISnormalizeCurvature(mris_template, which_norm) ; } else /* compute curvature of surface */ { sprintf(fname, "%s/%s.%s", surf_dir, hemi, surface_names[sno]) ; if (MRISreadVertexPositions(mris_template, fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, fname) ; if (tnbrs > 1) { MRISresetNeighborhoodSize(mris_template, tnbrs) ; } MRIScomputeMetricProperties(mris_template) ; MRIScomputeSecondFundamentalForm(mris_template) ; MRISuseMeanCurvature(mris_template) ; MRISaverageCurvatures(mris_template, navgs) ; MRISrestoreVertexPositions(mris_template, CANONICAL_VERTICES) ; MRISnormalizeCurvature(mris_template, which_norm) ; } fprintf(stderr, "computing parameterization for surface %s...\n", fname); MRIStoParameterization(mris_template, mrisp_template, scale, sno*3) ; MRISPsetFrameVal(mrisp_template, sno*3+1, 1.0) ; } } } else { fprintf(stderr, "reading template parameterization from %s...\n", template_fname) ; mrisp_template = MRISPread(template_fname) ; if (!mrisp_template) ErrorExit(ERROR_NOFILE, "%s: could not open template file %s", Progname, template_fname) ; if (noverlays > 0) { if (mrisp_template->Ip->num_frame != IMAGES_PER_SURFACE*noverlays) ErrorExit(ERROR_BADPARM, "template frames (%d) doesn't match input (%d x %d) = %d\n", mrisp_template->Ip->num_frame, IMAGES_PER_SURFACE,noverlays, IMAGES_PER_SURFACE*noverlays) ; } } if (use_defaults) { if (*IMAGEFseq_pix(mrisp_template->Ip, 0, 0, 2) <= 1.0) /* 1st time */ { parms.l_dist = 5.0 ; parms.l_corr = 1.0 ; parms.l_parea = 0.2 ; } else /* subsequent alignments */ { parms.l_dist = 5.0 ; parms.l_corr = 1.0 ; parms.l_parea = 0.2 ; } } if (nbrs > 1) { MRISresetNeighborhoodSize(mris, nbrs) ; } MRISprojectOntoSphere(mris, mris, DEFAULT_RADIUS) ; mris->status = MRIS_PARAMETERIZED_SPHERE ; MRIScomputeMetricProperties(mris) ; if (!FZERO(parms.l_dist)) { MRISscaleDistances(mris, scale) ; } #if 0 MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; MRISzeroNegativeAreas(mris) ; MRISstoreMetricProperties(mris) ; #endif MRISstoreMeanCurvature(mris) ; /* use curvature from file */ MRISsetOriginalFileName(orig_name) ; if (inflated_name) { MRISsetInflatedFileName(inflated_name) ; } err = MRISreadOriginalProperties(mris, orig_name) ; if (err != 0) { printf("ERROR %d from MRISreadOriginalProperties().\n",err); exit(1); } if (MRISreadCanonicalCoordinates(mris, canon_name) != NO_ERROR) ErrorExit(ERROR_BADFILE, "%s: could not read canon surface %s", Progname, canon_name) ; if (reverse_flag) { MRISreverse(mris, REVERSE_X, 1) ; MRISsaveVertexPositions(mris, TMP_VERTICES) ; MRISrestoreVertexPositions(mris, CANONICAL_VERTICES) ; MRISreverse(mris, REVERSE_X, 0) ; MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ; MRISrestoreVertexPositions(mris, TMP_VERTICES) ; MRIScomputeMetricProperties(mris) ; } #if 0 MRISsaveVertexPositions (mris, CANONICAL_VERTICES) ; // uniform spherical positions #endif if (starting_reg_fname) if (MRISreadVertexPositions(mris, starting_reg_fname) != NO_ERROR) { exit(Gerror) ; } if (multiframes) { if (use_initial_registration) MRISvectorRegister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; parms.l_corr=parms.l_pcorr=0.0f; #if 0 parms.l_dist = 0.0 ; parms.l_corr = 0.0 ; parms.l_parea = 0.0 ; parms.l_area = 0.0 ; parms.l_parea = 0.0f ; parms.l_dist = 0.0 ; parms.l_corr = 0.0f ; parms.l_nlarea = 0.0f ; parms.l_pcorr = 0.0f ; #endif MRISvectorRegister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; } else { double l_dist = parms.l_dist ; if (multi_scale > 0) { int i ; parms.l_dist = l_dist * pow(5.0, (multi_scale-1.0)) ; parms.flags |= IPFLAG_NOSCALE_TOL ; parms.flags &= ~IP_USE_CURVATURE ; for (i = 0 ; i < multi_scale ; i++) { printf("*************** round %d, l_dist = %2.3f **************\n", i, parms.l_dist) ; MRISregister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; parms.flags |= IP_NO_RIGID_ALIGN ; parms.flags &= ~IP_USE_INFLATED ; parms.l_dist /= 5 ; } if (parms.nbhd_size < 0) { parms.nbhd_size *= -1 ; printf("**** starting 2nd epoch, with long-range distances *****\n"); parms.l_dist = l_dist * pow(5.0, (multi_scale-2.0)) ; for (i = 1 ; i < multi_scale ; i++) { printf("*********** round %d, l_dist = %2.3f *************\n", i, parms.l_dist) ; MRISregister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; parms.l_dist /= 5 ; } } printf("****** final curvature registration ***************\n") ; if (parms.nbhd_size > 0) { parms.nbhd_size *= -1 ; // disable long-range stuff } parms.l_dist *= 5 ; parms.flags |= (IP_USE_CURVATURE | IP_NO_SULC); MRISregister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; } else MRISregister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; } if (remove_negative) { parms.niterations = 1000 ; MRISremoveOverlapWithSmoothing(mris,&parms) ; } fprintf(stderr, "writing registered surface to %s...\n", out_fname) ; MRISwrite(mris, out_fname) ; if (jacobian_fname) { MRIScomputeMetricProperties(mris) ; compute_area_ratios(mris) ; /* will put results in v->curv */ #if 0 MRISwriteArea(mris, jacobian_fname) ; #else MRISwriteCurvature(mris, jacobian_fname) ; #endif } msec = TimerStop(&start) ; if (Gdiag & DIAG_SHOW) printf("registration took %2.2f hours\n", (float)msec/(1000.0f*60.0f*60.0f)); MRISPfree(&mrisp_template) ; MRISfree(&mris) ; exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { char *gca_fname, *in_fname, **av, *xform_fname ; MRI *mri_in, *mri_tmp, *mri_orig = NULL ; GCA *gca ; int ac, nargs, input, ninputs ; TRANSFORM *transform = NULL ; char cmdline[CMD_LINE_LEN] ; double ll ; make_cmd_version_string (argc, argv, "$Id: mri_log_likelihood.c,v 1.4 2011/03/02 00:04:22 nicks Exp $", "$Name: stable5 $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_log_likelihood.c,v 1.4 2011/03/02 00:04:22 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; setRandomSeed(-1L) ; Progname = argv[0] ; DiagInit(NULL, NULL, NULL) ; ErrorInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) ErrorExit (ERROR_BADPARM, "usage: %s [<options>] <inbrain1> <inbrain2> ... " "<atlas> <transform file> ...\n", Progname) ; ninputs = (argc - 1) / 2 ; if (DIAG_VERBOSE_ON) printf("reading %d input volume%ss\n", ninputs, ninputs > 1 ? "s" : "") ; in_fname = argv[1] ; gca_fname = argv[1+ninputs] ; xform_fname = argv[2+ninputs] ; transform = TransformRead(xform_fname) ; if (!transform) ErrorExit(ERROR_NOFILE, "%s: could not read input transform from %s", Progname, xform_fname) ; if (DIAG_VERBOSE_ON) printf("reading atlas from '%s'...\n", gca_fname) ; gca = GCAread(gca_fname) ; if (!gca) ErrorExit(ERROR_NOFILE, "%s: could not read input atlas from %s", Progname, gca_fname) ; fflush(stdout) ; for (input = 0 ; input < ninputs ; input++) { in_fname = argv[1+input] ; if (DIAG_VERBOSE_ON) printf("reading input volume from %s...\n", in_fname) ; mri_tmp = MRIread(in_fname) ; if (!mri_tmp) ErrorExit(ERROR_NOFILE, "%s: could not read input MR volume from %s", Progname, in_fname) ; MRImakePositive(mri_tmp, mri_tmp) ; if (input == 0) { mri_in = MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth, mri_tmp->type, ninputs) ; if (!mri_in) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate input volume %dx%dx%dx%d", mri_tmp->width,mri_tmp->height,mri_tmp->depth,ninputs) ; MRIcopyHeader(mri_tmp, mri_in) ; } MRIcopyFrame(mri_tmp, mri_in, 0, input) ; MRIfree(&mri_tmp) ; } MRIaddCommandLine(mri_in, cmdline) ; TransformInvert(transform, mri_in) ; if (orig_fname) { mri_orig = MRIread(orig_fname) ; if (mri_orig == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read orig volume from %s", Progname, orig_fname) ; } ll = GCAimageLogLikelihood(gca, mri_in, transform, 1, mri_orig) ; printf("%2.0f\n", 10000*ll) ; MRIfree(&mri_in) ; if (gca) GCAfree(&gca) ; if (mri_in) MRIfree(&mri_in) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char **av, *out_fname, *T1_fname, *PD_fname ; int ac, nargs ; MRI *mri_T1, *mri_PD, *mri_out, *mri_T2star = NULL ; float TR, TE, alpha ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mri_synthesize.c,v 1.18 2011/03/02 00:04:25 nicks Exp $", "$Name: $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_synthesize.c,v 1.18 2011/03/02 00:04:25 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 7) usage_exit() ; TR = atof(argv[1]) ; alpha = atof(argv[2]) ; TE = atof(argv[3]) ; T1_fname = argv[4] ; PD_fname = argv[5] ; out_fname = argv[6] ; printf("reading T1 volume from %s...\n", T1_fname) ; mri_T1 = MRIread(T1_fname) ; if (!mri_T1) ErrorExit(ERROR_NOFILE, "%s: could not read T1 volume %s", Progname, T1_fname) ; if (extract) { MRI *mri_tmp ; int dx, dy, dz ; dx = mri_T1->width/2 ; dy = mri_T1->height/2 ; dz = mri_T1->depth/2 ; printf("extracting interior %dx%dx%d\n", dx, dy, dz) ; mri_tmp = MRIextract(mri_T1, NULL, dx/2, dy/2, dz/2, dx, dy, dz) ; MRIfree(&mri_T1) ; mri_T1 = mri_tmp ; } if (jpdf_name) { transform_T1_values_using_joint_pdf(mri_T1, jpdf_name, invert) ; } printf("reading PD volume from %s...\n", PD_fname) ; mri_PD = MRIread(PD_fname) ; if (!mri_PD) ErrorExit(ERROR_NOFILE, "%s: could not read PD volume %s", Progname, PD_fname) ; if (T2star_fname != NULL) { printf("reading T2* volume from %s...\n", T2star_fname) ; mri_T2star = MRIread(T2star_fname) ; if (!mri_T2star) ErrorExit(ERROR_NOFILE, "%s: could not read T2* volume %s", Progname, T2star_fname) ; } if (PDsat > 0) saturate_PD(mri_PD, PDsat) ; if (extract) { MRI *mri_tmp ; int dx, dy, dz ; dx = mri_PD->width/2 ; dy = mri_PD->height/2 ; dz = mri_PD->depth/2 ; mri_tmp = MRIextract(mri_PD, NULL, dx/2, dy/2, dz/2, dx, dy, dz) ; MRIfree(&mri_PD) ; mri_PD = mri_tmp ; } if (use_weighting) { mri_out = MRIsynthesizeWeightedVolume(mri_T1, mri_PD, w5, TR, w30, TR, 110,TE); } else { printf("synthesizing volume with TR=%2.1f msec, TE=%2.1f msec, and alpha=%2.2f degrees...\n", TR, TE, alpha) ; if (normalize) normalize_PD(mri_PD, 1000) ; if (discard) discard_PD(mri_PD, 250, 1500) ; if (nl_remap_T1) remap_T1(mri_T1, nl_mean, nl_scale) ; if (nfaf > 0) mri_out = MRIsynthesizeWithFAF(mri_T1, mri_PD, NULL, TR, RADIANS(alpha), TE, nfaf, faf_coefs) ; else mri_out = MRIsynthesize(mri_T1, mri_PD, mri_T2star, NULL, TR, RADIANS(alpha), TE) ; } if (nbias > 0) apply_bias_field(mri_out, nbias, bias_coefs) ; printf("writing output to %s.\n", out_fname) ; MRIaddCommandLine(mri_out, cmdline) ; MRIwrite(mri_out, out_fname) ; exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { char **av, *in_fname, *out_fname, fname[STRLEN], path[STRLEN] ; int ac, nargs, start_t, pass ; MRI_SURFACE *mris ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mris_smooth.c,v 1.28 2011/03/02 00:04:34 nicks Exp $", "$Name: stable5 $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_smooth.c,v 1.28 2011/03/02 00:04:34 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) { print_help() ; } in_fname = argv[1] ; out_fname = argv[2] ; FileNamePath(out_fname, path) ; mris = MRISfastRead(in_fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, in_fname) ; MRISaddCommandLine(mris, cmdline) ; MRISremoveTriangleLinks(mris) ; fprintf(stderr, "smoothing surface tessellation for %d iterations...\n", niterations); MRIScomputeMetricProperties(mris) ; MRISstoreMetricProperties(mris) ; MRISsetNeighborhoodSize(mris, nbrs) ; #define DT 0.5 if (gaussian_norm > 0) { int i, done, start_avgs = gaussian_avgs, j ; done = 0; start_t = 0 ; pass = 0 ; do { for (i = start_t ; i < niterations+start_t ; i++) { MRIScomputeMetricProperties(mris) ; MRISsaveVertexPositions(mris, TMP_VERTICES) ; for (j = 0 ; j < 5 ; j++) { MRISaverageVertexPositions(mris, 2) ; // turn flat spikes into tubular ones MRIScomputeMetricProperties(mris) ; MRIScomputeSecondFundamentalForm(mris) ; MRIShistoThresholdGaussianCurvatureToMarked(mris, (float)(mris->nvertices-20)/mris->nvertices) ; } MRISrestoreVertexPositions(mris, TMP_VERTICES) ; MRIScomputeMetricProperties(mris) ; MRISsmoothSurfaceNormals(mris, gaussian_avgs) ; MRISclearMarks(mris) ; MRISthresholdGaussianCurvatureToMarked(mris, 10, 50); MRIScomputeSecondFundamentalForm(mris) ; MRIShistoThresholdGaussianCurvatureToMarked(mris, (float)(mris->nvertices-20)/mris->nvertices) ; MRISthresholdGaussianCurvatureToMarked(mris, 10, 50); if ((write_iterations > 0) && ((i % write_iterations) == 0)) { char fname[STRLEN] ; sprintf(fname, "%s%04d", out_fname, i) ; printf("writing snapshot to %s...\n", fname) ; MRISwrite(mris, fname) ; if (Gdiag & DIAG_WRITE) { MRISuseGaussianCurvature(mris) ; sprintf(fname, "%s_K%04d", out_fname, i) ; printf("writing curvature to %s...\n", fname) ; MRISwriteCurvature(mris, fname) ; sprintf(fname, "%s_marked%04d", out_fname, i) ; printf("writing marks to %s...\n", fname) ; MRISwriteMarked(mris, fname) ; } } for (j = 0 ; j <= 5*nint(1/DT) ; j++) { MRISmarkedSpringTerm(mris, l_spring) ; MRISaverageGradients(mris, gaussian_avgs) ; MRISmomentumTimeStep(mris, momentum, DT, 1, gaussian_avgs) ; MRISclearGradient(mris) ; MRIScomputeMetricProperties(mris) ; MRISsmoothSurfaceNormals(mris, gaussian_avgs) ; { int vno ; VERTEX *v ; for (vno = 0 ; vno < mris->nvertices ; vno++) { v = &mris->vertices[vno] ; if (v->marked > 0) { v->K = 1.0/(v->marked) ; } else { v->K = 0 ; } } } } } MRISclearGradient(mris) ; if (gaussian_avgs == 2) { if (pass++ > 4) { done = 1 ; } else { int num = count_big_curvatures(mris, 2) ; printf("------------------------------------------------------\n") ; printf("------------------------------------------------------\n") ; printf("------------------ pass %d (num=%d) ------------------\n", pass, num) ; printf("------------------------------------------------------\n") ; printf("------------------------------------------------------\n") ; gaussian_avgs = start_avgs ; } } else { gaussian_avgs /= 2 ; if (done ==0) { printf("----------------- setting avgs to %d -----------------\n", gaussian_avgs) ; } } start_t = i ; } while (!done) ; #if 0 // more smoothing with principal curvatures gaussian_avgs = start_avgs ; printf("--------------------------------------------------------------------------\n") ; printf("--------------------------------------------------------------------------\n") ; printf("---------------------- starting threshold smoothing ----------------------\n") ; printf("--------------------------------------------------------------------------\n") ; printf("--------------------------------------------------------------------------\n") ; do { for (i = start_t ; i < niterations+start_t ; i++) { MRIScomputeMetricProperties(mris) ; MRIScomputeSecondFundamentalForm(mris) ; MRISsmoothSurfaceNormals(mris, 16) ; #define KTHRESH 1.5 // everything with kmin less than this will not move MRISthresholdPrincipalCurvatures(mris, KTHRESH) ; MRISspringTermWithGaussianCurvature(mris, gaussian_norm, l_spring) ; MRISaverageGradients(mris, gaussian_avgs) ; MRISmomentumTimeStep(mris, 0, 0.1, 1, gaussian_avgs) ; MRISclearGradient(mris) ; if ((write_iterations > 0) && (((i+1) % write_iterations) == 0)) { char fname[STRLEN] ; sprintf(fname, "%s%04d", out_fname, i+1) ; printf("writing snapshot to %s...\n", fname) ; MRISwrite(mris, fname) ; if (Gdiag & DIAG_WRITE/* && DIAG_VERBOSE_ON*/) { MRISuseGaussianCurvature(mris) ; sprintf(fname, "%s_K%04d", out_fname, i+1) ; printf("writing curvature to %s...\n", fname) ; MRISwriteCurvature(mris, fname) ; } } } MRISclearGradient(mris) ; done = (gaussian_avgs == 2) ; gaussian_avgs /= 2 ; if (done ==0) { printf("---------------------- setting avgs to %d ----------------------\n", gaussian_avgs) ; } start_t = i ; } while (!done) ; #endif } else { MRISaverageVertexPositions(mris, niterations) ; } fprintf(stderr, "smoothing complete - recomputing first and second " "fundamental forms...\n") ; MRIScomputeMetricProperties(mris) ; if (rescale) { MRISscaleBrainArea(mris) ; } MRIScomputeSecondFundamentalForm(mris) ; MRISuseMeanCurvature(mris) ; MRISaverageCurvatures(mris, navgs) ; if (normalize_flag) { MRISnormalizeCurvature(mris, which_norm) ; } sprintf(fname, "%s.%s", mris->hemisphere == LEFT_HEMISPHERE?"lh":"rh", curvature_fname); if (no_write == 0) { fprintf(stderr, "writing smoothed curvature to %s/%s\n", path,fname) ; MRISwriteCurvature(mris, fname) ; sprintf(fname, "%s.%s", mris->hemisphere == LEFT_HEMISPHERE?"lh":"rh", area_fname); fprintf(stderr, "writing smoothed area to %s/%s\n", path, fname) ; MRISwriteArea(mris, fname) ; } if (Gdiag & DIAG_SHOW) { fprintf(stderr, "writing smoothed surface to %s\n", out_fname) ; } MRISwrite(mris, out_fname) ; exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { char **av, *hemi, fname[STRLEN], *in_aseg_name, *out_aseg_name, *surf_dir ; int ac, nargs, h ; MRI_SURFACE *mris ; MRI *mri_aseg ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mri_relabel_hypointensities.c,v 1.13 2015/05/15 18:44:10 nicks Exp $", "$Name: $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_relabel_hypointensities.c,v 1.13 2015/05/15 18:44:10 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) { usage_exit() ; } in_aseg_name = argv[1] ; surf_dir = argv[2] ; out_aseg_name = argv[3] ; mri_aseg = MRIread(in_aseg_name) ; if (!mri_aseg) { ErrorExit(ERROR_NOFILE, "%s: could not read input segmentation %s", Progname, in_aseg_name) ; } for (h = 0 ; h <= 1 ; h++) { if (h == 0) { hemi = "lh" ; } else { hemi = "rh" ; } sprintf(fname, "%s/%s.%s", surf_dir, hemi, surf_name) ; printf("reading input surface %s...\n", fname) ; mris = MRISread(fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, fname) ; MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; MRIScomputeMetricProperties(mris) ; printf("relabeling %s hypointensities...\n", hemi) ; relabel_hypointensities(mri_aseg, mris, h) ; MRISfree(&mris) ; } relabel_hypointensities_neighboring_gray(mri_aseg) ; MRIwrite(mri_aseg, out_aseg_name) ; exit(0) ; return(0) ; /* for ansi */ }