00001
00002 #define DEBUG_3
00003 #ifdef DEBUG_1
00004 #define DEBUG_2
00005 #define DEBUG_3
00006 #endif
00007
00008
00009
00010 #include "SUMA_suma.h"
00011
00012 #ifdef STAND_ALONE
00013 SUMA_CommonFields *SUMAg_CF;
00014 #else
00015 extern SUMA_CommonFields *SUMAg_CF;
00016 #endif
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031 SUMA_ENGINE_CODE SUMA_GetListNextCommand (DList *list)
00032 {
00033 static char FuncName[]={"SUMA_GetListNextCommand"};
00034 DListElmt *next;
00035 SUMA_EngineData *ED = NULL;
00036
00037 SUMA_ENTRY;
00038
00039 if (!dlist_size(list)) {
00040 SUMA_RETURN (SE_Empty);
00041 }
00042
00043 next = (DListElmt *)dlist_head(list);
00044 ED = (SUMA_EngineData *)(next->data);
00045 SUMA_RETURN (ED->CommandCode);
00046
00047 }
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077 int SUMA_GetNextCommand (char *S, char d, char term, char *Scom)
00078 {
00079 static char FuncName[]={"SUMA_GetNextCommand"};
00080 int i=0, iBegin, iStop;
00081
00082 SUMA_ENTRY;
00083
00084 fprintf (SUMA_STDERR, "Error %s: This function is now obsolete. Must use SUMA_GetListNextCommand instead.\n", FuncName);
00085 SUMA_RETURN (NOPE);
00086
00087 iStop = strlen(S)-1;
00088
00089
00090 if (S[iStop] != term) {
00091 fprintf (stderr, "%s Error: Command poorly terminated!\n\a", FuncName);
00092 SUMA_RETURN (0);
00093 }
00094
00095 if (S[iStop-1] == d) {
00096 S[iStop] = '\0';
00097 iStop -= 1;
00098 S[iStop] = term;
00099 }
00100
00101
00102 iBegin = iStop -1;
00103 while (iBegin > -1 && S[iBegin]!= d) --iBegin;
00104 ++iBegin;
00105
00106
00107 for (i=0; i< iStop - iBegin; ++i) {
00108
00109 Scom[i] = S[iBegin+i];
00110 S[iBegin+i] = '\0'; }
00111
00112
00113 Scom[iStop-iBegin] = '\0';
00114 if (iBegin > 0) {
00115 S[iBegin-1] = term;
00116 iStop = iBegin-1;
00117 }
00118 else {
00119 S[iBegin] = term;
00120 iStop = iBegin;
00121
00122 }
00123
00124
00125 SUMA_RETURN (SUMA_CommandCode(Scom));
00126
00127 }
00128
00129 int SUMA_CommandCode(char *Scom)
00130 {
00131 static char FuncName[]={"SUMA_CommandCode"};
00132
00133 SUMA_ENTRY;
00134
00135 if (!strlen(Scom)) SUMA_RETURN (SE_Empty);
00136 if (strcmp(Scom,"~") == 0) SUMA_RETURN (SE_Empty);
00137
00138
00139 if (!strcmp(Scom,"SetLookAt")) SUMA_RETURN(SE_SetLookAt);
00140 if (!strcmp(Scom,"SetLookFrom")) SUMA_RETURN(SE_SetLookFrom);
00141 if (!strcmp(Scom,"Redisplay")) SUMA_RETURN(SE_Redisplay);
00142 if (!strcmp(Scom,"RedisplayNow")) SUMA_RETURN(SE_RedisplayNow);
00143 if (!strcmp(Scom,"Redisplay_AllVisible")) SUMA_RETURN(SE_Redisplay_AllVisible);
00144 if (!strcmp(Scom,"SetNodeColor")) SUMA_RETURN (SE_SetNodeColor);
00145 if (!strcmp(Scom,"FlipLight0Pos")) SUMA_RETURN(SE_FlipLight0Pos);
00146 if (!strcmp(Scom,"GetNearestNode")) SUMA_RETURN (SE_GetNearestNode);
00147 if (!strcmp(Scom,"SetLookAtNode")) SUMA_RETURN (SE_SetLookAtNode);
00148 if (!strcmp(Scom,"SetRotMatrix")) SUMA_RETURN (SE_SetRotMatrix);
00149 if (!strcmp(Scom,"SetCrossHair")) SUMA_RETURN (SE_SetCrossHair);
00150 if (!strcmp(Scom,"ToggleCrossHair")) SUMA_RETURN (SE_ToggleCrossHair);
00151 if (!strcmp(Scom,"HighlightNodes")) SUMA_RETURN (SE_HighlightNodes);
00152 if (!strcmp(Scom,"ToggleShowSelectedNode")) SUMA_RETURN (SE_ToggleShowSelectedNode);
00153 if (!strcmp(Scom,"SetSelectedNode")) SUMA_RETURN (SE_SetSelectedNode);
00154 if (!strcmp(Scom,"SetSelectedFaceSet")) SUMA_RETURN (SE_SetSelectedFaceSet);
00155 if (!strcmp(Scom,"ToggleShowSelectedFaceSet")) SUMA_RETURN (SE_ToggleShowSelectedFaceSet);
00156 if (!strcmp(Scom,"ToggleConnected")) SUMA_RETURN (SE_ToggleConnected);
00157 if (!strcmp(Scom,"StartListening")) SUMA_RETURN(SE_StartListening);
00158 if (!strcmp(Scom,"SetAfniCrossHair")) SUMA_RETURN (SE_SetAfniCrossHair);
00159 if (!strcmp(Scom,"SetForceAfniSurf")) SUMA_RETURN (SE_SetForceAfniSurf);
00160 if (!strcmp(Scom,"CloseStream4All")) SUMA_RETURN (SE_CloseStream4All);
00161 if (!strcmp(Scom,"SetAfniSurf")) SUMA_RETURN (SE_SetAfniSurf);
00162 if (!strcmp(Scom,"SetAfniThisSurf")) SUMA_RETURN (SE_SetAfniThisSurf);
00163 if (!strcmp(Scom,"SetAfniSurfList")) SUMA_RETURN (SE_SetAfniSurfList);
00164 if (!strcmp(Scom,"BindCrossHair")) SUMA_RETURN(SE_BindCrossHair);
00165 if (!strcmp(Scom,"ToggleForeground")) SUMA_RETURN (SE_ToggleForeground);
00166 if (!strcmp(Scom,"ToggleBackground")) SUMA_RETURN (SE_ToggleBackground);
00167 if (!strcmp(Scom,"FOVreset")) SUMA_RETURN (SE_FOVreset);
00168 if (!strcmp(Scom,"ResetOpenGLState")) SUMA_RETURN (SE_ResetOpenGLState);
00169 if (!strcmp(Scom,"LockCrossHair")) SUMA_RETURN(SE_LockCrossHair);
00170 if (!strcmp(Scom,"Home")) SUMA_RETURN (SE_Home);
00171 if (!strcmp(Scom,"Home_AllVisible")) SUMA_RETURN (SE_Home_AllVisible);
00172 if (!strcmp(Scom,"ToggleLockAllCrossHair")) SUMA_RETURN(SE_ToggleLockAllCrossHair);
00173 if (!strcmp(Scom,"SetLockAllCrossHair")) SUMA_RETURN(SE_SetLockAllCrossHair);
00174 if (!strcmp(Scom,"ToggleLockView")) SUMA_RETURN(SE_ToggleLockView);
00175 if (!strcmp(Scom,"ToggleLockAllViews")) SUMA_RETURN(SE_ToggleLockAllViews);
00176 if (!strcmp(Scom,"Load_Group")) SUMA_RETURN(SE_Load_Group);
00177 if (!strcmp(Scom,"Help")) SUMA_RETURN(SE_Help);
00178 if (!strcmp(Scom,"Help_Cmap")) SUMA_RETURN(SE_Help_Cmap);
00179 if (!strcmp(Scom,"UpdateLog")) SUMA_RETURN(SE_UpdateLog);
00180 if (!strcmp(Scom,"Log")) SUMA_RETURN(SE_Log);
00181 if (!strcmp(Scom,"SetRenderMode")) SUMA_RETURN(SE_SetRenderMode);
00182 if (!strcmp(Scom,"OpenDrawROI")) SUMA_RETURN(SE_OpenDrawROI);
00183 if (!strcmp(Scom,"RedisplayNow_AllVisible")) SUMA_RETURN(SE_RedisplayNow_AllVisible);
00184 if (!strcmp(Scom,"RedisplayNow_AllOtherVisible")) SUMA_RETURN(SE_RedisplayNow_AllOtherVisible);
00185 if (!strcmp(Scom,"SetLight0Pos")) SUMA_RETURN(SE_SetLight0Pos);
00186 if (!strcmp(Scom,"OpenColFileSelection")) SUMA_RETURN(SE_OpenColFileSelection);
00187 if (!strcmp(Scom,"OpenDsetFileSelection")) SUMA_RETURN(SE_OpenDsetFileSelection);
00188 if (!strcmp(Scom,"OpenCmapFileSelection")) SUMA_RETURN(SE_OpenCmapFileSelection);
00189 if (!strcmp(Scom,"SaveDrawnROIFileSelection")) SUMA_RETURN(SE_SaveDrawnROIFileSelection);
00190 if (!strcmp(Scom,"OpenDrawnROIFileSelection")) SUMA_RETURN(SE_OpenDrawnROIFileSelection);
00191 if (!strcmp(Scom,"SendColorMapToAfni")) SUMA_RETURN(SE_SendColorMapToAfni);
00192 if (!strcmp(Scom,"SaveSOFileSelection")) SUMA_RETURN(SE_SaveSOFileSelection);
00193 if (!strcmp(Scom,"SetSOinFocus")) SUMA_RETURN(SE_SetSOinFocus);
00194 if (!strcmp(Scom,"LoadViewFileSelection")) SUMA_RETURN(SE_LoadViewFileSelection);
00195 if (!strcmp(Scom,"SaveViewFileSelection")) SUMA_RETURN(SE_SaveViewFileSelection);
00196 if (!strcmp(Scom,"LoadSegDO")) SUMA_RETURN(SE_LoadSegDO);
00197
00198
00199
00200 SUMA_RETURN (SE_BadCode);
00201
00202 }
00203
00204 const char *SUMA_ColMixModeString (SUMA_COL_MIX_MODE mode)
00205 {
00206 static char FuncName[]={"SUMA_ColMixModeString"};
00207
00208 SUMA_ENTRY;
00209
00210 switch (mode) {
00211 case SUMA_BAD_MODE:
00212 SUMA_RETURN("BadMode");
00213 case SUMA_ORIG_MIX_MODE:
00214 SUMA_RETURN("ORIG");
00215 case SUMA_4AML:
00216 SUMA_RETURN("MOD1");
00217 default:
00218 SUMA_RETURN("VeryBadMode");
00219 }
00220
00221 }
00222
00223 const char *SUMA_DomainKinships_String (SUMA_DOMAIN_KINSHIPS code)
00224 {
00225 static char FuncName[]={"SUMA_DomainKinships_String"};
00226
00227 SUMA_ENTRY;
00228
00229 switch (code) {
00230 case SUMA_DOMAINS_ERROR:
00231 SUMA_RETURN("Code Error");
00232 case SUMA_DOMAINS_NOT_RELATED:
00233 SUMA_RETURN("Surfaces domains not related");
00234 case SUMA_SO1_is_SO2:
00235 SUMA_RETURN("Surfaces are the same (identical idcodes)");
00236 case SUMA_SO1_is_LDPSO2:
00237 SUMA_RETURN("Surface 1 is the local domain parent of Surface 2");
00238 case SUMA_SO2_is_LDPSO1:
00239 SUMA_RETURN("Surface 2 is the local domain parent of Surface 1");
00240 case SUMA_NUCELAR_FAMILY:
00241 SUMA_RETURN("Flag for nuclear family flag limit");
00242 case SUMA_LDPSO1_is_LDPSO2:
00243 SUMA_RETURN("Surfaces have same domain grandparent");
00244 case SUMA_SO1_is_GPSO2:
00245 SUMA_RETURN("Surface 1 is the domain grandparent of Surface 2");
00246 case SUMA_SO2_is_GPSO1:
00247 SUMA_RETURN("Surface 2 is the domain grandparent of Surface 1");
00248 default:
00249 SUMA_RETURN("Should not see this");
00250 }
00251
00252 SUMA_RETURN("Should not see this either");
00253 }
00254
00255
00256
00257
00258
00259 const char *SUMA_CommandString (SUMA_ENGINE_CODE code)
00260 {
00261 static char FuncName[]={"SUMA_CommandString"};
00262
00263 SUMA_ENTRY;
00264
00265 switch (code) {
00266 case SE_SetLookAt:
00267 SUMA_RETURN("SetLookAt");
00268 case SE_SetLookFrom:
00269 SUMA_RETURN("SetLookFrom");
00270 case SE_Redisplay:
00271 SUMA_RETURN("Redisplay");
00272 case SE_RedisplayNow:
00273 SUMA_RETURN("RedisplayNow");
00274 case SE_Redisplay_AllVisible:
00275 SUMA_RETURN("Redisplay_AllVisible");
00276 case SE_SetNodeColor:
00277 SUMA_RETURN("SetNodeColor");
00278 case SE_FlipLight0Pos:
00279 SUMA_RETURN("FlipLight0Pos");
00280 case SE_GetNearestNode:
00281 SUMA_RETURN("GetNearestNode");
00282 case SE_SetLookAtNode:
00283 SUMA_RETURN("SetLookAtNode");
00284 case SE_SetRotMatrix:
00285 SUMA_RETURN("SetRotMatrix");
00286 case SE_SetCrossHair:
00287 SUMA_RETURN("SetCrossHair");
00288 case SE_ToggleCrossHair:
00289 SUMA_RETURN("ToggleCrossHair");
00290 case SE_HighlightNodes:
00291 SUMA_RETURN("HighlightNodes");
00292 case SE_ToggleShowSelectedNode:
00293 SUMA_RETURN("ToggleShowSelectedNode");
00294 case SE_SetSelectedNode:
00295 SUMA_RETURN("SetSelectedNode");
00296 case SE_SetSelectedFaceSet:
00297 SUMA_RETURN("SetSelectedFaceSet");
00298 case SE_ToggleShowSelectedFaceSet:
00299 SUMA_RETURN("ToggleShowSelectedFaceSet");
00300 case SE_ToggleConnected:
00301 SUMA_RETURN("ToggleConnected");
00302 case SE_StartListening:
00303 SUMA_RETURN("StartListening");
00304 case SE_SetAfniCrossHair:
00305 SUMA_RETURN("SetAfniCrossHair");
00306 case SE_SetForceAfniSurf:
00307 SUMA_RETURN("SetForceAfniSurf");
00308 case SE_CloseStream4All:
00309 SUMA_RETURN("CloseStream4All");
00310 case SE_SetAfniThisSurf:
00311 SUMA_RETURN("SetAfniThisSurf");
00312 case SE_SetAfniSurf:
00313 SUMA_RETURN("SetAfniSurf");
00314 case SE_SetAfniSurfList:
00315 SUMA_RETURN("SetAfniSurfList");
00316 case SE_BindCrossHair:
00317 SUMA_RETURN("BindCrossHair");
00318 case SE_ToggleForeground:
00319 SUMA_RETURN("ToggleForeground");
00320 case SE_ToggleBackground:
00321 SUMA_RETURN("ToggleBackground");
00322 case SE_FOVreset:
00323 SUMA_RETURN("FOVreset");
00324 case SE_ResetOpenGLState:
00325 SUMA_RETURN("ResetOpenGLState");
00326 case SE_LockCrossHair:
00327 SUMA_RETURN("LockCrossHair");
00328 case SE_Home:
00329 SUMA_RETURN("Home");
00330 case SE_Home_AllVisible:
00331 SUMA_RETURN("Home_AllVisible");
00332 case SE_Empty:
00333 SUMA_RETURN("Empty");
00334 case SE_ToggleLockAllCrossHair:
00335 SUMA_RETURN("ToggleLockAllCrossHair");
00336 case SE_SetLockAllCrossHair:
00337 SUMA_RETURN("SetLockAllCrossHair");
00338 case SE_ToggleLockView:
00339 SUMA_RETURN("ToggleLockView");
00340 case SE_ToggleLockAllViews:
00341 SUMA_RETURN("ToggleLockAllViews");
00342 case SE_Load_Group:
00343 SUMA_RETURN("Load_Group");
00344 case SE_Help:
00345 SUMA_RETURN("Help");
00346 case SE_Help_Cmap:
00347 SUMA_RETURN("Help_Cmap");
00348 case SE_UpdateLog:
00349 SUMA_RETURN("UpdateLog");
00350 case SE_Log:
00351 SUMA_RETURN("Log");
00352 case SE_SetRenderMode:
00353 SUMA_RETURN("SetRenderMode");
00354 case SE_OpenDrawROI:
00355 SUMA_RETURN("OpenDrawROI");
00356 case SE_RedisplayNow_AllVisible:
00357 SUMA_RETURN("RedisplayNow_AllVisible");
00358 case SE_RedisplayNow_AllOtherVisible:
00359 SUMA_RETURN("RedisplayNow_AllOtherVisible");
00360 case SE_SetLight0Pos:
00361 SUMA_RETURN("SetLight0Pos");
00362 case SE_OpenColFileSelection:
00363 SUMA_RETURN("OpenColFileSelection");
00364 case SE_OpenDsetFileSelection:
00365 SUMA_RETURN("OpenDsetFileSelection");
00366 case SE_OpenCmapFileSelection:
00367 SUMA_RETURN("OpenCmapFileSelection");
00368 case SE_SaveDrawnROIFileSelection:
00369 SUMA_RETURN("SaveDrawnROIFileSelection");
00370 case SE_OpenDrawnROIFileSelection:
00371 SUMA_RETURN("OpenDrawnROIFileSelection");
00372 case SE_SendColorMapToAfni:
00373 SUMA_RETURN("SendColorMapToAfni");
00374 case SE_SaveSOFileSelection:
00375 SUMA_RETURN("SaveSOFileSelection");
00376 case SE_SetSOinFocus:
00377 SUMA_RETURN("SetSOinFocus");
00378 case SE_LoadViewFileSelection:
00379 SUMA_RETURN("LoadViewFileSelection");
00380 case SE_SaveViewFileSelection:
00381 SUMA_RETURN("SaveViewFileSelection");
00382 case SE_LoadSegDO:
00383 SUMA_RETURN("LoadSegDO");
00384
00385
00386 default:
00387 SUMA_RETURN ("BadCode");
00388 }
00389 }
00390
00391
00392
00393
00394 const char * SUMA_SurfaceTypeString (SUMA_SO_File_Type tp)
00395 {
00396 static char FuncName[]={"SUMA_SurfaceTypeString"};
00397
00398 SUMA_ENTRY;
00399 switch (tp) {
00400 case SUMA_FT_NOT_SPECIFIED:
00401 SUMA_RETURN("NotSpecified");
00402 break;
00403 case SUMA_FREE_SURFER:
00404 case SUMA_FREE_SURFER_PATCH:
00405 SUMA_RETURN("FreeSurfer");
00406 break;
00407 case SUMA_SUREFIT:
00408 SUMA_RETURN("SureFit");
00409 break;
00410 case SUMA_INVENTOR_GENERIC:
00411 SUMA_RETURN("GenericInventor");
00412 break;
00413 case SUMA_PLY:
00414 SUMA_RETURN("Ply");
00415 break;
00416 case SUMA_BRAIN_VOYAGER:
00417 SUMA_RETURN("BrainVoyager");
00418 break;
00419 case SUMA_VEC:
00420 SUMA_RETURN("1D");
00421 break;
00422 case SUMA_OPENDX_MESH:
00423 SUMA_RETURN("OpenDX");
00424 break;
00425 case SUMA_FT_ERROR:
00426 SUMA_RETURN("Error");
00427 default:
00428 SUMA_RETURN ("Error");
00429 }
00430 }
00431
00432
00433
00434
00435 SUMA_SO_File_Type SUMA_SurfaceTypeCode (char *cd)
00436 {
00437 static char FuncName[]={"SUMA_SurfaceTypeCode"};
00438
00439 SUMA_ENTRY;
00440
00441 if (!cd) { SUMA_RETURN(SUMA_FT_ERROR); }
00442
00443 if (!strcmp(cd, "NotSpecified")) { SUMA_RETURN(SUMA_FT_NOT_SPECIFIED ); }
00444 if (!strcmp(cd, "FreeSurfer") || !strcmp(cd, "FS")) { SUMA_RETURN( SUMA_FREE_SURFER); }
00445 if (!strcmp(cd, "SureFit") || !strcmp(cd, "SF")) { SUMA_RETURN( SUMA_SUREFIT); }
00446 if (!strcmp(cd, "GenericInventor") || !strcmp(cd, "INV")) { SUMA_RETURN(SUMA_INVENTOR_GENERIC ); }
00447 if (!strcmp(cd, "Ply") || !strcmp(cd, "PLY")) { SUMA_RETURN( SUMA_PLY); }
00448 if (!strcmp(cd, "DX") || !strcmp(cd, "dx") || !strcmp(cd, "OpenDX") || !strcmp(cd, "opendx")) { SUMA_RETURN( SUMA_OPENDX_MESH); }
00449 if (!strcmp(cd, "BrainVoyager") || !strcmp(cd, "BV") || !strcmp(cd, "bv")) { SUMA_RETURN( SUMA_BRAIN_VOYAGER); }
00450 if (!strcmp(cd, "1D") || !strcmp(cd, "VEC") || !strcmp(cd, "1d")) { SUMA_RETURN(SUMA_VEC ); }
00451 if (!strcmp(cd, "Error")) { SUMA_RETURN(SUMA_FT_ERROR ); }
00452
00453 SUMA_RETURN(SUMA_FT_ERROR);
00454
00455 }
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482 SUMA_Boolean SUMA_RegisterCommand (char *S, char d, char term, char *Scom, SUMA_Boolean Prepend)
00483 { int i, iStop, iorig, iStopNew, nCom;
00484 static char FuncName[]={"SUMA_RegisterCommand"};
00485
00486 SUMA_ENTRY;
00487
00488 fprintf (SUMA_STDERR, "Error %s: This function is now obsolete. Must use SUMA_RegisterCommand instead.\n", FuncName);
00489 SUMA_RETURN (NOPE);
00490
00491 iStop = strlen(S)-1;
00492
00493 nCom = strlen(Scom);
00494
00495 if (strlen(Scom) + iStop + 2 > SUMA_MAX_COMMAND_LENGTH ) {
00496 fprintf (stderr, "%s Error: Resultant command longer than SUMA_MAX_COMMAND_LENGTH!\n\a", FuncName);
00497 SUMA_RETURN (NOPE);
00498 }
00499 if (S[iStop] != term) {
00500 fprintf (stderr, "%s Error: S improperly terminated!\n\a", FuncName);
00501 SUMA_RETURN (NOPE);
00502 }
00503 if (!Prepend) {
00504
00505 if (S[iStop-1] != d) {
00506 S[iStop] = d;
00507 iStop += 1;
00508 }
00509
00510 for (i=0; i <nCom; ++i) {
00511 S[iStop+i] = Scom[i];
00512 }
00513 iStop += nCom;
00514 S[iStop] = term;
00515 S[iStop+1] = '\0';
00516 SUMA_RETURN (YUP);
00517 } else {
00518
00519 iStopNew = iStop+nCom+1;
00520 S[iStopNew+1] = '\0';
00521 iorig = 0;
00522 while (iorig <= iStop) {
00523 S[iStopNew-iorig] = S[iStop-iorig];
00524 ++iorig;
00525 }
00526 S[iStopNew-iorig] = d;
00527
00528
00529 for (i=0; i < nCom; ++i) {
00530 S[i] = Scom[i];
00531 }
00532 iStop = iStopNew;
00533 SUMA_RETURN (YUP);
00534 }
00535 }
00536
00537
00538
00539
00540 const char* SUMA_EngineFieldString (SUMA_ENGINE_FIELD_CODE i)
00541 {
00542 static char FuncName[]={"SUMA_EngineFieldString"};
00543
00544 SUMA_ENTRY;
00545
00546 switch (i) {
00547 case (SEF_fm):
00548 SUMA_RETURN ("fm");
00549 break;
00550 case (SEF_im):
00551 SUMA_RETURN ("im");
00552 break;
00553 case (SEF_ivec):
00554 SUMA_RETURN ("ivec");
00555 break;
00556 case (SEF_fvec):
00557 SUMA_RETURN ("fvec");
00558 break;
00559 case (SEF_fv3):
00560 SUMA_RETURN ("fv3");
00561 break;
00562 case (SEF_iv3):
00563 SUMA_RETURN ("iv3");
00564 break;
00565 case (SEF_fv15):
00566 SUMA_RETURN ("fv15");
00567 break;
00568 case (SEF_iv15):
00569 SUMA_RETURN ("iv15");
00570 break;
00571 case (SEF_iv200):
00572 SUMA_RETURN ("iv200");
00573 break;
00574 case (SEF_fv200):
00575 SUMA_RETURN ("fv200");
00576 break;
00577 case (SEF_i):
00578 SUMA_RETURN ("i");
00579 break;
00580 case (SEF_f):
00581 SUMA_RETURN ("f");
00582 break;
00583 case (SEF_s):
00584 SUMA_RETURN ("s");
00585 break;
00586 case (SEF_vp):
00587 SUMA_RETURN ("vp");
00588 break;
00589 case (SEF_cp):
00590 SUMA_RETURN ("cp");
00591 break;
00592 case (SEF_fp):
00593 SUMA_RETURN ("fp");
00594 break;
00595 case (SEF_ip):
00596 SUMA_RETURN ("ip");
00597 break;
00598 default:
00599 SUMA_RETURN ("Unknown");
00600 break;
00601
00602 }
00603
00604 }
00605
00606 SUMA_ENGINE_FIELD_CODE SUMA_EngineFieldCode(char *Scom)
00607 {
00608 static char FuncName[]={"SUMA_EngineFieldCode"};
00609
00610 SUMA_ENTRY;
00611
00612 if (!strlen(Scom)) SUMA_RETURN (SEF_Empty);
00613
00614
00615 if (!strcmp(Scom,"fm")) SUMA_RETURN(SEF_fm);
00616 if (!strcmp(Scom,"im")) SUMA_RETURN(SEF_im);
00617 if (!strcmp(Scom,"fvec")) SUMA_RETURN(SEF_fvec);
00618 if (!strcmp(Scom,"ivec")) SUMA_RETURN(SEF_ivec);
00619 if (!strcmp(Scom,"fv3")) SUMA_RETURN(SEF_fv3);
00620 if (!strcmp(Scom,"iv3")) SUMA_RETURN(SEF_iv3);
00621 if (!strcmp(Scom,"fv15")) SUMA_RETURN(SEF_fv15);
00622 if (!strcmp(Scom,"iv15")) SUMA_RETURN(SEF_iv15);
00623 if (!strcmp(Scom,"fv200")) SUMA_RETURN(SEF_fv200);
00624 if (!strcmp(Scom,"iv200")) SUMA_RETURN(SEF_iv200);
00625 if (!strcmp(Scom,"i")) SUMA_RETURN(SEF_i);
00626 if (!strcmp(Scom,"f")) SUMA_RETURN (SEF_f);
00627 if (!strcmp(Scom,"s")) SUMA_RETURN (SEF_s);
00628 if (!strcmp(Scom,"vp")) SUMA_RETURN (SEF_vp);
00629 if (!strcmp(Scom,"fp")) SUMA_RETURN(SEF_fp);
00630 if (!strcmp(Scom,"cp")) SUMA_RETURN(SEF_cp);
00631 if (!strcmp(Scom,"ip")) SUMA_RETURN(SEF_ip);
00632
00633
00634
00635 SUMA_RETURN (SEF_BadCode);
00636
00637 }
00638
00639 int SUMA_EngineSourceCode (char *Scom)
00640 {
00641 static char FuncName[]={"SUMA_EngineSourceCode"};
00642
00643 SUMA_ENTRY;
00644
00645 if (!strlen(Scom)) SUMA_RETURN (SES_Empty);
00646 if (!strcmp(Scom,"suma")) SUMA_RETURN(SES_Suma);
00647 if (!strcmp(Scom,"afni")) SUMA_RETURN(SES_Afni);
00648 if (!strcmp(Scom,"suma_widget")) SUMA_RETURN(SES_SumaWidget);
00649 if (!strcmp(Scom,"suma_from_afni")) SUMA_RETURN(SES_SumaFromAfni);
00650 if (!strcmp(Scom,"suma_from_any")) SUMA_RETURN(SES_SumaFromAny);
00651 if (!strcmp(Scom,"unknown")) SUMA_RETURN(SES_Unknown);
00652
00653
00654 SUMA_RETURN (SES_Unknown);
00655 }
00656
00657 void SUMA_EngineSourceString (char *Scom, int i)
00658 {
00659 static char FuncName[]={"SUMA_EngineSourceString"};
00660
00661 SUMA_ENTRY;
00662
00663 switch (i) {
00664 case SES_Empty:
00665 Scom[0]='\0';
00666 break;
00667 case SES_Suma:
00668 sprintf(Scom,"suma");
00669 break;
00670 case SES_Afni:
00671 sprintf(Scom, "afni");
00672 break;
00673 case SES_SumaWidget:
00674 sprintf(Scom, "suma_widget");
00675 break;
00676 case SES_SumaFromAfni:
00677 sprintf(Scom, "suma_from_afni");
00678 break;
00679 case SES_SumaFromAny:
00680 sprintf(Scom, "suma_from_any");
00681 break;
00682 case SES_Unknown:
00683 sprintf(Scom, "unknown");
00684 break;
00685 default:
00686 sprintf(Scom, "Undetermined flag");
00687 break;
00688 }
00689 SUMA_RETURNe;
00690 }
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705 SUMA_Boolean SUMA_RegisterMessage ( DList *list, char *Message,
00706 char *Source, SUMA_MESSAGE_TYPES Type,
00707 SUMA_MESSAGE_ACTION Action)
00708 {
00709 static char FuncName[]={"SUMA_RegisterMessage"};
00710 SUMA_MessageData *MD = NULL;
00711 SUMA_Boolean TryLogWindow = NOPE;
00712 int i=0, TrimTheFat=0;
00713
00714 SUMA_ENTRY;
00715
00716 if (!list) {
00717 fprintf (SUMA_STDERR, "Warning %s: list has not been initialized.\n"
00718 "Nothing done.\n", FuncName);
00719 SUMA_RETURN (YUP);
00720 }
00721
00722
00723 MD = (SUMA_MessageData *) SUMA_malloc(sizeof(SUMA_MessageData));
00724 if (!MD) {
00725 fprintf (SUMA_STDERR, "Error %s: Failed to allocate.\n", FuncName);
00726 SUMA_RETURN (NOPE);
00727 }
00728
00729 MD->Message = SUMA_copy_string(Message);
00730 MD->Source = SUMA_copy_string(Source);
00731 MD->Type = Type;
00732 MD->Action = Action;
00733
00734
00735 if (dlist_ins_next (list, dlist_tail(list), (void *)MD) < 0) {
00736 fprintf (SUMA_STDERR, "Error %s: Failed to insert message:\n%s from %s in list.\n",
00737 FuncName, MD->Message, MD->Source);
00738 SUMA_RETURN(NOPE);
00739 }
00740
00741
00742 TrimTheFat = list->size - SUMA_MAX_MESSAGES;
00743 if ( TrimTheFat > 0) {
00744 for (i=0; i < TrimTheFat; ++i) {
00745
00746 if (!SUMA_ReleaseMessageListElement (list, dlist_head(list))) {
00747 fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_ReleaseMessageListElement.\n", FuncName);
00748 SUMA_RETURN (NOPE);
00749 }
00750 }
00751 }
00752
00753
00754 switch (MD->Action) {
00755 case SMA_Nothing:
00756 break;
00757 case SMA_Log:
00758 TryLogWindow = YUP;
00759 break;
00760 case SMA_LogAndPopup:
00761 TryLogWindow = YUP;
00762 SUMA_PopUpMessage (MD);
00763 break;
00764 default:
00765 break;
00766
00767 }
00768
00769 if (TryLogWindow) {
00770 DList *Elist=NULL;
00771 SUMA_EngineData *ED=NULL;
00772
00773 Elist = SUMA_CreateList();
00774 SUMA_REGISTER_HEAD_COMMAND_NO_DATA(Elist, SE_UpdateLog, SES_Suma, NULL);
00775
00776 if (!SUMA_Engine (&Elist)) {
00777 fprintf(SUMA_STDERR, "Error %s: SUMA_Engine call failed.\n", FuncName);
00778 SUMA_RETURN (NOPE);
00779 }
00780 }
00781
00782
00783 SUMA_RETURN (YUP);
00784 }
00785
00786
00787
00788
00789
00790 char *SUMA_BuildMessageLog (DList *ML)
00791 {
00792 static char FuncName[]={"SUMA_BuildMessageLog"};
00793 char *s=NULL;
00794 SUMA_STRING *SS = NULL;
00795 SUMA_MessageData *MD=NULL;
00796 DListElmt *CurElmt=NULL;
00797
00798 SUMA_ENTRY;
00799
00800
00801 if (!ML->size) {
00802 SUMA_RETURN (NULL);
00803 }
00804
00805 SS = SUMA_StringAppend (NULL, NULL);
00806
00807 if (!(CurElmt = dlist_head(ML))) {
00808 SUMA_RETURN (NULL);
00809 }
00810 do {
00811 MD = (SUMA_MessageData *)CurElmt->data;
00812 SS = SUMA_StringAppend (SS, SUMA_FormatMessage (MD));
00813 if (MD->Type != SMT_Text)SS = SUMA_StringAppend (SS, "---------------------\n");
00814 } while ((CurElmt = dlist_next(CurElmt)));
00815
00816
00817 SS = SUMA_StringAppend (SS, NULL);
00818
00819 s = SS->s;
00820 SUMA_free(SS);
00821
00822 SUMA_RETURN (s);
00823
00824 }
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868 DListElmt * SUMA_RegisterEngineListCommand (DList *list, SUMA_EngineData * EngineData,
00869 SUMA_ENGINE_FIELD_CODE Fld, void *FldValp,
00870 SUMA_ENGINE_SOURCE Src, void *Srcp, SUMA_Boolean PassByPointer,
00871 SUMA_ENGINE_INSERT_LOCATION InsertAt, DListElmt *Element)
00872 {
00873 SUMA_ENGINE_CODE Dest=SES_Empty;
00874 static char FuncName[]={"SUMA_RegisterEngineListCommand"};
00875 SUMA_Boolean Refill = NOPE;
00876 DListElmt *tail=NULL, *head=NULL, *NewElement=NULL;
00877 SUMA_EngineData * Old_ED=NULL;
00878 SUMA_IVEC *ivec=NULL;
00879 SUMA_FVEC *fvec=NULL;
00880 SUMA_Boolean LocalHead = NOPE;
00881
00882 SUMA_ENTRY;
00883
00884 if (PassByPointer) {
00885 if (Fld != SEF_im && Fld != SEF_fm && Fld != SEF_ivec && Fld != SEF_fvec) {
00886 SUMA_SL_Err("Cannot use PassByPointer except with SEF_im || SEF_fm || SEF_ivec || SEF_fvec");
00887 SUMA_RETURN (NULL);
00888 }
00889 }
00890
00891 if (!list) {
00892 fprintf (SUMA_STDERR, "Error %s: list has not been initialized.\n", FuncName);
00893 SUMA_RETURN (NULL);
00894 }
00895
00896 if (InsertAt == SEI_In) {
00897
00898 Refill = YUP;
00899
00900 if (!Element) {
00901 SUMA_SL_Err("NULL element with SEI_In");
00902 SUMA_RETURN(NULL);
00903 }
00904 Old_ED = (SUMA_EngineData *)Element->data;
00905 if (Old_ED != EngineData) {
00906 fprintf (SUMA_STDERR, "Error %s: EngineData is different from initializing call for Element.\n", FuncName);
00907 SUMA_RETURN (NULL);
00908 }
00909 if (Old_ED->Src != Src) {
00910 fprintf (SUMA_STDERR, "Error %s: Src is different from initializing call for Element.\n", FuncName);
00911 SUMA_RETURN (NULL);
00912 }
00913 if (Old_ED->Srcp != Srcp) {
00914 fprintf (SUMA_STDERR, "Error %s: Srcp is different from initializing call for Element.\n", FuncName);
00915 SUMA_RETURN (NULL);
00916 }
00917 if (Old_ED->CommandCode != EngineData->CommandCode) {
00918 fprintf (SUMA_STDERR, "Error %s: CommandCode is different in EngineData from the one initializing call for Element.\n", FuncName);
00919 SUMA_RETURN (NULL);
00920 }
00921
00922 } else Refill = NOPE;
00923
00924 Dest = EngineData->CommandCode;
00925
00926 if (!Refill) {
00927
00928 switch (Dest) {
00929 case SE_BadCode:
00930 fprintf (SUMA_STDERR, "Error in %s: Bad code string.\n", FuncName);
00931 SUMA_RETURN (NULL);
00932 break;
00933 case SE_Empty:
00934 fprintf (SUMA_STDERR, "Error in %s: Empty code string.\n", FuncName);
00935 SUMA_RETURN (NULL);
00936 break;
00937 default:
00938 break;
00939 }
00940
00941
00942 if (EngineData->Srcp != NULL) {
00943 if (EngineData->Srcp != Srcp) {
00944 fprintf (SUMA_STDERR, "Error %s: Attempting to assign a Srcp to a structure that has a different Srcp.\n", FuncName);
00945 SUMA_RETURN (NULL);
00946 }
00947 }
00948
00949 EngineData->Srcp = Srcp;
00950 EngineData->Src = Src;
00951 }
00952
00953 if (LocalHead) fprintf(SUMA_STDOUT, "%s: Registering %s for %s\n", FuncName, SUMA_EngineFieldString(Fld), SUMA_CommandString (Dest));
00954
00955 switch (Fld) {
00956 case SEF_Empty:
00957 break;
00958 case SEF_fm:
00959 if (EngineData->fm_Dest != SEF_Empty) {
00960 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->fm_Dest);
00961 SUMA_RETURN (NULL);
00962 }
00963
00964 if (PassByPointer) {
00965
00966 EngineData->fm = (float **)FldValp;
00967 EngineData->fm_LocalAlloc = NOPE;
00968 }
00969 else {
00970 if (EngineData->fm != NULL) {
00971 fprintf(SUMA_STDERR, "Error %s: Passing by value and EngineData->fm is not NULL. Clean up your act.\n", FuncName);
00972 SUMA_RETURN(NULL);
00973 }
00974 if (!EngineData->N_rows || !EngineData->N_cols) {
00975 fprintf(SUMA_STDERR, "Error %s: EngineData->N_rows or EngineData->N_cols is 0.\n", FuncName);
00976 SUMA_RETURN(NULL);
00977 }
00978 EngineData->fm = (float **)SUMA_allocate2D(EngineData->N_rows, EngineData->N_cols, sizeof(float));
00979 if (EngineData->fm == NULL) {
00980 fprintf(SUMA_STDERR, "Error %s: Failed to allocate fm.\n", FuncName);
00981 SUMA_RETURN(NULL);
00982 }
00983 EngineData->fm_LocalAlloc = YUP;
00984 {
00985 float **fm;
00986 int i, j;
00987 fm = (float **)FldValp;
00988 for (i=0; i < EngineData->N_rows; ++i) {
00989 for (j=0; j < EngineData->N_cols; ++j)
00990 EngineData->fm[i][j] = fm[i][j];
00991 }
00992 }
00993 }
00994
00995 EngineData->fm_Dest = Dest;
00996 EngineData->fm_Source = Src;
00997 break;
00998 case SEF_im:
00999 if (EngineData->im_Dest != SEF_Empty) {
01000 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->im_Dest);
01001 SUMA_RETURN (NULL);
01002 }
01003
01004 if (PassByPointer) {
01005
01006 EngineData->im = (int **)FldValp;
01007 EngineData->im_LocalAlloc = NOPE;
01008 } else {
01009 if (EngineData->im != NULL) {
01010 fprintf(SUMA_STDERR, "Error %s: Passing by value and EngineData->im is not NULL. Clean up your act.\n", FuncName);
01011 SUMA_RETURN(NULL);
01012 }
01013 if (!EngineData->N_rows || !EngineData->N_cols) {
01014 fprintf(SUMA_STDERR, "Error %s: EngineData->N_rows or EngineData->N_cols is 0.\n", FuncName);
01015 SUMA_RETURN(NULL);
01016 }
01017 EngineData->im = (int **)SUMA_allocate2D(EngineData->N_rows, EngineData->N_cols, sizeof(int));
01018 if (EngineData->im == NULL) {
01019 fprintf(SUMA_STDERR, "Error %s: Failed to allocate im.\n", FuncName);
01020 SUMA_RETURN(NULL);
01021 }
01022 EngineData->im_LocalAlloc = YUP;
01023 {
01024 int **im;
01025 int i, j;
01026 im = (int **)FldValp;
01027 for (i=0; i < EngineData->N_rows; ++i) {
01028 for (j=0; j < EngineData->N_cols; ++j)
01029 EngineData->im[i][j] = im[i][j];
01030 }
01031 }
01032 }
01033
01034 EngineData->im_Dest = Dest;
01035 EngineData->im_Source = Src;
01036 break;
01037
01038 case SEF_ivec:
01039 if (EngineData->ivec_Dest != SEF_Empty) {
01040 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->ivec_Dest);
01041 SUMA_RETURN (NULL);
01042 }
01043 ivec = (SUMA_IVEC *)FldValp;
01044
01045 if (PassByPointer) {
01046 EngineData->ivec = ivec;
01047 EngineData->ivec_LocalAlloc = NOPE;
01048 } else {
01049 if (EngineData->fvec != NULL) {
01050 fprintf(SUMA_STDERR, "Error %s: Passing by value and EngineData->fvec is not NULL. Clean up your act.\n", FuncName);
01051 SUMA_RETURN(NULL);
01052 }
01053 if (ivec->n <= 0 && ivec->v) {
01054 fprintf(SUMA_STDERR, "Error %s: ivec->n <= 0 while ivec->v is not NULL. Clean up your act.\n", FuncName);
01055 SUMA_RETURN(NULL);
01056 }
01057 EngineData->ivec_LocalAlloc = YUP;
01058 EngineData->ivec = (SUMA_IVEC*)SUMA_malloc(sizeof(SUMA_IVEC));
01059 EngineData->ivec->v = (int *)SUMA_malloc(ivec->n * sizeof(int));
01060 if (!EngineData->ivec->v) {
01061 SUMA_SL_Crit("Failed to allocate");
01062 SUMA_RETURN(NULL);
01063 }
01064 SUMA_COPY_VEC(ivec->v, EngineData->ivec->v, ivec->n, int, int);
01065 EngineData->ivec->n = ivec->n;
01066 }
01067
01068 EngineData->ivec_Dest = Dest;
01069 EngineData->ivec_Source = Src;
01070 break;
01071
01072 case SEF_fvec:
01073 if (EngineData->fvec_Dest != SEF_Empty) {
01074 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->fvec_Dest);
01075 SUMA_RETURN (NULL);
01076 }
01077 fvec = (SUMA_FVEC *)FldValp;
01078
01079 if (PassByPointer) {
01080 EngineData->fvec = fvec;
01081 EngineData->fvec_LocalAlloc = NOPE;
01082 } else {
01083 if (EngineData->fvec != NULL) {
01084 fprintf(SUMA_STDERR, "Error %s: Passing by value and EngineData->fvec is not NULL. Clean up your act.\n", FuncName);
01085 SUMA_RETURN(NULL);
01086 }
01087 if (fvec->n <= 0 && fvec->v) {
01088 fprintf(SUMA_STDERR, "Error %s: fvec->n <= 0 while fvec->v is not NULL. Clean up your act.\n", FuncName);
01089 SUMA_RETURN(NULL);
01090 }
01091 EngineData->fvec_LocalAlloc = YUP;
01092 EngineData->fvec = (SUMA_FVEC*)SUMA_malloc(sizeof(SUMA_FVEC));
01093 EngineData->fvec->v = (float *)SUMA_malloc(fvec->n * sizeof(float));
01094 if (!EngineData->fvec->v) {
01095 SUMA_SL_Crit("Failed to allocate");
01096 SUMA_RETURN(NULL);
01097 }
01098 SUMA_COPY_VEC(fvec->v, EngineData->fvec->v, fvec->n, float, float);
01099 EngineData->fvec->n = fvec->n;
01100 }
01101
01102 EngineData->fvec_Dest = Dest;
01103 EngineData->fvec_Source = Src;
01104 break;
01105
01106 case SEF_i:
01107 if (EngineData->i_Dest != SEF_Empty) {
01108 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->i_Dest);
01109 SUMA_RETURN (NULL);
01110 }
01111 {
01112 int *it;
01113 it = (int*)FldValp;
01114 EngineData->i = *it;
01115 }
01116 EngineData->i_Dest = Dest;
01117 EngineData->i_Source = Src;
01118 break;
01119
01120 case SEF_f:
01121 if (EngineData->f_Dest != SEF_Empty) {
01122 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->f_Dest);
01123 SUMA_RETURN (NULL);
01124 }
01125 {
01126 float *ft;
01127 ft = (float*)FldValp;
01128 EngineData->f = *ft;
01129 }
01130 EngineData->f_Dest = Dest;
01131 EngineData->f_Source = Src;
01132 break;
01133
01134 case SEF_fv3:
01135 if (EngineData->fv3_Dest != SEF_Empty) {
01136 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->fv3_Dest);
01137 SUMA_RETURN (NULL);
01138 }
01139 {
01140 float *fvt;
01141 int kt;
01142 fvt = (float*)FldValp;
01143 for (kt=0; kt < 3; ++kt) EngineData->fv3[kt] = fvt[kt];
01144 }
01145 EngineData->fv3_Dest = Dest;
01146 EngineData->fv3_Source = Src;
01147 break;
01148
01149 case SEF_fv15:
01150 if (EngineData->fv15_Dest != SEF_Empty) {
01151 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->fv15_Dest);
01152 SUMA_RETURN (NULL);
01153 }
01154 {
01155 float *fvt;
01156 int kt;
01157 fvt = (float*)FldValp;
01158 for (kt=0; kt < 15; ++kt) EngineData->fv15[kt] = fvt[kt];
01159 }
01160 EngineData->fv15_Dest = Dest;
01161 EngineData->fv15_Source = Src;
01162 break;
01163
01164 case SEF_fv200:
01165 if (EngineData->fv200_Dest != SEF_Empty) {
01166 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->fv200_Dest);
01167 SUMA_RETURN (NULL);
01168 }
01169 {
01170 float *fvt;
01171 int kt;
01172 fvt = (float*)FldValp;
01173 for (kt=0; kt < 200; ++kt) EngineData->fv200[kt] = fvt[kt];
01174 }
01175 EngineData->fv200_Dest = Dest;
01176 EngineData->fv200_Source = Src;
01177 break;
01178
01179 case SEF_iv3:
01180 if (EngineData->iv3_Dest != SEF_Empty) {
01181 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->iv3_Dest);
01182 SUMA_RETURN (NULL);
01183 }
01184 {
01185 int *ivt;
01186 int kt;
01187 ivt = (int*)FldValp;
01188 for (kt=0; kt < 3; ++kt) EngineData->iv3[kt] = ivt[kt];
01189 }
01190 EngineData->iv3_Dest = Dest;
01191 EngineData->iv3_Source = Src;
01192 break;
01193
01194 case SEF_iv15:
01195 if (EngineData->iv15_Dest != SEF_Empty) {
01196 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->iv15_Dest);
01197 SUMA_RETURN (NULL);
01198 }
01199 {
01200 int *ivt;
01201 int kt;
01202 ivt = (int*)FldValp;
01203 for (kt=0; kt < 15; ++kt) EngineData->iv15[kt] = ivt[kt];
01204 }
01205 EngineData->iv15_Dest = Dest;
01206 EngineData->iv15_Source = Src;
01207 break;
01208
01209 case SEF_iv200:
01210 if (EngineData->iv200_Dest != SEF_Empty) {
01211 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->iv200_Dest);
01212 SUMA_RETURN (NULL);
01213 }
01214 {
01215 int *ivt;
01216 int kt;
01217 ivt = (int*)FldValp;
01218 for (kt=0; kt < 200; ++kt) EngineData->iv200[kt] = ivt[kt];
01219 }
01220 EngineData->iv200_Dest = Dest;
01221 EngineData->iv200_Source = Src;
01222 break;
01223
01224 case SEF_s:
01225 if (EngineData->s_Dest != SEF_Empty) {
01226 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->s_Dest);
01227 SUMA_RETURN (NULL);
01228 }
01229 {
01230 char *st;
01231 st = (char*)FldValp;
01232 if (strlen(st) < SUMA_MAX_STRING_LENGTH) {
01233 sprintf(EngineData->s,"%s", st);
01234 } else {
01235 fprintf(SUMA_STDERR, "Error %s: string in FldValp is longer than SUMA_MAX_STRING_LENGTH.\n", FuncName);
01236 SUMA_RETURN (NULL);
01237 }
01238 }
01239 EngineData->s_Dest = Dest;
01240 EngineData->s_Source = Src;
01241 break;
01242
01243 case SEF_vp:
01244 if (EngineData->vp_Dest != SEF_Empty) {
01245 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->vp_Dest);
01246 SUMA_RETURN (NULL);
01247 }
01248 EngineData->vp = (void *)FldValp;
01249 EngineData->vp_Dest = Dest;
01250 EngineData->vp_Source = Src;
01251 break;
01252
01253 case SEF_ip:
01254 if (EngineData->ip_Dest != SEF_Empty) {
01255 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->ip_Dest);
01256 SUMA_RETURN (NULL);
01257 }
01258 EngineData->ip = (int *)FldValp;
01259 EngineData->ip_Dest = Dest;
01260 break;
01261
01262 case SEF_fp:
01263 if (EngineData->fp_Dest != SEF_Empty) {
01264 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->fp_Dest);
01265 SUMA_RETURN (NULL);
01266 }
01267 EngineData->fp = (float *)FldValp;
01268 EngineData->fp_Dest = Dest;
01269 break;
01270
01271 case SEF_cp:
01272 if (EngineData->cp_Dest != SEF_Empty) {
01273 fprintf(SUMA_STDERR, "Error %s: field %d has a preset destination (%d).\n", FuncName, Fld, EngineData->cp_Dest);
01274 SUMA_RETURN (NULL);
01275 }
01276 EngineData->cp = (char *)FldValp;
01277 EngineData->cp_Dest = Dest;
01278 break;
01279
01280 default:
01281 fprintf(SUMA_STDERR, "Error %s: Not setup for field %d yet.\n", FuncName, Fld);
01282 SUMA_RETURN (NULL);
01283 break;
01284 }
01285
01286
01287 switch (InsertAt) {
01288 case SEI_In:
01289 if (LocalHead) fprintf (SUMA_STDERR, "%s: Element already in list.\n", FuncName);
01290 NewElement = Element;
01291 break;
01292 case SEI_Tail:
01293 if (LocalHead) fprintf (SUMA_STDERR, "%s: Inserting new element at end of list \n", FuncName);
01294 if (dlist_ins_next (list, dlist_tail(list), (void *)EngineData) < 0) {
01295 fprintf (SUMA_STDERR, "Error %s: Failed to insert element in list.\n", FuncName);
01296 SUMA_RETURN(NULL);
01297 }
01298 NewElement = dlist_tail(list);
01299 break;
01300 case SEI_Head:
01301 if (LocalHead) fprintf (SUMA_STDERR, "%s: Inserting new element at beginning of list \n", FuncName);
01302 if (dlist_ins_prev (list, dlist_head(list), (void *)EngineData) < 0) {
01303 fprintf (SUMA_STDERR, "Error %s: Failed to insert element in list.\n", FuncName);
01304 SUMA_RETURN(NULL);
01305 }
01306 NewElement = dlist_head(list);
01307 break;
01308 case SEI_Before:
01309 if (LocalHead) fprintf (SUMA_STDERR, "%s: Inserting new element before specified element.\n", FuncName);
01310 if (!Element) fprintf (SUMA_STDERR, "Error %s: NULL Element!\n", FuncName);
01311 if (dlist_ins_prev (list, Element, (void *)EngineData) < 0) {
01312 fprintf (SUMA_STDERR, "Error %s: Failed to insert element in list.\n", FuncName);
01313 SUMA_RETURN(NULL);
01314 }
01315 NewElement = Element->prev;
01316 if (!NewElement) {
01317 fprintf (SUMA_STDERR, "Error %s: No previous element. List size %d", FuncName, dlist_size(list));
01318 SUMA_RETURN(NULL);
01319 }
01320 break;
01321 case SEI_After:
01322 if (LocalHead) fprintf (SUMA_STDERR, "%s: Inserting new element after specified element.\n", FuncName);
01323 if (!Element) fprintf (SUMA_STDERR, "Error %s: NULL Element!\n", FuncName);
01324 if (dlist_ins_next (list, Element, (void *)EngineData) < 0) {
01325 fprintf (SUMA_STDERR, "Error %s: Failed to insert element in list.\n", FuncName);
01326 SUMA_RETURN(NULL);
01327 }
01328 NewElement = Element->next;
01329 if (!NewElement) {
01330 fprintf (SUMA_STDERR, "Error %s: No next element. List size %d", FuncName, dlist_size(list));
01331 SUMA_RETURN(NULL);
01332 }
01333 break;
01334 case SEI_WTSDS:
01335 case SEI_BadLoc:
01336 default:
01337 fprintf (SUMA_STDERR, "Error %s: Bad insertion location!\n", FuncName);
01338 SUMA_RETURN(NULL);
01339 break;
01340
01341 }
01342
01343 SUMA_RETURN (NewElement);
01344 }
01345
01346
01347
01348
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360
01361
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372 SUMA_Boolean SUMA_RegisterEngineData (SUMA_EngineData *ED, char *Fldname, void *FldValp, char *DestName, char *SourceName, SUMA_Boolean PassByPointer)
01373 {
01374 int Dest, Fld, Src;
01375 static char FuncName[]={"SUMA_RegisterEngineData"};
01376
01377 SUMA_ENTRY;
01378
01379 fprintf (SUMA_STDERR, "Error %s: This function is now obsolete. Must use SUMA_RegisterEngineListCommand instead.\n", FuncName);
01380 SUMA_RETURN (NOPE);
01381
01382 Dest = SUMA_CommandCode((char *)DestName);
01383 Fld = SUMA_EngineFieldCode((char *)Fldname);
01384 Src = SUMA_EngineSourceCode ((char *)SourceName);
01385
01386
01387 switch (Dest) {
01388 case SE_BadCode:
01389 fprintf (SUMA_STDERR, "Error in %s: Bad code string.\n", FuncName);
01390 SUMA_RETURN (NOPE);
01391 break;
01392 case SE_Empty:
01393 fprintf (SUMA_STDERR, "Error in %s: Empty code string.\n", FuncName);
01394 SUMA_RETURN (NOPE);
01395 break;
01396 default:
01397 break;
01398 }
01399
01400
01401
01402 switch (Fld) {
01403 case SEF_fm:
01404 if (ED->fm_Dest != SEF_Empty) {
01405 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->fm_Dest);
01406 SUMA_RETURN (NOPE);
01407 }
01408
01409 if (PassByPointer) {
01410
01411 ED->fm = (float **)FldValp;
01412 ED->fm_LocalAlloc = NOPE;
01413 }
01414 else {
01415 if (ED->fm != NULL) {
01416 fprintf(SUMA_STDERR, "Error %s: Passing by value and ED->fm is not NULL. Clean up your act.\n", FuncName);
01417 SUMA_RETURN(NOPE);
01418 }
01419 if (!ED->N_rows || !ED->N_cols) {
01420 fprintf(SUMA_STDERR, "Error %s: ED->N_rows or ED->N_cols is 0.\n", FuncName);
01421 SUMA_RETURN(NOPE);
01422 }
01423 ED->fm = (float **)SUMA_allocate2D(ED->N_rows, ED->N_cols, sizeof(float));
01424 if (ED->fm == NULL) {
01425 fprintf(SUMA_STDERR, "Error %s: Failed to allocate fm.\n", FuncName);
01426 SUMA_RETURN(NOPE);
01427 }
01428 ED->fm_LocalAlloc = YUP;
01429 {
01430 float **fm;
01431 int i, j;
01432 fm = (float **)FldValp;
01433 for (i=0; i < ED->N_rows; ++i) {
01434 for (j=0; j < ED->N_cols; ++j)
01435 ED->fm[i][j] = fm[i][j];
01436 }
01437 }
01438 }
01439
01440 ED->fm_Dest = Dest;
01441 ED->fm_Source = Src;
01442 SUMA_RETURN (YUP);
01443 break;
01444 case SEF_im:
01445 if (ED->im_Dest != SEF_Empty) {
01446 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->im_Dest);
01447 SUMA_RETURN (NOPE);
01448 }
01449
01450 if (PassByPointer) {
01451
01452 ED->im = (int **)FldValp;
01453 ED->im_LocalAlloc = NOPE;
01454 } else {
01455 if (ED->im != NULL) {
01456 fprintf(SUMA_STDERR, "Error %s: Passing by value and ED->im is not NULL. Clean up your act.\n", FuncName);
01457 SUMA_RETURN(NOPE);
01458 }
01459 if (!ED->N_rows || !ED->N_cols) {
01460 fprintf(SUMA_STDERR, "Error %s: ED->N_rows or ED->N_cols is 0.\n", FuncName);
01461 SUMA_RETURN(NOPE);
01462 }
01463 ED->im = (int **)SUMA_allocate2D(ED->N_rows, ED->N_cols, sizeof(int));
01464 if (ED->im == NULL) {
01465 fprintf(SUMA_STDERR, "Error %s: Failed to allocate im.\n", FuncName);
01466 SUMA_RETURN(NOPE);
01467 }
01468 ED->im_LocalAlloc = YUP;
01469 {
01470 int **im;
01471 int i, j;
01472 im = (int **)FldValp;
01473 for (i=0; i < ED->N_rows; ++i) {
01474 for (j=0; j < ED->N_cols; ++j)
01475 ED->im[i][j] = im[i][j];
01476 }
01477 }
01478 }
01479
01480 ED->im_Dest = Dest;
01481 ED->im_Source = Src;
01482 SUMA_RETURN (YUP);
01483 break;
01484
01485 case SEF_i:
01486 if (ED->i_Dest != SEF_Empty) {
01487 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->i_Dest);
01488 SUMA_RETURN (NOPE);
01489 }
01490 {
01491 int *it;
01492 it = (int*)FldValp;
01493 ED->i = *it;
01494 }
01495 ED->i_Dest = Dest;
01496 ED->i_Source = Src;
01497 SUMA_RETURN (YUP);
01498 break;
01499
01500 case SEF_f:
01501 if (ED->f_Dest != SEF_Empty) {
01502 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->f_Dest);
01503 SUMA_RETURN (NOPE);
01504 }
01505 {
01506 float *ft;
01507 ft = (float*)FldValp;
01508 ED->f = *ft;
01509 }
01510 ED->f_Dest = Dest;
01511 ED->f_Source = Src;
01512 SUMA_RETURN (YUP);
01513 break;
01514
01515 case SEF_fv3:
01516 if (ED->fv3_Dest != SEF_Empty) {
01517 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->fv3_Dest);
01518 SUMA_RETURN (NOPE);
01519 }
01520 {
01521 float *fvt;
01522 int kt;
01523 fvt = (float*)FldValp;
01524 for (kt=0; kt < 3; ++kt) ED->fv3[kt] = fvt[kt];
01525 }
01526 ED->fv3_Dest = Dest;
01527 ED->fv3_Source = Src;
01528 SUMA_RETURN (YUP);
01529 break;
01530
01531 case SEF_fv15:
01532 if (ED->fv15_Dest != SEF_Empty) {
01533 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->fv15_Dest);
01534 SUMA_RETURN (NOPE);
01535 }
01536 {
01537 float *fvt;
01538 int kt;
01539 fvt = (float*)FldValp;
01540 for (kt=0; kt < 15; ++kt) ED->fv15[kt] = fvt[kt];
01541 }
01542 ED->fv15_Dest = Dest;
01543 ED->fv15_Source = Src;
01544 SUMA_RETURN (YUP);
01545 break;
01546
01547 case SEF_fv200:
01548 if (ED->fv200_Dest != SEF_Empty) {
01549 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->fv200_Dest);
01550 SUMA_RETURN (NOPE);
01551 }
01552 {
01553 float *fvt;
01554 int kt;
01555 fvt = (float*)FldValp;
01556 for (kt=0; kt < 200; ++kt) ED->fv200[kt] = fvt[kt];
01557 }
01558 ED->fv200_Dest = Dest;
01559 ED->fv200_Source = Src;
01560 SUMA_RETURN (YUP);
01561 break;
01562
01563 case SEF_iv3:
01564 if (ED->iv3_Dest != SEF_Empty) {
01565 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->iv3_Dest);
01566 SUMA_RETURN (NOPE);
01567 }
01568 {
01569 int *ivt;
01570 int kt;
01571 ivt = (int*)FldValp;
01572 for (kt=0; kt < 3; ++kt) ED->iv3[kt] = ivt[kt];
01573 }
01574 ED->iv3_Dest = Dest;
01575 ED->iv3_Source = Src;
01576 SUMA_RETURN (YUP);
01577 break;
01578
01579 case SEF_iv15:
01580 if (ED->iv15_Dest != SEF_Empty) {
01581 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->iv15_Dest);
01582 SUMA_RETURN (NOPE);
01583 }
01584 {
01585 int *ivt;
01586 int kt;
01587 ivt = (int*)FldValp;
01588 for (kt=0; kt < 15; ++kt) ED->iv15[kt] = ivt[kt];
01589 }
01590 ED->iv15_Dest = Dest;
01591 ED->iv15_Source = Src;
01592 SUMA_RETURN (YUP);
01593 break;
01594
01595 case SEF_iv200:
01596 if (ED->iv200_Dest != SEF_Empty) {
01597 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->iv200_Dest);
01598 SUMA_RETURN (NOPE);
01599 }
01600 {
01601 int *ivt;
01602 int kt;
01603 ivt = (int*)FldValp;
01604 for (kt=0; kt < 200; ++kt) ED->iv200[kt] = ivt[kt];
01605 }
01606 ED->iv200_Dest = Dest;
01607 ED->iv200_Source = Src;
01608 SUMA_RETURN (YUP);
01609 break;
01610
01611 case SEF_s:
01612 if (ED->s_Dest != SEF_Empty) {
01613 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->s_Dest);
01614 SUMA_RETURN (NOPE);
01615 }
01616 {
01617 char *st;
01618 st = (char*)FldValp;
01619 if (strlen(st) < SUMA_MAX_STRING_LENGTH) {
01620 sprintf(ED->s,"%s", st);
01621 } else {
01622 fprintf(SUMA_STDERR, "Error %s: string in FldValp is longer than SUMA_MAX_STRING_LENGTH.\n", FuncName);
01623 SUMA_RETURN (NOPE);
01624 }
01625 }
01626 ED->s_Dest = Dest;
01627 ED->s_Source = Src;
01628 SUMA_RETURN (YUP);
01629 break;
01630
01631 case SEF_vp:
01632 if (ED->vp_Dest != SEF_Empty) {
01633 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->vp_Dest);
01634 SUMA_RETURN (NOPE);
01635 }
01636 ED->vp = (void *)FldValp;
01637 ED->vp_Dest = Dest;
01638 ED->vp_Source = Src;
01639 SUMA_RETURN (YUP);
01640 break;
01641
01642 case SEF_ip:
01643 if (ED->ip_Dest != SEF_Empty) {
01644 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->ip_Dest);
01645 SUMA_RETURN (NOPE);
01646 }
01647 ED->ip = (int *)FldValp;
01648 ED->ip_Dest = Dest;
01649 SUMA_RETURN (YUP);
01650 break;
01651
01652 case SEF_fp:
01653 if (ED->fp_Dest != SEF_Empty) {
01654 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->fp_Dest);
01655 SUMA_RETURN (NOPE);
01656 }
01657 ED->fp = (float *)FldValp;
01658 ED->fp_Dest = Dest;
01659 SUMA_RETURN (YUP);
01660 break;
01661
01662 case SEF_cp:
01663 if (ED->cp_Dest != SEF_Empty) {
01664 fprintf(SUMA_STDERR, "Error %s: field %s has a preset destination (%d).\n", FuncName, Fldname, ED->cp_Dest);
01665 SUMA_RETURN (NOPE);
01666 }
01667 ED->cp = (char *)FldValp;
01668 ED->cp_Dest = Dest;
01669 SUMA_RETURN (YUP);
01670 break;
01671
01672 default:
01673 fprintf(SUMA_STDERR, "Error %s: Not setup for field %s yet.\n", FuncName, Fldname);
01674 SUMA_RETURN (NOPE);
01675 break;
01676 }
01677
01678
01679 }
01680
01681
01682
01683
01684
01685
01686
01687
01688
01689 SUMA_EngineData *SUMA_InitializeEngineListData (SUMA_ENGINE_CODE CommandCode)
01690 {
01691 static char FuncName[]={"SUMA_InitializeEngineListData"};
01692 SUMA_EngineData *ED=NULL;
01693 int i;
01694
01695 SUMA_ENTRY;
01696
01697 if (CommandCode <= SE_Empty || CommandCode >= SE_BadCode) {
01698 fprintf(SUMA_STDERR,"Error %s: Bad command code.\n", FuncName);
01699 SUMA_RETURN (NULL);
01700 }
01701
01702 ED = SUMA_malloc(sizeof(SUMA_EngineData));
01703 if (!ED) {
01704 fprintf(SUMA_STDERR,"Error %s: Failed to allocate for ED.\n", FuncName);
01705 SUMA_RETURN (NULL);
01706 }
01707
01708 ED->CommandCode = CommandCode;
01709 ED->Srcp = NULL;
01710 ED->fm = NULL;
01711 ED->fm_LocalAlloc = NOPE;
01712 ED->im = NULL;
01713 ED->im_LocalAlloc = NOPE;
01714 ED->N_rows = 0;
01715 ED->N_cols = 0;
01716 ED->ivec = NULL;
01717 ED->fvec = NULL;
01718 ED->ivec_LocalAlloc = NOPE;
01719 ED->fvec_LocalAlloc = NOPE;
01720 ED->i = 0;
01721 ED->f = 0.0;
01722 ED->iv3[0] = ED->iv3[1] = ED->iv3[2] = 0;
01723 ED->fv3[0] = ED->fv3[1] = ED->fv3[2] = 0.0;
01724 for (i=0; i < 15; ++i) {
01725 ED->fv15[i] = 0.0;
01726 ED->iv15[i] = 0;
01727 }
01728 for (i=0; i < 200; ++i) {
01729 ED->fv200[i] = 0.0;
01730 ED->iv200[i] = 0;
01731 }
01732 sprintf(ED->s,"NOTHING");
01733
01734 ED->vp = NULL;
01735
01736 ED->fm_Dest = ED->im_Dest = ED->i_Dest = ED->f_Dest = ED->iv3_Dest = ED->fv3_Dest = \
01737 ED->fv15_Dest = ED->iv15_Dest = ED->fv200_Dest = ED->iv200_Dest = ED->s_Dest = ED->vp_Dest = ED->ip_Dest = ED->fp_Dest = \
01738 ED->cp_Dest = ED->ivec_Dest = ED->fvec_Dest = SE_Empty;
01739
01740 ED->fm_Source = ED->im_Source = ED->i_Source = ED->f_Source = ED->iv3_Source = ED->fv3_Source = \
01741 ED->fv15_Source = ED->iv15_Source = ED->fv200_Source = ED->iv200_Source = ED->s_Source = ED->vp_Source = \
01742 ED->ivec_Source = ED->fvec_Source = SES_Empty;
01743
01744 SUMA_RETURN (ED);
01745
01746 }
01747
01748
01749
01750
01751
01752
01753
01754 void SUMA_FreeActionStackData(void *asdata)
01755 {
01756 static char FuncName[]={"SUMA_FreeActionStackData"};
01757 SUMA_ACTION_STACK_DATA *AS_data=NULL;
01758 SUMA_Boolean LocalHead = NOPE;
01759
01760 SUMA_ENTRY;
01761
01762 AS_data=(SUMA_ACTION_STACK_DATA *)asdata;
01763 if (AS_data) {
01764 if (LocalHead) fprintf (SUMA_STDERR, "%s: Destroying Action Stack Data \n", FuncName);
01765
01766 AS_data->ActionDataDestructor(AS_data->ActionData);
01767
01768
01769 SUMA_free(AS_data);
01770 }
01771
01772 SUMA_RETURNe;
01773 }
01774
01775
01776
01777
01778
01779
01780 void SUMA_ReleaseActionStackData (void *asdata)
01781 {
01782 static char FuncName[]={"SUMA_ReleaseActionStackData"};
01783 SUMA_ACTION_STACK_DATA *AS_data=NULL;
01784 SUMA_Boolean LocalHead = NOPE;
01785
01786 SUMA_ENTRY;
01787
01788 AS_data=(SUMA_ACTION_STACK_DATA *)asdata;
01789 if (AS_data) {
01790 if (LocalHead) fprintf (SUMA_STDERR, "%s: Releasing Action Stack Data structure\n", FuncName);
01791
01792 if (AS_data->ActionData) SUMA_free(AS_data->ActionData);
01793
01794
01795 SUMA_free(AS_data);
01796 }
01797
01798 SUMA_RETURNe;
01799 }
01800
01801
01802
01803
01804
01805
01806 void SUMA_FreeMessageListData(void *Hv)
01807 {
01808 static char FuncName[]={"SUMA_FreeMessageListData"};
01809 SUMA_MessageData *H = NULL;
01810
01811 SUMA_ENTRY;
01812
01813 H = (SUMA_MessageData *)Hv;
01814
01815 if (!H) {
01816 fprintf(SUMA_STDERR,"Warning %s: H is null, nothing to do!\n", FuncName);
01817 SUMA_RETURNe;
01818 }
01819
01820 #if 1
01821
01822
01823
01824 if (H->Message) SUMA_free(H->Message);
01825 if (H->Source) SUMA_free(H->Source);
01826 #endif
01827
01828 if (H) SUMA_free(H);
01829
01830 SUMA_RETURNe;
01831 }
01832
01833
01834
01835
01836
01837
01838
01839
01840
01841
01842
01843
01844 void SUMA_FreeEngineListData(void *EDv)
01845 {
01846 static char FuncName[]={"SUMA_FreeEngineListData"};
01847 SUMA_EngineData *ED = NULL;
01848
01849 SUMA_ENTRY;
01850
01851 ED = (SUMA_EngineData *)EDv;
01852
01853 if (ED == NULL) {
01854 fprintf(SUMA_STDERR,"Warning %s: ED is null, nothing to do!\n", FuncName);
01855 SUMA_RETURNe;
01856 }
01857
01858
01859 if (ED->fm_LocalAlloc) {
01860 if (!ED->N_rows || !ED->N_cols) {
01861 fprintf(SUMA_STDERR,"Error %s: N_rows or N_cols are 0.\n\a", FuncName);
01862 SUMA_RETURNe;
01863 }
01864 if (ED->fm == NULL) {
01865 fprintf(SUMA_STDERR,"Error %s: ED->fm is NULL, not good here.\n\a", FuncName);
01866 SUMA_RETURNe;
01867 }
01868
01869 SUMA_free2D((char **)ED->fm, ED->N_rows);
01870 }
01871
01872 if (ED->im_LocalAlloc) {
01873 if (!ED->N_rows || !ED->N_cols) {
01874 fprintf(SUMA_STDERR,"Error %s: N_rows or N_cols are 0.\n\a", FuncName);
01875 SUMA_RETURNe;
01876 }
01877 if (ED->im == NULL) {
01878 fprintf(SUMA_STDERR,"Error %s: ED->im is NULL, not good here.\n\a", FuncName);
01879 SUMA_RETURNe;
01880 }
01881
01882 SUMA_free2D((char **)ED->im, ED->N_rows);
01883 }
01884
01885
01886 SUMA_free(ED);
01887 SUMA_RETURNe;
01888 }
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901
01902
01903
01904
01905 SUMA_Boolean SUMA_FreeEngineData (SUMA_EngineData *ED)
01906 {
01907 static char FuncName[]={"SUMA_FreeEngineData"};
01908
01909 SUMA_ENTRY;
01910
01911 fprintf (SUMA_STDERR, "Error %s: This function is now obsolete. Must use SUMA_FreeEngineListData instead.\n", FuncName);
01912 SUMA_RETURN (NOPE);
01913
01914 if (ED == NULL) {
01915 fprintf(SUMA_STDERR,"Error %s: ED is null, nothing to do!\n", FuncName);
01916 SUMA_RETURN (NOPE);
01917 }
01918
01919
01920 if (ED->fm_LocalAlloc) {
01921 if (!ED->N_rows || !ED->N_cols) {
01922 fprintf(SUMA_STDERR,"Error %s: N_rows or N_cols are 0.\n", FuncName);
01923 SUMA_RETURN (NOPE);
01924 }
01925 if (ED->fm == NULL) {
01926 fprintf(SUMA_STDERR,"Error %s: ED->fm is NULL, not good here.\n", FuncName);
01927 SUMA_RETURN (NOPE);
01928 }
01929
01930 SUMA_free2D((char **)ED->fm, ED->N_rows);
01931 }
01932
01933 if (ED->im_LocalAlloc) {
01934 if (!ED->N_rows || !ED->N_cols) {
01935 fprintf(SUMA_STDERR,"Error %s: N_rows or N_cols are 0.\n", FuncName);
01936 SUMA_RETURN (NOPE);
01937 }
01938 if (ED->im == NULL) {
01939 fprintf(SUMA_STDERR,"Error %s: ED->im is NULL, not good here.\n", FuncName);
01940 SUMA_RETURN (NOPE);
01941 }
01942
01943 SUMA_free2D((char **)ED->im, ED->N_rows);
01944 }
01945
01946
01947 SUMA_RETURN (YUP);
01948 }
01949
01950
01951
01952
01953
01954
01955
01956
01957
01958
01959
01960 SUMA_Boolean SUMA_ReleaseEngineListElement (DList *list, DListElmt *element)
01961 {
01962 static char FuncName[]={"SUMA_ReleaseEngineListElement"};
01963 void *ED=NULL;
01964
01965 SUMA_ENTRY;
01966 if (!element) {
01967 SUMA_SL_Err("Null element");
01968 SUMA_RETURN (NOPE);
01969 }
01970 if (dlist_remove (list, element, &ED) < 0) {
01971 fprintf (SUMA_STDERR, "Error %s: Failed to remove element from list.\n", FuncName);
01972 SUMA_RETURN (NOPE);
01973 }
01974 if (ED) {
01975 SUMA_FreeEngineListData((SUMA_EngineData *)ED);
01976 }
01977
01978 SUMA_RETURN (YUP);
01979 }
01980
01981
01982
01983
01984
01985
01986
01987
01988
01989
01990
01991 SUMA_Boolean SUMA_ReleaseMessageListElement (DList *list, DListElmt *element)
01992 {
01993 static char FuncName[]={"SUMA_ReleaseMessageListElement"};
01994 void *H=NULL;
01995
01996 SUMA_ENTRY;
01997
01998 if (dlist_remove (list, element, &H) < 0) {
01999 fprintf (SUMA_STDERR, "Error %s: Failed to remove element from list.\n", FuncName);
02000 SUMA_RETURN (NOPE);
02001 }
02002 if (H) {
02003 SUMA_FreeMessageListData((SUMA_MessageData *)H);
02004 }
02005
02006 SUMA_RETURN (YUP);
02007 }
02008
02009
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020 DList * SUMA_DestroyList (DList *list)
02021 {
02022 static char FuncName[]={"SUMA_DestroyList"};
02023
02024 SUMA_ENTRY;
02025
02026 if (list->size) {
02027 fprintf (SUMA_STDERR, "Error %s: list still contains elements.\n", FuncName);
02028 SUMA_RETURN (list);
02029 }
02030
02031 dlist_destroy(list);
02032 if (list) SUMA_free(list);
02033 SUMA_RETURN (NULL);
02034 }
02035
02036
02037
02038
02039
02040
02041
02042
02043
02044
02045 DList * SUMA_EmptyDestroyList (DList *list)
02046 {
02047 static char FuncName[]={"SUMA_EmptyDestroyList"};
02048
02049 SUMA_ENTRY;
02050
02051 dlist_destroy(list);
02052 if (list) SUMA_free(list);
02053 SUMA_RETURN (NULL);
02054 }
02055
02056
02057
02058
02059
02060
02061
02062
02063 DList *SUMA_CreateActionStack (void)
02064 {
02065 static char FuncName[]={"SUMA_CreateActionStack"};
02066 DList *list=NULL;
02067
02068 SUMA_ENTRY;
02069
02070 list = (DList *)malloc (sizeof(DList));
02071 if (!list) {
02072 fprintf (SUMA_STDERR, "Error %s: Failed to allocate for list.\n", FuncName);
02073 SUMA_RETURN(NULL);
02074 }
02075
02076
02077
02078
02079
02080
02081
02082
02083 dlist_init(list, SUMA_ReleaseActionStackData);
02084
02085 SUMA_RETURN (list);
02086 }
02087
02088
02089
02090
02091
02092
02093
02094
02095 DList *SUMA_EmptyDestroyActionStack (DList *AS)
02096 {
02097 static char FuncName[]={"SUMA_DestroyActionStack"};
02098
02099 SUMA_ENTRY;
02100
02101 dlist_destroy(AS);
02102
02103 SUMA_RETURN (NULL);
02104 }
02105
02106
02107
02108
02109
02110
02111
02112
02113
02114 DList *SUMA_CreateMessageList (void)
02115 {
02116 static char FuncName[]={"SUMA_CreateMessageList"};
02117 DList *list=NULL;
02118
02119
02120 list = (DList *)malloc (sizeof(DList));
02121 if (!list) {
02122 fprintf (SUMA_STDERR, "Error %s: Failed to allocate for list.\n", FuncName);
02123 return (NULL);
02124 }
02125
02126 dlist_init(list, SUMA_FreeMessageListData);
02127
02128 return (list);
02129 }
02130
02131
02132
02133
02134
02135
02136
02137 DList *SUMA_CreateList (void)
02138 {
02139 static char FuncName[]={"SUMA_CreateList"};
02140 DList *list=NULL;
02141
02142 SUMA_ENTRY;
02143
02144 list = (DList *)SUMA_malloc (sizeof(DList));
02145 if (!list) {
02146 fprintf (SUMA_STDERR, "Error %s: Failed to allocate for list.\n", FuncName);
02147 SUMA_RETURN (NULL);
02148 }
02149
02150 dlist_init(list, SUMA_FreeEngineListData);
02151
02152 SUMA_RETURN (list);
02153 }
02154
02155
02156
02157
02158
02159
02160
02161
02162
02163
02164
02165
02166
02167
02168
02169
02170
02171
02172
02173
02174
02175
02176
02177 SUMA_Boolean SUMA_ReleaseEngineData (SUMA_EngineData *ED, char *Location)
02178 {
02179 static char FuncName[]={"SUMA_ReleaseEngineData"};
02180 int Loc;
02181
02182 SUMA_ENTRY;
02183
02184 fprintf (SUMA_STDERR, "Error %s: This function is now obsolete. Must use SUMA_ReleaseEngineListElement instead.\n", FuncName);
02185 SUMA_RETURN (NOPE);
02186
02187
02188 Loc = SUMA_CommandCode((char *)Location);
02189
02190
02191 switch (Loc) {
02192 case SE_BadCode:
02193 fprintf (SUMA_STDERR, "Error in %s: Bad code string.\n", FuncName);
02194 SUMA_RETURN (NOPE);
02195 break;
02196 case SE_Empty:
02197 fprintf (SUMA_STDERR, "Error in %s: Empty code string.\n", FuncName);
02198 SUMA_RETURN (NOPE);
02199 break;
02200 default:
02201 break;
02202 }
02203
02204
02205
02206
02207 if (ED->fm_Dest == Loc) {
02208
02209 if (ED->fm_LocalAlloc) {
02210
02211 if (!ED->N_rows || !ED->N_cols) {
02212 fprintf (SUMA_STDERR, "Error in %s: ED->N_rows or ED->N_cols is 0 .\n", FuncName);
02213 SUMA_RETURN (NOPE);
02214 }
02215 if (ED->fm == NULL) {
02216 fprintf (SUMA_STDERR, "Error in %s: fm is null already. This should not be .\n", FuncName);
02217 SUMA_RETURN (NOPE);
02218 }
02219 SUMA_free2D((char **)ED->fm, ED->N_rows);
02220 ED->N_rows = ED->N_cols = 0;
02221 ED->fm = NULL;
02222 ED->fm_Dest = SE_Empty;
02223 ED->fm_Source = SES_Empty;
02224 } else {
02225 ED->fm = NULL;
02226 ED->N_rows = ED->N_cols = 0;
02227 ED->fm_Dest = SE_Empty;
02228 ED->fm_Source = SES_Empty;
02229 }
02230 }
02231
02232
02233 if (ED->im_Dest == Loc) {
02234
02235 if (ED->im_LocalAlloc) {
02236
02237 if (!ED->N_rows || !ED->N_cols) {
02238 fprintf (SUMA_STDERR, "Error in %s: ED->N_rows or ED->N_cols is 0 .\n", FuncName);
02239 SUMA_RETURN (NOPE);
02240 }
02241 if (ED->im == NULL) {
02242 fprintf (SUMA_STDERR, "Error in %s: im is null already. This should not be .\n", FuncName);
02243 SUMA_RETURN (NOPE);
02244 }
02245 SUMA_free2D((char **)ED->im, ED->N_rows);
02246 ED->N_rows = ED->N_cols = 0;
02247 ED->im = NULL;
02248 ED->im_Dest = SE_Empty;
02249 ED->im_Source = SES_Empty;
02250 } else {
02251 ED->im = NULL;
02252 ED->N_rows = ED->N_cols = 0;
02253 ED->im_Dest = SE_Empty;
02254 ED->im_Source = SES_Empty;
02255 }
02256 }
02257
02258
02259 if (ED->ivec_Dest == Loc) {
02260
02261 if (ED->ivec_LocalAlloc) {
02262
02263 if (!ED->ivec) {
02264 fprintf (SUMA_STDERR, "Error %s: NULL ivec, why?\n", FuncName);
02265 SUMA_RETURN (NOPE);
02266 }
02267 if (ED->ivec->n > 0 && !ED->ivec->v) {
02268 fprintf (SUMA_STDERR, "Error %s: ED->ivec->n >= 0 && ED->ivec->v = NULL.\n", FuncName);
02269 SUMA_RETURN (NOPE);
02270 }
02271 if (ED->ivec->v == NULL) {
02272 fprintf (SUMA_STDERR, "Error in %s: v is null already. This should not be .\n", FuncName);
02273 SUMA_RETURN (NOPE);
02274 }
02275 if (ED->ivec->v) SUMA_free(ED->ivec->v);
02276 if (ED->ivec) SUMA_free(ED->ivec);
02277 ED->ivec = NULL;
02278 ED->ivec_Dest = SE_Empty;
02279 ED->ivec_Source = SES_Empty;
02280 } else {
02281 ED->ivec = NULL;
02282 ED->ivec_Dest = SE_Empty;
02283 ED->ivec_Source = SES_Empty;
02284 }
02285 }
02286
02287
02288 if (ED->fvec_Dest == Loc) {
02289
02290 if (ED->fvec_LocalAlloc) {
02291
02292 if (!ED->fvec) {
02293 fprintf (SUMA_STDERR, "Error %s: NULL fvec, why?\n", FuncName);
02294 SUMA_RETURN (NOPE);
02295 }
02296 if (ED->fvec->n > 0 && !ED->fvec->v) {
02297 fprintf (SUMA_STDERR, "Error %s: ED->fvec->n >= 0 && ED->fvec->v = NULL.\n", FuncName);
02298 SUMA_RETURN (NOPE);
02299 }
02300 if (ED->fvec->v == NULL) {
02301 fprintf (SUMA_STDERR, "Error in %s: v is null already. This should not be .\n", FuncName);
02302 SUMA_RETURN (NOPE);
02303 }
02304 if (ED->fvec->v) SUMA_free(ED->fvec->v);
02305 if (ED->fvec) SUMA_free(ED->fvec);
02306 ED->fvec = NULL;
02307 ED->fvec_Dest = SE_Empty;
02308 ED->fvec_Source = SES_Empty;
02309 } else {
02310 ED->fvec = NULL;
02311 ED->fvec_Dest = SE_Empty;
02312 ED->fvec_Source = SES_Empty;
02313 }
02314 }
02315
02316
02317 if (ED->i_Dest == Loc) {
02318 ED->i_Dest = SE_Empty;
02319 ED->i_Source = SES_Empty;
02320 }
02321
02322
02323 if (ED->iv3_Dest == Loc) {
02324 ED->iv3_Dest = SE_Empty;
02325 ED->iv3_Source = SES_Empty;
02326 }
02327
02328
02329 if (ED->iv15_Dest == Loc) {
02330 ED->iv15_Dest = SE_Empty;
02331 ED->iv15_Source = SES_Empty;
02332 }
02333
02334
02335 if (ED->iv200_Dest == Loc) {
02336 ED->iv200_Dest = SE_Empty;
02337 ED->iv200_Source = SES_Empty;
02338 }
02339
02340
02341 if (ED->f_Dest == Loc) {
02342 ED->f_Dest = SE_Empty;
02343 ED->f_Source = SES_Empty;
02344 }
02345
02346
02347 if (ED->fv3_Dest == Loc) {
02348 ED->fv3_Dest = SE_Empty;
02349 ED->fv3_Source = SES_Empty;
02350 }
02351
02352
02353 if (ED->fv15_Dest == Loc) {
02354 ED->fv15_Dest = SE_Empty;
02355 ED->fv15_Source = SES_Empty;
02356 }
02357
02358
02359 if (ED->fv200_Dest == Loc) {
02360 ED->fv200_Dest = SE_Empty;
02361 ED->fv200_Source = SES_Empty;
02362 }
02363
02364
02365 if (ED->s_Dest == Loc) {
02366 ED->s_Dest = SE_Empty;
02367 ED->s_Source = SES_Empty;
02368 }
02369
02370
02371 if (ED->vp_Dest == Loc) {
02372 ED->vp_Dest = SE_Empty;
02373 ED->vp_Source = SES_Empty;
02374 }
02375
02376
02377 if (ED->cp_Dest == Loc) {
02378 ED->cp_Dest = SE_Empty;
02379 }
02380
02381
02382 if (ED->ip_Dest == Loc) {
02383 ED->ip_Dest = SE_Empty;
02384 }
02385
02386
02387 if (ED->fp_Dest == Loc) {
02388 ED->fp_Dest = SE_Empty;
02389 }
02390
02391 SUMA_RETURN (YUP);
02392 }
02393
02394
02395
02396
02397
02398
02399
02400
02401
02402 void SUMA_ShowList (DList *list, FILE *Out)
02403 {
02404 static char FuncName[]={"SUMA_ShowList"};
02405 DListElmt *NE;
02406 SUMA_EngineData *ED;
02407
02408 SUMA_ENTRY;
02409
02410 if (!Out) Out = stdout;
02411
02412 if (!list) {
02413 fprintf (Out,"%s: NULL List.\n", FuncName);
02414 SUMA_RETURNe;
02415 }
02416
02417 if (!list->size) {
02418 fprintf (Out,"%s: Empty List.\n", FuncName);
02419 SUMA_RETURNe;
02420 }
02421
02422 fprintf (Out,"%s: List of %d elements.\n\t", FuncName, list->size);
02423 do{
02424 NE = dlist_head(list);
02425 ED = (SUMA_EngineData *) NE->data;
02426 if (!ED) {
02427 fprintf (Out, "NULL-This should not be | ");
02428 } else {
02429 fprintf (Out, "%s | ", SUMA_CommandString (ED->CommandCode));
02430 }
02431 } while (!dlist_is_tail(NE));
02432
02433 fprintf (Out,"\n");
02434
02435 SUMA_RETURNe;
02436 }
02437
02438
02439
02440
02441
02442 SUMA_SO_File_Type SUMA_guess_surftype_argv(char *str)
02443 {
02444 static char FuncName[]={"SUMA_guess_surftype_argv"};
02445 SUMA_SO_File_Type tp=SUMA_FT_NOT_SPECIFIED;
02446
02447 SUMA_ENTRY;
02448
02449 if (SUMA_iswordin_ci(str, "FreeSurfer") == 1 || SUMA_iswordin_ci(str, "fs") == 1 ) {
02450 SUMA_RETURN( SUMA_FREE_SURFER );
02451 }
02452 if (SUMA_iswordin_ci(str, "SureFit") == 1 || SUMA_iswordin_ci(str, "sf") == 1 || SUMA_iswordin_ci(str, "caret") == 1 ) SUMA_RETURN( SUMA_SUREFIT );
02453 if (SUMA_iswordin_ci(str, "Inventor") == 1 || SUMA_iswordin_ci(str, "iv") == 1 || SUMA_iswordin_ci(str, "inv") == 1 ) SUMA_RETURN( SUMA_INVENTOR_GENERIC );
02454 if (SUMA_iswordin_ci(str, "dx") == 1 ) SUMA_RETURN( SUMA_OPENDX_MESH );
02455 if (SUMA_iswordin_ci(str, "ply") == 1 ) SUMA_RETURN( SUMA_PLY );
02456 if (SUMA_iswordin_ci(str, "vec") == 1 || SUMA_iswordin_ci(str, "1d") == 1 ) SUMA_RETURN( SUMA_VEC );
02457 if (SUMA_iswordin_ci(str, "BrainVoyager") == 1 || SUMA_iswordin_ci(str, "bv") == 1 ) SUMA_RETURN( SUMA_BRAIN_VOYAGER );
02458 if (SUMA_iswordin_ci(str, "cmap") == 1 ) SUMA_RETURN( SUMA_CMAP_SO );
02459
02460 SUMA_RETURN(tp);
02461 }
02462
02463
02464
02465
02466
02467
02468
02469
02470
02471
02472
02473
02474
02475
02476
02477
02478 void *SUMA_AdvancePastNumbers(char *op, char **opend, SUMA_VARTYPE tp)
02479 {
02480 static char FuncName[]={"SUMA_AdvancePastNumbers"};
02481 double *d=NULL, db;
02482 int nrealloc = 0, Chunk = 100, nalloc = 0;
02483 int Found = 0, i, nread;
02484 void *ans;
02485 SUMA_Boolean LocalHead = NOPE;
02486
02487 SUMA_ENTRY;
02488
02489 nread = 0;
02490 Found = 1;
02491 while (Found) {
02492 SUMA_ADVANCE_PAST_NUM(op, db, Found);
02493 if (Found) {
02494 if (nread == nalloc) {
02495 nalloc += Chunk; ++nrealloc;
02496 d = (double*)SUMA_realloc(d, nalloc*sizeof(double));
02497 if (!d) { SUMA_SL_Crit("Failed to allocate"); if (d) SUMA_free(d); d = NULL; SUMA_RETURN(NULL); }
02498 if (!(nrealloc % 10)) { SUMA_SL_Warn("Too much reallocation, improper use of function?"); }
02499 }
02500 d[nread] = db;
02501 ++(nread);
02502 }
02503 }
02504
02505 if (LocalHead) {
02506 fprintf(SUMA_STDERR,"%s: Found %d numbers:\n", FuncName, nread);
02507 for (i=0; i<nread; ++i) fprintf(SUMA_STDERR,"%f\t", d[i]);
02508 fprintf(SUMA_STDERR,"\n");
02509 }
02510
02511 if (opend) *opend = op;
02512
02513 ans = NULL;
02514 switch (tp) {
02515 case SUMA_int:
02516 {
02517 SUMA_IVEC *ivec= (SUMA_IVEC *)SUMA_malloc(sizeof(SUMA_IVEC));
02518 ivec->v = (int *)SUMA_calloc(nread,sizeof(int));
02519 ivec->n = nread;
02520 for (i=0; i<nread; ++i) ivec->v[i] = (int)d[i];
02521 ans = (void *)ivec;
02522 }
02523 break;
02524 case SUMA_float:
02525 {
02526 SUMA_FVEC *fvec= (SUMA_FVEC *)SUMA_malloc(sizeof(SUMA_FVEC));
02527 fvec->v = (float *)SUMA_calloc(nread,sizeof(float));
02528 fvec->n = nread;
02529 for (i=0; i<nread; ++i) fvec->v[i] = (float)d[i];
02530 ans = (void *)fvec;
02531 }
02532 break;
02533 case SUMA_double:
02534 {
02535 SUMA_DVEC *dvec= (SUMA_DVEC *)SUMA_malloc(sizeof(SUMA_DVEC));
02536 dvec->v = (double *)SUMA_calloc(nread,sizeof(double));
02537 dvec->n = nread;
02538 for (i=0; i<nread; ++i) dvec->v[i] = (double)d[i];
02539 ans = (void *)dvec;
02540 }
02541 break;
02542 case SUMA_notypeset:
02543 SUMA_SL_Err("Type not set");
02544 ans = NULL;
02545 break;
02546 default:
02547 SUMA_SL_Err("Type not supported by this function");
02548 ans = NULL;
02549 break;
02550
02551 }
02552 if (d) SUMA_free(d); d = NULL;
02553
02554 SUMA_RETURN(ans);
02555
02556 }
02557
02558
02559
02560
02561
02562
02563
02564
02565 void *SUMA_strtol_vec(char *op, int nvals, int *nread, SUMA_VARTYPE vtp)
02566 {
02567 static char FuncName[]={"SUMA_strtol_vec"};
02568 void *ans = NULL;
02569 long lv;
02570 double dv;
02571 char *endptr=NULL;
02572 SUMA_Boolean LocalHead = NOPE;
02573
02574 SUMA_ENTRY;
02575 *nread = 0;
02576 if (!SUMA_OK_OPENDX_DATA_TYPE(vtp)) {
02577 SUMA_SL_Err("Bad type");
02578 SUMA_RETURN(ans);
02579 }
02580
02581 ans = NULL;
02582 switch (vtp) {
02583 case SUMA_byte:
02584 {
02585 byte *bvec=NULL;
02586 bvec = (byte *)SUMA_calloc(nvals,sizeof(byte));
02587 lv = strtol(op, &endptr, 10);
02588 while (endptr && endptr != op && *nread < nvals) {
02589 bvec[*nread] = (byte)lv;
02590
02591 ++(*nread);
02592 op = endptr;
02593 lv = strtol(op, &endptr, 10);
02594 }
02595 ans = (void *)bvec;
02596 }
02597 break;
02598 case SUMA_int:
02599 {
02600 int *ivec=NULL;
02601 ivec = (int *)SUMA_calloc(nvals,sizeof(int));
02602 lv = strtol(op, &endptr, 10);
02603 while (endptr && endptr != op && *nread < nvals) {
02604 ivec[*nread] = (int)lv;
02605
02606 ++(*nread);
02607 op = endptr;
02608 lv = strtol(op, &endptr, 10);
02609 }
02610 ans = (void *)ivec;
02611 }
02612 break;
02613 case SUMA_float:
02614 {
02615 float *fvec=NULL;
02616 fvec = (float *)SUMA_calloc(nvals,sizeof(float));
02617 dv = strtod(op, &endptr);
02618 while (endptr && endptr != op && *nread < nvals) {
02619 fvec[*nread] = (float)dv;
02620
02621 ++(*nread);
02622 op = endptr;
02623 dv = strtod(op, &endptr);
02624 }
02625 ans = (void *)fvec;
02626 }
02627 break;
02628 case SUMA_double:
02629 {
02630 double *dvec=NULL;
02631 dvec = (double *)SUMA_calloc(nvals,sizeof(double));
02632 dv = strtod(op, &endptr);
02633 while (endptr && endptr != op && *nread < nvals) {
02634 dvec[*nread] = (double)dv;
02635
02636 ++(*nread);
02637 op = endptr;
02638 dv = strtod(op, &endptr);
02639 }
02640 ans = (void *)dvec;
02641 }
02642 break;
02643 case SUMA_notypeset:
02644 SUMA_SL_Err("Type not set");
02645 ans = NULL;
02646 break;
02647 default:
02648 SUMA_SL_Err("Type not supported by this function");
02649 ans = NULL;
02650 break;
02651
02652 }
02653
02654 SUMA_RETURN(ans);
02655 }
02656
02657
02658
02659
02660
02661
02662
02663
02664
02665
02666
02667
02668 SUMA_GENERIC_PROG_OPTIONS_STRUCT * SUMA_Alloc_Generic_Prog_Options_Struct(void)
02669 {
02670 static char FuncName[]={"SUMA_Alloc_Generic_Prog_Options_Struct"};
02671 int i;
02672 SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt = NULL;
02673
02674 Opt = (SUMA_GENERIC_PROG_OPTIONS_STRUCT *)SUMA_malloc(sizeof(SUMA_GENERIC_PROG_OPTIONS_STRUCT));
02675 Opt->SpatNormDxyz = 0.0;
02676 Opt->spec_file = NULL;
02677 Opt->out_vol_prefix = NULL;
02678 Opt->out_vol_view[0]='\0';
02679 Opt->out_vol_exists = -1;
02680 Opt->out_grid_prefix = NULL;
02681 Opt->out_grid_view[0]='\0';
02682 Opt->out_grid_exists = -1;
02683 Opt->in_vol_prefix = NULL;
02684 Opt->in_vol_view[0]='\0';
02685 Opt->in_vol_exists = -1;
02686 Opt->out_prefix = NULL;
02687 Opt->sv_name = NULL;
02688 Opt->N_surf = -1;
02689 Opt->in_name = NULL;
02690 Opt->cmask = NULL;
02691 Opt->MaskMode = SUMA_ISO_UNDEFINED;
02692 for (i=0; i<SUMA_GENERIC_PROG_MAX_SURF; ++i) { Opt->surf_names[i] = NULL; }
02693 Opt->in_vol = NULL;
02694 Opt->nvox = -1;
02695 Opt->ninmask = -1;
02696 Opt->mcdatav = NULL;
02697 Opt->debug = 0;
02698 Opt->v0 = 0.0;
02699 Opt->v1 = 0.0;
02700 Opt->dvec = NULL;
02701 Opt->SurfFileType = SUMA_PLY;
02702 Opt->SurfFileFormat = SUMA_ASCII;
02703 Opt->xform = SUMA_ISO_XFORM_UNDEFINED;
02704 Opt->obj_type = -1;
02705 Opt->obj_type_res = -1;
02706 Opt->XYZ = NULL;
02707 Opt->in_1D = NULL;
02708 Opt->N_XYZ = 0;
02709 Opt->Zt = 0.0;
02710 Opt->ExpFrac = 0.0;
02711 Opt->N_it = 0;
02712 Opt->Icold = 0;
02713 Opt->NodeDbg = -1;
02714 Opt->t2 = Opt->t98 = Opt->t = Opt->tm = -1;
02715 Opt->r = 0;
02716 Opt->d1 = 0;
02717 Opt->su1 = 0;
02718 Opt->UseNew = 0.0;
02719 Opt->d4 = 0;
02720 Opt->ztv = NULL;
02721 Opt->Kill98 = 0;
02722 Opt->NoEyes = 0;
02723 Opt->NNsmooth = 0;
02724 Opt->smootheach = 0;
02725 Opt->avoid_vent = 0;
02726 Opt->smooth_end = 0;
02727 Opt->fix_winding = 0;
02728 Opt->k98mask = NULL;
02729 Opt->k98maskcnt = 0;
02730 Opt->dbg_eyenodes = NULL;
02731 Opt->travstp = 0.0;
02732 Opt->Stop = NULL;
02733 Opt->MaxIntIter = 0;
02734 Opt->UseExpansion = 0;
02735 Opt->PercInt = 0;
02736 Opt->UseSkull = 0;
02737 Opt->send_hull = 0;
02738 Opt->bot_lztclip = 0.0;
02739 Opt->var_lzt = 0.0;
02740
02741 Opt->DemoPause = 0;
02742 Opt->DoSpatNorm = 0;
02743 Opt->WriteSpatNorm = 0;
02744 Opt->fillhole = -1;
02745 Opt->iset = NULL;
02746 Opt->SpatShift[0] = Opt->SpatShift[1] = Opt->SpatShift[2] = 0.0;
02747 Opt->OrigSpatNormedSet = NULL;
02748 Opt->in_edvol = NULL;
02749 Opt->blur_fwhm = 0.0;
02750 Opt->iset_hand = 0;
02751
02752 Opt->NearestNode = 0;
02753 Opt->NearestTriangle = 0;
02754 Opt->DistanceToMesh = 0;
02755 Opt->ProjectionOnMesh = 0;
02756 Opt->Data = 0;
02757
02758 Opt->in_nodeindices = NULL;
02759
02760 SUMA_RETURN(Opt);
02761 }
02762 SUMA_GENERIC_PROG_OPTIONS_STRUCT * SUMA_Free_Generic_Prog_Options_Struct(SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt)
02763 {
02764 static char FuncName[]={"SUMA_Free_Generic_Prog_Options_Struct"};
02765
02766 SUMA_ENTRY;
02767
02768 if (!Opt) SUMA_RETURN(NULL);
02769
02770 if (Opt->OrigSpatNormedSet && Opt->OrigSpatNormedSet != Opt->in_vol) { DSET_delete(Opt->OrigSpatNormedSet); Opt->OrigSpatNormedSet = NULL; }
02771 else Opt->OrigSpatNormedSet = NULL;
02772
02773 if (Opt->dbg_eyenodes) fclose(Opt->dbg_eyenodes); Opt->dbg_eyenodes = NULL;
02774 if (Opt->k98mask) SUMA_free(Opt->k98mask); Opt->k98mask = NULL;
02775 if (Opt->Stop) SUMA_free(Opt->Stop); Opt->Stop = NULL;
02776 if (Opt->dvec) SUMA_free(Opt->dvec); Opt->dvec = NULL;
02777 if (Opt->mcdatav) {SUMA_free(Opt->mcdatav); Opt->mcdatav = NULL;}
02778 if (Opt->in_vol) { DSET_delete( Opt->in_vol); Opt->in_vol = NULL;}
02779 if (Opt->out_prefix) SUMA_free(Opt->out_prefix); Opt->out_prefix = NULL;
02780 if (Opt->out_vol_prefix) SUMA_free(Opt->out_vol_prefix); Opt->out_vol_prefix = NULL;
02781 if (Opt->in_vol_prefix) SUMA_free(Opt->in_vol_prefix); Opt->in_vol_prefix = NULL;
02782 if (Opt->out_grid_prefix) SUMA_free(Opt->out_grid_prefix); Opt->out_grid_prefix = NULL;
02783 if (Opt->XYZ) SUMA_free(Opt->XYZ); Opt->XYZ = NULL;
02784 if (Opt->ztv) SUMA_free(Opt->ztv); Opt->ztv = NULL;
02785 if (Opt) SUMA_free(Opt);
02786
02787 SUMA_RETURN(NULL);
02788
02789 }
02790 SUMA_GENERIC_ARGV_PARSE *SUMA_CreateGenericArgParse(char *optflags)
02791 {
02792 static char FuncName[]={"SUMA_CreateGenericArgParse"};
02793 SUMA_GENERIC_ARGV_PARSE *ps=NULL;
02794 int i;
02795 SUMA_ENTRY;
02796
02797 ps = (SUMA_GENERIC_ARGV_PARSE*)SUMA_malloc(sizeof(SUMA_GENERIC_ARGV_PARSE));
02798
02799 ps->cs = NULL;
02800
02801 for (i=0;i<SUMA_MAX_SURF_ON_COMMAND; ++i) {
02802 ps->t_surfnames[i] = ps->t_surftopo[i] = ps->t_surfpath[i] = ps->t_surfprefix[i] = ps->t_state[i] = NULL;
02803 ps->t_N_surfnames = 0; ps->t_FF[i] = SUMA_FF_NOT_SPECIFIED; ps->t_FT[i] = SUMA_FT_NOT_SPECIFIED; ps->t_anatomical[i] = NOPE;
02804 ps->i_surfnames[i] = ps->i_surftopo[i] = ps->i_surfpath[i] = ps->i_surfprefix[i] = ps->i_state[i] = ps->i_group[i] = NULL;
02805 ps->i_N_surfnames = 0; ps->i_FF[i] = SUMA_FF_NOT_SPECIFIED; ps->i_FT[i] = SUMA_FT_NOT_SPECIFIED; ps->i_anatomical[i] = NOPE;
02806 ps->ipar_surfnames[i] = ps->ipar_surftopo[i] = ps->ipar_surfpath[i] = ps->ipar_surfprefix[i] = ps->ipar_state[i] = ps->ipar_group[i] = NULL;
02807 ps->ipar_N_surfnames = 0; ps->ipar_FF[i] = SUMA_FF_NOT_SPECIFIED; ps->ipar_FT[i] = SUMA_FT_NOT_SPECIFIED; ps->ipar_anatomical[i] = NOPE;
02808 ps->o_surfnames[i] = ps->o_surftopo[i] = ps->o_surfpath[i] = ps->o_surfprefix[i] = ps->o_state[i] = ps->o_group[i] = NULL;
02809 ps->o_N_surfnames = 0; ps->o_FF[i] = SUMA_FF_NOT_SPECIFIED; ps->o_FT[i] = SUMA_FT_NOT_SPECIFIED; ps->o_anatomical[i] = NOPE;
02810 ps->s_surfnames[i] = ps->s_surfprefix[i] = ps->s_surfpath[i] = NULL;
02811 ps->s_N_surfnames = 0;
02812 ps->spec_names[i] = NULL; ps->N_spec_names = 0;
02813 ps->sv[i] = NULL; ps->N_sv = 0;
02814 ps->vp[i] = NULL; ps->N_vp = 0;
02815 }
02816
02817 for (i=0; i< SUMA_N_ARGS_MAX; ++i) {
02818 ps->arg_checked[i] = 0;
02819 }
02820 ps->N_args = 0;
02821
02822 if (SUMA_iswordin(optflags,"-t;")) ps->accept_t = 1; else ps->accept_t = 0;
02823 if (SUMA_iswordin(optflags,"-i;")) ps->accept_i = 1; else ps->accept_i = 0;
02824 if (SUMA_iswordin(optflags,"-ipar;")) ps->accept_ipar = 1; else ps->accept_ipar = 0;
02825 if (SUMA_iswordin(optflags,"-s;")) ps->accept_s = 1; else ps->accept_s = 0;
02826 if (SUMA_iswordin(optflags,"-o;")) ps->accept_o = 1; else ps->accept_o = 0;
02827 if (SUMA_iswordin(optflags,"-spec;")) ps->accept_spec = 1; else ps->accept_spec = 0;
02828 if (SUMA_iswordin(optflags,"-sv;")) ps->accept_sv = 1; else ps->accept_sv = 0;
02829 if (SUMA_iswordin(optflags,"-talk;")) ps->accept_talk_suma = 1; else ps->accept_talk_suma = 0;
02830 ps->check_input_surf = 1;
02831
02832 SUMA_RETURN(ps);
02833 }
02834
02835 SUMA_GENERIC_ARGV_PARSE *SUMA_FreeGenericArgParse(SUMA_GENERIC_ARGV_PARSE *ps)
02836 {
02837 static char FuncName[]={"SUMA_FreeGenericArgParse"};
02838 int i;
02839 SUMA_ENTRY;
02840
02841 if (ps) {
02842 for (i=0; i<SUMA_MAX_SURF_ON_COMMAND; ++i) {
02843 if (ps->t_surfnames[i]) SUMA_free(ps->t_surfnames[i]); ps->t_surfnames[i]= NULL;
02844 if (ps->t_surftopo[i]) SUMA_free(ps->t_surftopo[i]); ps->t_surftopo[i]= NULL;
02845 if (ps->t_surfpath[i]) SUMA_free(ps->t_surfpath[i]); ps->t_surfpath[i]= NULL;
02846 if (ps->t_surfprefix[i]) SUMA_free(ps->t_surfprefix[i]);ps->t_surfprefix[i] = NULL;
02847 if (ps->t_state[i]) SUMA_free(ps->t_state[i]);ps->t_state[i] = NULL;
02848 if (ps->i_surfnames[i]) SUMA_free(ps->i_surfnames[i]); ps->i_surfnames[i]= NULL;
02849 if (ps->i_surftopo[i]) SUMA_free(ps->i_surftopo[i]); ps->i_surftopo[i]= NULL;
02850 if (ps->i_surfpath[i]) SUMA_free(ps->i_surfpath[i]); ps->i_surfpath[i]= NULL;
02851 if (ps->i_surfprefix[i]) SUMA_free(ps->i_surfprefix[i]);ps->i_surfprefix[i] = NULL;
02852 if (ps->i_state[i]) SUMA_free(ps->i_state[i]);ps->i_state[i] = NULL;
02853 if (ps->ipar_surfnames[i]) SUMA_free(ps->ipar_surfnames[i]); ps->ipar_surfnames[i]= NULL;
02854 if (ps->ipar_surftopo[i]) SUMA_free(ps->ipar_surftopo[i]); ps->ipar_surftopo[i]= NULL;
02855 if (ps->ipar_surfpath[i]) SUMA_free(ps->ipar_surfpath[i]); ps->ipar_surfpath[i]= NULL;
02856 if (ps->ipar_surfprefix[i]) SUMA_free(ps->ipar_surfprefix[i]);ps->ipar_surfprefix[i] = NULL;
02857 if (ps->ipar_state[i]) SUMA_free(ps->ipar_state[i]);ps->ipar_state[i] = NULL;
02858 if (ps->o_surfnames[i]) SUMA_free(ps->o_surfnames[i]); ps->o_surfnames[i]= NULL;
02859 if (ps->o_surftopo[i]) SUMA_free(ps->o_surftopo[i]); ps->o_surftopo[i]= NULL;
02860 if (ps->o_surfpath[i]) SUMA_free(ps->o_surfpath[i]); ps->o_surfpath[i]= NULL;
02861 if (ps->o_surfprefix[i]) SUMA_free(ps->o_surfprefix[i]);ps->o_surfprefix[i] = NULL;
02862 if (ps->o_state[i]) SUMA_free(ps->o_state[i]);ps->o_state[i] = NULL;
02863 if (ps->s_surfnames[i]) SUMA_free(ps->s_surfnames[i]); ps->s_surfnames[i]= NULL;
02864 if (ps->s_surfprefix[i]) SUMA_free(ps->s_surfprefix[i]);ps->s_surfprefix[i] = NULL;
02865 if (ps->s_surfpath[i]) SUMA_free(ps->s_surfpath[i]); ps->s_surfpath[i]= NULL;
02866 if (ps->spec_names[i]) SUMA_free(ps->spec_names[i]); ps->spec_names[i] = NULL;
02867 if (ps->sv[i]) SUMA_free(ps->sv[i]); ps->sv[i] = NULL;
02868 if (ps->vp[i]) SUMA_free(ps->vp[i]); ps->vp[i] = NULL;
02869 }
02870 if (ps->cs) SUMA_Free_CommSrtuct(ps->cs); ps->cs = NULL;
02871 SUMA_free(ps); ps = NULL;
02872 }
02873 SUMA_RETURN(NULL);
02874 }
02875
02876 char *SUMA_help_IO_Args(SUMA_GENERIC_ARGV_PARSE *opt)
02877 {
02878 static char FuncName[]={"SUMA_help_IO_Args"};
02879 char *s=NULL, *st = NULL;
02880 SUMA_STRING *SS = NULL;
02881
02882 SUMA_ENTRY;
02883 SS = SUMA_StringAppend (NULL, NULL);
02884
02885 if (opt->accept_i) {
02886 SS = SUMA_StringAppend (SS,
02887 " Specifying input surfaces using -i_TYPE options: \n"
02888 " -i_TYPE inSurf specifies the input surface,\n"
02889 " TYPE is one of the following:\n"
02890 " fs: FreeSurfer surface. \n"
02891 " If surface name has .asc it is assumed to be\n"
02892 " in ASCII format. Otherwise it is assumed to be\n"
02893 " in BINARY_BE (Big Endian) format.\n"
02894 " Patches in Binary format cannot be read at the moment.\n"
02895 " sf: SureFit surface. \n"
02896 " You must specify the .coord followed by the .topo file.\n"
02897 " vec (or 1D): Simple ascii matrix format. \n"
02898 " You must specify the coord (NodeList) file followed by \n"
02899 " the topo (FaceSetList) file.\n"
02900 " coord contains 3 floats per line, representing \n"
02901 " X Y Z vertex coordinates.\n"
02902 " topo contains 3 ints per line, representing \n"
02903 " v1 v2 v3 triangle vertices.\n"
02904 " ply: PLY format, ascii or binary.\n"
02905 " Only vertex and triangulation info is preserved.\n"
02906 " bv: BrainVoyager format. \n"
02907 " Only vertex and triangulation info is preserved.\n"
02908 " dx: OpenDX ascii mesh format.\n"
02909 " Only vertex and triangulation info is preserved.\n"
02910 " Requires presence of 3 objects, the one of class \n"
02911 " 'field' should contain 2 components 'positions'\n"
02912 " and 'connections' that point to the two objects\n"
02913 " containing node coordinates and topology, respectively.\n"
02914 );
02915 }
02916 if (opt->accept_ipar) {
02917 SS = SUMA_StringAppend (SS,
02918 " -ipar_TYPE ParentSurf specifies the parent surface. Only used\n"
02919 " when -o_fsp is used, see -o_TYPE options.\n"
02920 );
02921 }
02922
02923 if (opt->accept_t) {
02924 SS = SUMA_StringAppend (SS,
02925 " Specifying surfaces using -t* options: \n"
02926 " -tn TYPE NAME: specify surface type and name.\n"
02927 " See below for help on the parameters.\n"
02928 " -tsn TYPE STATE NAME: specify surface type state and name.\n"
02929 " TYPE: Choose from the following (case sensitive):\n"
02930 " 1D: 1D format\n"
02931 " FS: FreeSurfer ascii format\n"
02932 " PLY: ply format\n"
02933 " SF: Caret/SureFit format\n"
02934 " BV: BrainVoyager format\n"
02935 " NAME: Name of surface file. \n"
02936 " For SF and 1D formats, NAME is composed of two names\n"
02937 " the coord file followed by the topo file\n"
02938 " STATE: State of the surface.\n"
02939 " Default is S1, S2.... for each surface.\n"
02940 );
02941 }
02942
02943
02944 if (opt->accept_sv) {
02945 SS = SUMA_StringAppend (SS,
02946 " Specifying a Surface Volume:\n"
02947 " -sv SurfaceVolume [VolParam for sf surfaces]\n"
02948 " If you supply a surface volume, the coordinates of the input surface.\n"
02949 " are modified to SUMA's convention and aligned with SurfaceVolume.\n"
02950 " You must also specify a VolParam file for SureFit surfaces.\n"
02951 );
02952 }
02953
02954 if (opt->accept_spec) {
02955 SS = SUMA_StringAppend (SS,
02956 " Specifying a surface specification (spec) file:\n"
02957 " -spec SPEC: specify the name of the SPEC file.\n"
02958 );
02959 }
02960
02961 if (opt->accept_s) {
02962 SS = SUMA_StringAppend (SS,
02963 " Specifying a surface using -surf_? method:\n"
02964 " -surf_A SURFACE: specify the name of the first\n"
02965 " surface to load. If the program requires\n"
02966 " or allows multiple surfaces, use -surf_B\n"
02967 " ... -surf_Z .\n"
02968 " You need not use _A if only one surface is\n"
02969 " expected.\n"
02970 " SURFACE is the name of the surface as specified\n"
02971 " in the SPEC file. The use of -surf_ option \n"
02972 " requires the use of -spec option.\n"
02973
02974 );
02975 }
02976
02977 if (opt->accept_o) {
02978 SS = SUMA_StringAppend (SS,
02979 " Specifying output surfaces using -o_TYPE options: \n"
02980 " -o_TYPE outSurf specifies the output surface, \n"
02981 " TYPE is one of the following:\n"
02982 " fs: FreeSurfer ascii surface. \n"
02983 " fsp: FeeSurfer ascii patch surface. \n"
02984 " In addition to outSurf, you need to specify\n"
02985 " the name of the parent surface for the patch.\n"
02986 " using the -ipar_TYPE option.\n"
02987 " This option is only for ConvertSurface \n"
02988 " sf: SureFit surface. \n"
02989 " For most programs, you are expected to specify prefix:\n"
02990 " i.e. -o_sf brain. In some programs, you are allowed to \n"
02991 " specify both .coord and .topo file names: \n"
02992 " i.e. -o_sf XYZ.coord TRI.topo\n"
02993 " The program will determine your choice by examining \n"
02994 " the first character of the second parameter following\n"
02995 " -o_sf. If that character is a '-' then you have supplied\n"
02996 " a prefix and the program will generate the coord and topo names.\n"
02997 " vec (or 1D): Simple ascii matrix format. \n"
02998 " For most programs, you are expected to specify prefix:\n"
02999 " i.e. -o_1D brain. In some programs, you are allowed to \n"
03000 " specify both coord and topo file names: \n"
03001 " i.e. -o_1D brain.1D.coord brain.1D.topo\n"
03002 " coord contains 3 floats per line, representing \n"
03003 " X Y Z vertex coordinates.\n"
03004 " topo contains 3 ints per line, representing \n"
03005 " v1 v2 v3 triangle vertices.\n"
03006 " ply: PLY format, ascii or binary.\n"
03007 );
03008 }
03009
03010 if (opt->accept_talk_suma) {
03011 st = SUMA_help_talk();
03012 SS = SUMA_StringAppend_va (SS,
03013 "\n"
03014 "%s"
03015 "\n",
03016 st
03017 );
03018 SUMA_free(st); st = NULL;
03019 }
03020
03021 SUMA_SS2S(SS, s);
03022
03023 SUMA_RETURN(s);
03024
03025 }
03026
03027
03028
03029
03030
03031
03032 SUMA_GENERIC_ARGV_PARSE *SUMA_Parse_IO_Args (int argc, char *argv[], char *optflags)
03033 {
03034 static char FuncName[]={"SUMA_Parse_IO_Args"};
03035 int i, kar, ind, N_name;
03036 SUMA_Boolean brk = NOPE;
03037 SUMA_GENERIC_ARGV_PARSE *ps=NULL;
03038
03039 SUMA_ENTRY;
03040
03041 if (argc >= SUMA_N_ARGS_MAX) {
03042 SUMA_S_Err("Number of arguments exceeds SUMA's parsing limit.");
03043 SUMA_RETURN(NULL);
03044 }
03045
03046 ps = SUMA_CreateGenericArgParse(optflags);
03047 if (!ps) {
03048 SUMA_S_Err("Failed to create parse structure.");
03049 SUMA_RETURN(NULL);
03050 }
03051 ps->N_args = argc;
03052 ps->cs = SUMA_Create_CommSrtuct();
03053 kar = 1;
03054 brk = NOPE;
03055 while (kar < argc) {
03056 if (ps->accept_talk_suma) {
03057 if (!brk && (strcmp(argv[kar], "-talk_suma") == 0)) {
03058 ps->arg_checked[kar]=1;
03059 ps->cs->talk_suma = 1;
03060 brk = YUP;
03061 }
03062
03063 if (!brk && (strcmp(argv[kar], "-feed_afni") == 0)) {
03064 ps->arg_checked[kar]=1;
03065 ps->cs->Feed2Afni = 1;
03066 brk = YUP;
03067 }
03068
03069 if (!brk && strcmp(argv[kar], "-send_kth") == 0)
03070 {
03071 ps->arg_checked[kar]=1;
03072 kar ++; ps->arg_checked[kar]=1;
03073 if (kar >= argc) {
03074 SUMA_S_Err("need argument after -send_kth \n");
03075 exit (1);
03076 }
03077 ps->cs->kth = atoi(argv[kar]);
03078 if (ps->cs->kth <= 0) {
03079 fprintf (SUMA_STDERR, "Bad value (%d) for send_kth\n", ps->cs->kth);
03080 exit (1);
03081 }
03082
03083 brk = YUP;
03084 }
03085
03086 if (!brk && strcmp(argv[kar], "-ni_text") == 0)
03087 {
03088 ps->arg_checked[kar]=1;
03089 ps->cs->comm_NI_mode = NI_TEXT_MODE;
03090 brk = YUP;
03091 }
03092
03093 if (!brk && strcmp(argv[kar], "-ni_binary") == 0)
03094 {
03095 ps->arg_checked[kar]=1;
03096 ps->cs->comm_NI_mode = NI_BINARY_MODE;
03097 brk = YUP;
03098 }
03099
03100 if (!brk && strcmp(argv[kar], "-sh") == 0)
03101 {
03102 ps->arg_checked[kar]=1;
03103 kar ++; ps->arg_checked[kar]=1;
03104 if (kar >= argc) {
03105 SUMA_S_Err("need argument after -sh \n");
03106 exit (1);
03107 }
03108 if (strcmp(argv[kar],"localhost") != 0) {
03109 ps->cs->suma_host_name = SUMA_copy_string(argv[kar]);
03110 }else {
03111 fprintf (SUMA_STDERR, "localhost is the default for -sh\nNo need to specify it.\n");
03112 }
03113
03114 brk = YUP;
03115 }
03116
03117 if (!brk && strcmp(argv[kar], "-ah") == 0)
03118 {
03119 ps->arg_checked[kar]=1;
03120 kar ++; ps->arg_checked[kar]=1;
03121 if (kar >= argc) {
03122 SUMA_S_Err("need argument after -ah \n");
03123 exit (1);
03124 }
03125 if (strcmp(argv[kar],"localhost") != 0) {
03126 ps->cs->afni_host_name = SUMA_copy_string(argv[kar]);
03127 }else {
03128 fprintf (SUMA_STDERR, "localhost is the default for -ah\nNo need to specify it.\n");
03129 }
03130
03131 brk = YUP;
03132 }
03133
03134 if (!brk && strcmp(argv[kar], "-refresh_rate") == 0)
03135 {
03136 ps->arg_checked[kar]=1;
03137 kar ++; ps->arg_checked[kar]=1;
03138 if (kar >= argc) {
03139 SUMA_S_Err("need argument after -refresh_rate \n");
03140 exit (1);
03141 }
03142 ps->cs->rps = atof(argv[kar]);
03143 if (ps->cs->rps <= 0) {
03144 fprintf (SUMA_STDERR, "Bad value (%f) for refresh_rate\n", ps->cs->rps);
03145 exit (1);
03146 }
03147
03148 brk = YUP;
03149 }
03150
03151 }
03152
03153 if (ps->accept_sv) {
03154 if (!brk && (strcmp(argv[kar], "-sv") == 0)) {
03155 ps->arg_checked[kar]=1;
03156 kar ++; ps->arg_checked[kar]=1;
03157 if (kar >= argc) {
03158 SUMA_S_Err("need 1 or 2 arguments after -sv ");
03159 exit (1);
03160 }
03161 if (ps->N_sv >= SUMA_MAX_SURF_ON_COMMAND) {
03162 SUMA_S_Err("Exceeding maximum number of allowed sv files...");
03163 exit(1);
03164 }
03165 ps->sv[ps->N_sv] = SUMA_copy_string(argv[kar]);
03166
03167 if (kar+1 < argc) {
03168
03169 if (argv[kar+1][0] == '-') {
03170 } else {
03171 kar ++; ps->arg_checked[kar]=1;
03172 ps->vp[ps->N_vp] = SUMA_copy_string(argv[kar]);
03173 ++ps->N_vp;
03174 }
03175 }
03176 ++ps->N_sv;
03177 brk = YUP;
03178 }
03179 }
03180 if (ps->accept_spec || ps->accept_s) {
03181 if (!brk && (strcmp(argv[kar], "-spec") == 0)) {
03182 ps->arg_checked[kar]=1;
03183 kar ++; ps->arg_checked[kar]=1;
03184 if (kar >= argc) {
03185 SUMA_S_Err( "need argument after -spec ");
03186 exit (1);
03187 }
03188 if (ps->N_spec_names >= SUMA_MAX_SURF_ON_COMMAND) {
03189 SUMA_SL_Err("Exceeding maximum number of allowed spec files...");
03190 exit(1);
03191 }
03192 ps->spec_names[ps->N_spec_names] = SUMA_copy_string(argv[kar]);
03193 ++ps->N_spec_names;
03194 brk = YUP;
03195 }
03196 }
03197 if (ps->accept_s) {
03198 if (!brk && (strncmp(argv[kar], "-surf_", 6) == 0)) {
03199 ps->arg_checked[kar]=1;
03200 if (kar + 1>= argc) {
03201 SUMA_S_Err( "need argument after -surf_X SURF_NAME \n");
03202 exit (1);
03203 }
03204 ind = argv[kar][6] - 'A';
03205 if (ind < 0 || ind >= 'Z') {
03206 fprintf (SUMA_STDERR, "Error %s:\n -surf_X SURF_NAME option is out of range.\n"
03207 "Only %d surfaces are allowed. \n"
03208 "Must start with surf_A for first surface.\n", FuncName, 'Z');
03209 exit (1);
03210 }
03211 kar ++;
03212 ps->arg_checked[kar]=1;
03213 if (ps->s_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03214 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03215 exit(1);
03216 }
03217 ps->s_surfnames[ps->s_N_surfnames+ind] = SUMA_copy_string(argv[kar]);
03218 ++ps->s_N_surfnames;
03219 brk = YUP;
03220 }
03221 if (!brk && (strncmp(argv[kar], "-surf", 5) == 0)) {
03222 ps->arg_checked[kar]=1;
03223 if (kar + 1>= argc) {
03224 SUMA_S_Err( "need argument after -surf SURF_NAME \n");
03225 exit (1);
03226 }
03227 ind = 0;
03228
03229 kar ++;
03230 ps->arg_checked[kar]=1;
03231 if (ps->s_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03232 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03233 exit(1);
03234 }
03235 if (ps->s_surfnames[ps->s_N_surfnames+ind]) {
03236 SUMA_SL_Err("surface (A) already specified.");
03237 exit(1);
03238 }
03239 ps->s_surfnames[ps->s_N_surfnames+ind] = SUMA_copy_string(argv[kar]);
03240 ++ps->s_N_surfnames;
03241 brk = YUP;
03242 }
03243 }
03244 if (ps->accept_i) {
03245 if (!brk && ( (strcmp(argv[kar], "-i_bv") == 0) || (strcmp(argv[kar], "-i_BV") == 0) ) ) {
03246 ps->arg_checked[kar]=1;
03247 kar ++; ps->arg_checked[kar]=1;
03248 if (kar >= argc) {
03249 SUMA_S_Err( "need argument after -i_bv ");
03250 exit (1);
03251 }
03252 if (ps->i_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03253 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03254 exit(1);
03255 }
03256 ps->i_surfnames[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03257 ps->i_FT[ps->i_N_surfnames] = SUMA_BRAIN_VOYAGER;
03258 ps->i_FF[ps->i_N_surfnames] = SUMA_BINARY;
03259 ++ps->i_N_surfnames;
03260 brk = YUP;
03261 }
03262
03263 if (!brk && ( (strcmp(argv[kar], "-i_fs") == 0) || (strcmp(argv[kar], "-i_FS") == 0)) ) {
03264 ps->arg_checked[kar]=1;
03265 kar ++; ps->arg_checked[kar]=1;
03266 if (kar >= argc) {
03267 SUMA_S_Err( "need argument after -i_fs ");
03268 exit (1);
03269 }
03270 if (ps->i_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03271 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03272 exit(1);
03273 }
03274 ps->i_surfnames[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03275 ps->i_FT[ps->i_N_surfnames] = SUMA_FREE_SURFER;
03276 if (SUMA_isExtension(ps->i_surfnames[ps->i_N_surfnames], ".asc"))
03277 ps->i_FF[ps->i_N_surfnames] = SUMA_ASCII;
03278 else
03279 ps->i_FF[ps->i_N_surfnames] = SUMA_BINARY_BE;
03280 ++ps->i_N_surfnames;
03281 brk = YUP;
03282 }
03283
03284 if (!brk && ( (strcmp(argv[kar], "-i_sf") == 0) || (strcmp(argv[kar], "-i_SF") == 0)) ){
03285 ps->arg_checked[kar]=1;
03286 kar ++; ps->arg_checked[kar]=1;
03287 if (kar+1 >= argc) {
03288 SUMA_S_Err( "need 2 arguments after -i_sf");
03289 exit (1);
03290 }
03291 if (ps->i_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03292 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03293 exit(1);
03294 }
03295 ps->i_surfnames[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03296 kar ++; ps->arg_checked[kar]=1;
03297 ps->i_surftopo[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03298 ps->i_FT[ps->i_N_surfnames] = SUMA_SUREFIT;
03299 ps->i_FF[ps->i_N_surfnames] = SUMA_ASCII;
03300 ++ps->i_N_surfnames;
03301 brk = YUP;
03302 }
03303
03304 if (!brk && ( (strcmp(argv[kar], "-i_vec") == 0) || (strcmp(argv[kar], "-i_1d") == 0) ||
03305 (strcmp(argv[kar], "-i_VEC") == 0) || (strcmp(argv[kar], "-i_1D") == 0) ) ) {
03306 ps->arg_checked[kar]=1;
03307 kar ++; ps->arg_checked[kar]=1;
03308 if (kar+1 >= argc) {
03309 SUMA_S_Err( "need 2 argument after -i_vec or -i_1d");
03310 exit (1);
03311 }
03312 if (ps->i_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03313 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03314 exit(1);
03315 }
03316 ps->i_surfnames[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03317 kar ++; ps->arg_checked[kar]=1;
03318 ps->i_surftopo[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03319 ps->i_FT[ps->i_N_surfnames] = SUMA_VEC;
03320 ps->i_FF[ps->i_N_surfnames] = SUMA_ASCII;
03321 ++ps->i_N_surfnames;
03322 brk = YUP;
03323 }
03324
03325 if (!brk && ( (strcmp(argv[kar], "-i_ply") == 0) || (strcmp(argv[kar], "-i_Ply") == 0) || (strcmp(argv[kar], "-i_PLY") == 0))) {
03326 ps->arg_checked[kar]=1;
03327 kar ++; ps->arg_checked[kar]=1;
03328 if (kar >= argc) {
03329 SUMA_S_Err( "need argument after -i_ply ");
03330 exit (1);
03331 }
03332 if (ps->i_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03333 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03334 exit(1);
03335 }
03336 ps->i_surfnames[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03337 ps->i_FT[ps->i_N_surfnames] = SUMA_PLY;
03338 ps->i_FF[ps->i_N_surfnames] = SUMA_FF_NOT_SPECIFIED;
03339 ++ps->i_N_surfnames;
03340 brk = YUP;
03341 }
03342 if (!brk && ( (strcmp(argv[kar], "-i_DX") == 0) || (strcmp(argv[kar], "-i_dx") == 0) || (strcmp(argv[kar], "-i_Dx") == 0))) {
03343 ps->arg_checked[kar]=1;
03344 kar ++; ps->arg_checked[kar]=1;
03345 if (kar >= argc) {
03346 SUMA_S_Err( "need argument after -i_dx ");
03347 exit (1);
03348 }
03349 if (ps->i_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03350 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03351 exit(1);
03352 }
03353 ps->i_surfnames[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03354 ps->i_FT[ps->i_N_surfnames] = SUMA_OPENDX_MESH;
03355 ps->i_FF[ps->i_N_surfnames] = SUMA_ASCII;
03356 ++ps->i_N_surfnames;
03357 brk = YUP;
03358 }
03359 if (!brk && ( (strcmp(argv[kar], "-i_iv") == 0) || (strcmp(argv[kar], "-i_IV") == 0) )) {
03360 ps->arg_checked[kar]=1;
03361 kar ++; ps->arg_checked[kar]=1;
03362 if (kar >= argc) {
03363 SUMA_S_Err( "need argument after -i_iv ");
03364 exit (1);
03365 }
03366 if (ps->i_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03367 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03368 exit(1);
03369 }
03370 ps->i_surfnames[ps->i_N_surfnames] = SUMA_copy_string(argv[kar]);
03371 ps->i_FT[ps->i_N_surfnames] = SUMA_INVENTOR_GENERIC;
03372 ps->i_FF[ps->i_N_surfnames] = SUMA_ASCII;
03373 ++ps->i_N_surfnames;
03374 brk = YUP;
03375 }
03376
03377 }
03378
03379 if (ps->accept_ipar) {
03380 if (!brk && ( (strcmp(argv[kar], "-ipar_bv") == 0) || (strcmp(argv[kar], "-ipar_BV") == 0) ) ) {
03381 ps->arg_checked[kar]=1;
03382 kar ++; ps->arg_checked[kar]=1;
03383 if (kar >= argc) {
03384 SUMA_S_Err( "need argument after -ipar_bv ");
03385 exit (1);
03386 }
03387 if (ps->ipar_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03388 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03389 exit(1);
03390 }
03391 ps->ipar_surfnames[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03392 ps->ipar_FT[ps->ipar_N_surfnames] = SUMA_BRAIN_VOYAGER;
03393 ps->ipar_FF[ps->ipar_N_surfnames] = SUMA_BINARY;
03394 ++ps->ipar_N_surfnames;
03395 brk = YUP;
03396 }
03397
03398 if (!brk && ( (strcmp(argv[kar], "-ipar_fs") == 0) || (strcmp(argv[kar], "-ipar_FS") == 0)) ) {
03399 ps->arg_checked[kar]=1;
03400 kar ++; ps->arg_checked[kar]=1;
03401 if (kar >= argc) {
03402 SUMA_S_Err( "need argument after -ipar_fs ");
03403 exit (1);
03404 }
03405 if (ps->ipar_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03406 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03407 exit(1);
03408 }
03409 ps->ipar_surfnames[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03410 ps->ipar_FT[ps->ipar_N_surfnames] = SUMA_FREE_SURFER;
03411 if (SUMA_isExtension(ps->ipar_surfnames[ps->ipar_N_surfnames], ".asc"))
03412 ps->ipar_FF[ps->ipar_N_surfnames] = SUMA_ASCII;
03413 else
03414 ps->ipar_FF[ps->ipar_N_surfnames] = SUMA_BINARY_BE;
03415 ++ps->ipar_N_surfnames;
03416 brk = YUP;
03417 }
03418
03419 if (!brk && ( (strcmp(argv[kar], "-ipar_sf") == 0) || (strcmp(argv[kar], "-ipar_SF") == 0)) ){
03420 ps->arg_checked[kar]=1;
03421 kar ++; ps->arg_checked[kar]=1;
03422 if (kar+1 >= argc) {
03423 SUMA_S_Err( "need 2 arguments after -ipar_sf");
03424 exit (1);
03425 }
03426 if (ps->ipar_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03427 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03428 exit(1);
03429 }
03430 ps->ipar_surfnames[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03431 kar ++; ps->arg_checked[kar]=1;
03432 ps->ipar_surftopo[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03433 ps->ipar_FT[ps->ipar_N_surfnames] = SUMA_SUREFIT;
03434 ps->ipar_FF[ps->ipar_N_surfnames] = SUMA_ASCII;
03435 ++ps->ipar_N_surfnames;
03436 brk = YUP;
03437 }
03438
03439 if (!brk && ( (strcmp(argv[kar], "-ipar_vec") == 0) || (strcmp(argv[kar], "-ipar_1d") == 0) ||
03440 (strcmp(argv[kar], "-ipar_VEC") == 0) || (strcmp(argv[kar], "-ipar_1D") == 0) ) ) {
03441 ps->arg_checked[kar]=1;
03442 kar ++; ps->arg_checked[kar]=1;
03443 if (kar+1 >= argc) {
03444 SUMA_S_Err( "need 2 argument after -ipar_vec or -ipar_1d");
03445 exit (1);
03446 }
03447 if (ps->ipar_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03448 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03449 exit(1);
03450 }
03451 ps->ipar_surfnames[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03452 kar ++; ps->arg_checked[kar]=1;
03453 ps->ipar_surftopo[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03454 ps->ipar_FT[ps->ipar_N_surfnames] = SUMA_VEC;
03455 ps->ipar_FF[ps->ipar_N_surfnames] = SUMA_ASCII;
03456 ++ps->ipar_N_surfnames;
03457 brk = YUP;
03458 }
03459
03460 if (!brk && ( (strcmp(argv[kar], "-ipar_ply") == 0) || (strcmp(argv[kar], "-ipar_Ply") == 0) || (strcmp(argv[kar], "-ipar_PLY") == 0))) {
03461 ps->arg_checked[kar]=1;
03462 kar ++; ps->arg_checked[kar]=1;
03463 if (kar >= argc) {
03464 SUMA_S_Err( "need argument after -ipar_ply ");
03465 exit (1);
03466 }
03467 if (ps->ipar_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03468 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03469 exit(1);
03470 }
03471 ps->ipar_surfnames[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03472 ps->ipar_FT[ps->ipar_N_surfnames] = SUMA_PLY;
03473 ps->ipar_FF[ps->ipar_N_surfnames] = SUMA_FF_NOT_SPECIFIED;
03474 ++ps->ipar_N_surfnames;
03475 brk = YUP;
03476 }
03477 if (!brk && ( (strcmp(argv[kar], "-ipar_DX") == 0) || (strcmp(argv[kar], "-ipar_dx") == 0) || (strcmp(argv[kar], "-ipar_Dx") == 0))) {
03478 ps->arg_checked[kar]=1;
03479 kar ++; ps->arg_checked[kar]=1;
03480 if (kar >= argc) {
03481 SUMA_S_Err( "need argument after -ipar_dx ");
03482 exit (1);
03483 }
03484 if (ps->ipar_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03485 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03486 exit(1);
03487 }
03488 ps->ipar_surfnames[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03489 ps->ipar_FT[ps->ipar_N_surfnames] = SUMA_OPENDX_MESH;
03490 ps->ipar_FF[ps->ipar_N_surfnames] = SUMA_ASCII;
03491 ++ps->ipar_N_surfnames;
03492 brk = YUP;
03493 }
03494 if (!brk && ( (strcmp(argv[kar], "-ipar_iv") == 0) || (strcmp(argv[kar], "-ipar_IV") == 0) )) {
03495 ps->arg_checked[kar]=1;
03496 kar ++; ps->arg_checked[kar]=1;
03497 if (kar >= argc) {
03498 SUMA_S_Err( "need argument after -ipar_iv ");
03499 exit (1);
03500 }
03501 if (ps->ipar_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03502 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03503 exit(1);
03504 }
03505 ps->ipar_surfnames[ps->ipar_N_surfnames] = SUMA_copy_string(argv[kar]);
03506 ps->ipar_FT[ps->ipar_N_surfnames] = SUMA_INVENTOR_GENERIC;
03507 ps->ipar_FF[ps->ipar_N_surfnames] = SUMA_ASCII;
03508 ++ps->ipar_N_surfnames;
03509 brk = YUP;
03510 }
03511 }
03512
03513 if (ps->accept_t) {
03514 if (!brk && (strcmp(argv[kar], "-tn") == 0)) {
03515 ps->arg_checked[kar]=1;
03516 kar ++; ps->arg_checked[kar]=1;
03517 if (kar >= argc) {
03518 SUMA_S_Err( "Type argument must follow -tn ");
03519 exit (1);
03520 }
03521 if (ps->t_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03522 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03523 exit(1);
03524 }
03525
03526 ps->t_FT[ps->t_N_surfnames] = SUMA_SurfaceTypeCode(argv[kar]);
03527 if (ps->t_FT[ps->t_N_surfnames] == SUMA_FT_ERROR || ps->t_FT[ps->t_N_surfnames] == SUMA_FT_NOT_SPECIFIED) {
03528 fprintf (SUMA_STDERR, "%s is a bad file type.\n", argv[kar]);
03529 exit(1);
03530 }
03531
03532 if (ps->t_FT[ps->t_N_surfnames] == SUMA_SUREFIT || ps->t_FT[ps->t_N_surfnames] == SUMA_VEC) N_name = 2;
03533 else N_name = 1;
03534 if (kar+N_name >= argc) {
03535 fprintf (SUMA_STDERR, "need %d elements for NAME \n", N_name);
03536 exit (1);
03537 }
03538 kar ++; ps->arg_checked[kar]=1;
03539 ps->t_surfnames[ps->t_N_surfnames] = SUMA_copy_string(argv[kar]);
03540 if (N_name == 2) {
03541 kar ++; ps->arg_checked[kar]=1;
03542 ps->t_surftopo[ps->t_N_surfnames] = SUMA_copy_string(argv[kar]);
03543 }
03544
03545 ++ps->t_N_surfnames;
03546 brk = YUP;
03547 }
03548
03549 if (!brk && (strcmp(argv[kar], "-tsn") == 0)) {
03550 ps->arg_checked[kar]=1;
03551 kar ++; ps->arg_checked[kar]=1;
03552 if (kar >= argc) {
03553 fprintf (SUMA_STDERR, "Type argument must follow -tn \n");
03554 exit (1);
03555 }
03556 if (ps->t_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03557 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03558 exit(1);
03559 }
03560
03561 ps->t_FT[ps->t_N_surfnames] = SUMA_SurfaceTypeCode(argv[kar]);
03562 if (ps->t_FT[ps->t_N_surfnames] == SUMA_FT_ERROR || ps->t_FT[ps->t_N_surfnames] == SUMA_FT_NOT_SPECIFIED) {
03563 fprintf (SUMA_STDERR, "%s is a bad file type.\n", argv[kar]);
03564 exit(1);
03565 }
03566
03567 kar ++; ps->arg_checked[kar]=1;
03568 if (kar >= argc) {
03569 SUMA_S_Err( "STATE argument must follow TYPE with -tsn ");
03570 exit (1);
03571 }
03572 ps->t_state[ps->t_N_surfnames] = SUMA_copy_string(argv[kar]);
03573
03574
03575 if (ps->t_FT[ps->t_N_surfnames] == SUMA_SUREFIT || ps->t_FT[ps->t_N_surfnames] == SUMA_VEC) N_name = 2;
03576 else N_name = 1;
03577 if (kar+N_name >= argc) {
03578 fprintf (SUMA_STDERR, "Error %s:\nneed %d elements for NAME \n", FuncName, N_name);
03579 exit (1);
03580 }
03581 kar ++; ps->arg_checked[kar]=1;
03582 ps->t_surfnames[ps->t_N_surfnames] = SUMA_copy_string(argv[kar]);
03583 if (N_name == 2) {
03584 kar ++; ps->arg_checked[kar]=1;
03585 ps->t_surftopo[ps->t_N_surfnames] = SUMA_copy_string(argv[kar]);
03586 }
03587
03588 if ( ps->t_FT[ps->t_N_surfnames] == SUMA_SUREFIT || ps->t_FT[ps->t_N_surfnames] == SUMA_VEC ||
03589 ps->t_FT[ps->t_N_surfnames] == SUMA_INVENTOR_GENERIC || ps->t_FT[ps->t_N_surfnames] == SUMA_OPENDX_MESH)
03590 ps->t_FF[ps->t_N_surfnames] = SUMA_ASCII;
03591 else if (ps->t_FT[ps->t_N_surfnames] == SUMA_PLY) ps->t_FF[ps->t_N_surfnames] = SUMA_FF_NOT_SPECIFIED;
03592 else if (ps->t_FT[ps->t_N_surfnames] == SUMA_BRAIN_VOYAGER) ps->t_FF[ps->t_N_surfnames] = SUMA_BINARY;
03593 else if (ps->t_FT[ps->t_N_surfnames] == SUMA_FREE_SURFER) {
03594 if (SUMA_isExtension(ps->t_surfnames[ps->t_N_surfnames], ".asc"))
03595 ps->t_FF[ps->t_N_surfnames] = SUMA_ASCII;
03596 else
03597 ps->t_FF[ps->t_N_surfnames] = SUMA_BINARY_BE;
03598 }
03599
03600 ++ps->t_N_surfnames;
03601 brk = YUP;
03602 }
03603
03604 }
03605 if (ps->accept_o) {
03606 if (!brk && ( (strcmp(argv[kar], "-o_fs") == 0) || (strcmp(argv[kar], "-o_FS") == 0) ) ) {
03607 ps->arg_checked[kar]=1;
03608 kar ++; ps->arg_checked[kar]=1;
03609 if (kar >= argc) {
03610 SUMA_S_Err( "need argument after -o_fs ");
03611 exit (1);
03612 }
03613 if (ps->o_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03614 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03615 exit(1);
03616 }
03617 ps->o_surfnames[ps->o_N_surfnames] = SUMA_RemoveSurfNameExtension(argv[kar], SUMA_FREE_SURFER);
03618 ps->o_FT[ps->o_N_surfnames] = SUMA_FREE_SURFER;
03619 ps->o_FF[ps->o_N_surfnames] = SUMA_ASCII;
03620 ++ps->o_N_surfnames;
03621 brk = YUP;
03622 }
03623
03624 if (!brk && ( (strcmp(argv[kar], "-o_fsp") == 0) || (strcmp(argv[kar], "-o_FSP") == 0) ) ) {
03625 ps->arg_checked[kar]=1;
03626 kar ++; ps->arg_checked[kar]=1;
03627 if (kar >= argc) {
03628 SUMA_S_Err( "need argument after -o_fsp ");
03629 exit (1);
03630 }
03631 if (ps->o_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03632 SUMA_SL_Err("Exceeding maximum number of allowed surfaces...");
03633 exit(1);
03634 }
03635
03636 ps->o_surfnames[ps->o_N_surfnames] = SUMA_RemoveSurfNameExtension(argv[kar], SUMA_FREE_SURFER_PATCH);
03637 ps->o_FT[ps->o_N_surfnames] = SUMA_FREE_SURFER_PATCH;
03638 ps->o_FF[ps->o_N_surfnames] = SUMA_BINARY;
03639 ++ps->o_N_surfnames;
03640 brk = YUP;
03641 }
03642
03643 if (!brk && ( (strcmp(argv[kar], "-o_sf") == 0) || (strcmp(argv[kar], "-o_SF") == 0)) ) {
03644 ps->arg_checked[kar]=1;
03645 kar ++; ps->arg_checked[kar]=1;
03646 if (kar >= argc) {
03647 SUMA_S_Err( "need 1 or 2 argument after -o_sf ");
03648 exit (1);
03649 }
03650 if (ps->o_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03651 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03652 exit(1);
03653 }
03654 ps->o_surfnames[ps->o_N_surfnames] = SUMA_RemoveSurfNameExtension(argv[kar], SUMA_SUREFIT);
03655 ps->o_FT[ps->o_N_surfnames] = SUMA_SUREFIT;
03656 ps->o_FF[ps->o_N_surfnames] = SUMA_ASCII;
03657
03658 if (kar+1 < argc) {
03659 if (argv[kar+1][0] == '-') {
03660
03661 ps->o_surftopo[ps->o_N_surfnames] = SUMA_copy_string(ps->o_surfnames[ps->o_N_surfnames]);
03662 } else {
03663 kar ++; ps->arg_checked[kar]=1;
03664 ps->o_surftopo[ps->o_N_surfnames] = SUMA_RemoveSurfNameExtension(argv[kar], SUMA_SUREFIT);
03665 }
03666 }
03667 ++ps->o_N_surfnames;
03668 brk = YUP;
03669 }
03670
03671
03672 if (!brk && ( (strcmp(argv[kar], "-o_vec") == 0) || (strcmp(argv[kar], "-o_1d") == 0) ||
03673 (strcmp(argv[kar], "-o_VEC") == 0) || (strcmp(argv[kar], "-o_1D") == 0) ) ) {
03674 ps->arg_checked[kar]=1;
03675 kar ++; ps->arg_checked[kar]=1;
03676 if (kar >= argc) {
03677 SUMA_S_Err( "need 1 or 2 argument after -o_sf ");
03678 exit (1);
03679 }
03680 if (ps->o_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03681 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03682 exit(1);
03683 }
03684 ps->o_surfnames[ps->o_N_surfnames] = SUMA_RemoveSurfNameExtension(argv[kar], SUMA_VEC);
03685 ps->o_FT[ps->o_N_surfnames] = SUMA_VEC;
03686 ps->o_FF[ps->o_N_surfnames] = SUMA_ASCII;
03687
03688 if (kar+1 < argc) {
03689 if (argv[kar+1][0] == '-') {
03690
03691 ps->o_surftopo[ps->o_N_surfnames] = SUMA_copy_string(ps->o_surfnames[ps->o_N_surfnames]);
03692 } else {
03693 kar ++; ps->arg_checked[kar]=1;
03694 ps->o_surftopo[ps->o_N_surfnames] = SUMA_RemoveSurfNameExtension(argv[kar], SUMA_VEC);
03695 }
03696 }
03697 ++ps->o_N_surfnames;
03698 brk = YUP;
03699 }
03700
03701 if (!brk && ( (strcmp(argv[kar], "-o_dx") == 0) || (strcmp(argv[kar], "-o_DX") == 0) || (strcmp(argv[kar], "-o_Dx") == 0)) ) {
03702 ps->arg_checked[kar]=1;
03703 kar ++; ps->arg_checked[kar]=1;
03704 if (kar >= argc) {
03705 SUMA_S_Err( "need argument after -o_dx \n");
03706 exit (1);
03707 }
03708 if (ps->o_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03709 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03710 exit(1);
03711 }
03712 ps->o_surfnames[ps->o_N_surfnames] = SUMA_RemoveSurfNameExtension(argv[kar], SUMA_OPENDX_MESH);
03713 ps->o_FT[ps->o_N_surfnames] = SUMA_OPENDX_MESH;
03714 ps->o_FF[ps->o_N_surfnames] = SUMA_ASCII;
03715 ++ps->o_N_surfnames;
03716 brk = YUP;
03717 }
03718 if (!brk && ( (strcmp(argv[kar], "-o_ply") == 0) || (strcmp(argv[kar], "-o_PLY") == 0) || (strcmp(argv[kar], "-o_Ply") == 0)) ) {
03719 ps->arg_checked[kar]=1;
03720 kar ++; ps->arg_checked[kar]=1;
03721 if (kar >= argc) {
03722 SUMA_S_Err( "need argument after -o_ply \n");
03723 exit (1);
03724 }
03725 if (ps->o_N_surfnames >= SUMA_MAX_SURF_ON_COMMAND) {
03726 SUMA_S_Err("Exceeding maximum number of allowed surfaces...");
03727 exit(1);
03728 }
03729 ps->o_surfnames[ps->o_N_surfnames] = SUMA_RemoveSurfNameExtension(argv[kar], SUMA_PLY);
03730 ps->o_FT[ps->o_N_surfnames] = SUMA_PLY;
03731 ps->o_FF[ps->o_N_surfnames] = SUMA_ASCII;
03732 ++ps->o_N_surfnames;
03733 brk = YUP;
03734 }
03735 }
03736
03737 brk = NOPE;
03738 kar ++;
03739 }
03740
03741 if (ps->cs->rps > 0) { ps->cs->nelps = (float)ps->cs->talk_suma * ps->cs->rps; }
03742 else { ps->cs->nelps = (float) ps->cs->talk_suma * -1.0; }
03743
03744
03745 SUMA_RETURN(ps);
03746 }
03747
03748
03749 #ifdef STAND_ALONE
03750 void usage ()
03751
03752 {
03753 printf ("\nUsage: SUMA_GetNextCommand ..... \n");
03754 printf ("\t ..... \n\n");
03755 printf ("\t To Compile:\ngcc -DSTAND_ALONE -Wall -o $1 $1.c -I/usr/X11R6/include -I./\n");
03756 printf ("\t\t Ziad S. Saad SSCC/NIMH/NIH ziad@nih.gov \tTue Feb 5 10:39:02 EST 2002 \n");
03757 exit (0);
03758 }
03759
03760 int main (int argc,char *argv[])
03761 {
03762 char FuncName[100];
03763 char Scom[500], S[500], term, d;
03764
03765
03766 sprintf (FuncName,"SUMA_GetNextCommand-Main-");
03767
03768 term = '~';
03769 d = '|';
03770
03771 if (argc < 2)
03772 {
03773 usage ();
03774 exit (1);
03775 }
03776
03777
03778 sprintf (S,"%s", argv[1]);
03779 fprintf(stderr,"INITIAL: %s, \n", S);
03780
03781 if(!SUMA_RegisterCommand (S, d, term, "Newly Registered Append", NOPE)) {
03782 fprintf (stderr, "%s Error: Failed to register new command\n", FuncName);
03783 }
03784 if(!SUMA_RegisterCommand (S, d, term, "Newly Registered Prepend", YUP)) {
03785 fprintf (stderr, "%s Error: Failed to register new command\n", FuncName);
03786 }
03787
03788
03789 fprintf(stderr,"%s\n", S);
03790 while (SUMA_GetNextCommand (S, d, term, Scom) != SE_Empty) {
03791 fprintf (stdout, "Command->%s<-\n", Scom);
03792 fprintf(stderr,"%s\n", S);
03793 }
03794 return(0);
03795 }
03796 #endif