/*---------------------------------------------------------------*/
int main(int argc, char **argv)
{
int c,r,s,f;
double val,rval;
FILE *fp;
MRI *mritmp;
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
/* assign default geometry */
cdircos[0] = 1.0;
cdircos[1] = 0.0;
cdircos[2] = 0.0;
rdircos[0] = 0.0;
rdircos[1] = 1.0;
rdircos[2] = 0.0;
sdircos[0] = 0.0;
sdircos[1] = 0.0;
sdircos[2] = 1.0;
res[0] = 1.0;
res[1] = 1.0;
res[2] = 1.0;
cras[0] = 0.0;
cras[1] = 0.0;
cras[2] = 0.0;
res[3] = 2.0; /* TR */
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
dump_options(stdout);
if(tempid != NULL) {
printf("INFO: reading template header\n");
if(! DoCurv) mritemp = MRIreadHeader(tempid,tempfmtid);
else mritemp = MRIread(tempid);
if (mritemp == NULL) {
printf("ERROR: reading %s header\n",tempid);
exit(1);
}
if(NewVoxSizeSpeced){
dim[0] = round(mritemp->width*mritemp->xsize/res[0]);
dim[1] = round(mritemp->height*mritemp->ysize/res[1]);
dim[2] = round(mritemp->depth*mritemp->zsize/res[2]);
dim[3] = mritemp->nframes;
res[3] = mritemp->tr;
dimSpeced = 1;
}
if(dimSpeced){
mritmp = MRIallocSequence(dim[0],dim[1],dim[2],MRI_FLOAT,dim[3]);
MRIcopyHeader(mritemp,mritmp);
MRIfree(&mritemp);
mritemp = mritmp;
}
if(resSpeced){
mritemp->xsize = res[0];
mritemp->ysize = res[1];
mritemp->zsize = res[2];
mritemp->tr = res[3];
}
dim[0] = mritemp->width;
dim[1] = mritemp->height;
dim[2] = mritemp->depth;
if (nframes > 0) dim[3] = nframes;
else dim[3] = mritemp->nframes;
mritemp->nframes = dim[3];
}
if(mritemp) {
if(SpikeTP >= mritemp->nframes){
printf("ERROR: SpikeTP = %d >= mritemp->nframes = %d\n",
SpikeTP,mritemp->nframes);
exit(1);
}
}
printf("Synthesizing\n");
srand48(seed);
if (strcmp(pdfname,"gaussian")==0)
mri = MRIrandn(dim[0], dim[1], dim[2], dim[3], gausmean, gausstd, NULL);
else if (strcmp(pdfname,"uniform")==0)
mri = MRIdrand48(dim[0], dim[1], dim[2], dim[3], 0, 1, NULL);
else if (strcmp(pdfname,"const")==0)
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], ValueA, NULL);
else if (strcmp(pdfname,"sphere")==0) {
if(voxradius < 0)
voxradius =
sqrt( pow(dim[0]/2.0,2)+pow(dim[1]/2.0,2)+pow(dim[2]/2.0,2) )/2.0;
printf("voxradius = %lf\n",voxradius);
mri = MRIsphereMask(dim[0], dim[1], dim[2], dim[3],
dim[0]/2.0, dim[1]/2.0, dim[2]/2.0,
voxradius, ValueA, NULL);
} else if (strcmp(pdfname,"delta")==0) {
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], delta_off_value, NULL);
if (delta_crsf_speced == 0) {
delta_crsf[0] = dim[0]/2;
delta_crsf[1] = dim[1]/2;
delta_crsf[2] = dim[2]/2;
delta_crsf[3] = dim[3]/2;
}
printf("delta set to %g at %d %d %d %d\n",delta_value,delta_crsf[0],
delta_crsf[1],delta_crsf[2],delta_crsf[3]);
MRIFseq_vox(mri,
delta_crsf[0],
delta_crsf[1],
delta_crsf[2],
delta_crsf[3]) = delta_value;
} else if (strcmp(pdfname,"chi2")==0) {
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("chi2");
rfs->params[0] = dendof;
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
printf("Synthesizing chi2 with dof=%d\n",dendof);
RFsynth(mri,rfs,NULL);
} else if (strcmp(pdfname,"z")==0) {
printf("Synthesizing z \n");
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("gaussian");
rfs->params[0] = 0; // mean
rfs->params[1] = 1; // std
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
} else if (strcmp(pdfname,"t")==0) {
printf("Synthesizing t with dof=%d\n",dendof);
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("t");
rfs->params[0] = dendof;
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
} else if (strcmp(pdfname,"tr")==0) {
printf("Synthesizing t with dof=%d as ratio of z/sqrt(chi2)\n",dendof);
rfs = RFspecInit(seed,NULL);
// numerator
rfs->name = strcpyalloc("gaussian");
rfs->params[0] = 0; // mean
rfs->params[1] = 1; // std
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
// denominator
rfs->name = strcpyalloc("chi2");
rfs->params[0] = dendof;
mri2 = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri2,rfs,NULL);
fMRIsqrt(mri2,mri2); // sqrt of chi2
mri = MRIdivide(mri,mri2,mri);
MRIscalarMul(mri, mri, sqrt(dendof)) ;
MRIfree(&mri2);
} else if (strcmp(pdfname,"F")==0) {
printf("Synthesizing F with num=%d den=%d\n",numdof,dendof);
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("F");
rfs->params[0] = numdof;
rfs->params[1] = dendof;
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
} else if (strcmp(pdfname,"Fr")==0) {
printf("Synthesizing F with num=%d den=%d as ratio of two chi2\n",
numdof,dendof);
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("chi2");
// numerator
rfs->params[0] = numdof;
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
// denominator
rfs->params[0] = dendof;
mri2 = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri2,rfs,NULL);
mri = MRIdivide(mri,mri2,mri);
MRIscalarMul(mri, mri, (double)dendof/numdof) ;
MRIfree(&mri2);
} else if (strcmp(pdfname,"voxcrs")==0) {
// three frames. 1st=col, 2nd=row, 3rd=slice
printf("Filling with vox CRS\n");
mri = MRIconst(dim[0], dim[1], dim[2], 3, 0, NULL);
for(c=0; c < mri->width; c ++){
for(r=0; r < mri->height; r ++){
for(s=0; s < mri->depth; s ++){
MRIsetVoxVal(mri,c,r,s,0,c);
MRIsetVoxVal(mri,c,r,s,1,r);
MRIsetVoxVal(mri,c,r,s,2,s);
}
}
}
} else if (strcmp(pdfname,"boundingbox")==0) {
printf("Setting bounding box \n");
if(mritemp == NULL)
mritemp = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
mri = MRIsetBoundingBox(mritemp,&boundingbox,ValueA,ValueB);
if(!mri) exit(1);
}
else if (strcmp(pdfname,"checker")==0) {
printf("Checker \n");
mri=MRIchecker(mritemp,NULL);
if(!mri) exit(1);
}
else if (strcmp(pdfname,"sliceno")==0) {
printf("SliceNo \n");
if(mritemp == NULL){
printf("ERROR: need --temp with sliceno\n");
exit(1);
}
mri=MRIsliceNo(mritemp,NULL);
if(!mri) exit(1);
}
else if (strcmp(pdfname,"indexno")==0) {
printf("IndexNo \n");
if(mritemp == NULL){
printf("ERROR: need --temp with indexno\n");
exit(1);
}
mri=MRIindexNo(mritemp,NULL);
if(!mri) exit(1);
}
else if (strcmp(pdfname,"crs")==0) {
printf("CRS \n");
if(mritemp == NULL){
printf("ERROR: need --temp with crs\n");
exit(1);
}
mri=MRIcrs(mritemp,NULL);
if(!mri) exit(1);
}
else {
printf("ERROR: pdf %s unrecognized, must be gaussian, uniform,\n"
"const, delta, checker\n", pdfname);
exit(1);
}
if (tempid != NULL) {
MRIcopyHeader(mritemp,mri);
mri->type = MRI_FLOAT;
// Override
if(nframes > 0) mri->nframes = nframes;
if(TR > 0) mri->tr = TR;
} else {
if(mri == NULL) {
usage_exit();
}
mri->xsize = res[0];
mri->ysize = res[1];
mri->zsize = res[2];
mri->tr = res[3];
mri->x_r = cdircos[0];
mri->x_a = cdircos[1];
mri->x_s = cdircos[2];
mri->y_r = rdircos[0];
mri->y_a = rdircos[1];
mri->y_s = rdircos[2];
mri->z_r = sdircos[0];
mri->z_a = sdircos[1];
mri->z_s = sdircos[2];
if(!usep0){
mri->c_r = cras[0];
mri->c_a = cras[1];
mri->c_s = cras[2];
}
else MRIp0ToCRAS(mri, p0[0], p0[1], p0[2]);
}
if (gstd > 0) {
if(!UseFFT){
printf("Smoothing\n");
MRIgaussianSmooth(mri, gstd, gmnnorm, mri); /* gmnnorm = 1 = normalize */
}
else {
printf("Smoothing with FFT \n");
mri2 = MRIcopy(mri,NULL);
mri = MRI_fft_gaussian(mri2, mri,
gstd, gmnnorm); /* gmnnorm = 1 = normalize */
}
if (rescale) {
printf("Rescaling\n");
if (strcmp(pdfname,"z")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"chi2")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"t")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"tr")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"F")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"Fr")==0) RFrescale(mri,rfs,NULL,mri);
}
}
if(DoHSC){
// This multiplies each frame by a random number
// between HSCMin HSCMax to simulate heteroscedastisity
printf("Applying HSC %lf %lf\n",HSCMin,HSCMax);
for(f=0; f < mri->nframes; f++){
rval = (HSCMax-HSCMin)*drand48() + HSCMin;
if(debug) printf("%3d %lf\n",f,rval);
for(c=0; c < mri->width; c ++){
for(r=0; r < mri->height; r ++){
for(s=0; s < mri->depth; s ++){
val = MRIgetVoxVal(mri,c,r,s,f);
MRIsetVoxVal(mri,c,r,s,f,rval*val);
}
}
}
}
}
if(AddOffset) {
printf("Adding offset\n");
offset = MRIread(tempid);
if(offset == NULL) exit(1);
if(OffsetFrame == -1) OffsetFrame = nint(offset->nframes/2);
printf("Offset frame %d\n",OffsetFrame);
mritmp = fMRIframe(offset, OffsetFrame, NULL);
if(mritmp == NULL) exit(1);
MRIfree(&offset);
offset = mritmp;
fMRIaddOffset(mri, offset, NULL, mri);
}
if(SpikeTP > 0){
printf("Spiking time point %d\n",SpikeTP);
for(c=0; c < mri->width; c ++){
for(r=0; r < mri->height; r ++){
for(s=0; s < mri->depth; s ++){
MRIsetVoxVal(mri,c,r,s,SpikeTP,1e9);
}
}
}
}
if(DoAbs){
printf("Computing absolute value\n");
MRIabs(mri,mri);
}
if(!NoOutput){
printf("Saving\n");
if(!DoCurv) MRIwriteAnyFormat(mri,volid,volfmt,-1,NULL);
else {
printf("Saving in curv format\n");
MRIScopyMRI(surf, mri, 0, "curv");
MRISwriteCurvature(surf,volid);
}
}
if(sum2file){
val = MRIsum2All(mri);
fp = fopen(sum2file,"w");
if(fp == NULL){
printf("ERROR: opening %s\n",sum2file);
exit(1);
}
printf("sum2all: %20.10lf\n",val);
printf("vrf: %20.10lf\n",1/val);
fprintf(fp,"%20.10lf\n",val);
}
return(0);
}
/*---------------------------------------------------------*/
int main(int argc, char **argv) {
int n,err, f, nhits, r,c,s;
float ipr, bpr, intensity;
float *framepower=NULL, val;
LTA *lta;
int nargs;
//int endian,roitype;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_vol2roi.c,v 1.32 2011/03/02 00:04:25 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
printf("--------------------------------------------------------\n");
getcwd(tmpstr,2000);
printf("%s\n",tmpstr);
printf("%s\n",Progname);
for (n=0;n<argc;n++) printf(" %s",argv[n]);
printf("\n");
printf("version %s\n",vcid);
printf("--------------------------------------------------------\n");
dump_options(stdout);
/* --------- load in the (possibly 4-D) source volume --------------*/
printf("Loading volume %s ...",srcvolid);
mSrcVol = MRIread(srcvolid);
if(mSrcVol == NULL) exit(1);
printf("done\n");
/* Dsrc: read the source registration file */
if (srcregfile != NULL) {
err = regio_read_register(srcregfile, &srcsubject, &ipr, &bpr,
&intensity, &Dsrc, &float2int_src);
if (err) exit(1);
printf("srcreg Dsrc -------------\n");
MatrixPrint(stdout,Dsrc);
printf("----------------------------------\n");
} else Dsrc = NULL;
/* Wsrc: Get the source warping Transform */
Wsrc = NULL;
/* Fsrc: Get the source FOV registration matrix */
Fsrc = NULL;
/* Qsrc: Compute the quantization matrix for src volume */
Qsrc = FOVQuantMatrix(mSrcVol->width, mSrcVol->height, mSrcVol->depth,
mSrcVol->xsize, mSrcVol->ysize, mSrcVol->zsize);
printf("ras2vox src (tkreg) Qsrc -------------\n");
MatrixPrint(stdout,Qsrc);
printf("----------------------------------\n");
/* ----------- load in the label ----------------- */
if (labelfile != NULL) {
Label = LabelReadFile(labelfile);
if (Label == NULL) exit(1);
/* load in the source-to-label registration */
if (src2lblregfile != NULL) {
//err = regio_read_xfm(src2lblregfile, &Msrc2lbl);
//if(err) exit(1);
lta = LTAread(src2lblregfile);
if (lta->type == LINEAR_VOX_TO_VOX) {
printf("INFO: converting LTA to RAS\n");
LTAvoxelTransformToCoronalRasTransform(lta);
}
Msrc2lbl = MatrixCopy(lta->xforms[0].m_L,NULL);
} else if (labeltal) {
/* Load the talairach.xfm and make it approp for reg.dat*/
Msrc2lbl = DevolveXFM(srcsubject,NULL,talxfm);
if (Msrc2lbl==NULL) exit(1);
} else Msrc2lbl = NULL;
if (Msrc2lbl != NULL) {
printf("-- Source2Label %s ---- \n",src2lblregfile);
MatrixPrint(stdout,Msrc2lbl);
printf("-------------------------------\n");
}
} else {
Label = NULL;
Msrc2lbl = NULL;
}
/* -------------- load mask volume stuff -----------------------------*/
if (mskvolid != NULL) {
/* load the mask volume (single frame) */
printf("Reading %s\n",mskvolid);
mMskVol = MRIread(mskvolid);
if(mMskVol == NULL) exit(1);
if(mskframe > 0){
mritmp = fMRIframe(mMskVol, mskframe, NULL);
if(mritmp == NULL) exit(1);
MRIfree(&mMskVol);
mMskVol = mritmp;
}
/* Qmsk: Compute the quantization matrix for msk volume */
/* crsFOV = Qmsk*xyzFOV */
Qmsk = FOVQuantMatrix(mMskVol->width, mMskVol->height, mMskVol->depth,
mMskVol->xsize, mMskVol->ysize, mMskVol->zsize);
/* get the mask2source registration information */
/* xyzSrc = Mmsk2src * xyzMsk */
if (msk2srcregfile != NULL) {
err = regio_read_mincxfm(msk2srcregfile, &Mmsk2src, NULL);
if (err) exit(1);
} else Mmsk2src = NULL;
/* convert from Mask Anatomical to Src FOV */
if (!msksamesrc) {
mSrcMskVol = vol2vol_linear(mMskVol, Qmsk, NULL, NULL, Dmsk,
Qsrc, Fsrc, Wsrc, Dsrc,
mSrcVol->height, mSrcVol->width, mSrcVol->depth,
Mmsk2src, INTERP_NEAREST, float2int_msk);
if (mSrcMskVol == NULL) exit(1);
} else mSrcMskVol = mMskVol;
/* binarize the mask volume */
mri_binarize(mSrcMskVol, mskthresh, msktail, mskinvert,
mSrcMskVol, &nmskhits);
} else {
mSrcMskVol = NULL;
nmskhits = 0;
}
/*-------------- Done loading mask stuff -------------------------*/
/* If this is a statistical volume, raise each frame to it's appropriate
power (eg, stddev needs to be squared)*/
if (is_sxa_volume(srcvolid)) {
printf("INFO: Source volume detected as selxavg format\n");
sxa = ld_sxadat_from_stem(srcvolid);
if (sxa == NULL) exit(1);
framepower = sxa_framepower(sxa,&f);
if (f != mSrcVol->nframes) {
fprintf(stderr," number of frames is incorrect (%d,%d)\n",
f,mSrcVol->nframes);
exit(1);
}
printf("INFO: Adjusting Frame Power\n");
fflush(stdout);
mri_framepower(mSrcVol,framepower);
}
/*--------- Prepare the final mask ------------------------*/
if (Label != NULL) {
mFinalMskVol = label2mask_linear(mSrcVol, Qsrc, Fsrc, Wsrc,
Dsrc, mSrcMskVol,
Msrc2lbl, Label, labelfillthresh, float2int_src,
&nlabelhits, &nfinalhits);
if (mFinalMskVol == NULL) exit(1);
} else {
mFinalMskVol = mSrcMskVol;
nfinalhits = nmskhits;
}
if (!oldtxtstyle) {
/* count the number of functional voxels = 1 in the mask */
nfinalhits = 0;
for (r=0;r<mFinalMskVol->height;r++) {
for (c=0;c<mFinalMskVol->width;c++) {
for (s=0;s<mFinalMskVol->depth;s++) {
val = MRIgetVoxVal(mFinalMskVol,c,r,s,0);
if (val > 0.5) nfinalhits ++;
}
}
}
if (Label != NULL)
nlabelhits = CountLabelHits(mSrcVol, Qsrc, Fsrc,
Wsrc, Dsrc, Msrc2lbl,
Label, labelfillthresh,float2int_src);
else nlabelhits = 0;
}
/*-------------------------------------------------------*/
/*--------- Map the volume into the ROI -----------------*/
printf("Averging over ROI\n");
fflush(stdout);
mROI = vol2maskavg(mSrcVol, mFinalMskVol,&nhits);
if (mROI == NULL) exit(1);
printf("Done averging over ROI (nhits = %d)\n",nhits);
/*-------------------------------------------------------*/
/* ------- Save the final mask ------------------ */
if (finalmskvolid != 0) {
//mri_save_as_bvolume(mFinalMskVol,finalmskvolid,endian,BF_FLOAT);
//MRIwriteAnyFormat(mFinalMskVol,finalmskvolid,"bfloat",-1,NULL);
sprintf(tmpstr,"%s.%s",finalmskvolid,outext);
MRIwrite(mFinalMskVol,tmpstr);
}
/* ------- Save CRS of the the final mask ------------------ */
if (finalmskcrs != NULL) {
fp = fopen(finalmskcrs,"w");
if (fp==NULL) {
fprintf(stderr,"ERROR: cannot open %s\n",finalmskcrs);
exit(1);
}
for (r=0;r<mFinalMskVol->height;r++) {
for (c=0;c<mFinalMskVol->width;c++) {
for (s=0;s<mFinalMskVol->depth;s++) {
val = MRIgetVoxVal(mFinalMskVol,c,r,s,0);
if (val > 0.5) {
fprintf(fp,"%d %d %d\n",c,r,s);
}
}
}
}
fclose(fp);
}
/* If this is a statistical volume, lower each frame to it's appropriate
power (eg, variance needs to be sqrt'ed) */
if (is_sxa_volume(srcvolid)) {
printf("INFO: Readjusting Frame Power\n");
fflush(stdout);
for (f=0; f < mROI->nframes; f++) framepower[f] = 1.0/framepower[f];
mri_framepower(mROI,framepower);
}
/* save the target volume in an appropriate format */
if(roifile != NULL){
sprintf(tmpstr,"%s.%s",roifile,outext);
MRIwrite(mROI,tmpstr);
/* for a stat volume, save the .dat file */
if (is_sxa_volume(srcvolid)) {
sxa->nrows = 1;
sxa->ncols = 1;
sv_sxadat_by_stem(sxa,roifile);
}
}
/* save as text */
if(roitxtfile != NULL) {
fp = fopen(roitxtfile,"w");
if (fp==NULL) {
fprintf(stderr,"ERROR: cannot open %s\n",roitxtfile);
exit(1);
}
if (oldtxtstyle) {
printf("INFO: saving as old style txt\n");
fprintf(fp,"%d \n",nmskhits);
}
if (! plaintxtstyle ) {
fprintf(fp,"%d \n",nlabelhits);
fprintf(fp,"%d \n",nfinalhits);
}
for (f=0; f < mROI->nframes; f++)
fprintf(fp,"%f\n",MRIgetVoxVal(mROI,0,0,0,f));
fclose(fp);
}
/* ------- Mask the source and save it ------------------ */
if (srcmskvolid != 0) {
for (r=0;r<mFinalMskVol->height;r++) {
for (c=0;c<mFinalMskVol->width;c++) {
for (s=0;s<mFinalMskVol->depth;s++) {
val = MRIgetVoxVal(mFinalMskVol,c,r,s,0);
if (val < 0.5) {
for (f=0; f < mROI->nframes; f++)
MRIFseq_vox(mSrcVol,c,r,s,f) = 0.0;
}
}
}
}
MRIwrite(mSrcVol,srcmskvolid);
}
/* ------- Save as a text list ------------------ */
if (ListFile != 0) {
fp = fopen(ListFile,"w");
for (c=0;c<mFinalMskVol->width;c++) {
for (r=0;r<mFinalMskVol->height;r++) {
for (s=0;s<mFinalMskVol->depth;s++) {
val = MRIFseq_vox(mFinalMskVol,c,r,s,0);
if(val < 0.5) continue;
fprintf(fp,"%3d %3d %3d ",c,r,s);
for (f=0; f < mROI->nframes; f++){
val = MRIgetVoxVal(mSrcVol,c,r,s,f);
fprintf(fp,"%f ",val);
}
fprintf(fp,"\n");
}
}
}
fclose(fp);
}
return(0);
}
