/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs;
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR == NULL) {
printf("ERROR: SUBJECTS_DIR not defined in environment\n");
exit(1);
}
return 0;
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs;
char *surf1_fname ;
char *surf2_fname ;
char *out_fname ;
MRI_SURFACE *mris1, *mris2 ;
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR == NULL) {
printf("ERROR: SUBJECTS_DIR not defined in environment\n");
exit(1);
}
surf1_fname = argv[0] ; surf2_fname = argv[1] ; out_fname = argv[2] ;
mris1 = MRISread(surf1_fname) ;
if (mris1 == NULL)
ErrorExit(ERROR_NOFILE, "could not read surface 1 from %s", surf1_fname) ;
mris2 = MRISread(surf2_fname) ;
if (mris2 == NULL)
ErrorExit(ERROR_NOFILE, "could not read surface 2 from %s", surf2_fname) ;
compute_surface_distance(mris1, mris2, mris1) ;
MRISwriteValues(mris1, out_fname) ;
return 0;
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs, n, err;
char tmpstr[2000], *signstr=NULL,*SUBJECTS_DIR, fname[2000];
//char *OutDir = NULL;
RFS *rfs;
int nSmoothsPrev, nSmoothsDelta;
MRI *z, *zabs=NULL, *sig=NULL, *p=NULL;
int FreeMask = 0;
int nthSign, nthFWHM, nthThresh;
double sigmax, zmax, threshadj, csize, csizeavg, searchspace,avgvtxarea;
int csizen;
int nClusters, cmax,rmax,smax;
SURFCLUSTERSUM *SurfClustList;
struct timeb mytimer;
LABEL *clabel;
FILE *fp, *fpLog=NULL;
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
if(LogFile){
fpLog = fopen(LogFile,"w");
if(fpLog == NULL){
printf("ERROR: opening %s\n",LogFile);
exit(1);
}
dump_options(fpLog);
}
if(SynthSeed < 0) SynthSeed = PDFtodSeed();
srand48(SynthSeed);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
// Create output directory
printf("Creating %s\n",OutTop);
err = fio_mkdirp(OutTop,0777);
if(err) exit(1);
for(nthFWHM=0; nthFWHM < nFWHMList; nthFWHM++){
for(nthThresh = 0; nthThresh < nThreshList; nthThresh++){
for(nthSign = 0; nthSign < nSignList; nthSign++){
if(SignList[nthSign] == 0) signstr = "abs";
if(SignList[nthSign] == +1) signstr = "pos";
if(SignList[nthSign] == -1) signstr = "neg";
sprintf(tmpstr,"%s/fwhm%02d/%s/th%02d",
OutTop,(int)round(FWHMList[nthFWHM]),
signstr,(int)round(10*ThreshList[nthThresh]));
sprintf(fname,"%s/%s.csd",tmpstr,csdbase);
if(fio_FileExistsReadable(fname)){
printf("ERROR: output file %s exists\n",fname);
if(fpLog) fprintf(fpLog,"ERROR: output file %s exists\n",fname);
exit(1);
}
err = fio_mkdirp(tmpstr,0777);
if(err) exit(1);
}
}
}
// Load the target surface
sprintf(tmpstr,"%s/%s/surf/%s.%s",SUBJECTS_DIR,subject,hemi,surfname);
printf("Loading %s\n",tmpstr);
surf = MRISread(tmpstr);
if(!surf) return(1);
// Handle masking
if(LabelFile){
printf("Loading label file %s\n",LabelFile);
sprintf(tmpstr,"%s/%s/label/%s.%s.label",
SUBJECTS_DIR,subject,hemi,LabelFile);
if(!fio_FileExistsReadable(tmpstr)){
printf(" Cannot find label file %s\n",tmpstr);
sprintf(tmpstr,"%s",LabelFile);
printf(" Trying label file %s\n",tmpstr);
if(!fio_FileExistsReadable(tmpstr)){
printf(" ERROR: cannot read or find label file %s\n",LabelFile);
exit(1);
}
}
printf("Loading %s\n",tmpstr);
clabel = LabelRead(NULL, tmpstr);
mask = MRISlabel2Mask(surf, clabel, NULL);
FreeMask = 1;
}
if(MaskFile){
printf("Loading %s\n",MaskFile);
mask = MRIread(MaskFile);
if(mask == NULL) exit(1);
}
if(mask && SaveMask){
sprintf(tmpstr,"%s/mask.mgh",OutTop);
printf("Saving mask to %s\n",tmpstr);
err = MRIwrite(mask,tmpstr);
if(err) exit(1);
}
// Compute search space
searchspace = 0;
nmask = 0;
for(n=0; n < surf->nvertices; n++){
if(mask && MRIgetVoxVal(mask,n,0,0,0) < 0.5) continue;
searchspace += surf->vertices[n].area;
nmask++;
}
printf("Found %d voxels in mask\n",nmask);
if(surf->group_avg_surface_area > 0)
searchspace *= (surf->group_avg_surface_area/surf->total_area);
printf("search space %g mm2\n",searchspace);
avgvtxarea = searchspace/nmask;
printf("average vertex area %g mm2\n",avgvtxarea);
// Determine how many iterations are needed for each FWHM
nSmoothsList = (int *) calloc(sizeof(int),nFWHMList);
for(nthFWHM=0; nthFWHM < nFWHMList; nthFWHM++){
nSmoothsList[nthFWHM] = MRISfwhm2niters(FWHMList[nthFWHM], surf);
printf("%2d %5.1f %4d\n",nthFWHM,FWHMList[nthFWHM],nSmoothsList[nthFWHM]);
if(fpLog) fprintf(fpLog,"%2d %5.1f %4d\n",nthFWHM,FWHMList[nthFWHM],nSmoothsList[nthFWHM]);
}
printf("\n");
// Allocate the CSDs
for(nthFWHM=0; nthFWHM < nFWHMList; nthFWHM++){
for(nthThresh = 0; nthThresh < nThreshList; nthThresh++){
for(nthSign = 0; nthSign < nSignList; nthSign++){
csd = CSDalloc();
sprintf(csd->simtype,"%s","null-z");
sprintf(csd->anattype,"%s","surface");
sprintf(csd->subject,"%s",subject);
sprintf(csd->hemi,"%s",hemi);
sprintf(csd->contrast,"%s","NA");
csd->seed = SynthSeed;
csd->nreps = nRepetitions;
csd->thresh = ThreshList[nthThresh];
csd->threshsign = SignList[nthSign];
csd->nullfwhm = FWHMList[nthFWHM];
csd->varfwhm = -1;
csd->searchspace = searchspace;
CSDallocData(csd);
csdList[nthFWHM][nthThresh][nthSign] = csd;
}
}
}
// Alloc the z map
z = MRIallocSequence(surf->nvertices, 1,1, MRI_FLOAT, 1);
// Set up the random field specification
rfs = RFspecInit(SynthSeed,NULL);
rfs->name = strcpyalloc("gaussian");
rfs->params[0] = 0;
rfs->params[1] = 1;
printf("Thresholds (%d): ",nThreshList);
for(n=0; n < nThreshList; n++) printf("%5.2f ",ThreshList[n]);
printf("\n");
printf("Signs (%d): ",nSignList);
for(n=0; n < nSignList; n++) printf("%2d ",SignList[n]);
printf("\n");
printf("FWHM (%d): ",nFWHMList);
for(n=0; n < nFWHMList; n++) printf("%5.2f ",FWHMList[n]);
printf("\n");
// Start the simulation loop
printf("\n\nStarting Simulation over %d Repetitions\n",nRepetitions);
if(fpLog) fprintf(fpLog,"\n\nStarting Simulation over %d Repetitions\n",nRepetitions);
TimerStart(&mytimer) ;
for(nthRep = 0; nthRep < nRepetitions; nthRep++){
msecTime = TimerStop(&mytimer) ;
printf("%5d %7.1f ",nthRep,(msecTime/1000.0)/60);
if(fpLog) {
fprintf(fpLog,"%5d %7.1f ",nthRep,(msecTime/1000.0)/60);
fflush(fpLog);
}
// Synthesize an unsmoothed z map
RFsynth(z,rfs,mask);
nSmoothsPrev = 0;
// Loop through FWHMs
for(nthFWHM=0; nthFWHM < nFWHMList; nthFWHM++){
printf("%d ",nthFWHM);
if(fpLog) {
fprintf(fpLog,"%d ",nthFWHM);
fflush(fpLog);
}
nSmoothsDelta = nSmoothsList[nthFWHM] - nSmoothsPrev;
nSmoothsPrev = nSmoothsList[nthFWHM];
// Incrementally smooth z
MRISsmoothMRI(surf, z, nSmoothsDelta, mask, z); // smooth z
// Rescale
RFrescale(z,rfs,mask,z);
// Slightly tortured way to get the right p-values because
// RFstat2P() computes one-sided, but I handle sidedness
// during thresholding.
// First, use zabs to get a two-sided pval bet 0 and 0.5
zabs = MRIabs(z,zabs);
p = RFstat2P(zabs,rfs,mask,0,p);
// Next, mult pvals by 2 to get two-sided bet 0 and 1
MRIscalarMul(p,p,2.0);
sig = MRIlog10(p,NULL,sig,1); // sig = -log10(p)
for(nthThresh = 0; nthThresh < nThreshList; nthThresh++){
for(nthSign = 0; nthSign < nSignList; nthSign++){
csd = csdList[nthFWHM][nthThresh][nthSign];
// If test is not ABS then apply the sign
if(csd->threshsign != 0) MRIsetSign(sig,z,0);
// Get the max stats
sigmax = MRIframeMax(sig,0,mask,csd->threshsign,
&cmax,&rmax,&smax);
zmax = MRIgetVoxVal(z,cmax,rmax,smax,0);
if(csd->threshsign == 0){
zmax = fabs(zmax);
sigmax = fabs(sigmax);
}
// Mask
if(mask) MRImask(sig,mask,sig,0.0,0.0);
// Surface clustering
MRIScopyMRI(surf, sig, 0, "val");
if(csd->threshsign == 0) threshadj = csd->thresh;
else threshadj = csd->thresh - log10(2.0); // one-sided test
SurfClustList = sclustMapSurfClusters(surf,threshadj,-1,csd->threshsign,
0,&nClusters,NULL);
// Actual area of cluster with max area
csize = sclustMaxClusterArea(SurfClustList, nClusters);
// Number of vertices of cluster with max number of vertices.
// Note: this may be a different cluster from above!
csizen = sclustMaxClusterCount(SurfClustList, nClusters);
// Area of this cluster based on average vertex area. This just scales
// the number of vertices.
csizeavg = csizen * avgvtxarea;
if(UseAvgVtxArea) csize = csizeavg;
// Store results
csd->nClusters[nthRep] = nClusters;
csd->MaxClusterSize[nthRep] = csize;
csd->MaxSig[nthRep] = sigmax;
csd->MaxStat[nthRep] = zmax;
} // Sign
} // Thresh
} // FWHM
printf("\n");
if(fpLog) fprintf(fpLog,"\n");
if(SaveEachIter || fio_FileExistsReadable(SaveFile)) SaveOutput();
if(fio_FileExistsReadable(StopFile)) {
printf("Found stop file %s\n",StopFile);
goto finish;
}
} // Simulation Repetition
finish:
SaveOutput();
msecTime = TimerStop(&mytimer) ;
printf("Total Sim Time %g min (%g per rep)\n",
msecTime/(1000*60.0),(msecTime/(1000*60.0))/nthRep);
if(fpLog) fprintf(fpLog,"Total Sim Time %g min (%g per rep)\n",
msecTime/(1000*60.0),(msecTime/(1000*60.0))/nthRep);
if(DoneFile){
fp = fopen(DoneFile,"w");
fprintf(fp,"%g\n",msecTime/(1000*60.0));
fclose(fp);
}
printf("mri_mcsim done\n");
if(fpLog){
fprintf(fpLog,"mri_mcsim done\n");
fclose(fpLog);
}
exit(0);
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs, n, Ntp, nsearch, nsearch2=0;
double fwhm = 0, nresels, voxelvolume, nvoxperresel, reselvolume;
double car1mn, rar1mn,sar1mn,cfwhm,rfwhm,sfwhm, ftmp;
double car2mn, rar2mn,sar2mn;
double gmean, gstd, gmax;
FILE *fp;
sprintf(tmpstr, "S%sER%sRONT%sOR", "URF", "_F", "DO") ;
setenv(tmpstr,"1",0);
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
if (SynthSeed < 0) SynthSeed = PDFtodSeed();
if (debug) dump_options(stdout);
// ------------- load or synthesize input ---------------------
InVals = MRIreadType(inpath,InValsType);
if(InVals == NULL) exit(1);
if(SetTR){
printf("Setting TR to %g ms\n",TR);
InVals->tr = TR;
}
if((nframes < 0 && synth) || !synth) nframes = InVals->nframes;
if(nframes < nframesmin && !SmoothOnly && !sum2file) {
printf("ERROR: nframes = %d, need at least %d\n",
nframes,nframesmin);
exit(1);
}
if (InVals->type != MRI_FLOAT) {
mritmp = MRISeqchangeType(InVals, MRI_FLOAT, 0, 0, 0);
MRIfree(&InVals);
InVals = mritmp;
}
if(synth) {
printf("Synthesizing %d frames, Seed = %d\n",nframes,SynthSeed);
mritmp = MRIcloneBySpace(InVals,MRI_FLOAT,nframes);
MRIfree(&InVals);
MRIrandn(mritmp->width, mritmp->height, mritmp->depth,
nframes, 0, 1, mritmp);
InVals = mritmp;
}
voxelvolume = InVals->xsize * InVals->ysize * InVals->zsize ;
printf("voxelvolume %g mm3\n",voxelvolume);
if(DoSqr){
printf("Computing square of input\n");
MRIsquare(InVals,NULL,InVals);
}
// -------------------- handle masking ------------------------
if (maskpath) {
printf("Loading mask %s\n",maskpath);
mask = MRIread(maskpath);
if(mask==NULL) exit(1);
if(MRIdimMismatch(mask,InVals,0)){
printf("ERROR: dimension mismatch between mask and input\n");
exit(1);
}
MRIbinarize2(mask, mask, maskthresh, 0, 1);
}
if (automask) {
RFglobalStats(InVals, NULL, &gmean, &gstd, &gmax);
maskthresh = gmean * automaskthresh;
printf("Computing mask, relative threshold = %g, gmean = %g, absthresh = %g\n",
automaskthresh,gmean,maskthresh);
mritmp = MRIframeMean(InVals,NULL);
//MRIwrite(mritmp,"fmean.mgh");
mask = MRIbinarize2(mritmp, NULL, maskthresh, 0, 1);
MRIfree(&mritmp);
}
if (mask) {
if (maskinv) {
printf("Inverting mask\n");
MRImaskInvert(mask,mask);
}
nsearch = MRInMask(mask);
if (nsearch == 0) {
printf("ERROR: no voxels found in mask\n");
exit(1);
}
// Erode the mask -----------------------------------------------
if (nerode > 0) {
printf("Eroding mask %d times\n",nerode);
for (n=0; n<nerode; n++) MRIerode(mask,mask);
nsearch2 = MRInMask(mask);
if (nsearch2 == 0) {
printf("ERROR: no voxels found in mask after eroding\n");
exit(1);
}
printf("%d voxels in mask after eroding\n",nsearch2);
}
//---- Save mask -----
if (outmaskpath) MRIwrite(mask,outmaskpath);
} else nsearch = InVals->width * InVals->height * InVals->depth;
printf("Search region is %d voxels = %lf mm3\n",nsearch,nsearch*voxelvolume);
if( (infwhm > 0 || infwhmc > 0 || infwhmr > 0 || infwhms > 0) && SmoothOnly) {
if(SaveUnmasked) mritmp = NULL;
else mritmp = mask;
if(infwhm > 0) {
printf("Smoothing input by fwhm=%lf, gstd=%lf\n",infwhm,ingstd);
MRImaskedGaussianSmooth(InVals, mritmp, ingstd, InVals);
}
if(infwhmc > 0 || infwhmr > 0 || infwhms > 0) {
printf("Smoothing input by fwhm=(%lf,%lf,%lf) gstd=(%lf,%lf,%lf)\n",
infwhmc,infwhmr,infwhms,ingstdc,ingstdr,ingstds);
MRIgaussianSmoothNI(InVals, ingstdc, ingstdr, ingstds, InVals);
}
printf("Saving to %s\n",outpath);
MRIwrite(InVals,outpath);
printf("SmoothOnly requested, so exiting now\n");
exit(0);
}
// Make a copy, if needed, prior to doing anything to data
if(outpath) InValsCopy = MRIcopy(InVals,NULL);
// Compute variance reduction factor -------------------
if(sum2file){
ftmp = MRIsum2All(InVals);
fp = fopen(sum2file,"w");
if(fp == NULL){
printf("ERROR: opening %s\n",sum2file);
exit(1);
}
printf("sum2all: %20.10lf\n",ftmp);
printf("vrf: %20.10lf\n",1/ftmp);
fprintf(fp,"%20.10lf\n",ftmp);
exit(0);
}
//------------------------ Detrend ------------------
if(DetrendOrder >= 0) {
Ntp = InVals->nframes;
printf("Polynomial detrending, order = %d\n",DetrendOrder);
X = MatrixAlloc(Ntp,DetrendOrder+1,MATRIX_REAL);
for (n=0;n<Ntp;n++) X->rptr[n+1][1] = 1.0;
ftmp = Ntp/2.0;
if (DetrendOrder >= 1)
for (n=0;n<Ntp;n++) X->rptr[n+1][2] = (n-ftmp)/ftmp;
if (DetrendOrder >= 2)
for (n=0;n<Ntp;n++) X->rptr[n+1][3] = pow((n-ftmp),2.0)/(ftmp*ftmp);
}
if(X){
printf("Detrending\n");
if (X->rows != InVals->nframes) {
printf("ERROR: dimension mismatch between X and input\n");
exit(1);
}
mritmp = fMRIdetrend(InVals,X);
if (mritmp == NULL) exit(1);
MRIfree(&InVals);
InVals = mritmp;
}
// ------------ Smooth Input BY infwhm -------------------------
if(infwhm > 0) {
printf("Smoothing input by fwhm=%lf, gstd=%lf\n",infwhm,ingstd);
MRImaskedGaussianSmooth(InVals, mask, ingstd, InVals);
}
// ------------ Smooth Input BY infwhm -------------------------
if(infwhmc > 0 || infwhmr > 0 || infwhms > 0) {
printf("Smoothing input by fwhm=(%lf,%lf,%lf) gstd=(%lf,%lf,%lf)\n",
infwhmc,infwhmr,infwhms,ingstdc,ingstdr,ingstds);
MRIgaussianSmoothNI(InVals, ingstdc, ingstdr, ingstds, InVals);
}
// ------------ Smooth Input TO fwhm -------------------------
if (tofwhm > 0) {
printf("Attempting to smooth to %g +/- %g mm fwhm (nitersmax=%d)\n",
tofwhm,tofwhmtol,tofwhmnitersmax);
mritmp = MRImaskedGaussianSmoothTo(InVals, mask, tofwhm,
tofwhmtol, tofwhmnitersmax,
&byfwhm, &tofwhmact, &tofwhmniters,
InVals);
if (mritmp == NULL) exit(1);
printf("Smoothed by %g to %g in %d iterations\n",
byfwhm,tofwhmact,tofwhmniters);
if (tofwhmfile) {
fp = fopen(tofwhmfile,"w");
if (!fp) {
printf("ERROR: opening %s\n",tofwhmfile);
exit(1);
}
fprintf(fp,"tofwhm %lf\n",tofwhm);
fprintf(fp,"tofwhmtol %lf\n",tofwhmtol);
fprintf(fp,"tofwhmact %lf\n",tofwhmact);
fprintf(fp,"byfwhm %lf\n",byfwhm);
fprintf(fp,"niters %d\n",tofwhmniters);
fprintf(fp,"nitersmax %d\n",tofwhmnitersmax);
fclose(fp);
}
}
// ------ Save smoothed/detrended ------------------------------
if(outpath) {
// This is a bit of a hack in order to be able to save undetrended
// Operates on InValsCopy, which has not been modified (requires
// smoothing twice, which is silly:).
printf("Saving to %s\n",outpath);
// Smoothed output will not be masked
if (SaveDetrended && X) {
mritmp = fMRIdetrend(InValsCopy,X);
if (mritmp == NULL) exit(1);
MRIfree(&InValsCopy);
InValsCopy = mritmp;
}
if (SaveUnmasked) mritmp = NULL;
else mritmp = mask;
if(infwhm > 0)
MRImaskedGaussianSmooth(InValsCopy, mritmp, ingstd, InValsCopy);
if(infwhmc > 0 || infwhmr > 0 || infwhms > 0)
MRIgaussianSmoothNI(InValsCopy, ingstdc, ingstdr, ingstds, InValsCopy);
if(tofwhm > 0) {
bygstd = byfwhm/sqrt(log(256.0));
MRImaskedGaussianSmooth(InValsCopy, mritmp, bygstd, InValsCopy);
}
MRIwrite(InValsCopy,outpath);
MRIfree(&InValsCopy);
}
// ----------- Compute smoothness -----------------------------
printf("Computing spatial AR1 in volume.\n");
ar1 = fMRIspatialAR1(InVals, mask, NULL);
if (ar1 == NULL) exit(1);
fMRIspatialAR1Mean(ar1, mask, &car1mn, &rar1mn, &sar1mn);
cfwhm = RFar1ToFWHM(car1mn, InVals->xsize);
rfwhm = RFar1ToFWHM(rar1mn, InVals->ysize);
sfwhm = RFar1ToFWHM(sar1mn, InVals->zsize);
fwhm = sqrt((cfwhm*cfwhm + rfwhm*rfwhm + sfwhm*sfwhm)/3.0);
printf("ar1mn = (%lf,%lf,%lf)\n",car1mn,rar1mn,sar1mn);
printf("colfwhm = %lf\n",cfwhm);
printf("rowfwhm = %lf\n",rfwhm);
printf("slicefwhm = %lf\n",sfwhm);
printf("outfwhm = %lf\n",fwhm);
reselvolume = cfwhm*rfwhm*sfwhm;
nvoxperresel = reselvolume/voxelvolume;
nresels = voxelvolume*nsearch/reselvolume;
printf("reselvolume %lf\n",reselvolume);
printf("nresels %lf\n",nresels);
printf("nvoxperresel %lf\n",nvoxperresel);
if(DoAR2){
printf("Computing spatial AR2 in volume.\n");
fMRIspatialAR2Mean(InVals, mask, &car2mn, &rar2mn, &sar2mn);
printf("ar2mn = (%lf,%lf,%lf)\n",car2mn,rar2mn,sar2mn);
}
if(ar1path) MRIwrite(ar1,ar1path);
fflush(stdout);
// ---------- Save summary file ---------------------
if(sumfile) {
fp = fopen(sumfile,"w");
if (fp == NULL) {
printf("ERROR: opening %s\n",sumfile);
exit(1);
}
dump_options(fp);
fprintf(fp,"nsearch2 %d\n",nsearch2);
fprintf(fp,"searchspace_vox %d\n",nsearch);
fprintf(fp,"searchspace_mm3 %lf\n",nsearch*voxelvolume);
fprintf(fp,"voxelvolume_mm3 %g\n",voxelvolume);
fprintf(fp,"voxelsize_mm %g %g %g\n",InVals->xsize,InVals->ysize,InVals->zsize);
fprintf(fp,"ar1mn %lf %lf %lf\n",car1mn,rar1mn,sar1mn);
fprintf(fp,"colfwhm_mm %lf\n",cfwhm);
fprintf(fp,"rowfwhm_mm %lf\n",rfwhm);
fprintf(fp,"slicefwhm_mm %lf\n",sfwhm);
fprintf(fp,"outfwhm_mm %lf\n",fwhm);
fprintf(fp,"reselvolume_mm3 %lf\n",reselvolume);
fprintf(fp,"nresels %lf\n",nresels);
fprintf(fp,"nvox_per_resel %lf\n",nvoxperresel);
fclose(fp);
}
if(datfile) {
fp = fopen(datfile,"w");
if(fp == NULL) {
printf("ERROR: opening %s\n",datfile);
exit(1);
}
fprintf(fp,"%lf\n",fwhm);
fclose(fp);
}
printf("mri_fwhm done\n");
return 0;
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs,n;
MRIS *SurfReg[100];
MRI *SrcVal, *TrgVal;
char *base;
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
printf("Loading %s\n",SrcValFile);
SrcVal = MRIread(SrcValFile);
if(SrcVal==NULL) exit(1);
if(DoSynthRand) {
if (SynthSeed < 0) SynthSeed = PDFtodSeed();
printf("INFO: synthesizing, seed = %d\n",SynthSeed);
srand48(SynthSeed);
MRIrandn(SrcVal->width, SrcVal->height, SrcVal->depth,
SrcVal->nframes,0, 1, SrcVal);
}
if(DoSynthOnes != 0) {
printf("INFO: filling input with all 1s\n");
MRIconst(SrcVal->width, SrcVal->height, SrcVal->depth,
SrcVal->nframes, 1, SrcVal);
}
for(n=0; n<nsurfs; n++) {
printf("%d Loading %s\n",n+1,SurfRegFile[n]);
base = fio_basename(SurfRegFile[n],".tri");
if(strcmp(base,"ic7")==0) {
// Have to do it this way to rescale. Need to find a better more robust way.
printf(" reading as ico 7, rescaling radius to 100\n");
SurfReg[n] = ReadIcoByOrder(7, 100);
}
else
SurfReg[n] = MRISread(SurfRegFile[n]);
free(base);
if(SurfReg[n]==NULL) exit(1);
}
TrgVal = MRISapplyReg(SrcVal, SurfReg, nsurfs,ReverseMapFlag,DoJac,UseHash);
if(TrgVal == NULL) exit(1);
printf("Writing %s\n",TrgValFile);
MRIwrite(TrgVal,TrgValFile);
printf("mris_apply_reg done\n");
return 0;
}
/*---------------------------------------------------------------*/
int main(int argc, char **argv) {
SDCMFILEINFO **sdfi_list;
SDCMFILEINFO *sdfi=NULL;
int nlist;
int NRuns;
int nthfile;
char *fname, *psname, *protoname;
int PrevRunNo;
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
cmdline = argv2cmdline(argc,argv);
parse_commandline(argc, argv);
check_options();
uname(&uts);
getcwd(cwd,2000);
fprintf(stdout,"%s\n",vcid);
fprintf(stdout,"cwd %s\n",cwd);
fprintf(stdout,"cmdline %s\n",cmdline);
fprintf(stdout,"sysname %s\n",uts.sysname);
fprintf(stdout,"hostname %s\n",uts.nodename);
fprintf(stdout,"machine %s\n",uts.machine);
fprintf(stdout,"user %s\n",VERuser());
strip_leading_slashes(sdicomdir);
/* open the output file, or set output stream to stdout */
if (outfile != NULL) {
outstream = fopen(outfile,"w");
if (outstream == NULL) {
fprintf(stderr,"ERROR: could not open %s for writing\n",outfile);
exit(1);
}
} else outstream = stdout;
/* Get all the Siemens DICOM files from this directory */
fprintf(stderr,"INFO: scanning path to Siemens DICOM DIR:\n %s\n",
sdicomdir);
sdfi_list = ScanSiemensDCMDir(sdicomdir, &nlist);
if (sdfi_list == NULL) {
fprintf(stderr,"ERROR: scanning directory %s\n",sdicomdir);
exit(1);
}
printf("INFO: found %d Siemens files\n",nlist);
printf("%s\n",sdfi_list[0]->NumarisVer);
tmpstring = sdcmExtractNumarisVer(sdfi_list[0]->NumarisVer, &Maj, &Min, &MinMin);
if (tmpstring == NULL) free(tmpstring);
else {
if ((Min == 1 && MinMin <= 6) && Maj < 4) {
// This should only be run for pretty old data. I've lost
// track as to which versions should do this. With Maj<4,
// I'm pretty sure that this section of code will never
// be run. It might need to be run with version 4VA16
// and earlier. Note: this same code is in DICOMRead.c
printf("Computing TR with number of slices\n");
TRSlice = 1;
}
}
/* Sort the files by Series, Slice Position, and Image Number */
printf("Sorting\n");
fflush(stdout);
fflush(stderr);
SortSDCMFileInfo(sdfi_list,nlist);
/* Assign run numbers to each file (count number of runs)*/
if (sortbyrun) {
fprintf(stderr,"Assigning Run Numbers\n");
fflush(stderr);
NRuns = sdfiAssignRunNo2(sdfi_list, nlist);
if (NRuns == 0) {
fprintf(stderr,"ERROR: sorting runs\n");
fflush(stderr);
exit(1);
}
}
PrevRunNo = -1;
for (nthfile = 0; nthfile < nlist; nthfile++) {
sdfi = sdfi_list[nthfile];
if (summarize && PrevRunNo == sdfi->RunNo) continue;
PrevRunNo = sdfi->RunNo;
sdfi->RepetitionTime /= 1000.0;
// Old version of Siemens software had reptime as time between
// slices. New has reptime as time between volumes.
// Code (above) looks at version and does the right thing.
if (sdfi->IsMosaic && TRSlice) sdfi->RepetitionTime *= sdfi->VolDim[2];
fname = fio_basename(sdfi->FileName,NULL);
psname = strip_white_space(sdfi->PulseSequence);
protoname = strip_white_space(sdfi->ProtocolName);
fprintf(outstream,
"%4d %s %3d %d %4d %d %3d %3d %3d %3d %8.4f %8.4f %s\n",
nthfile+1, fname,
sdfi->SeriesNo, sdfi->ErrorFlag,
sdfi->ImageNo, sdfi->IsMosaic,
sdfi->VolDim[0], sdfi->VolDim[1], sdfi->VolDim[2], sdfi->NFrames,
sdfi->RepetitionTime, sdfi->EchoTime,
protoname);
fflush(outstream);
free(fname);
free(psname);
free(protoname);
}
while (nlist--) {
// free strings
free(sdfi_list[nlist]->FileName);
free(sdfi_list[nlist]->StudyDate);
free(sdfi_list[nlist]->StudyTime);
free(sdfi_list[nlist]->PatientName);
free(sdfi_list[nlist]->SeriesTime);
free(sdfi_list[nlist]->AcquisitionTime);
free(sdfi_list[nlist]->ScannerModel);
free(sdfi_list[nlist]->NumarisVer);
free(sdfi_list[nlist]->PulseSequence);
free(sdfi_list[nlist]->ProtocolName);
free(sdfi_list[nlist]->PhEncDir);
//
free(sdfi_list[nlist]);
}
free(sdfi_list);
if (outfile != NULL) fclose(outstream);
fflush(stdout);
fflush(stderr);
exit(0);
return(0);
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs, nthvtx, nnbrs1, nnbrs2, nthnbr, nbrvtxno1, nbrvtxno2;
int nthface, annot1, annot2;
VERTEX *vtx1, *vtx2;
FACE *face1, *face2;
float diff, maxdiff;
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR == NULL) {
printf("INFO: SUBJECTS_DIR not defined in environment\n");
//exit(1);
}
if (SUBJECTS_DIR1 == NULL) SUBJECTS_DIR1 = SUBJECTS_DIR;
if (SUBJECTS_DIR2 == NULL) SUBJECTS_DIR2 = SUBJECTS_DIR;
if (surf1path == NULL && surfname == NULL) surfname = "orig";
if (surf1path == NULL) {
sprintf(tmpstr,"%s/%s/surf/%s.%s",SUBJECTS_DIR1,subject1,hemi,surfname);
surf1path = strcpyalloc(tmpstr);
}
if (surf2path == NULL) {
sprintf(tmpstr,"%s/%s/surf/%s.%s",SUBJECTS_DIR2,subject2,hemi,surfname);
surf2path = strcpyalloc(tmpstr);
}
dump_options(stdout);
//read-in each surface. notice that the random number generator is
//seeded with the same value prior to each read. this is because in
//the routine MRIScomputeNormals, if it finds a zero-length vertex
//normal, is adds a random value to the x,y,z and recomputes the normal.
//so if comparing identical surfaces, the seed must be the same so that
//any zero-length vertex normals appear the same.
setRandomSeed(seed) ;
surf1 = MRISread(surf1path);
if (surf1 == NULL) {
printf("ERROR: could not read %s\n",surf1path);
exit(1);
}
setRandomSeed(seed) ;
surf2 = MRISread(surf2path);
if (surf2 == NULL) {
printf("ERROR: could not read %s\n",surf2path);
exit(1);
}
printf("Number of vertices %d %d\n",surf1->nvertices,surf2->nvertices);
printf("Number of faces %d %d\n",surf1->nfaces,surf2->nfaces);
//Number of Vertices ----------------------------------------
if (surf1->nvertices != surf2->nvertices) {
printf("Surfaces differ in number of vertices %d %d\n",
surf1->nvertices,surf2->nvertices);
exit(101);
}
//Number of Faces ------------------------------------------
if (surf1->nfaces != surf2->nfaces) {
printf("Surfaces differ in number of faces %d %d\n",
surf1->nfaces,surf2->nfaces);
exit(101);
}
//surf1->faces[10000].area = 100;
//surf1->vertices[10000].x = 100;
if (ComputeNormalDist) {
double dist, dx, dy, dz, dot ;
MRI *mri_dist ;
mri_dist = MRIalloc(surf1->nvertices,1,1,MRI_FLOAT) ;
MRIScomputeMetricProperties(surf1) ;
MRIScomputeMetricProperties(surf2) ;
for (nthvtx=0; nthvtx < surf1->nvertices; nthvtx++) {
vtx1 = &(surf1->vertices[nthvtx]);
vtx2 = &(surf2->vertices[nthvtx]);
dx = vtx2->x-vtx1->x ;
dy = vtx2->y-vtx1->y ;
dz = vtx2->z-vtx1->z ;
dist = sqrt(dx*dx + dy*dy + dz*dz) ;
dot = dx*vtx1->nx + dy*vtx1->ny + dz*vtx1->nz ;
dist = dist * dot / fabs(dot) ;
MRIsetVoxVal(mri_dist, nthvtx, 0, 0, 0, dist) ;
}
MRIwrite(mri_dist, out_fname) ;
MRIfree(&mri_dist) ;
exit(0);
}
maxdiff=0;
//------------------------------------------------------------
if (CheckSurf) {
printf("Comparing surfaces\n");
// Loop over vertices ---------------------------------------
error_count=0;
for (nthvtx=0; nthvtx < surf1->nvertices; nthvtx++) {
vtx1 = &(surf1->vertices[nthvtx]);
vtx2 = &(surf2->vertices[nthvtx]);
if (vtx1->ripflag != vtx2->ripflag) {
printf("Vertex %d differs in ripflag %c %c\n",
nthvtx,vtx1->ripflag,vtx2->ripflag);
if (++error_count>=MAX_NUM_ERRORS) break;
}
if (CheckXYZ) {
diff=fabs(vtx1->x - vtx2->x);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Vertex %d differs in x %g %g\t(%g)\n",
nthvtx,vtx1->x,vtx2->x,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
diff=fabs(vtx1->y - vtx2->y);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Vertex %d differs in y %g %g\t(%g)\n",
nthvtx,vtx1->y,vtx2->y,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
diff=fabs(vtx1->z - vtx2->z);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Vertex %d differs in z %g %g\t(%g)\n",
nthvtx,vtx1->z,vtx2->z,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
}
if (CheckNXYZ) {
diff=fabs(vtx1->nx - vtx2->nx);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Vertex %d differs in nx %g %g\t(%g)\n",
nthvtx,vtx1->nx,vtx2->nx,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
diff=fabs(vtx1->ny - vtx2->ny);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Vertex %d differs in ny %g %g\t(%g)\n",
nthvtx,vtx1->ny,vtx2->ny,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
diff=fabs(vtx1->nz - vtx2->nz);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Vertex %d differs in nz %g %g\t(%g)\n",
nthvtx,vtx1->nz,vtx2->nz,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
}
nnbrs1 = surf1->vertices[nthvtx].vnum;
nnbrs2 = surf2->vertices[nthvtx].vnum;
if (nnbrs1 != nnbrs2) {
printf("Vertex %d has a different number of neighbors %d %d\n",
nthvtx,nnbrs1,nnbrs2);
if (++error_count>=MAX_NUM_ERRORS) break;
}
for (nthnbr=0; nthnbr < nnbrs1; nthnbr++) {
nbrvtxno1 = surf1->vertices[nthvtx].v[nthnbr];
nbrvtxno2 = surf2->vertices[nthvtx].v[nthnbr];
if (nbrvtxno1 != nbrvtxno2) {
printf("Vertex %d differs in the identity of the "
"%dth neighbor %d %d\n",nthvtx,nthnbr,nbrvtxno1,nbrvtxno2);
if (++error_count>=MAX_NUM_ERRORS) break;
}
}
if (error_count>=MAX_NUM_ERRORS) break;
}// loop over vertices
if (maxdiff>0) printf("maxdiff=%g\n",maxdiff);
if (error_count > 0) {
printf("Exiting after finding %d errors\n",error_count);
if (error_count>=MAX_NUM_ERRORS) {
printf("Exceeded MAX_NUM_ERRORS loop guard\n");
}
exit(103);
}
// Loop over faces ----------------------------------------
error_count=0;
for (nthface=0; nthface < surf1->nfaces; nthface++) {
face1 = &(surf1->faces[nthface]);
face2 = &(surf2->faces[nthface]);
if (CheckNXYZ) {
diff=fabs(face1->nx - face2->nx);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Face %d differs in nx %g %g\t(%g)\n",
nthface,face1->nx,face2->nx,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
diff=fabs(face1->ny - face2->ny);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Face %d differs in ny %g %g\t(%g)\n",
nthface,face1->ny,face2->ny,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
diff=fabs(face1->nz - face2->nz);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Face %d differs in nz %g %g\t(%g)\n",
nthface,face1->nz,face2->nz,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
}
diff=fabs(face1->area - face2->area);
if (diff>maxdiff) maxdiff=diff;
if (diff>thresh) {
printf("Face %d differs in area %g %g\t(%g)\n",
nthface,face1->area,face2->area,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
if (face1->ripflag != face2->ripflag) {
printf("Face %d differs in ripflag %c %c\n",
nthface,face1->ripflag,face2->ripflag);
if (++error_count>=MAX_NUM_ERRORS) break;
}
for (nthvtx = 0; nthvtx < 3; nthvtx++) {
if (face1->v[nthvtx] != face2->v[nthvtx]) {
printf("Face %d differs in identity of %dth vertex %d %d\n",
nthface,nthvtx,face1->ripflag,face2->ripflag);
if (++error_count>=MAX_NUM_ERRORS) break;
}
} // end loop over nthface vertex
if (error_count>=MAX_NUM_ERRORS) break;
} // end loop over faces
if (maxdiff>0) printf("maxdiff=%g\n",maxdiff);
if (error_count > 0) {
printf("Exiting after finding %d errors\n",error_count);
if (error_count>=MAX_NUM_ERRORS) {
printf("Exceeded MAX_NUM_ERRORS loop guard\n");
}
exit(103);
}
printf("Surfaces are the same\n");
exit(0);
} // end check surf
// -----------------------------------------------------------------
if (CheckCurv) {
printf("Checking curv file %s\n",curvname);
sprintf(tmpstr,"%s/%s/surf/%s.%s",SUBJECTS_DIR1,subject1,hemi,curvname);
printf("Loading curv file %s\n",tmpstr);
if (MRISreadCurvatureFile(surf1, tmpstr) != 0) {
printf("ERROR: reading curvature file %s\n",tmpstr);
exit(1);
}
sprintf(tmpstr,"%s/%s/surf/%s.%s",SUBJECTS_DIR2,subject2,hemi,curvname);
printf("Loading curv file %s\n",tmpstr);
if (MRISreadCurvatureFile(surf2, tmpstr) != 0) {
printf("ERROR: reading curvature file %s\n",tmpstr);
exit(1);
}
error_count=0;
for (nthvtx=0; nthvtx < surf1->nvertices; nthvtx++) {
vtx1 = &(surf1->vertices[nthvtx]);
vtx2 = &(surf2->vertices[nthvtx]);
diff=fabs(vtx1->curv - vtx2->curv);
if (diff>maxdiff) maxdiff=diff;
if (diff > thresh) {
printf("curv files differ at vertex %d %g %g\t(%g)\n",
nthvtx,vtx1->curv,vtx2->curv,diff);
if (++error_count>=MAX_NUM_ERRORS) break;
}
} // end loop over vertices
if (maxdiff>0) printf("maxdiff=%g\n",maxdiff);
if (error_count > 0) {
printf("Exiting after finding %d errors\n",error_count);
if (error_count>=MAX_NUM_ERRORS) {
printf("Exceeded MAX_NUM_ERRORS loop guard\n");
}
exit(103);
}
printf("Curv files are the same\n");
exit(0);
} // end check curv
// ---------------------------------------------------------
if (CheckAParc) {
printf("Checking AParc %s\n",aparcname);
sprintf(tmpstr,"%s/%s/label/%s.%s.annot",
SUBJECTS_DIR1,subject1,hemi,aparcname);
printf("Loading aparc file %s\n",tmpstr);
fflush(stdout);
if (MRISreadAnnotation(surf1, tmpstr)) {
printf("ERROR: MRISreadAnnotation() failed %s\n",tmpstr);
exit(1);
}
if (aparc2name) aparcname = aparc2name;
sprintf(tmpstr,"%s/%s/label/%s.%s.annot",
SUBJECTS_DIR2,subject2,hemi,aparcname);
printf("Loading aparc file %s\n",tmpstr);
fflush(stdout);
if (MRISreadAnnotation(surf2, tmpstr)) {
printf("ERROR: MRISreadAnnotation() failed %s\n",tmpstr);
exit(1);
}
error_count=0;
for (nthvtx=0; nthvtx < surf1->nvertices; nthvtx++) {
annot1 = surf1->vertices[nthvtx].annotation;
annot2 = surf2->vertices[nthvtx].annotation;
if (annot1 != annot2) {
printf("aparc files differ at vertex %d: 1:%s 2:%s\n",
nthvtx,
CTABgetAnnotationName(surf1->ct,annot1),
CTABgetAnnotationName(surf2->ct,annot2));
if (++error_count>=MAX_NUM_ERRORS) break;
}
} // end loop over vertices
if (error_count > 0) {
printf("Exiting after finding %d errors\n",error_count);
if (error_count>=MAX_NUM_ERRORS) {
printf("Exceeded MAX_NUM_ERRORS loop guard\n");
}
exit(103);
}
printf("\n"
"AParc files are the same\n"
"------------------------\n");
exit(0);
}
return 0;
}
/*--------------------------------------------------*/
int main(int argc, char **argv) {
int nargs,r,c;
struct utsname uts;
char *cmdline, cwd[2000];
double maxdiff,d;
int cmax,rmax,smax,fmax;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
printf("\n");
printf("%s\n",vcid);
printf("cwd %s\n",cwd);
printf("cmdline %s\n",cmdline);
printf("sysname %s\n",uts.sysname);
printf("hostname %s\n",uts.nodename);
printf("machine %s\n",uts.machine);
dump_options(stdout);
vol1 = MRIread(vol1File);
if (vol1 == NULL) exit(1);
vol2 = MRIread(vol2File);
if (vol2 == NULL) exit(1);
vox2ras1 = MRIxfmCRS2XYZ(vol1,0);
vox2ras2 = MRIxfmCRS2XYZ(vol2,0);
if (vol1->xsize != vol2->xsize ||
vol1->ysize != vol2->ysize ||
vol1->zsize != vol2->zsize) {
printf("volumes differ in resolution\n");
if (!AllowResolution) exit(RESOLUTION_EC);
printf(" but continuing\n");
}
if (vol1->type != vol2->type) {
printf("volumes differ in precision\n");
if (!AllowPrecision) exit(PRECISION_EC);
printf(" but continuing\n");
}
for (c=1; c <= 4; c++) {
for (r=1; r <= 4; r++) {
d = fabs(vox2ras1->rptr[c][r] - vox2ras2->rptr[c][r]);
if (fabs(d) > vox2ras_thresh) {
printf("volumes differ in vox2ras %d %d %g %g\n",c,r,
vox2ras1->rptr[c][r],vox2ras2->rptr[c][r]);
if (!AllowVox2RAS) exit(VOX2RAS_EC);
printf(" but continuing\n");
c=4;
r=4;
}
}
}
if (vol1->width != vol2->width ||
vol1->height != vol2->height ||
vol1->depth != vol2->depth ||
vol1->nframes != vol2->nframes) {
printf("volumes differ in dimension (%d %d %d %d) (%d %d %d %d) \n",
vol1->width,vol1->height,vol1->depth,vol1->nframes,
vol2->width,vol2->height,vol2->depth,vol2->nframes);
exit(DIMENSION_EC);
}
maxdiff = MRImaxAbsDiff(vol1,vol2,&cmax,&rmax,&smax,&fmax);
printf("pixdiff %g at %d %d %d %d\n",maxdiff,cmax,rmax,smax,fmax);
if (maxdiff > pixdiff_thresh) {
printf("volumes differ in pixel data\n");
exit(PIXEL_EC);
}
printf("volumes are consistent\n");
printf("mri_voldiff done\n");
return(0);
exit(0);
}
/*--------------------------------------------------*/
int main(int argc, char **argv) {
int nargs, err, asegid, c, r, s, annot, hemioffset;
int annotid;
struct utsname uts;
char *cmdline, cwd[2000];
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
dump_options(stdout);
printf("\n");
printf("%s\n",vcid);
printf("cwd %s\n",cwd);
printf("cmdline %s\n",cmdline);
printf("sysname %s\n",uts.sysname);
printf("hostname %s\n",uts.nodename);
printf("machine %s\n",uts.machine);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR==NULL) {
printf("ERROR: SUBJECTS_DIR not defined in environment\n");
exit(1);
}
printf("SUBJECTS_DIR %s\n",SUBJECTS_DIR);
printf("subject %s\n",subject);
printf("\n");
fflush(stdout);
/* ------ Load subject's lh white surface ------ */
sprintf(tmpstr,"%s/%s/surf/lh.white",SUBJECTS_DIR,subject);
printf("Reading lh white surface \n %s\n",tmpstr);
lhwhite = MRISread(tmpstr);
if (lhwhite == NULL) {
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
printf("Building hash of lh white\n");
lhwhite_hash = MHTfillVertexTableRes(lhwhite, NULL,CURRENT_VERTICES,16);
/* ------ Load lh annotation ------ */
sprintf(annotfile,"%s/%s/label/lh.aparc.annot",SUBJECTS_DIR,subject);
printf("Loading lh annotations from %s\n",annotfile);
err = MRISreadAnnotation(lhwhite, annotfile);
if (err) {
printf("ERROR: MRISreadAnnotation() failed %s\n",annotfile);
exit(1);
}
/* ------ Load subject's rh surface ------ */
sprintf(tmpstr,"%s/%s/surf/rh.white",SUBJECTS_DIR,subject);
printf("Reading rh white surface \n %s\n",tmpstr);
rhwhite = MRISread(tmpstr);
if (rhwhite == NULL) {
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
if (debug) printf("Building hash of rh white\n");
rhwhite_hash = MHTfillVertexTableRes(rhwhite, NULL,CURRENT_VERTICES,16);
/* ------ Load rh annotation ------ */
sprintf(annotfile,"%s/%s/label/rh.aparc.annot",SUBJECTS_DIR,subject);
printf("Loading rh annotations from %s\n",annotfile);
err = MRISreadAnnotation(rhwhite, annotfile);
if (err) {
printf("ERROR: MRISreadAnnotation() failed %s\n",annotfile);
exit(1);
}
if (debug && lhwhite->ct) printf("Have color table for annotation\n");
if (debug) print_annotation_table(stdout);
/* ------ Load ASeg ------ */
sprintf(tmpstr,"%s/%s/mri/aseg.mgz",SUBJECTS_DIR,subject);
if (!fio_FileExistsReadable(tmpstr)) {
sprintf(tmpstr,"%s/%s/mri/aseg.mgh",SUBJECTS_DIR,subject);
if (!fio_FileExistsReadable(tmpstr)) {
sprintf(tmpstr,"%s/%s/mri/aseg/COR-.info",SUBJECTS_DIR,subject);
if (!fio_FileExistsReadable(tmpstr)) {
printf("ERROR: cannot find aseg\n");
exit(1);
} else
sprintf(tmpstr,"%s/%s/mri/aseg/",SUBJECTS_DIR,subject);
}
}
printf("Loading aseg from %s\n",tmpstr);
ASeg = MRIread(tmpstr);
if (ASeg == NULL) {
printf("ERROR: loading aseg %s\n",tmpstr);
exit(1);
}
mritmp = MRIchangeType(ASeg,MRI_INT,0,0,0);
MRIfree(&ASeg);
ASeg = mritmp;
WMSeg = MRIclone(ASeg,NULL);
Vox2RAS = MRIxfmCRS2XYZtkreg(ASeg);
if (debug) {
printf("ASeg Vox2RAS: -----------\n");
MatrixPrint(stdout,Vox2RAS);
printf("-------------------------\n");
}
CRS = MatrixAlloc(4,1,MATRIX_REAL);
CRS->rptr[4][1] = 1;
RAS = MatrixAlloc(4,1,MATRIX_REAL);
RAS->rptr[4][1] = 1;
// Go through each voxel in the aseg
printf("\n");
printf("Labeling WM\n");
for (c=0; c < ASeg->width; c++) {
if (debug) printf("%3d ",c);
if (debug && c%20 ==19) printf("\n");
for (r=0; r < ASeg->height; r++) {
for (s=0; s < ASeg->depth; s++) {
// If it's not labeled as white matter in the aseg, set
// seg value to that from the aseg and skip the rest
asegid = MRIgetVoxVal(ASeg,c,r,s,0);
if (asegid != 2 && asegid != 41) {
MRIsetVoxVal(WMSeg,c,r,s,0,asegid);
continue;
}
// Convert the CRS to RAS
CRS->rptr[1][1] = c;
CRS->rptr[2][1] = r;
CRS->rptr[3][1] = s;
RAS = MatrixMultiply(Vox2RAS,CRS,RAS);
vtx.x = RAS->rptr[1][1];
vtx.y = RAS->rptr[2][1];
vtx.z = RAS->rptr[3][1];
// Get the index of the closest vertex in the
// lh.white, rh.white
lhwvtx = MHTfindClosestVertexNo(lhwhite_hash,lhwhite,&vtx,&dlhw);
rhwvtx = MHTfindClosestVertexNo(rhwhite_hash,rhwhite,&vtx,&drhw);
if ( (lhwvtx < 0) && (rhwvtx < 0) ) {
printf("ERROR: could not map to any surface.\n");
printf("crs = %d %d %d, ras = %6.4f %6.4f %6.4f \n",
c,r,s,vtx.x,vtx.y,vtx.z);
exit(1);
}
if (lhwvtx < 0) dlhw = 1000000000000000.0;
if (rhwvtx < 0) drhw = 1000000000000000.0;
if (dlhw < drhw) {
// Left hemi is closer than the right
annot = lhwhite->vertices[lhwvtx].annotation;
hemioffset = 1000;
if (lhwhite->ct)
CTABfindAnnotation(lhwhite->ct, annot, &annotid);
else
annotid = annotation_to_index(annot);
} else {
// Right hemi is closer than the left
annot = rhwhite->vertices[rhwvtx].annotation;
hemioffset = 2000;
if (rhwhite->ct)
CTABfindAnnotation(lhwhite->ct, annot, &annotid);
else
annotid = annotation_to_index(annot);
}
MRIsetVoxVal(WMSeg,c,r,s,0,annotid+hemioffset);
}
}
}
printf("\nWriting output wmseg to %s\n",WMSegFile);
MRIwrite(WMSeg,WMSegFile);
printf("mri_aparc2wmseg done\n");
return(0);
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs,n,err;
MRIS *SurfReg[100];
MRI *SrcVal, *TrgVal;
char *base;
COLOR_TABLE *ctab=NULL;
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
// Load in surface registrations
for(n=0; n<nsurfs;n++){
printf("%d Loading %s\n",n+1,SurfRegFile[n]);
base = fio_basename(SurfRegFile[n],".tri");
if(strcmp(base,"ic7")==0){
// Have to do it this way to rescale. Need to find a better more robust way.
printf(" reading as ico 7, rescaling radius to 100\n");
SurfReg[n] = ReadIcoByOrder(7, 100);
}
else
SurfReg[n] = MRISread(SurfRegFile[n]);
free(base);
if(SurfReg[n]==NULL) exit(1);
}
// Load in source data
SrcVal = NULL;
if(DoSynthRand) {
if (SynthSeed < 0) SynthSeed = PDFtodSeed();
printf("INFO: synthesizing, seed = %d\n",SynthSeed);
srand48(SynthSeed);
MRIrandn(SrcVal->width, SrcVal->height, SrcVal->depth,
SrcVal->nframes,0, 1, SrcVal);
}
else if(DoSynthOnes != 0) {
printf("INFO: filling input with all 1s\n");
MRIconst(SrcVal->width, SrcVal->height, SrcVal->depth,
SrcVal->nframes, 1, SrcVal);
}
else if(AnnotFile) {
printf("Loading annotation %s\n",AnnotFile);
err = MRISreadAnnotation(SurfReg[0], AnnotFile);
if(err) exit(1);
SrcVal = MRISannotIndex2Seg(SurfReg[0]);
ctab = CTABdeepCopy(SurfReg[0]->ct);
}
else if(LabelFile) {
LABEL *srclabel;
printf("Loading label %s\n",LabelFile);
srclabel = LabelRead(NULL, LabelFile);
if(srclabel == NULL) exit(1);
SrcVal = MRISlabel2Mask(SurfReg[0],srclabel,NULL);
printf(" %d points in input label\n",srclabel->n_points);
LabelFree(&srclabel);
}
else {
printf("Loading %s\n",SrcValFile);
SrcVal = MRIread(SrcValFile);
if(SrcVal==NULL) exit(1);
}
// Apply registration to source
TrgVal = MRISapplyReg(SrcVal, SurfReg, nsurfs, ReverseMapFlag, DoJac, UseHash);
if(TrgVal == NULL) exit(1);
// Save output
if(AnnotFile){
printf("Converting to target annot\n");
err = MRISseg2annot(SurfReg[nsurfs-1],TrgVal,ctab);
if(err) exit(1);
printf("Writing %s\n",TrgValFile);
MRISwriteAnnotation(SurfReg[nsurfs-1], TrgValFile);
}
else if(LabelFile){
LABEL *label;
label = MRISmask2Label(SurfReg[nsurfs-1], TrgVal, 0, 10e-5);
printf(" %d points in output label\n",label->n_points);
err = LabelWrite(label,TrgValFile);
if(err){
printf("ERROR: writing label file %s\n",TrgValFile);
exit(1);
}
LabelFree(&label);
}
else{
printf("Writing %s\n",TrgValFile);
MRIwrite(TrgVal,TrgValFile);
}
printf("mris_apply_reg done\n");
return 0;
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs, nthlabel, n, vtxno, ano, index, nunhit;
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
// Make sure subject exists
sprintf(tmpstr,"%s/%s",SUBJECTS_DIR,subject);
if (!fio_IsDirectory(tmpstr)) {
printf("ERROR: cannot find %s\n",tmpstr);
exit(1);
}
if(AnnotPath == NULL){
// Get path to annot, make sure it does not exist
sprintf(tmpstr,"%s/%s/label/%s.%s.annot",
SUBJECTS_DIR,subject,hemi,AnnotName);
if (fio_FileExistsReadable(tmpstr)) {
printf("ERROR: %s already exists\n",tmpstr);
exit(1);
}
AnnotPath = strcpyalloc(tmpstr);
}
// Read the surf
sprintf(tmpstr,"%s/%s/surf/%s.orig",SUBJECTS_DIR,subject,hemi);
printf("Loading %s\n",tmpstr);
mris = MRISread(tmpstr);
if (mris == NULL) exit(1);
// Set up color table
set_atable_from_ctable(ctab);
mris->ct = ctab;
// Set up something to keep track of nhits
nhits = MRIalloc(mris->nvertices,1,1,MRI_INT);
// Set up something to keep track of max stat for that vertex
if (maxstatwinner) maxstat = MRIalloc(mris->nvertices,1,1,MRI_FLOAT);
// Go thru each label
for (nthlabel = 0; nthlabel < nlabels; nthlabel ++) {
label = LabelRead(subject,LabelFiles[nthlabel]);
if (label == NULL) {
printf("ERROR: reading %s\n",LabelFiles[nthlabel]);
exit(1);
}
index = nthlabel;
if (MapUnhitToUnknown) index ++;
ano = index_to_annotation(index);
printf("%2d %2d %s\n",index,ano,index_to_name(index));
for (n = 0; n < label->n_points; n++) {
vtxno = label->lv[n].vno;
if (vtxno < 0 || vtxno > mris->nvertices) {
printf("ERROR: %s, n=%d, vertex %d out of range\n",
LabelFiles[nthlabel],n,vtxno);
exit(1);
}
if(DoLabelThresh && label->lv[n].stat < LabelThresh) continue;
if (maxstatwinner) {
float stat = MRIgetVoxVal(maxstat,vtxno,0,0,0);
if (label->lv[n].stat < stat) {
if (verbose) {
printf("Keeping prior label for vtxno %d "
"(old_stat=%f > this_stat=%f)\n",
vtxno,stat,label->lv[n].stat);
}
continue;
}
MRIsetVoxVal(maxstat,vtxno,0,0,0,label->lv[n].stat);
}
if (verbose) {
if (MRIgetVoxVal(nhits,vtxno,0,0,0) > 0) {
printf
("WARNING: vertex %d maps to multiple labels! (overwriting)\n",
vtxno);
}
}
MRIsetVoxVal(nhits,vtxno,0,0,0,MRIgetVoxVal(nhits,vtxno,0,0,0)+1);
mris->vertices[vtxno].annotation = ano;
//printf("%5d %2d %2d %s\n",vtxno,segid,ano,index_to_name(segid));
} // label ponts
LabelFree(&label);
}// Label
nunhit = 0;
if (MapUnhitToUnknown) {
printf("Mapping unhit to unknown\n");
for (vtxno = 0; vtxno < mris->nvertices; vtxno++) {
if (MRIgetVoxVal(nhits,vtxno,0,0,0) == 0) {
ano = index_to_annotation(0);
mris->vertices[vtxno].annotation = ano;
nunhit ++;
}
}
printf("Found %d unhit vertices\n",nunhit);
}
if (dilate_label_name)
{
dilate_label_into_unknown(mris, dilate_label_annot) ;
}
printf("Writing annot to %s\n",AnnotPath);
MRISwriteAnnotation(mris, AnnotPath);
if (NHitsFile != NULL) MRIwrite(nhits,NHitsFile);
return 0;
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs,r,c,s,n,segid,err;
double val;
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR == NULL) {
printf("ERROR: SUBJECTS_DIR not defined in environment\n");
exit(1);
}
if (DoDavid) {
printf("Loading David's stat file\n");
nitems = LoadDavidsTable(statfile, &lutindex, &log10p);
}
if (DoSue) {
printf("Loading Sue's stat file\n");
nitems = LoadSuesTable(statfile, datcol1, log10flag, &lutindex, &log10p);
}
if (nitems == 0) {
printf("ERROR: could not find any items in %s\n",statfile);
exit(1);
}
if (annot == NULL) {
seg = MRIread(segfile);
if (seg == NULL) exit(1);
} else {
printf("Constructing seg from annotation\n");
sprintf(tmpstr,"%s/%s/surf/%s.white",SUBJECTS_DIR,subject,hemi);
mris = MRISread(tmpstr);
if (mris==NULL) exit(1);
sprintf(tmpstr,"%s/%s/label/%s.%s.annot",SUBJECTS_DIR,subject,hemi,annot);
err = MRISreadAnnotation(mris, tmpstr);
if (err) exit(1);
seg = MRISannotIndex2Seg(mris);
}
out = MRIallocSequence(seg->width,seg->height,seg->depth,MRI_FLOAT,1);
MRIcopyHeader(seg,out);
for (c=0; c < seg->width; c++) {
//printf("%3d ",c);
//if(c%20 == 19) printf("\n");
fflush(stdout);
for (r=0; r < seg->height; r++) {
for (s=0; s < seg->depth; s++) {
segid = MRIgetVoxVal(seg,c,r,s,0);
val = 0;
if (segid != 0) {
if (annot != NULL) {
if (strcmp(hemi,"lh")==0) segid = segid + 1000;
if (strcmp(hemi,"rh")==0) segid = segid + 2000;
MRIsetVoxVal(seg,c,r,s,0,segid);
}
for (n=0; n < nitems; n++) {
if (lutindex[n] == segid) {
val = log10p[n];
break;
}
}
}
MRIsetVoxVal(out,c,r,s,0,val);
}
}
}
printf("\n");
MRIwrite(out,outfile);
MRIwrite(seg,"segtmp.mgh");
printf("mri_stats2seg done\n");
return 0;
}
