NI_group *SUMA_NewAfniSurfaceObjectTriangle(void)
{
static char FuncName[]={"SUMA_NewAfniSurfaceObjectTriangle"};
NI_element *nel=NULL;
NI_group *ngr=NULL;
SUMA_ENTRY;
ngr = NI_new_group_element();
NI_rename_group(ngr, "Gifti_Triangle");
nel = NI_new_data_element("Mesh_IJK", 1);
NI_add_to_group(ngr, nel);
SUMA_RETURN(ngr);
}
NI_group *SUMA_NewAfniSurfaceObjectNormals(void)
{
static char FuncName[]={"SUMA_NewAfniSurfaceObjectNormals"};
NI_element *nel=NULL;
NI_group *ngr=NULL;
SUMA_ENTRY;
ngr = NI_new_group_element();
NI_rename_group(ngr, "Gifti_Normals");
nel = NI_new_data_element("Node_Normals", 1);
NI_add_to_group(ngr, nel);
SUMA_RETURN(ngr);
}
NI_group *SUMA_NewAfniSurfaceObjectPointset(void)
{
static char FuncName[]={"SUMA_NewAfniSurfaceObjectPointset"};
NI_element *nel=NULL;
NI_group *ngr=NULL;
SUMA_ENTRY;
ngr = NI_new_group_element();
NI_rename_group(ngr, "Gifti_Pointset");
nel = NI_new_data_element("Node_XYZ", 4251);
NI_add_to_group(ngr, nel);
nel = NI_new_data_element("Coord_System", 16);
NI_add_column(nel,NI_DOUBLE,NULL);
NI_add_to_group(ngr, nel);
SUMA_RETURN(ngr);
}
NI_group *SUMA_NewAfniSurfaceObject(void)
{
static char FuncName[]={"SUMA_NewAfniSurfaceObject"};
NI_group *aSO=NULL;
NI_group *ngr=NULL;
SUMA_ENTRY;
aSO = NI_new_group_element();
NI_rename_group(aSO, "SurfaceObject");
ngr = SUMA_NewAfniSurfaceObjectTriangle();
NI_add_to_group(aSO, ngr);
ngr = SUMA_NewAfniSurfaceObjectPointset();
NI_add_to_group(aSO, ngr);
ngr = SUMA_NewAfniSurfaceObjectNormals();
NI_add_to_group(aSO, ngr);
SUMA_RETURN(aSO);
}
int main( int argc , char *argv[] )
{
COMM_STRUCT *cs = NULL;
NI_group *ngr = NULL;
char sss[256]={""};
int i, nn;
/* mini parsing of command line */
nn = 1;
while (nn < argc && argv[nn][0] == '-') {
if (!strcmp(argv[nn], "-help") || !strcmp(argv[nn], "-h")) {
HalloSuma_usage(strlen(argv[nn]) > 3 ? 2:1);
exit(0);
}
++nn;
}
/* Initialize the communications structure */
cs = NewCommStruct(NULL, -1);
/*------------------------------------------------------*/
/******************** Ruf SUMA an ***********************/
/*------------------------------------------------------*/
if (!SendToSuma(cs, NULL, 0)) { /* buzz SUMA */
fprintf (stderr,"Failed to initiate call suma\n");
exit(1);
}
/* Next comes two sections illustrating how to send, and how
to receive. These two operations occur asynchronously in
an interactive program. Sending is usually triggered by
a user event in the developer's program (exemplified by HalloSuma).
Receiving can happen any time SUMA sends something, so the
function that checks for incoming elements should be added to
the developer's program workprocess functions. */
/*------------------------------------------------------*/
/***************** Sending Example **********************/
/*------------------------------------------------------*/
/* This next block sends a bunch of commands to SUMA asking it
to jump to particular nodes.
Each command consists of a NIML element that is formatted a la DriveSuma.
I adopted this approach because DriveSuma can then serve as an
example for how to format a large number of commands.
For example, to see the element that DriveSuma sends to SUMA when
asking it to jump node 28, you can run:
DriveSuma -echo_nel_stdout -com viewer_cont '-key:v28' j
*/
ngr = NI_new_group_element();
NI_rename_group(ngr, "EngineCommand");/* DriveSuma's element to boss SUMA */
NI_set_attribute(ngr, "Command", "viewer_cont"); /* like -com view_cont */
NI_set_attribute(ngr,"N_Key","1"); /* like -key option */
NI_set_attribute(ngr,"Key_0","j");
NI_set_attribute(ngr,"Key_rep_0","1");
NI_set_attribute(ngr,"Key_pause_0","0");
NI_set_attribute(ngr,"Key_redis_0","1");
for (i=0; i<10; ++i) { /* Send a bunch of calls to SUMA, reusing element*/
/* Make SUMA jump somewhere to nodes i*/
sprintf(sss,"v%d",i);
NI_set_attribute(ngr,"Key_strval_0",sss);
if (!SendToSuma(cs, ngr, 1)) {
fprintf (stderr,"Failed to send item %d\n", i);
}
}
NI_free(ngr); ngr=NULL; /* Done with this element, free it */
/*------------------------------------------------------*/
/***************** Receiving Example ********************/
/*------------------------------------------------------*/
/* Here we'll go into a listening loop that will only end
when the connection is broken.
Normally, Hallo_niml_workproc() is the kind of function that
gets registered with an application's main loop which would
take care of calling Hallo_niml_workproc() in each application loop cycle.
For the sake of simplicity, we'll do it the simple way here */
while (!Hallo_niml_workproc((void *)cs)) {
NI_sleep(100); /* 100 msec nap - not needed in real worprocess*/
}
/*------------------------------------------------------*/
/************ Be nice and hang up nicely ****************/
/*------------------------------------------------------*/
if (!SendToSuma(cs, NULL, 2)) { /* terminate call to SUMA */
fprintf (stderr,"Failed to close call suma\n");
exit(1);
}
free(cs); cs = NULL;
exit(0);
}
SEXP R_THD_write_dset(SEXP Sfname, SEXP Sdset, SEXP Opts)
{
SEXP Rdset, brik, head, names, opt, node_list;
int i=0, ip=0, sb, cnt=0, scale = 1, overwrite=0, addFDR=0,
kparts=2, *iv=NULL;
char *fname = NULL, *head_str, *stmp=NULL, *hist=NULL;
NI_group *ngr=NULL;
NI_element *nel=NULL;
char *listels[3] = {"head","brk","index_list"}; /* the brk is on purpose
for backward compatibility */
double *dv=NULL;
float *fv=NULL;
THD_3dim_dataset *dset = NULL;
int debug=0;
if (!debug) debug = get_odebug();
/* get the options list, maybe */
PROTECT(Opts = AS_LIST(Opts));
if ((opt = getListElement(Opts,"debug")) != R_NilValue) {
debug = (int)INTEGER_VALUE(opt);
if (debug>2) set_odebug(debug);
if (debug > 1) INFO_message("Debug is %d\n", debug);
}
/* get the filename */
PROTECT(Sfname = AS_CHARACTER(Sfname));
fname = R_alloc(strlen(CHAR(STRING_ELT(Sfname,0)))+1, sizeof(char));
strcpy(fname, CHAR(STRING_ELT(Sfname,0)));
if (debug >1) INFO_message("Output filename %s\n"
, fname);
/* get the dset structure elements */
PROTECT(Rdset = AS_LIST(Sdset));
if ((head = AS_CHARACTER(getListElement(Rdset,"head"))) == R_NilValue) {
ERROR_message("No header found");
UNPROTECT(3);
return(R_NilValue);
}
if (debug > 1) INFO_message("First head element %s\n"
, CHAR(STRING_ELT(head,0)));
if ((brik = AS_NUMERIC(getListElement(Rdset,"brk"))) == R_NilValue) {
ERROR_message("No brick found");
UNPROTECT(3);
return(R_NilValue);
}
dv = NUMERIC_POINTER(brik);
if (debug > 1) INFO_message("First brik value %f\n"
, dv[0]);
ngr = NI_new_group_element();
NI_rename_group(ngr, "AFNI_dataset" );
NI_set_attribute(ngr,"AFNI_prefix", fname);
if ((opt = getListElement(Opts,"idcode")) != R_NilValue) {
opt = AS_CHARACTER(opt);
stmp = (char *)(CHAR(STRING_ELT(opt,0)));
if (stmp && !strcmp(stmp,"SET_AT_WRITE_FILENAME")) {
stmp = UNIQ_hashcode(fname);
NI_set_attribute(ngr, "AFNI_idcode", stmp);
free(stmp);
} else if (stmp && !strcmp(stmp,"SET_AT_WRITE_RANDOM")) {
stmp = UNIQ_idcode() ;
NI_set_attribute(ngr, "AFNI_idcode", stmp);
free(stmp);
} else if (stmp) {
NI_set_attribute(ngr, "AFNI_idcode",
(char *)(CHAR(STRING_ELT(opt,0))));
}
}
if ((opt = getListElement(Opts,"scale")) != R_NilValue) {
scale = (int)INTEGER_VALUE(opt);
if (debug > 1) INFO_message("Scale is %d\n", scale);
}
if ((opt = getListElement(Opts,"overwrite")) != R_NilValue) {
overwrite = (int)INTEGER_VALUE(opt);
if (debug > 1) INFO_message("overwrite is %d\n", overwrite);
THD_force_ok_overwrite(overwrite) ;
if (overwrite) THD_set_quiet_overwrite(1);
}
if ((opt = getListElement(Opts,"addFDR")) != R_NilValue) {
addFDR = (int)INTEGER_VALUE(opt);
if (debug > 1) INFO_message("addFDR is %d\n", addFDR);
}
PROTECT(opt = getListElement(Opts,"hist"));
if ( opt != R_NilValue) {
opt = AS_CHARACTER(opt);
hist = R_alloc(strlen(CHAR(STRING_ELT(opt,0)))+1, sizeof(char));
strcpy(hist, CHAR(STRING_ELT(opt,0)));
if (debug > 1) INFO_message("hist is %s\n", hist);
}
UNPROTECT(1);
for (ip=0,i=0; i<length(head); ++i) {
head_str = (char *)CHAR(STRING_ELT(head,i));
if (debug > 1) {
INFO_message("Adding %s\n", head_str);
}
nel = NI_read_element_fromstring(head_str);
if (!nel->vec) {
ERROR_message("Empty attribute vector for\n%s\n"
"This is not expected.\n",
head_str);
UNPROTECT(3);
return(R_NilValue);
}
NI_add_to_group(ngr,nel);
}
if (debug > 1) INFO_message("Creating dset header\n");
if (!(dset = THD_niml_to_dataset(ngr, 1))) {
ERROR_message("Failed to create header");
UNPROTECT(3);
return(R_NilValue);
}
if (debug > 2) {
INFO_message("Have header of %d, %d, %d, %d, scale=%d\n",
DSET_NX(dset), DSET_NY(dset),
DSET_NZ(dset), DSET_NVALS(dset), scale);
}
for (i=0; i<DSET_NVALS(dset); ++i) {
if (debug > 2) {
INFO_message("Putting values in sub-brick %d, type %d\n",
i, DSET_BRICK_TYPE(dset,i));
}
if ( ( DSET_BRICK_TYPE(dset,i) == MRI_byte ||
DSET_BRICK_TYPE(dset,i) == MRI_short ) ) {
EDIT_substscale_brick(dset, i,
MRI_double, dv+i*DSET_NVOX(dset),
DSET_BRICK_TYPE(dset,i), scale ? -1.0:1.0);
} else if ( DSET_BRICK_TYPE(dset,i) == MRI_double ) {
EDIT_substitute_brick(dset, i,
MRI_double, dv+i*DSET_NVOX(dset));
} else if ( DSET_BRICK_TYPE(dset,i) == MRI_float ) {
float *ff=(float*)calloc(DSET_NVOX(dset), sizeof(float));
double *dvi=dv+i*DSET_NVOX(dset);
for (ip=0; ip<DSET_NVOX(dset); ++ip) {
ff[ip] = dvi[ip];
}
EDIT_substitute_brick(dset, i, MRI_float, ff);
}
}
/* THD_update_statistics( dset ) ; */
if (addFDR) {
DSET_BRICK_FDRCURVE_ALLKILL(dset) ;
DSET_BRICK_MDFCURVE_ALLKILL(dset) ; /* 22 Oct 2008 */
if( addFDR > 0 ){
int nFDRmask=0; /* in the future, perhaps allow for a mask */
byte *FDRmask=NULL; /* to be sent in also, for now, mask is exact */
/* 0 voxels . */
mri_fdr_setmask( (nFDRmask == DSET_NVOX(dset)) ? FDRmask : NULL ) ;
ip = THD_create_all_fdrcurves(dset) ;
if( ip > 0 ){
if (debug)
ININFO_message("created %d FDR curve%s in dataset header",
ip,(ip==1)?"\0":"s") ;
} else {
if (debug)
ININFO_message("failed to create FDR curves in dataset header") ;
}
}
}
/* Do we have an index_list? */
if ((node_list=AS_INTEGER(getListElement(Rdset,"index_list")))!=R_NilValue) {
iv = INTEGER_POINTER(node_list);
if (debug > 1) INFO_message("First node index value %d, total (%d)\n",
iv[0], length(node_list));
dset->dblk->nnodes = length(node_list);
dset->dblk->node_list = (int *)XtMalloc(dset->dblk->nnodes * sizeof(int));
memcpy(dset->dblk->node_list, iv, dset->dblk->nnodes*sizeof(int));
}
if (hist) {
tross_Append_History(dset, hist);
}
DSET_write(dset);
UNPROTECT(3);
return(R_NilValue);
}
