/* static LTA *ltaReadFileEx(const char *fname)
{
FILE *fp;
LINEAR_TRANSFORM *lt ;
int i, nxforms, type ;
char line[STRLEN], *cp ;
LTA *lta ;
fp = fopen(fname,"r");
if (fp==NULL)
ErrorReturn(NULL,
(ERROR_BADFILE, "ltaReadFile(%s): can't open file",fname));
cp = fgetl(line, 199, fp) ;
if (cp == NULL)
{
fclose(fp) ;
ErrorReturn(NULL,
(ERROR_BADFILE, "ltaReadFile(%s): can't read data",fname));
}
sscanf(cp, "type = %d\n", &type) ;
cp = fgetl(line, 199, fp) ;
sscanf(cp, "nxforms = %d\n", &nxforms) ;
lta = LTAalloc(nxforms, NULL) ;
lta->type = type ;
for (i = 0 ; i < lta->num_xforms ; i++)
{
lt = <a->xforms[i] ;
fscanf(fp, "mean = %f %f %f\n", <->x0, <->y0, <->z0) ;
fscanf(fp, "sigma = %f\n", <->sigma) ;
MatrixAsciiReadFrom(fp, lt->m_L) ;
}
// oh, well this is the added part
for (i=0; i < lta->num_xforms; i++)
{
if (fgets(line, 199, fp))
{
if (strncmp(line, "src volume info", 15)==0)
{
char *p;
readVolGeom(fp, <a->xforms[i].src);
p = fgets(line, 199, fp);
if (strncmp(line, "dst volume info", 15)==0)
readVolGeom(fp, <a->xforms[i].dst);
}
}
}
fclose(fp) ;
return(lta) ;
}
*/
static int
get_option(int argc, char *argv[])
{
int nargs = 0 ;
char *option ;
option = argv[1] + 1 ; /* past '-' */
if (!stricmp(option, "help"))
{
usage(0) ;
}
else if (!stricmp(option, "invert1"))
{
invert1 = 1;
fprintf(stderr, "invert the first LTA before applying it \n");
}
else if (!stricmp(option, "out_type"))
{
out_type = atoi(argv[2]) ;
nargs = 1;
fprintf(stderr, "set final LTA type to %d\n", out_type);
}
else if (!stricmp(option, "tal"))
{
tal_src_file = argv[2];
tal_dst_file = argv[3];
nargs = 2;
fprintf(stderr, "Talairach xfrm src file is %s\n", tal_src_file);
fprintf(stderr, "Talairach xfrm dst file is %s\n", tal_dst_file);
tal_src = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN);
if (!tal_src)
{
ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]);
}
tal_dst = MRIreadHeader(argv[3], MRI_VOLUME_TYPE_UNKNOWN);
if (!tal_dst)
{
ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[3]);
}
}
else if (!stricmp(option, "invert2"))
{
invert2 = 1;
fprintf(stderr, "invert the second LTA before applying it \n");
}
else
{
fprintf(stderr, "unknown option %s\n", argv[1]) ;
usage(1) ;
exit(1) ;
}
return(nargs) ;
}
/*----------------------------------------------------------------------
Parameters:
Description:
----------------------------------------------------------------------*/
static int
get_option(int argc, char *argv[])
{
int nargs = 0 ;
char *option ;
option = argv[1] + 1 ; /* past '-' */
if (!stricmp(option, "debug_voxel"))
{
Gx = atoi(argv[2]) ;
Gy = atoi(argv[3]) ;
Gz = atoi(argv[4]) ;
debug_flag = 1;
nargs = 3 ;
printf("debugging voxel (%d, %d, %d)...\n", Gx, Gy, Gz) ;
}
else if (!stricmp(option, "scaling"))
{
scale = atof(argv[2]);
nargs = 1;
printf("scale input by %g\n", scale);
}
else if (!stricmp(option, "low"))
{
thred_low = atof(argv[2]);
nargs = 1;
printf("Lower threshold for histogram scaling is %g\n", thred_low);
}
else if (!stricmp(option, "high"))
{
thred_high = atof(argv[2]);
nargs = 1;
printf("Higher threshold for histogram scaling is %g\n", thred_high);
}
else if (!stricmp(option, "noscale"))
{
noscale = 1;
printf("do not do histogram scaling at output stage\n");
}
else if (!stricmp(option, "autoscale"))
{
autoscale = 1;
printf("automatically scale output volume histo peak to 110 \n");
}
else if (!stricmp(option, "out_type"))
{
out_type = atoi(argv[2]);
nargs = 1;
printf("Output type is %d\n", out_type);
}
else if (!stricmp(option, "out_like") ||
!stricmp(option, "like"))
{
out_like_fname = argv[2];
nargs = 1;
printf("Shape the output like the volume in file %s\n", out_like_fname);
}
else if (!stricmp(option, "transform") ||
!stricmp(option, "at"))
{
transform_fname = argv[2];
transform_flag = 1;
nargs = 1;
printf("Apply transformation specified by file %s\n", transform_fname);
}
else if (!stricmp(option, "lta_src") ||
!stricmp(option, "src")
)
{
fprintf(stderr, "src volume for the given transform (given by -xform) is %s\n",argv[2]);
fprintf(stderr, "Reading the src volume...\n");
lta_src = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN);
if (!lta_src)
{
ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]);
}
nargs = 1;
}
else if (!stricmp(option, "lta_dst") ||
!stricmp(option, "dst")
)
{
fprintf(stderr, "dst volume for the transform (given by -xform) is %s\n",argv[2]);
fprintf(stderr, "Reading the dst volume...\n");
lta_dst = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN);
if (!lta_dst)
{
ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]);
}
nargs = 1;
}
else if (!stricmp(option, "invert_transform") ||
!stricmp(option, "ait"))
{
transform_fname = argv[2];
transform_flag = 1;
invert_flag = 1;
nargs = 1;
printf("Apply inversely the transformation specified by file %s\n", transform_fname);
}
/*E* Interpolation method. Default is trilinear, other options are
nearest, cubic, sinc. You can say -foo or -interp foo. For sinc,
you can say -interp sinc 3 or -interp sinc -hw 3 or -sinc 3 or
-sinc -hw 3. Maybe -hw 3 should imply sinc, but right now it
doesn't. */
else if (!stricmp(option, "st") ||
!stricmp(option, "sample") ||
!stricmp(option, "sample_type") ||
!stricmp(option, "interp"))
{
nargs = 1;
if (!stricmp(argv[2], "bspline"))
InterpMethod = SAMPLE_BSPLINE;
else
InterpMethod = MRIinterpCode(argv[2]) ;
if (InterpMethod==SAMPLE_SINC)
{
if ((argc<4) || !strncmp(argv[3],"-",1)) /*E* i.e. no sinchalfwindow value supplied */
{
printf("using sinc interpolation (default windowwidth is 6)\n");
}
else
{
sinchalfwindow = atoi(argv[3]);
nargs = 2;
printf("using sinc interpolation with windowwidth of %d\n", 2*sinchalfwindow);
}
}
else if (InterpMethod == SAMPLE_BSPLINE)
{
if ((argc<4) || !strncmp(argv[3],"-",1)) /* i.e. no spline-degree value supplied */
{
printf("using BSPline interpolation (default Bspline degree is 3)\n");
}
else
{
SplineDegree = atoi(argv[3]);
nargs = 2;
printf("using BSpline interpolation with degree of %d\n", SplineDegree);
}
}
}
else if (!stricmp(option, "sinc"))
{
InterpMethod = SAMPLE_SINC;
if ((argc<3) || !strncmp(argv[2],"-",1)) /*E* i.e. no sinchalfwindow value supplied */
{
printf("using sinc interpolation (default windowwidth is 6)\n");
}
else
{
sinchalfwindow = atoi(argv[2]);
nargs = 1;
printf("using sinc interpolation with windowwidth of %d\n", 2*sinchalfwindow);
}
}
else if (!stricmp(option, "bspline"))
{
InterpMethod = SAMPLE_BSPLINE;
if ((argc<3) || !strncmp(argv[2],"-",1)) /*E* i.e. no spline degree supplied */
{
printf("using cubic-bspline interpolation \n");
}
else
{
SplineDegree = atoi(argv[2]);
nargs = 1;
printf("using B-spline interpolation with degree of %d\n", SplineDegree);
}
}
else if (!stricmp(option, "sinchalfwindow") ||
!stricmp(option, "hw"))
{
InterpMethod = SAMPLE_SINC;
sinchalfwindow = atoi(argv[2]);
nargs = 1;
printf("using sinc interpolation with windowwidth of %d\n", 2*sinchalfwindow);
}
else if (!stricmp(option, "trilinear"))
{
InterpMethod = SAMPLE_TRILINEAR;
printf("using trilinear interpolation\n");
}
else if (!stricmp(option, "cubic"))
{
InterpMethod = SAMPLE_CUBIC;
printf("using cubic interpolation\n");
}
else if (!stricmp(option, "nearest"))
{
InterpMethod = SAMPLE_NEAREST;
printf("using nearest-neighbor interpolation\n");
}
else switch (toupper(*option))
{
case '?':
case 'U':
usage_exit(0) ;
break ;
default:
printf("unknown option %s\n", argv[1]) ;
exit(1) ;
break ;
}
return(nargs) ;
}
int
main(int argc, char *argv[]) {
char **av, *avg_surf_name, *canon_surf_name, fname[STRLEN],
*mdir, ico_fname[STRLEN], *hemi, *out_sname ;
int ac, nargs, i, vno, n ;
VERTEX *v ;
MRI_SURFACE *mris_ico ;
MRI_SP *mrisp_total ;
LTA *lta ;
VOL_GEOM vg;
float average_surface_area = 0.0 ;
MATRIX *XFM=NULL;
GCA_MORPH *gcam=NULL;
memset((void *) &vg, 0, sizeof (VOL_GEOM));
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mris_make_average_surface.c,v 1.29 2011/03/02 00:04:33 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
mdir = getenv("FREESURFER_HOME") ;
if (!mdir)
ErrorExit(ERROR_BADPARM,
"%s: no FREESURFER_HOME in environment.\n",Progname);
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (sdir == NULL) {
sdir = getenv("SUBJECTS_DIR");
if (!sdir)
ErrorExit(ERROR_BADPARM,
"%s: no SUBJECTS_DIR in environment.\n",Progname);
}
if (sdirout == NULL) sdirout = sdir;
if (argc < 6) usage_exit() ;
hemi = argv[1] ;
avg_surf_name = argv[2] ;
canon_surf_name = argv[3] ;
out_sname = argv[4] ;
printf("---------------------------------------------------\n");
printf("hemi = %s\n",hemi);
printf("avg_surf_name = %s\n",avg_surf_name);
printf("canon_surf_name = %s\n",canon_surf_name);
printf("out_sname = %s\n",out_sname);
printf("xform = %s\n",xform_name);
printf("---------------------------------------------------\n");
printf("\n\n");
fflush(stdout);
#define SCALE 1
mrisp_total = MRISPalloc(SCALE, 3) ;
for (n = 0, i = 5 ; i < argc ; i++) {
MRI *mri;
MRI_SURFACE *mris;
MRI_SP *mrisp;
printf("\n---------------------------------------------------\n");
printf("#@# processing subject %d/%d %s...\n", i-4,argc-5,argv[i]) ;
fflush(stdout);
// read sphere.reg
sprintf(fname, "%s/%s/surf/%s.%s", sdir, argv[i], hemi, canon_surf_name) ;
printf(" Reading %s\n",fname);
fflush(stdout);
mris = MRISread(fname) ;
if (!mris) {
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
exit(1);
}
// get "pial" surface vertex into ->origx, origy, origz
if (MRISreadOriginalProperties(mris, orig_name) != NO_ERROR)
ErrorExit(ERROR_BADFILE,"%s: could not read orig file for %s.\n",
Progname, argv[1]);
// read transform
if (0) {
sprintf(fname, "%s/%s/mri/transforms/%s", sdir, argv[i], xform_name) ;
lta = LTAreadEx(fname) ;
if (!lta)
ErrorExit(ERROR_BADPARM,
"%s: could not read transform from %s", Progname, fname) ;
}
// read T1 volume
sprintf(fname, "%s/%s/mri/T1.mgz", sdir, argv[i]) ;
if (fio_FileExistsReadable(fname)) mri = MRIreadHeader(fname,MRI_MGH_FILE);
else {
sprintf(fname, "%s/%s/mri/T1", sdir, argv[i]) ;
mri = MRIreadHeader(fname, MRI_UCHAR); // MRI_CORONAL_SLICE_DIRECTORY) ;
}
printf(" Read %s\n",fname);
fflush(stdout);
if (!mri)
ErrorExit(ERROR_BADPARM,
"%s: could not read reference MRI volume from %s",
Progname, fname) ;
// save current vertex position into ->cx
MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ;
// get the vertex position from ->origx, ...
// (get the "pial" vertex position)
MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ;
MRIScomputeMetricProperties(mris) ;
printf(" Surface area: %2.1f cm^2\n", mris->total_area/100) ;
fflush(stdout);
average_surface_area += mris->total_area ;
// this means that we transform "pial" surface
if (xform_name)
{
if (!strcmp(xform_name,"talairach.xfm")) {
printf(" Applying linear transform\n");
fflush(stdout);
XFM = DevolveXFMWithSubjectsDir(argv[i], NULL, "talairach.xfm", sdir);
if (XFM == NULL) exit(1);
MRISmatrixMultiply(mris, XFM);
MatrixFree(&XFM);
} else if (!strcmp(xform_name,"talairach.m3z")) {
printf(" Applying GCA Morph\n");
fflush(stdout);
sprintf(fname, "%s/%s/mri/transforms/talairach.m3z", sdir, argv[i]) ;
gcam = GCAMreadAndInvert(fname);
if (gcam == NULL) exit(1);
GCAMmorphSurf(mris, gcam);
GCAMfree(&gcam);
} else {
printf("ERROR: don't know what to do with %s\n",xform_name);
exit(1);
}
}
// save transformed position in ->orig
// (store "pial" vertices position in orig)
MRIScomputeMetricProperties(mris) ;
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
// get the vertex position from ->cx
// (note that this is not transformed) sphere.reg vertices
MRISrestoreVertexPositions(mris, CANONICAL_VERTICES) ;
// mris contains sphere.reg in vertex and pial vertices in orig
// map to a theta-phi space and accumulate values
mrisp = MRIScoordsToParameterization(mris, NULL, SCALE, ORIGINAL_VERTICES) ;
MRISPaccumulate(mrisp, mrisp_total, 0) ;
MRISPaccumulate(mrisp, mrisp_total, 1) ;
MRISPaccumulate(mrisp, mrisp_total, 2) ;
MRISPfree(&mrisp) ;
MRISfree(&mris) ;
MRIfree(&mri) ;
//LTAfree(<a) ;
fflush(stdout);
n++ ;
}
printf("Finished loading all data\n");
average_surface_area /= (float)n ;
printf("Avg surf area = %g cm\n",average_surface_area/100.0);
fflush(stdout);
// mrisp_total lost info on the modified surface
sprintf(ico_fname, "%s/lib/bem/ic%d.tri", mdir, ico_no) ;
printf("Reading icosahedron from %s...\n", ico_fname) ;
mris_ico = ICOread(ico_fname) ;
if (!mris_ico)
ErrorExit(ERROR_NOFILE, "%s: could not read icosahedron file %s\n",
Progname,ico_fname) ;
MRISscaleBrain(mris_ico, mris_ico,
DEFAULT_RADIUS/MRISaverageRadius(mris_ico)) ;
// save current ico position to ->cx, cy, cz
MRISsaveVertexPositions(mris_ico, CANONICAL_VERTICES) ;
// using mrisp_total to calculate position into ->origx, origy, origz
// (orig is the "pial" vertices)
MRIScoordsFromParameterization(mrisp_total, mris_ico, ORIGINAL_VERTICES) ;
// copy geometry info
memcpy((void *) &mris_ico->vg, (void *) &vg, sizeof (VOL_GEOM));
if (Gdiag_no >= 0 && Gdiag_no < mris_ico->nvertices) {
int n ;
VERTEX *vn ;
v = &mris_ico->vertices[Gdiag_no] ;
printf( "v %d: x = (%2.2f, %2.2f, %2.2f)\n",
Gdiag_no, v->origx, v->origy, v->origz) ;
for (n = 0 ; n < v->vnum ; n++) {
vn = &mris_ico->vertices[v->v[n]] ;
printf( "v %d: x = (%2.2f, %2.2f, %2.2f)\n",
v->v[n], vn->origx, vn->origy, vn->origz) ;
}
}
// write *h.sphere.reg
sprintf(fname, "%s/%s/surf/%s.%s",
sdirout, out_sname, hemi, canon_surf_name) ;
if (Gdiag & DIAG_SHOW)
printf("writing average canonical surface to %s\n", fname);
MRISwrite(mris_ico, fname) ;
// get "pial vertices" from orig
MRISrestoreVertexPositions(mris_ico, ORIG_VERTICES);
for (vno = 0 ; vno < mris_ico->nvertices ; vno++) {
v = &mris_ico->vertices[vno] ;
// n = number of subjects
v->x /= (float)n ;
v->y /= (float)n ;
v->z /= (float)n ;
}
if (normalize_area) {
MRIScomputeMetricProperties(mris_ico) ;
printf("setting group surface area to be %2.1f cm^2 (scale=%2.2f)\n",
average_surface_area/100.0,
sqrt(average_surface_area/mris_ico->total_area)) ;
#if 0
MRISscaleBrain(mris_ico, mris_ico,
sqrt(average_surface_area/mris_ico->total_area)) ;
#else
mris_ico->group_avg_surface_area = average_surface_area ;
#endif
MRIScomputeMetricProperties(mris_ico) ;
}
sprintf(fname, "%s/%s/surf/%s.%s", sdirout,out_sname, hemi, avg_surf_name) ;
printf("writing average %s surface to %s\n", avg_surf_name, fname);
MRISwrite(mris_ico, fname) ;
if (0) {
char path[STRLEN] ;
LTA *lta ;
FileNamePath(fname, path) ;
lta = LTAalloc(1, NULL) ;
// write to a different location
sprintf(fname, "%s/../mri/transforms/%s", path,xform_name) ;
LTAwriteEx(lta, fname) ;
LTAfree(<a) ;
}
MRISfree(&mris_ico) ;
MRISPfree(&mrisp_total) ;
printf("mris_make_average_surface done\n");
exit(0) ;
return(0) ; /* for ansi */
}
/*---------------------------------------------------------------*/
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 nargs, nthin, nframestot=0, nr=0,nc=0,ns=0, fout;
int r,c,s,f,outf,nframes,err,nthrep;
double v, v1, v2, vavg, vsum;
int inputDatatype=MRI_UCHAR;
MATRIX *Upca=NULL,*Spca=NULL;
MRI *Vpca=NULL;
char *stem;
/* 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;
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);
if(maskfile)
{
printf("Loading mask %s\n",maskfile);
mask = MRIread(maskfile);
if(mask == NULL)
{
exit(1);
}
}
printf("ninputs = %d\n",ninputs);
if(DoCheck)
{
printf("Checking inputs\n");
for(nthin = 0; nthin < ninputs; nthin++)
{
if(Gdiag_no > 0 || debug)
{
printf("Checking %2d %s\n",nthin,inlist[nthin]);
fflush(stdout);
}
mritmp = MRIreadHeader(inlist[nthin],MRI_VOLUME_TYPE_UNKNOWN);
if (mritmp == NULL)
{
printf("ERROR: reading %s\n",inlist[nthin]);
exit(1);
}
if (nthin == 0)
{
nc = mritmp->width;
nr = mritmp->height;
ns = mritmp->depth;
}
if (mritmp->width != nc ||
mritmp->height != nr ||
mritmp->depth != ns)
{
printf("ERROR: dimension mismatch between %s and %s\n",
inlist[0],inlist[nthin]);
exit(1);
}
nframestot += mritmp->nframes;
inputDatatype = mritmp->type; // used by DoKeepDatatype option
MRIfree(&mritmp);
}
}
else
{
printf("NOT Checking inputs, assuming nframestot = ninputs\n");
nframestot = ninputs;
mritmp = MRIreadHeader(inlist[0],MRI_VOLUME_TYPE_UNKNOWN);
if (mritmp == NULL)
{
printf("ERROR: reading %s\n",inlist[0]);
exit(1);
}
nc = mritmp->width;
nr = mritmp->height;
ns = mritmp->depth;
MRIfree(&mritmp);
}
printf("nframestot = %d\n",nframestot);
if (DoRMS)
{
if (ninputs != 1)
{
printf("ERROR: --rms supports only single input w/ multiple frames\n");
exit (1);
}
if (nframestot == 1)
{
printf("ERROR: --rms input must have multiple frames\n");
exit (1);
}
}
if(ngroups != 0)
{
printf("Creating grouped mean matrix ngroups=%d, nper=%d\n",
ngroups,nframestot/ngroups);
M = GroupedMeanMatrix(ngroups,nframestot);
if(M==NULL)
{
exit(1);
}
if(debug)
{
MatrixPrint(stdout,M);
}
}
if(M != NULL)
{
if(nframestot != M->cols)
{
printf("ERROR: dimension mismatch between inputs (%d) and matrix (%d)\n",
nframestot,M->rows);
exit(1);
}
}
if (DoPaired)
{
if (remainder(nframestot,2) != 0)
{
printf("ERROR: --paired-xxx specified but there are an "
"odd number of frames\n");
exit(1);
}
}
printf("Allocing output\n");
fflush(stdout);
int datatype=MRI_FLOAT;
if (DoKeepDatatype)
{
datatype = inputDatatype;
}
if (DoRMS)
{
// RMS always has single frame output
mriout = MRIallocSequence(nc,nr,ns,datatype,1);
}
else
{
mriout = MRIallocSequence(nc,nr,ns,datatype,nframestot);
}
if (mriout == NULL)
{
exit(1);
}
printf("Done allocing\n");
fout = 0;
for (nthin = 0; nthin < ninputs; nthin++)
{
if (DoRMS) break; // MRIrms reads the input frames
if(Gdiag_no > 0 || debug)
{
printf("Loading %dth input %s\n",
nthin+1,fio_basename(inlist[nthin],NULL));
fflush(stdout);
}
mritmp = MRIread(inlist[nthin]);
if(mritmp == NULL)
{
printf("ERROR: loading %s\n",inlist[nthin]);
exit(1);
}
if(nthin == 0)
{
MRIcopyHeader(mritmp, mriout);
//mriout->nframes = nframestot;
}
if(DoAbs)
{
if(Gdiag_no > 0 || debug)
{
printf("Removing sign from input\n");
}
MRIabs(mritmp,mritmp);
}
if(DoPos)
{
if(Gdiag_no > 0 || debug)
{
printf("Setting input negatives to 0.\n");
}
MRIpos(mritmp,mritmp);
}
if(DoNeg)
{
if(Gdiag_no > 0 || debug)
{
printf("Setting input positives to 0.\n");
}
MRIneg(mritmp,mritmp);
}
for(f=0; f < mritmp->nframes; f++)
{
for(c=0; c < nc; c++)
{
for(r=0; r < nr; r++)
{
for(s=0; s < ns; s++)
{
v = MRIgetVoxVal(mritmp,c,r,s,f);
MRIsetVoxVal(mriout,c,r,s,fout,v);
}
}
}
fout++;
}
MRIfree(&mritmp);
}
if(DoCombine)
{
// Average frames from non-zero voxels
int nhits;
mritmp = MRIallocSequence(nc,nr,ns,MRI_FLOAT,1);
MRIcopyHeader(mritmp,mriout);
for(c=0; c < nc; c++)
{
for(r=0; r < nr; r++)
{
for(s=0; s < ns; s++)
{
nhits = 0;
vsum = 0;
for(f=0; f < mriout->nframes; f++)
{
v = MRIgetVoxVal(mriout,c,r,s,f);
if (v > 0)
{
vsum += v;
nhits ++;
}
}
if(nhits > 0 )
{
MRIsetVoxVal(mritmp,c,r,s,0,vsum/nhits);
}
} // for s
}// for r
} // for c
MRIfree(&mriout);
mriout = mritmp;
} // do combine
if(DoPrune)
{
// This computes the prune mask, applied below
printf("Computing prune mask \n");
PruneMask = MRIframeBinarize(mriout,FLT_MIN,NULL);
printf("Found %d voxels in prune mask\n",MRInMask(PruneMask));
}
if(DoNormMean)
{
printf("Normalizing by mean across frames\n");
MRInormalizeFramesMean(mriout);
}
if(DoNorm1)
{
printf("Normalizing by first across frames\n");
MRInormalizeFramesFirst(mriout);
}
if(DoASL)
{
printf("Computing ASL matrix matrix\n");
M = ASLinterpMatrix(mriout->nframes);
}
if(M != NULL)
{
printf("Multiplying by matrix\n");
mritmp = fMRImatrixMultiply(mriout, M, NULL);
if(mritmp == NULL)
{
exit(1);
}
MRIfree(&mriout);
mriout = mritmp;
}
if(DoPaired)
{
printf("Combining pairs\n");
mritmp = MRIcloneBySpace(mriout,-1,mriout->nframes/2);
for (c=0; c < nc; c++)
{
for (r=0; r < nr; r++)
{
for (s=0; s < ns; s++)
{
fout = 0;
for (f=0; f < mriout->nframes; f+=2)
{
v1 = MRIgetVoxVal(mriout,c,r,s,f);
v2 = MRIgetVoxVal(mriout,c,r,s,f+1);
v = 0;
if(DoPairedAvg)
{
v = (v1+v2)/2.0;
}
if(DoPairedSum)
{
v = (v1+v2);
}
if(DoPairedDiff)
{
v = v1-v2; // difference
}
if(DoPairedDiffNorm)
{
v = v1-v2; // difference
vavg = (v1+v2)/2.0;
if (vavg != 0.0)
{
v = v/vavg;
}
}
if(DoPairedDiffNorm1)
{
v = v1-v2; // difference
if (v1 != 0.0)
{
v = v/v1;
}
else
{
v = 0;
}
}
if(DoPairedDiffNorm2)
{
v = v1-v2; // difference
if (v2 != 0.0)
{
v = v/v2;
}
else
{
v = 0;
}
}
MRIsetVoxVal(mritmp,c,r,s,fout,v);
fout++;
}
}
}
}
MRIfree(&mriout);
mriout = mritmp;
}
nframes = mriout->nframes;
printf("nframes = %d\n",nframes);
if(DoBonfCor)
{
DoAdd = 1;
AddVal = -log10(mriout->nframes);
}
if(DoMean)
{
printf("Computing mean across frames\n");
mritmp = MRIframeMean(mriout,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoMedian)
{
printf("Computing median across frames\n");
mritmp = MRIframeMedian(mriout,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoMeanDivN)
{
printf("Computing mean2 = sum/(nframes^2)\n");
mritmp = MRIframeSum(mriout,NULL);
MRIfree(&mriout);
mriout = mritmp;
MRImultiplyConst(mriout, 1.0/(nframes*nframes), mriout);
}
if(DoSum)
{
printf("Computing sum across frames\n");
mritmp = MRIframeSum(mriout,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoTAR1)
{
printf("Computing temoral AR1 %d\n",mriout->nframes-TAR1DOFAdjust);
mritmp = fMRItemporalAR1(mriout,TAR1DOFAdjust,NULL,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoStd || DoVar)
{
printf("Computing std/var across frames\n");
if(mriout->nframes < 2)
{
printf("ERROR: cannot compute std from one frame\n");
exit(1);
}
//mritmp = fMRIvariance(mriout, -1, 1, NULL);
mritmp = fMRIcovariance(mriout, 0, -1, NULL, NULL);
if(DoStd)
{
MRIsqrt(mritmp, mritmp);
}
MRIfree(&mriout);
mriout = mritmp;
}
if(DoMax)
{
printf("Computing max across all frames \n");
mritmp = MRIvolMax(mriout,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoMaxIndex)
{
printf("Computing max index across all frames \n");
mritmp = MRIvolMaxIndex(mriout,1,NULL,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoConjunction)
{
printf("Computing conjunction across all frames \n");
mritmp = MRIconjunct(mriout,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoMin)
{
printf("Computing min across all frames \n");
mritmp = MRIvolMin(mriout,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoSort)
{
printf("Sorting \n");
mritmp = MRIsort(mriout,mask,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoVote)
{
printf("Voting \n");
mritmp = MRIvote(mriout,mask,NULL);
MRIfree(&mriout);
mriout = mritmp;
}
if(DoMultiply)
{
printf("Multiplying by %lf\n",MultiplyVal);
MRImultiplyConst(mriout, MultiplyVal, mriout);
}
if(DoAdd)
{
printf("Adding %lf\n",AddVal);
MRIaddConst(mriout, AddVal, mriout);
}
if(DoSCM)
{
printf("Computing spatial correlation matrix (%d)\n",mriout->nframes);
mritmp = fMRIspatialCorMatrix(mriout);
if(mritmp == NULL)
{
exit(1);
}
MRIfree(&mriout);
mriout = mritmp;
}
if(DoPCA)
{
// Saves only non-zero components
printf("Computing PCA\n");
if(PCAMaskFile)
{
printf(" PCA Mask %s\n",PCAMaskFile);
PCAMask = MRIread(PCAMaskFile);
if(PCAMask == NULL)
{
exit(1);
}
}
err=MRIpca(mriout, &Upca, &Spca, &Vpca, PCAMask);
if(err)
{
exit(1);
}
stem = IDstemFromName(out);
sprintf(tmpstr,"%s.u.mtx",stem);
MatrixWriteTxt(tmpstr, Upca);
sprintf(tmpstr,"%s.stats.dat",stem);
WritePCAStats(tmpstr,Spca);
MRIfree(&mriout);
mriout = Vpca;
}
if(NReplications > 0)
{
printf("NReplications %d\n",NReplications);
mritmp = MRIallocSequence(mriout->width,
mriout->height,
mriout->depth,
mriout->type,
mriout->nframes*NReplications);
if(mritmp == NULL)
{
exit(1);
}
printf("Done allocing\n");
MRIcopyHeader(mriout,mritmp);
for(c=0; c < mriout->width; c++)
{
for(r=0; r < mriout->height; r++)
{
for(s=0; s < mriout->depth; s++)
{
outf = 0;
for(nthrep = 0; nthrep < NReplications; nthrep++)
{
for(f=0; f < mriout->nframes; f++)
{
v = MRIgetVoxVal(mriout,c,r,s,f);
MRIsetVoxVal(mritmp,c,r,s,outf,v);
outf ++;
}
}
}
}
}
MRIfree(&mriout);
mriout = mritmp;
}
if(DoPrune)
{
// Apply prune mask that was computed above
printf("Applying prune mask \n");
MRImask(mriout, PruneMask, mriout, 0, 0);
}
if(DoRMS)
{
printf("Computing RMS across input frames\n");
mritmp = MRIread(inlist[0]);
MRIcopyHeader(mritmp, mriout);
MRIrms(mritmp,mriout);
}
printf("Writing to %s\n",out);
err = MRIwrite(mriout,out);
if(err)
{
exit(err);
}
return(0);
}
static int
get_option(int argc, char *argv[]) {
int nargs = 0 ;
char *option ;
option = argv[1] + 1 ; /* past '-' */
if (!stricmp(option, "debug_voxel")) {
Gx = atoi(argv[2]) ;
Gy = atoi(argv[3]) ;
Gz = atoi(argv[4]) ;
debug_flag = 1;
nargs = 3 ;
printf("debugging voxel (%d, %d, %d)...\n", Gx, Gy, Gz) ;
} else if (!stricmp(option, "T1")) {
tp1_T1_fname = argv[2];
printf("Use file %s for tp1's T1 volume \n", tp1_T1_fname) ;
nargs = 1;
} else if (!stricmp(option, "threshold")) {
noise_threshold = atof(argv[2]);
printf("Take values < %g as background for both volumes \n",
noise_threshold) ;
nargs = 1;
} else if (!stricmp(option, "mask1")) {
mask1_fname = (argv[2]);
printf("Use volume %s as brain mask for tp1, and will be mapped to\n"
"tp2 to get rough mask for tp2 in computing "
"intensity normalization \n", mask1_fname) ;
nargs = 1;
} else if (!stricmp(option, "mask2")) {
mask2_fname = (argv[2]);
printf("Use volume %s as brain mask for tp2, and will be mapped to \n"
"tp1 to get rough mask for tp1 in computing "
"intensity normalization \n", mask2_fname) ;
nargs = 1;
} else if (!stricmp(option, "ctrl")) {
tp1_ctrl_fname = argv[2];
printf("Use file %s for control points volume for tp1\n", tp1_ctrl_fname) ;
nargs = 1;
} else if (!stricmp(option, "xform")) {
xform_fname = argv[2];
nargs = 1;
fprintf(stderr, "transform file name is %s\n", xform_fname);
} else if (!stricmp(option, "invert")) {
invert = 1;
fprintf(stderr, "Inversely apply the given LTA transform\n");
} else if (!stricmp(option, "lta_src") ||
!stricmp(option, "src")
) {
fprintf
(stderr,
"src volume for the given transform (given by -xform) is %s\n",argv[2]);
fprintf(stderr, "Reading the src volume...\n");
lta_src = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN);
if (!lta_src) {
ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]);
}
nargs = 1;
} else if (!stricmp(option, "lta_dst") ||
!stricmp(option, "dst")
) {
fprintf
(stderr,
"dst volume for the transform (given by -xform) is %s\n",argv[2]);
fprintf(stderr, "Reading the dst volume...\n");
lta_dst = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN);
if (!lta_dst) {
ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]);
}
nargs = 1;
} else switch (toupper(*option)) {
case '?':
case 'U':
usage(0) ;
break ;
default:
printf("unknown option %s\n", argv[1]) ;
exit(1) ;
break ;
}
return(nargs) ;
}
/*---------------------------------------------------------------*/
int main(int argc, char **argv) {
char *srcsubj;
float betplaneres, inplaneres, intensity;
MATRIX *R, *Xsrc, *invXsrc, *Xtarg, *Rtarg;
int float2int, err;
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);
/* Load the registration matrix, fix if necessary */
err = regio_read_register(srcregpath, &srcsubj, &inplaneres,
&betplaneres, &intensity, &R,
&float2int);
if (err) exit(1);
printf("---- Input registration matrix --------\n");
MatrixPrint(stdout,R);
if (float2int == FLT2INT_TKREG && fixtkreg) {
if (fvolid == NULL) {
printf("ERROR: the input registration file requires that you "
"supply an example functional volume with --fvol\n");
exit(1);
}
FuncMRI = MRIreadHeader(fvolid,MRI_VOLUME_TYPE_UNKNOWN);
if (FuncMRI==NULL) exit(1);
printf("INFO: making tkreg matrix compatible with round\n");
R = MRIfixTkReg(FuncMRI,R);
printf("---- Fixed input registration matrix --------\n");
MatrixPrint(stdout,R);
}
float2int = FLT2INT_ROUND;
/* Load the source subject xfm */
Xsrc = DevolveXFM(srcsubj,NULL,xfmrname);
if (Xsrc == NULL) exit(1);
invXsrc = MatrixInverse(Xsrc,NULL);
/* Load the target subject xfm */
Xtarg = DevolveXFM(targsubj,NULL,xfmrname);
if (Xtarg == NULL) exit(1);
/* Rtarg = R*inv(Xsrc)*Xtarg */
Rtarg = MatrixMultiply(R,invXsrc,NULL);
Rtarg = MatrixMultiply(Rtarg,Xtarg,Rtarg);
printf("---- New registration matrix --------\n");
MatrixPrint(stdout,Rtarg);
err = regio_write_register(targregpath, targsubj, inplaneres,
betplaneres, intensity, Rtarg, float2int);
if (err) {
printf("ERROR: could not write to %s\n",targregpath);
exit(1);
}
return(0);
exit(0);
}
static int
get_option(int argc, char *argv[])
{
int nargs = 0 ;
char *option ;
option = argv[1] + 1 ; /* past '-' */
if (!stricmp(option, "-help")||!stricmp(option, "-usage"))
{
usage(1) ;
}
else if (!stricmp(option, "version"))
{
print_version() ;
}
else if (!stricmp(option, "abs"))
{
DoAbs = 1;
}
else if (!stricmp(option, "xform"))
{
xform_fname = argv[2];
nargs = 1;
fprintf(stderr, "transform file name is %s\n", xform_fname);
}
else if (!stricmp(option, "T")
|| !stricmp(option, "threshold")
)
{
threshold = (float)atof(argv[2]);
nargs = 1;
fprintf(stderr, "threshold mask volume at %g\n", threshold);
}
else if (!stricmp(option, "BB")|| !stricmp(option, "boundingbox"))
{
nPadBB = (int)atoi(argv[2]);
DoBB = 1;
nargs = 1;
printf("bounding box npad = %d\n",nPadBB);
}
else if (!stricmp(option, "transfer"))
{
do_transfer = 1;
transfer_val = (float)atof(argv[2]);
nargs = 1;
fprintf(stderr, "transfer mask voxels=%g to dst vol\n", transfer_val);
}
else if (!stricmp(option, "invert"))
{
invert = 1;
fprintf(stderr, "Inversely apply the given LTA transform\n");
}
else if (!stricmp(option, "lta_src") ||
!stricmp(option, "src")
)
{
fprintf(stderr, "src volume for the given transform "
"(given by -xform) is %s\n",argv[2]);
fprintf(stderr, "Reading the src volume...\n");
lta_src = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN);
if (!lta_src)
{
ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]);
}
nargs = 1;
}
else if (!stricmp(option, "lta_dst") ||
!stricmp(option, "dst")
)
{
fprintf(stderr, "dst volume for the transform "
"(given by -xform) is %s\n",argv[2]);
fprintf(stderr, "Reading the dst volume...\n");
lta_dst = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN);
if (!lta_dst)
{
ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]);
}
nargs = 1;
}
else if (!stricmp(option, "keep_mask_deletion_edits"))
{
keep_mask_deletion_edits = 1;
fprintf(stderr, "Transferring mask edits ('1' voxels) to dst vol\n");
}
else
{
fprintf(stderr, "unknown option %s\n", argv[1]) ;
usage(1) ;
exit(1) ;
}
return(nargs) ;
}
