/***********************************************************************//**
* @brief Return pointer on child walking down a hierarchy of tags (const
* version)
*
* @param[in] name Child element hierarchy.
* @return Pointer to child element (NULL if element does not exist).
*
* @exception GException::invalid_argument
* Hierarchy string invalid.
*
* Returns a pointer to the child element described by a hierarchy of the
* following syntax
*
* params > param[1] > value > struct
*
* The > symbols indicate subsequent hierarchy levels, the square brackets
* provides the index in case that multiple tags with the same name exist
* at a given hierarchy level. Omitting the index means that the first
* tag with the specified name is accessed.
*
* If the specified element does not exist the method returns a NULL pointer.
***************************************************************************/
const GXmlElement* GXmlNode::element(const std::string& name) const
{
// Initialise child node pointer
const GXmlElement* element = NULL;
// Split name into tags
std::vector<std::string> tags = gammalib::split(name, ">");
// Walk down the hierarchy
const GXmlNode* current = this;
for (int i = 0; i < tags.size(); ++i) {
// Get tag name and index
std::string tag = gammalib::strip_whitespace(tags[i]);
int index = extract_index(tag);
// Break if the requested node does not exist
int n = current->elements(tag);
if (n < 1 || index < 0 || index >= n) {
element = NULL;
break;
}
// Get node
element = current->element(tag, index);
current = element;
// Break if node has not been found
if (current == NULL) {
element = NULL;
break;
}
} // endfor: walked down hierarchy
// Return child element
return element;
}
static char * EXTRACT_main( PLUGIN_interface * plint )
{
extract_data uda,*ud;
MRI_IMAGE * tsim;
MCW_idcode * idc ; /* input dataset idcode */
THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */
char *tmpstr , * str , *nprfxstr;
int ntime, nvec ,nprfx, Err=0 , itmp;
float * vec , fs , T ;
char * tag; /* plugin option tag */
/* Allocate as much character space as Bob specifies in afni.h + a bit more */
tmpstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char));
nprfxstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char));
if (tmpstr == NULL || nprfxstr == NULL)
return "********************\n"
"Could not Allocate\n"
"a teeni weeni bit of\n"
"Memory ! Go complain\n"
"to yer Mamma ! \n"
"********************\n";
ud = &uda; /* ud now points to an allocated space */
ud->errcode = 0; /*reset error flag */
/*--------------------------------------------------------------------*/
/*----- Check inputs from AFNI to see if they are reasonable-ish -----*/
/*--------- go to first input line ---------*/
tag = PLUTO_get_optiontag(plint) ;
if (tag == NULL)
{
return "************************\n"
"Bad 1st line option \n"
"************************" ;
}
idc = PLUTO_get_idcode(plint) ; /* get dataset item */
old_dset = PLUTO_find_dset(idc) ; /* get ptr to dataset */
if( old_dset == NULL )
return "*************************\n"
"Cannot find Input Dataset\n"
"*************************" ;
ud->dsetname = DSET_FILECODE (old_dset);
ud->ignore = PLUTO_get_number(plint) ; /* get number item */
str = PLUTO_get_string(plint) ;
ud->dtrnd = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings );
/*--------- loop over ramining options ---------*/
ud->iloc = -1;
ud->xloc = -1;
ud->yloc = -1;
ud->zloc = -1;
do
{
tag = PLUTO_get_optiontag(plint) ;
if (tag == NULL) break;
if (strcmp (tag, "Mask") == 0)
{
ud->strin = PLUTO_get_string(plint) ;
ud->ncols = PLUTO_get_number(plint) ;
ud->pass = PLUTO_get_number(plint) ;
ud->fail = 0; /* Set voxels that don't make it to 0 */
continue;
}
if (strcmp (tag, "Index") == 0)
{
ud->iloc = PLUTO_get_number(plint) ; /* get number item */
continue;
}
if (strcmp (tag, "XYZ") == 0)
{
ud->xloc = PLUTO_get_number(plint) ; /* get number item */
ud->yloc = PLUTO_get_number(plint) ; /* get number item */
ud->zloc = PLUTO_get_number(plint) ; /* get number item */
continue;
}
if (strcmp (tag, "Output") == 0)
{
ud->new_prefix = PLUTO_get_string(plint) ; /* get string item (the output prefix) */
/* check to see if the field is empty */
if (ud->new_prefix == NULL)
nprfx = 0;
else
nprfx = 1;
/* check if the size is larger than 0. I did not want to check for this unless it's allocated */
if (nprfx == 1 && (int)strlen (ud->new_prefix) == 0)
nprfx = 0;
if (nprfx == 0) /* now create the new name and make new_prefix point to it */
{
sprintf (nprfxstr,"%s.XTRCT",DSET_PREFIX (old_dset));
ud->new_prefix = nprfxstr;
/*printf ("New prefix is set to be : %s\n\a",ud->new_prefix);*/
}
if( ! PLUTO_prefix_ok(ud->new_prefix) ) /* check if it is OK */
return "************************\n"
"Output Prefix is illegal\n"
"************************" ;
ud->strout = PLUTO_get_string(plint) ;
str = PLUTO_get_string(plint) ;
ud->format = (int)PLUTO_string_index( str , NUM_FORMAT_STRINGS , format_strings );
continue;
}
} while (1);
/* ------------------ Check for some errorsor inconsistencies ------------- */
if (ud->iloc == -1 && ud->xloc == -1)
{
return "**************************\n"
"At least iloc or x/y/zloc\n"
"must be specified\n"
"**************************\n"
;
}
if (ud->iloc != -1 && ud->xloc != -1)
{
return "***************************\n"
"iloc AND x/y/zloc can not\n"
"be simultaneously specified\n"
"***************************\n"
;
}
/* ------------------Done with user parameters ---------------------------- */
/* Now loadup that index list or the xyz list */
if (ud->iloc != -1)
{
itmp = 0; /* might want to give option of setting it to number of rows if*/
/* the users know it, otherwise, it is automatically determined*/
ud->indvect = extract_index (ud->strin, ud->iloc, ud->ncols, &itmp, &Err);
}
else /* assuming the only other case is that x y z are specified */
{
itmp = 0;
ud->xyzvect = extract_xyz (ud->strin , ud->xloc , ud->yloc , ud->zloc , ud->ncols, &itmp, &Err);
}
ud->nrows = itmp;
switch (Err)
{
case (0):
break;
case (1):
return "****************************************\n"
"index location should be > 0 and < ncols\n"
"****************************************\n";
case (2):
return "********************************************\n"
"file size and number of columns do not match\n"
"********************************************\n";
case (3):
return "**********************\n"
"Can't find matrix file\n"
"**********************\n";
case (4):
return "*****************\n"
"ncols must be > 0\n"
"*****************\n";
case (5):
return "****************************************\n"
"x/y/z column numbers can NOT be the same\n"
"****************************************\n";
default:
return "****************************************\n"
"Should not have gotten here .....\n"
"****************************************\n";
}
if (strcmp (ud->strout,"") == 0) /* no output file is specified */
{
sprintf ( tmpstr , "%s" , ud->new_prefix);
ud->strout = tmpstr;
}
if (filexists(ud->strout) == 1)
{
return "*******************************\n"
"Outfile exists, won't overwrite\n"
"*******************************\n";
}
ud->outwritets = fopen (ud->strout ,"w");
sprintf ( tmpstr , "%s.log" , ud->strout);
if (filexists(tmpstr) == 1)
{
return "*******************************\n"
"Outfile.log exists, won't overwrite\n"
"*******************************\n";
}
ud->outlogfile = fopen (tmpstr ,"w");
if ((ud->outwritets == NULL) || (ud->outlogfile == NULL) )
{
ud->errcode = ERROR_FILEWRITE;
return "***********************\n"
"Could Not Write Outfile\n"
"***********************\n";
}
ud->nxx = (int)old_dset->daxes->nxx; /* get data set dimensions */
ud->nyy = (int)old_dset->daxes->nyy;
ud->nzz = (int)old_dset->daxes->nzz;
/* ready to dump the log file */
write_ud (ud);
/*------------- ready to compute new dataset -----------*/
new_dset = PLUTO_4D_to_typed_fim( old_dset , /* input dataset */
ud->new_prefix , /* output prefix */
-1, /* negative value indicating data type is like original brick */
ud->ignore , /* ignore count */
ud->dtrnd , /* detrend */
EXTRACT_tsfunc , /* timeseries processor */
(void *)ud /* data for tsfunc */
) ;
PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ;
fclose (ud->outlogfile);
fclose (ud->outwritets);
free (tmpstr);
free (nprfxstr);
return NULL ; /* null string returned means all was OK */
}
RESULT firstpic_bi(FILE *mainfile, FILE *indexfile, FILE *bindexfile,
char **seqname, long *from, long *to, int step){
static char *preseqname=NULL;
static size_t namelength=MAXLETTER_FIRSTPIC_B;
static off_t position;
char tmp[MAXLETTER_FIRSTPIC_B];
long seqlength;
RESULT result;
/* initialize */
if(preseqname==NULL){
/*preseqname=(char *)calloc(namelength,sizeof(char));*/
preseqname=(char *)malloc(namelength);
preseqname[0]='\0';
}
result.namebuffer=strlen(*seqname)+10;
result.name=(char *)malloc(result.namebuffer);
strcpy(result.name, *seqname); /* search key is *seqname */
/* search for index position by binary index */
if(strcmp(preseqname,result.name)!=0){
preseqname[0]='\0';
seqlength=strlen(result.name);
if(seqlength+4>namelength){
namelength=seqlength+MAXLETTER_FIRSTPIC_B;
preseqname=(char *)realloc(preseqname,namelength*sizeof(char *));
}
strcpy(preseqname,result.name);
/*fprintf(stderr,"search: [%s]\n",preseqname);*/
position=bi_tree_search(bindexfile, indexfile, result.name);
}
if (position==-1) {
result.sequence=NULL;
return result;
}
/* search sequence position from normal index */
fseeko(indexfile,position,SEEK_SET);
/* get full sequence name */
if(result.name!=NULL){free(result.name); result.name=NULL; }
/*uhmin_fgets(&tmpseqname,MAXLETTER_FIRSTPIC_B-1,indexfile);*/
uhmin_fgets(&result.name, MAXLETTER_FIRSTPIC_B-1, indexfile);
/* get sequence */
result.sequence=extract_index(mainfile, indexfile, from, to, step, result);
if (*from!=0 && *to!=0){
/* add region information to seqname */
seqlength=strlen(result.name);
chomp(result.name);
sprintf(tmp," from=%ld, to=%ld\n",*from,*to);
result.name=(char *)realloc(result.name,(seqlength+strlen(tmp)+3)*sizeof(char));
strcat(result.name,tmp);
}
if(*seqname!=NULL){free(*seqname); *seqname=NULL;}
*seqname=result.name;
return result;
}
