bool get_options(
int argc,
char *argv[],
const cmd_option_t *options_,
size_t option_count,
cmd_options_t &cmd_options)
{
if (argc == 2 && strcmp(argv[1], "--help") == 0)
{
dump_options(argv[0], options_, option_count);
return false;
}
std::vector<cmd_option_t> options;
std::copy(options_, options_ + option_count, std::back_inserter(options));
for (int i = 1; i < argc; ++i)
{
auto iter = find_option(argv[i], options);
if (iter != options.end())
{
iter->mandatory = false;
if (iter->has_data)
{
if (++i >= argc)
{
log(log_error, "get_options : missing option value for %s\n", iter->opt);
dump_options(argv[0], options_, option_count);
return false;
}
debug_ex(printf("setting option %s to %s\n", iter->codename, argv[i]));
cmd_options[iter->codename] = argv[i];
}
else
{
debug_ex(printf("setting option %s to yes\n", iter->codename));
cmd_options[iter->codename] = "yes";
}
}
}
for (auto option : options)
{
if (option.mandatory)
{
log(log_error, "get_options : missing option %s <%s>\n", option.opt, option.codename);
dump_options(argv[0], options_, option_count);
return false;
}
}
return true;
}
/*---------------------------------------------------------------*/
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;
}
static int rule_iter(pRule r, int param)
{
printf("%s", r->symbol);
if(r->params) {
printf(" ( ");
dump_params(r->params);
printf(")");
};
printf(" : (%d options)\n", option_length(r->options));
dump_options(r->options);
};
//! Set up device and execute command(s).
//
int main(int argc, char** argv) {
// read in program arguments
read_arguments(argc, argv);
#ifdef _DEBUG
// DEBUG: list the options
dump_options();
#endif // _DEBUG
// help over-rides all. For options variable see cmdline.h
if (options.showHelp) {
printHelp();
exit(0);
}
// open the device or its imposter (file), see dfile.h
if (options.inputFromFile == 1) {
dopen(cmdFilename);
}
else {
dopen(":usb:");
}
// dump header can be executed with other commands
if (options.dumpHeader == 1) {
printHeader();
}
// now dispatch for processing
if (options.dumpMemory == 1) {
// hexdump device memory
dumpmemory(memoryDumpStart, memoryDumpEnd, DumpWidth);
}
else if (options.writeMemoryToFile == 1) {
// copy device memory to a file
copymem(cmdFilename);
}
else if (options.printRecordsSince == 1) {
// list records since given date & time
listRecordsSince(dateSince);
}
else if (options.printRecords == 1) {
// list specified records (0 = current, n = oldest)
if (options.untilFirstRecord == 1) {
endRecordNumber = getRecordsStored();
}
listRecords(startRecordNumber, endRecordNumber);
}
dclose();
}
/*---------------------------------------------------------------*/
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;
}
/* Main function to export a configuration file */
int dump_configuration(screen_t** sc, int num_screens, struct option* o)
{
FILE* out;
/* Don't overwrite existing file */
if (access(config_file, F_OK) != -1)
return -1;
out = fopen(config_file, "w");
if (out == NULL)
return -1;
if (fprintf(out, "%s\n%s\n", introduction, tip_sta) < 0)
return -1;
if (dump_options(out, o) < 0)
return -1;
if (dump_screens(out, sc, num_screens) < 0)
return -1;
if (fprintf(out, "%s\n", tip_clo) < 0)
return -1;
fclose(out);
return 0;
}
/*
* trusted_instantiate - create a new trusted key
*
* Unseal an existing trusted blob or, for a new key, get a
* random key, then seal and create a trusted key-type key,
* adding it to the specified keyring.
*
* On success, return 0. Otherwise return errno.
*/
static int trusted_instantiate(struct key *key, const void *data,
size_t datalen)
{
struct trusted_key_payload *payload = NULL;
struct trusted_key_options *options = NULL;
char *datablob;
int ret = 0;
int key_cmd;
if (datalen <= 0 || datalen > 32767 || !data)
return -EINVAL;
datablob = kmalloc(datalen + 1, GFP_KERNEL);
if (!datablob)
return -ENOMEM;
memcpy(datablob, data, datalen);
datablob[datalen] = '\0';
options = trusted_options_alloc();
if (!options) {
ret = -ENOMEM;
goto out;
}
payload = trusted_payload_alloc(key);
if (!payload) {
ret = -ENOMEM;
goto out;
}
key_cmd = datablob_parse(datablob, payload, options);
if (key_cmd < 0) {
ret = key_cmd;
goto out;
}
dump_payload(payload);
dump_options(options);
switch (key_cmd) {
case Opt_load:
ret = key_unseal(payload, options);
dump_payload(payload);
dump_options(options);
if (ret < 0)
pr_info("trusted_key: key_unseal failed (%d)\n", ret);
break;
case Opt_new:
ret = my_get_random(payload->key, payload->key_len);
if (ret < 0) {
pr_info("trusted_key: key_create failed (%d)\n", ret);
goto out;
}
ret = key_seal(payload, options);
if (ret < 0)
pr_info("trusted_key: key_seal failed (%d)\n", ret);
break;
default:
ret = -EINVAL;
goto out;
}
if (!ret && options->pcrlock)
ret = pcrlock(options->pcrlock);
out:
kfree(datablob);
kfree(options);
if (!ret)
rcu_assign_pointer(key->payload.data, payload);
else
kfree(payload);
return ret;
}
/*---------------------------------------------------------------*/
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, err, asegid, c, r, s, nctx, annot,vtxno,nripped;
int annotid, IsCortex=0, IsWM=0, IsHypo=0, hemi=0, segval=0;
int RibbonVal=0,nbrute=0;
float dmin=0.0, lhRibbonVal=0, rhRibbonVal=0;
/* 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();
}
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR==NULL)
{
printf("ERROR: SUBJECTS_DIR not defined in environment\n");
exit(1);
}
parse_commandline(argc, argv);
check_options();
dump_options(stdout);
/* ------ Load subject's lh white surface ------ */
sprintf(tmpstr,"%s/%s/surf/lh.white",SUBJECTS_DIR,subject);
printf("\nReading lh white surface \n %s\n",tmpstr);
lhwhite = MRISread(tmpstr);
if (lhwhite == NULL)
{
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
/* ------ Load subject's lh pial surface ------ */
sprintf(tmpstr,"%s/%s/surf/lh.pial",SUBJECTS_DIR,subject);
printf("\nReading lh pial surface \n %s\n",tmpstr);
lhpial = MRISread(tmpstr);
if (lhpial == NULL)
{
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
if (lhwhite->nvertices != lhpial->nvertices)
{
printf("ERROR: lh white and pial have a different number of "
"vertices (%d,%d)\n",
lhwhite->nvertices,lhpial->nvertices);
exit(1);
}
/* ------ Load lh annotation ------ */
sprintf(annotfile,"%s/%s/label/lh.%s.annot",SUBJECTS_DIR,subject,annotname);
printf("\nLoading 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 white surface ------ */
sprintf(tmpstr,"%s/%s/surf/rh.white",SUBJECTS_DIR,subject);
printf("\nReading rh white surface \n %s\n",tmpstr);
rhwhite = MRISread(tmpstr);
if (rhwhite == NULL)
{
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
/* ------ Load subject's rh pial surface ------ */
sprintf(tmpstr,"%s/%s/surf/rh.pial",SUBJECTS_DIR,subject);
printf("\nReading rh pial surface \n %s\n",tmpstr);
rhpial = MRISread(tmpstr);
if (rhpial == NULL)
{
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
if (rhwhite->nvertices != rhpial->nvertices)
{
printf("ERROR: rh white and pial have a different "
"number of vertices (%d,%d)\n",
rhwhite->nvertices,rhpial->nvertices);
exit(1);
}
/* ------ Load rh annotation ------ */
sprintf(annotfile,"%s/%s/label/rh.%s.annot",SUBJECTS_DIR,subject,annotname);
printf("\nLoading rh annotations from %s\n",annotfile);
err = MRISreadAnnotation(rhwhite, annotfile);
if (err)
{
printf("ERROR: MRISreadAnnotation() failed %s\n",annotfile);
exit(1);
}
if (lhwhite->ct)
{
printf("Have color table for lh white annotation\n");
}
if (rhwhite->ct)
{
printf("Have color table for rh white annotation\n");
}
//print_annotation_table(stdout);
if (UseRibbon)
{
sprintf(tmpstr,"%s/%s/mri/lh.ribbon.mgz",SUBJECTS_DIR,subject);
printf("Loading lh ribbon mask from %s\n",tmpstr);
lhRibbon = MRIread(tmpstr);
if (lhRibbon == NULL)
{
printf("ERROR: loading %s\n",tmpstr);
exit(1);
}
sprintf(tmpstr,"%s/%s/mri/rh.ribbon.mgz",SUBJECTS_DIR,subject);
printf("Loading rh ribbon mask from %s\n",tmpstr);
rhRibbon = MRIread(tmpstr);
if (rhRibbon == NULL)
{
printf("ERROR: loading %s\n",tmpstr);
exit(1);
}
}
if (UseNewRibbon)
{
sprintf(tmpstr,"%s/%s/mri/ribbon.mgz",SUBJECTS_DIR,subject);
printf("Loading ribbon segmentation from %s\n",tmpstr);
RibbonSeg = MRIread(tmpstr);
if (RibbonSeg == NULL)
{
printf("ERROR: loading %s\n",tmpstr);
exit(1);
}
}
if (LabelHypoAsWM)
{
sprintf(tmpstr,"%s/%s/mri/filled.mgz",SUBJECTS_DIR,subject);
printf("Loading filled from %s\n",tmpstr);
filled = MRIread(tmpstr);
if (filled == NULL)
{
printf("ERROR: loading filled %s\n",tmpstr);
exit(1);
}
}
// ------------ Rip -----------------------
if (RipUnknown)
{
printf("Ripping vertices labeled as unkown\n");
nripped = 0;
for (vtxno = 0; vtxno < lhwhite->nvertices; vtxno++)
{
annot = lhwhite->vertices[vtxno].annotation;
CTABfindAnnotation(lhwhite->ct, annot, &annotid);
// Sometimes the annotation will be "none" indicated by
// annotid = -1. We interpret this as "unknown".
if (annotid == 0 || annotid == -1)
{
lhwhite->vertices[vtxno].ripflag = 1;
lhpial->vertices[vtxno].ripflag = 1;
nripped++;
}
}
printf("Ripped %d vertices from left hemi\n",nripped);
nripped = 0;
for (vtxno = 0; vtxno < rhwhite->nvertices; vtxno++)
{
annot = rhwhite->vertices[vtxno].annotation;
CTABfindAnnotation(rhwhite->ct, annot, &annotid);
if (annotid == 0 || annotid == -1)
{
rhwhite->vertices[vtxno].ripflag = 1;
rhpial->vertices[vtxno].ripflag = 1;
nripped++;
}
}
printf("Ripped %d vertices from right hemi\n",nripped);
}
printf("\n");
printf("Building hash of lh white\n");
lhwhite_hash = MHTfillVertexTableRes(lhwhite, NULL,CURRENT_VERTICES,hashres);
printf("\n");
printf("Building hash of lh pial\n");
lhpial_hash = MHTfillVertexTableRes(lhpial, NULL,CURRENT_VERTICES,hashres);
printf("\n");
printf("Building hash of rh white\n");
rhwhite_hash = MHTfillVertexTableRes(rhwhite, NULL,CURRENT_VERTICES,hashres);
printf("\n");
printf("Building hash of rh pial\n");
rhpial_hash = MHTfillVertexTableRes(rhpial, NULL,CURRENT_VERTICES,hashres);
/* ------ 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("\nLoading 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,1);
MRIfree(&ASeg);
ASeg = mritmp;
if (CtxSegFile)
{
printf("Loading Ctx Seg File %s\n",CtxSegFile);
CtxSeg = MRIread(CtxSegFile);
if (CtxSeg == NULL)
{
exit(1);
}
}
AParc = MRIclone(ASeg,NULL);
if (OutDistFile != NULL)
{
Dist = MRIclone(ASeg,NULL);
mritmp = MRIchangeType(Dist,MRI_FLOAT,0,0,0);
if (mritmp == NULL)
{
printf("ERROR: could change type\n");
exit(1);
}
MRIfree(&Dist);
Dist = mritmp;
}
Vox2RAS = MRIxfmCRS2XYZtkreg(ASeg);
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;
if (crsTest)
{
printf("Testing point %d %d %d\n",ctest,rtest,stest);
err = FindClosestLRWPVertexNo(ctest,rtest,stest,
&lhwvtx, &lhpvtx,
&rhwvtx, &rhpvtx, Vox2RAS,
lhwhite, lhpial,
rhwhite, rhpial,
lhwhite_hash, lhpial_hash,
rhwhite_hash, rhpial_hash);
printf("Result: err = %d\n",err);
exit(err);
}
printf("\nLabeling Slice\n");
nctx = 0;
annot = 0;
annotid = 0;
nbrute = 0;
// Go through each voxel in the aseg
for (c=0; c < ASeg->width; c++)
{
printf("%3d ",c);
if (c%20 ==19)
{
printf("\n");
}
fflush(stdout);
for (r=0; r < ASeg->height; r++)
{
for (s=0; s < ASeg->depth; s++)
{
asegid = MRIgetVoxVal(ASeg,c,r,s,0);
if (asegid == 3 || asegid == 42)
{
IsCortex = 1;
}
else
{
IsCortex = 0;
}
if (asegid >= 77 && asegid <= 82)
{
IsHypo = 1;
}
else
{
IsHypo = 0;
}
if (asegid == 2 || asegid == 41)
{
IsWM = 1;
}
else
{
IsWM = 0;
}
if (IsHypo && LabelHypoAsWM && MRIgetVoxVal(filled,c,r,s,0))
{
IsWM = 1;
}
// integrate surface information
//
// Only Do This for GM,WM or Unknown labels in the ASEG !!!
//
// priority is given to the ribbon computed from the surface
// namely
// ribbon=GM => GM
// aseg=GM AND ribbon=WM => WM
// ribbon=UNKNOWN => UNKNOWN
if (UseNewRibbon && ( IsCortex || IsWM || asegid==0 ) )
{
RibbonVal = MRIgetVoxVal(RibbonSeg,c,r,s,0);
MRIsetVoxVal(ASeg,c,r,s,0, RibbonVal);
if (RibbonVal==2 || RibbonVal==41)
{
IsWM = 1;
IsCortex = 0;
}
else if (RibbonVal==3 || RibbonVal==42)
{
IsWM = 0;
IsCortex = 1;
}
if (RibbonVal==0)
{
IsWM = 0;
IsCortex = 0;
}
}
// If it's not labeled as cortex or wm in the aseg, skip
if (!IsCortex && !IsWM)
{
continue;
}
// If it's wm but not labeling wm, skip
if (IsWM && !LabelWM)
{
continue;
}
// Check whether this point is in the ribbon
if (UseRibbon)
{
lhRibbonVal = MRIgetVoxVal(lhRibbon,c,r,s,0);
rhRibbonVal = MRIgetVoxVal(rhRibbon,c,r,s,0);
if (IsCortex)
{
// ASeg says it's in cortex
if (lhRibbonVal < 0.5 && rhRibbonVal < 0.5)
{
// but it is not part of the ribbon,
// so set it to unknown (0) and go to the next voxel.
MRIsetVoxVal(ASeg,c,r,s,0,0);
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, lh.pial, rh.white, rh.pial
if (UseHash)
{
lhwvtx = MHTfindClosestVertexNo(lhwhite_hash,lhwhite,&vtx,&dlhw);
lhpvtx = MHTfindClosestVertexNo(lhpial_hash, lhpial, &vtx,&dlhp);
rhwvtx = MHTfindClosestVertexNo(rhwhite_hash,rhwhite,&vtx,&drhw);
rhpvtx = MHTfindClosestVertexNo(rhpial_hash, rhpial, &vtx,&drhp);
if (lhwvtx < 0 && lhpvtx < 0 && rhwvtx < 0 && rhpvtx < 0)
{
/*
printf(" Could not map to any surface with hash table:\n");
printf(" crs = %d %d %d, ras = %6.4f %6.4f %6.4f \n",
c,r,s,vtx.x,vtx.y,vtx.z);
printf(" Using brute force search %d ... \n",nbrute);
fflush(stdout);
*/
lhwvtx = MRISfindClosestVertex(lhwhite,vtx.x,vtx.y,vtx.z,&dlhw);
lhpvtx = MRISfindClosestVertex(lhpial,vtx.x,vtx.y,vtx.z,&dlhp);
rhwvtx = MRISfindClosestVertex(rhwhite,vtx.x,vtx.y,vtx.z,&drhw);
rhpvtx = MRISfindClosestVertex(rhpial,vtx.x,vtx.y,vtx.z,&drhp);
nbrute ++;
//exit(1);
}
}
else
{
lhwvtx = MRISfindClosestVertex(lhwhite,vtx.x,vtx.y,vtx.z,&dlhw);
lhpvtx = MRISfindClosestVertex(lhpial,vtx.x,vtx.y,vtx.z,&dlhp);
rhwvtx = MRISfindClosestVertex(rhwhite,vtx.x,vtx.y,vtx.z,&drhw);
rhpvtx = MRISfindClosestVertex(rhpial,vtx.x,vtx.y,vtx.z,&drhp);
}
if (lhwvtx < 0)
{
dlhw = 1000000000000000.0;
}
if (lhpvtx < 0)
{
dlhp = 1000000000000000.0;
}
if (rhwvtx < 0)
{
drhw = 1000000000000000.0;
}
if (rhpvtx < 0)
{
drhp = 1000000000000000.0;
}
if (dlhw <= dlhp && dlhw < drhw && dlhw < drhp && lhwvtx >= 0)
{
annot = lhwhite->vertices[lhwvtx].annotation;
hemi = 1;
if (lhwhite->ct)
{
CTABfindAnnotation(lhwhite->ct, annot, &annotid);
}
else
{
annotid = annotation_to_index(annot);
}
dmin = dlhw;
}
if (dlhp < dlhw && dlhp < drhw && dlhp < drhp && lhpvtx >= 0)
{
annot = lhwhite->vertices[lhpvtx].annotation;
hemi = 1;
if (lhwhite->ct)
{
CTABfindAnnotation(lhwhite->ct, annot, &annotid);
}
else
{
annotid = annotation_to_index(annot);
}
dmin = dlhp;
}
if (drhw < dlhp && drhw < dlhw && drhw <= drhp && rhwvtx >= 0)
{
annot = rhwhite->vertices[rhwvtx].annotation;
hemi = 2;
if (rhwhite->ct)
{
CTABfindAnnotation(rhwhite->ct, annot, &annotid);
}
else
{
annotid = annotation_to_index(annot);
}
dmin = drhw;
}
if (drhp < dlhp && drhp < drhw && drhp < dlhw && rhpvtx >= 0)
{
annot = rhwhite->vertices[rhpvtx].annotation;
hemi = 2;
if (rhwhite->ct)
{
CTABfindAnnotation(rhwhite->ct, annot, &annotid);
}
else
{
annotid = annotation_to_index(annot);
}
dmin = drhp;
}
// Sometimes the annotation will be "none" indicated by
// annotid = -1. We interpret this as "unknown".
if (annotid == -1)
{
annotid = 0;
}
// why was this here in the first place?
/*
if (annotid == 0 &&
lhwvtx >= 0 &&
lhpvtx >= 0 &&
rhwvtx >= 0 &&
rhpvtx >= 0) {
printf("%d %d %d %d\n",
lhwhite->vertices[lhwvtx].ripflag,
lhpial->vertices[lhpvtx].ripflag,
rhwhite->vertices[rhwvtx].ripflag,
rhpial->vertices[rhpvtx].ripflag);
} */
if ( IsCortex && hemi == 1)
{
segval = annotid+1000 + baseoffset; //ctx-lh
}
if ( IsCortex && hemi == 2)
{
segval = annotid+2000 + baseoffset; //ctx-rh
}
if (!IsCortex && hemi == 1)
{
segval = annotid+3000 + baseoffset; // wm-lh
}
if (!IsCortex && hemi == 2)
{
segval = annotid+4000 + baseoffset; // wm-rh
}
if (!IsCortex && dmin > dmaxctx && hemi == 1)
{
segval = 5001;
}
if (!IsCortex && dmin > dmaxctx && hemi == 2)
{
segval = 5002;
}
// This is a hack for getting the right cortical seg with --rip-unknown
// The aparc+aseg should be passed as CtxSeg.
if (IsCortex && CtxSeg)
{
segval = MRIgetVoxVal(CtxSeg,c,r,s,0);
}
MRIsetVoxVal(ASeg,c,r,s,0,segval);
MRIsetVoxVal(AParc,c,r,s,0,annot);
if (OutDistFile != NULL)
{
MRIsetVoxVal(Dist,c,r,s,0,dmin);
}
if (debug || annotid == -1)
{
// Gets here when there is no label at the found vertex.
// This is different than having a vertex labeled as "unknown"
if (!debug)
{
continue;
}
printf("\n");
printf("Found closest vertex, but it has no label.\n");
printf("aseg id = %d\n",asegid);
printf("crs = %d %d %d, ras = %6.4f %6.4f %6.4f \n",
c,r,s,vtx.x,vtx.y,vtx.z);
if (lhwvtx > 0) printf("lhw %d %7.5f %6.4f %6.4f %6.4f\n",
lhwvtx, dlhw,
lhwhite->vertices[lhwvtx].x,
lhwhite->vertices[lhwvtx].y,
lhwhite->vertices[lhwvtx].z);
if (lhpvtx > 0) printf("lhp %d %7.5f %6.4f %6.4f %6.4f\n",
lhpvtx, dlhp,
lhpial->vertices[lhpvtx].x,
lhpial->vertices[lhpvtx].y,
lhpial->vertices[lhpvtx].z);
if (rhwvtx > 0) printf("rhw %d %7.5f %6.4f %6.4f %6.4f\n",
rhwvtx, drhw,
rhwhite->vertices[rhwvtx].x,
rhwhite->vertices[rhwvtx].y,
rhwhite->vertices[rhwvtx].z);
if (rhpvtx > 0) printf("rhp %d %7.5f %6.4f %6.4f %6.4f\n",
rhpvtx, drhp,
rhpial->vertices[rhpvtx].x,
rhpial->vertices[rhpvtx].y,
rhpial->vertices[rhpvtx].z);
printf("annot = %d, annotid = %d\n",annot,annotid);
CTABprintASCII(lhwhite->ct,stdout);
continue;
}
nctx++;
}
}
}
printf("nctx = %d\n",nctx);
printf("Used brute-force search on %d voxels\n",nbrute);
if (FixParaHipWM)
{
/* This is a bit of a hack. There are some vertices that have been
ripped because they are "unkown". When the above alorithm finds
these, it searches for the closest known vertex. If this is
less than dmax away, then the wm voxel gets labeled
accordingly. However, there are often some voxels near
ventralDC that are just close enough in 3d space to parahip to
get labeled even though they are very far away along the
surface. These voxels end up forming an island. CCSegment()
will eliminate any islands. Unforunately, CCSegment() uses
6-neighbor (face) definition of connectedness, so some voxels
may be eliminated.
*/
printf("Fixing Parahip LH WM\n");
CCSegment(ASeg, 3016, 5001); //3016 = lhphwm, 5001 = unsegmented WM left
printf("Fixing Parahip RH WM\n");
CCSegment(ASeg, 4016, 5002); //4016 = rhphwm, 5002 = unsegmented WM right
}
printf("Writing output aseg to %s\n",OutASegFile);
MRIwrite(ASeg,OutASegFile);
if (OutAParcFile != NULL)
{
printf("Writing output aparc to %s\n",OutAParcFile);
MRIwrite(AParc,OutAParcFile);
}
if (OutDistFile != NULL)
{
printf("Writing output dist file to %s\n",OutDistFile);
MRIwrite(Dist,OutDistFile);
}
return(0);
}
/*---------------------------------------------------------------*/
int main(int argc, char **argv) {
int n, v, c;
FILE *fp;
char *covarname;
char SumFile[2000];
char DatFile[2000];
char MatFile[2000];
char OutGDFile[2000];
int nargs;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_gdfglm.c,v 1.8.2.1 2011/05/05 15:29:51 greve 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();
printf("\n\n");
printf("%s ",Progname);
for (n=0; n < argc; n++) printf("%s ",argv[n]);
printf("\n\n");
printf("%s\n\n",vcid);
parse_commandline(argc, argv);
check_options();
dump_options(stdout);
X = gdfMatrixDODS(fsgd,NULL);
if (X==NULL) exit(1);
if (debug) MatrixPrint(stdout,X);
Xnorm = MatrixNormalizeCol(X,NULL,NULL);
Xcondition = sqrt(MatrixNSConditionNumber(Xnorm));
MatrixFree(&Xnorm);
printf("INFO: Normalized Design Matrix Condition Number is %g\n",
Xcondition);
if (Xcondition > 100000) {
printf("ERROR: Design matrix is badly conditioned, check for linear\n"
"dependency between columns (ie, two or more columns \n"
"that add up to another column).\n\n");
exit(1);
}
printf("Extracting DepVar\n");
y = DVTgetDepVar(dvt,nDepVarList,DepVarList,wDepVar);
printf("Performing Estimation\n");
pinvX = MatrixPseudoInverse(X,NULL);
beta = MatrixMultiply(pinvX,y,NULL);
yhat = MatrixMultiply(X,beta,NULL);
r = MatrixSubtract(y,yhat,NULL);
dof = X->rows-X->cols;
rvar = VectorVar(r, &rmean);
rvar = rvar * (X->rows-1)/dof;
printf("Beta: -----------------\n");
MatrixPrint(stdout,beta);
printf("---------------------------------\n\n");
printf("rvar = %g, rstd = %g\n",rvar,sqrt(rvar));
C = gdfContrastDODS(fsgd, wClass, wCovar);
printf("C: -----------------\n");
MatrixPrint(stdout,C);
printf("---------------------------------\n\n");
ces = MatrixMultiply(C,beta,NULL);
vmf = ContrastVMF(X,C);
tval = ces->rptr[1][1]/sqrt(rvar*vmf);
sigtval = sigt(tval, rint(dof));
printf("ces = %g, vmf = %g, t = %g, sigt = %g\n",
ces->rptr[1][1],vmf,tval,sigtval);
sprintf(SumFile,"%s.sum",OutBase);
fp = fopen(SumFile,"w");
fprintf(fp,"mri_gdfglm summary file\n\n");
fprintf(fp,"Group Descriptor File %s\n",GDFile);
fprintf(fp,"Dependent Variable File %s\n",DVTFile);
fprintf(fp,"Dependent Variable Weights: ");
if (wDepVar == NULL)
fprintf(fp," all 1s\n");
else {
fprintf(fp,"\n");
for (n=0; n < nwDepVar; n++)
fprintf(fp," %s %g\n",DepVarList[n],wDepVar[n]);
}
fprintf(fp,"\n");
fprintf(fp,"Class Contrast Weights: ");
if (nwClass == 0)
fprintf(fp," all 1s\n");
else {
fprintf(fp,"\n");
for (n=0; n < nwClass; n++)
fprintf(fp," %s %g\n",fsgd->classlabel[n],wClass[n]);
}
fprintf(fp,"\n");
fprintf(fp,"Covar Contrast Weights: ");
if (nwCovar == 0)
if (!TestOffset) fprintf(fp," all 1s\n");
else fprintf(fp," all 0s\n");
else {
fprintf(fp,"\n");
for (n=0; n < nwCovar; n++)
fprintf(fp," %s %g",CovarList[n],wCovar[n]);
fprintf(fp,"\n");
}
fprintf(fp,"TestOffset = %d\n",TestOffset);
fprintf(fp,"\n");
fprintf(fp,"Parameter Estimates and Contrast Weighting:\n\n");
n = 0;
for (v=0; v < fsgd->nvariables+1; v++) {
if (v==0) covarname = "Offset";
else covarname = fsgd->varlabel[v-1];
for (c=0; c < fsgd->nclasses; c++) {
fprintf(fp,"%-10s %-10s %12.5f %5.2f\n",fsgd->classlabel[c],
covarname,beta->rptr[n+1][1],C->rptr[1][n+1]);
n++;
}
fprintf(fp,"\n");
}
fprintf(fp,"\n");
fprintf(fp,"Residual Variance %g\n",rvar);
fprintf(fp,"Residual StdDev %g\n",sqrt(rvar));
fprintf(fp,"DOF %g\n",dof);
fprintf(fp,"\n");
fprintf(fp,"Contrast Effect Size %g\n",ces->rptr[1][1]);
fprintf(fp,"Variance Reduction Factor %g\n",1/vmf);
fprintf(fp,"t-Ratio %g\n",tval);
fprintf(fp,"Significance %g\n",sigtval);
fprintf(fp,"\n");
fclose(fp);
/*----------------------------------------*/
sprintf(DatFile,"%s.dat",OutBase);
fp = fopen(DatFile,"w");
for (n=0; n < fsgd->ninputs; n++) {
fprintf(fp,"%2d ",n);
if (KeepSubjId) fprintf(fp,"%s",fsgd->subjid[n]);
for (v=0; v < fsgd->nvariables; v++)
fprintf(fp," %g",fsgd->varvals[n][v]);
fprintf(fp," %g %g",y->rptr[n+1][1],yhat->rptr[n+1][1]);
fprintf(fp,"\n");
}
fclose(fp);
/*----------------------------------------*/
sprintf(MatFile,"%s.mat",OutBase);
all = MatrixHorCat(X,y,NULL);
all = MatrixHorCat(all,yhat,NULL);
all = MatrixHorCat(all,r,NULL);
MatlabWrite(all,MatFile,"X");
/*----------------------------------------*/
sprintf(OutGDFile,"%s.gdf",OutBase);
fp = fopen(OutGDFile,"w");
gdfPrintHeader(fp,fsgd);
fclose(fp);
/*----------------------------------------*/
WriteAllClassDat(OutBase,fsgd,y,yhat,X,beta);
return(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;
}
static bool
ReadUTFBufferAndDumpToStream (const ReadStringAndDumpToStreamOptions& options,
ConversionResult (*ConvertFunction) (const SourceDataType**,
const SourceDataType*,
UTF8**,
UTF8*,
ConversionFlags))
{
assert(options.GetStream() && "need a Stream to print the string to");
if (options.GetLocation() == 0 || options.GetLocation() == LLDB_INVALID_ADDRESS)
return false;
lldb::ProcessSP process_sp(options.GetProcessSP());
if (!process_sp)
return false;
const int type_width = sizeof(SourceDataType);
const int origin_encoding = 8 * type_width ;
if (origin_encoding != 8 && origin_encoding != 16 && origin_encoding != 32)
return false;
// if not UTF8, I need a conversion function to return proper UTF8
if (origin_encoding != 8 && !ConvertFunction)
return false;
if (!options.GetStream())
return false;
uint32_t sourceSize = options.GetSourceSize();
bool needs_zero_terminator = options.GetNeedsZeroTermination();
if (!sourceSize)
{
sourceSize = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
needs_zero_terminator = true;
}
else if (!options.GetIgnoreMaxLength())
sourceSize = std::min(sourceSize,process_sp->GetTarget().GetMaximumSizeOfStringSummary());
const int bufferSPSize = sourceSize * type_width;
lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize,0));
if (!buffer_sp->GetBytes())
return false;
Error error;
char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes());
if (needs_zero_terminator)
process_sp->ReadStringFromMemory(options.GetLocation(), buffer, bufferSPSize, error, type_width);
else
process_sp->ReadMemoryFromInferior(options.GetLocation(), (char*)buffer_sp->GetBytes(), bufferSPSize, error);
if (error.Fail())
{
options.GetStream()->Printf("unable to read data");
return true;
}
DataExtractor data(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize());
ReadBufferAndDumpToStreamOptions dump_options(options);
dump_options.SetData(data);
dump_options.SetSourceSize(sourceSize);
return DumpUTFBufferToStream(ConvertFunction, dump_options);
}
/*--------------------------------------------------*/
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) {
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);
}
/*--------------------------------------------------*/
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[])
{
FILE *log = stdout;
struct timeval tv;
option_block options;
int i;
g_plugin = NULL;
sfuzz_setsearchpath(
#ifndef __WIN32__
"./:"PREFIX"/share/sfuzz-db"
#else
"./"
#endif
);
memset(&options, 0, sizeof(options));
gettimeofday(&tv, NULL);
birth = tv.tv_sec;
options.pFilename = malloc(MAX_FILENAME_SIZE);
options.pLogFilename = malloc(MAX_FILENAME_SIZE);
options.host_spec = malloc(MAX_HOSTSPEC_SIZE);
options.port_spec = malloc(MAX_PORTSPEC_SIZE);
options.repl_pol = 2; /* once ! for always, choose 1. */
memset(options.pFilename, 0, MAX_FILENAME_SIZE-1);
memset(options.pLogFilename, 0, MAX_FILENAME_SIZE-1);
/*default line terminator*/
options.line_term[0] = '\n';
options.line_terminator_size = 1;
options.state = CMD_LINE_OPTS;
process_opts(argc, argv, &options);
options.state = INIT_READ;
read_config(&options);
if(options.pLogFilename[0] != 0)
{
if(options.new_logfile)
{
strncat(options.pLogFilename, ".0", MAX_FILENAME_SIZE);
}
log = fopen(options.pLogFilename, "w");
if(log != NULL)
{
options.fp_log = log;
} else
{
fprintf(stderr, "[%s] error: using stdout - unable to open log.\n",
get_time_as_log());
log = stdout;
}
}
if(options.verbosity == VERBOSE)
dump_options(&options);
if(options.verbosity != QUIET)
{
fprintf(log, "[%s] info: beginning fuzz - method:", get_time_as_log());
if(options.tcp_flag)
{
fprintf(log, " tcp,");
} else if(options.udp_flag)
{
fprintf(log, " udp,");
}
else
{
fprintf(log, " io,");
}
fprintf(log, " config from: [%s], out: [%s:%d]\n",
options.pFilename, options.host_spec, options.port);
}
options.state = FUZZ;
execute_fuzz(&options);
if(options.verbosity != QUIET)
fprintf(log, "[%s] completed fuzzing.\n", get_time_as_log());
free( options.pFilename );
free( options.pLogFilename );
free( options.host_spec );
for(i = 0; i < options.num_litr; ++i)
{
free(options.litr[i]);
}
free(options.litr);
free(options.litr_lens);
for(i = 0; i < options.num_seq; ++i)
{
free(options.seq[i]);
}
free(options.seq);
free(options.seq_lens);
/*this might be the better way of doing things =)*/
if(options.sym_count)
free(options.syms_array);
return 0;
}
void player_dump( void )
{
FILE *dumpfile;
char dump_name[ 32 ];
/* build player dump file name as "charactername.txt" */
strncpy( dump_name, Player.name, 27 );
strcat( dump_name, ".txt" );
/* try to open dump file for writing, not using checkfopen() */
/* (file.c) because there is no need to quit the program if */
/* fopen fails. */
dumpfile = fopen( dump_name, "w" );
if ( !dumpfile )
{
why = "couldn't open file";
goto dump_failed;
}
/* dump name, stats, etc. */
if ( !dump_basic( dumpfile ) )
goto dump_failed;
/* dump options */
if ( !dump_options( dumpfile ) )
goto dump_failed;
if ( do_dump_stat_imm )
{
/* dump stati */
if ( !dump_stati( dumpfile ) )
goto dump_failed;
/* dump immunities */
if ( !dump_immunities( dumpfile ) )
goto dump_failed;
}
/* dump ranks */
if ( !dump_ranks( dumpfile ) )
goto dump_failed;
/* dump possessions */
if ( !dump_possessions( dumpfile ) )
goto dump_failed;
fclose( dumpfile );
/*_ftype = 'odat';*/
clearmsg();
print1( "Character dump successful" );
morewait();
return;
dump_failed:
clearmsg();
sprintf( Str3, "Character dump unsuccessful (%s)", why );
print1( Str3 );
morewait();
return;
}
/*---------------------------------------------------------------*/
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)
{
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);
}
/*
* trusted_instantiate - create a new trusted key
*
* Unseal an existing trusted blob or, for a new key, get a
* random key, then seal and create a trusted key-type key,
* adding it to the specified keyring.
*
* On success, return 0. Otherwise return errno.
*/
static int trusted_instantiate(struct key *key,
struct key_preparsed_payload *prep)
{
struct trusted_key_payload *payload = NULL;
struct trusted_key_options *options = NULL;
size_t datalen = prep->datalen;
char *datablob;
int ret = 0;
int key_cmd;
size_t key_len;
int tpm2;
tpm2 = tpm_is_tpm2(TPM_ANY_NUM);
if (tpm2 < 0)
return tpm2;
if (datalen <= 0 || datalen > 32767 || !prep->data)
return -EINVAL;
datablob = kmalloc(datalen + 1, GFP_KERNEL);
if (!datablob)
return -ENOMEM;
memcpy(datablob, prep->data, datalen);
datablob[datalen] = '\0';
options = trusted_options_alloc();
if (!options) {
ret = -ENOMEM;
goto out;
}
payload = trusted_payload_alloc(key);
if (!payload) {
ret = -ENOMEM;
goto out;
}
key_cmd = datablob_parse(datablob, payload, options);
if (key_cmd < 0) {
ret = key_cmd;
goto out;
}
if (!options->keyhandle) {
ret = -EINVAL;
goto out;
}
dump_payload(payload);
dump_options(options);
switch (key_cmd) {
case Opt_load:
if (tpm2)
ret = tpm_unseal_trusted(TPM_ANY_NUM, payload, options);
else
ret = key_unseal(payload, options);
dump_payload(payload);
dump_options(options);
if (ret < 0)
pr_info("trusted_key: key_unseal failed (%d)\n", ret);
break;
case Opt_new:
key_len = payload->key_len;
ret = tpm_get_random(TPM_ANY_NUM, payload->key, key_len);
if (ret != key_len) {
pr_info("trusted_key: key_create failed (%d)\n", ret);
goto out;
}
if (tpm2)
ret = tpm_seal_trusted(TPM_ANY_NUM, payload, options);
else
ret = key_seal(payload, options);
if (ret < 0)
pr_info("trusted_key: key_seal failed (%d)\n", ret);
break;
default:
ret = -EINVAL;
goto out;
}
if (!ret && options->pcrlock)
ret = pcrlock(options->pcrlock);
out:
kfree(datablob);
kfree(options);
if (!ret)
rcu_assign_keypointer(key, payload);
else
kfree(payload);
return ret;
}
/*---------------------------------------------------------------*/
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 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);
}
/*---------------------------------------------------------------*/
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, 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,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;
}
