1 #ifndef SUMA_SEGFUNC_INCLUDED 2 #define SUMA_SEGFUNC_INCLUDED 3 4 5 /*! 6 Swap a column between two dsets. 7 This macro will check for nothing. 8 You must ensure that the two dsets have the same 9 dimensions, brick types, etc. 10 */ 11 #define SWAP_COL(p1,p2,i) { \ 12 void *m_ap1 = DSET_ARRAY(p1,i); \ 13 void *m_ap2 = DSET_ARRAY(p2,i); \ 14 float m_f1 = DSET_BRICK_FACTOR(p1,i); \ 15 float m_f2 = DSET_BRICK_FACTOR(p2,i); \ 16 mri_fix_data_pointer(m_ap1,DSET_BRICK(p2,i)); \ 17 mri_fix_data_pointer(m_ap2,DSET_BRICK(p1,i)); \ 18 EDIT_BRICK_FACTOR(p2,i,m_f1); \ 19 EDIT_BRICK_FACTOR(p1,i,m_f2); \ 20 } 21 22 /*! Macros to get (and put) value from sub-brick k, vox ijk 23 24 DSET_ARRAY calls mri_data_pointer, 25 this can perhaps be sped up with direct access 26 to im with: 27 *(dset->dblk->brick->imarr[k]->im+ijk) 28 */ 29 #define GVAL(dset,k,ijk,V) {\ 30 short *cc = (short *)DSET_ARRAY(dset,k); \ 31 V = cc[ijk]; \ 32 } 33 #define GSCVAL(dset,k,ijk,sf,V) {\ 34 short *cc = (short *)DSET_ARRAY(dset,k); \ 35 V = cc[ijk]*sf; \ 36 } 37 #define PVAL(dset,k,ijk,V) {\ 38 short *cc = (short *)DSET_ARRAY(dset,k); \ 39 cc[ijk] = (short)V; \ 40 } 41 #define PSCVAL(dset,k,ijk,sf,V) {\ 42 short *cc = (short *)DSET_ARRAY(dset,k); \ 43 cc[ijk] = (short)(V/sf); \ 44 } 45 46 /*! 47 Get a sub-brick index from label 48 */ 49 #define SB_LABEL(p,lbl, ia) { \ 50 for (ia = 0; ia <DSET_NVALS(p); ++ia) { \ 51 if (!strcmp(DSET_BRICK_LABEL(p,ia),lbl)) break; \ 52 } \ 53 if (ia==DSET_NVALS(p)) ia = -1; /* failed */\ 54 } 55 56 #define GET_BFs(pout, bf) { \ 57 int m_i; \ 58 for (m_i=0; m_i<DSET_NVALS(pout); ++m_i) { \ 59 bf[m_i] = DSET_BRICK_FACTOR(pout,m_i); \ 60 }\ 61 } 62 #define PUT_BFs(pout, bf) { \ 63 int m_i; \ 64 for (m_i=0; m_i<DSET_NVALS(pout); ++m_i) { \ 65 EDIT_BRICK_FACTOR(pout,m_i, bf[m_i]); \ 66 } \ 67 } 68 69 #define GET_VEC_AT_VOX(pout, j, dv, bf) { \ 70 int m_i; \ 71 short *m_p; \ 72 for (m_i=0; m_i<DSET_NVALS(pout); ++m_i) { \ 73 m_p = (short *)DSET_ARRAY(pout, m_i); \ 74 if (bf[m_i]!=0.0f) { \ 75 dv[m_i] = m_p[j]*bf[m_i]; \ 76 } else { dv[m_i] = m_p[j]; } \ 77 } \ 78 } 79 80 #define MAX_AT_VOX(pout, j, imax, max) { \ 81 int m_i; \ 82 short *m_p=(short *)DSET_ARRAY(pout, 0); \ 83 max = m_p[j]; imax = 0; \ 84 for (m_i=1; m_i<DSET_NVALS(pout); ++m_i) { \ 85 m_p = (short *)DSET_ARRAY(pout, m_i); \ 86 if (m_p[j] > max) { imax=m_i; max = m_p[j]; } \ 87 } \ 88 } 89 90 #define MAX_SC_AT_VOX(pout, j, imax, max) { \ 91 int m_i; \ 92 short *m_p=(short *)DSET_ARRAY(pout, 0); \ 93 float m_f = DSET_BRICK_FACTOR(pout,0); if (m_f == 0.0f) m_f = 1.0; \ 94 max = m_p[j]*m_f; imax = 0; \ 95 for (m_i=1; m_i<DSET_NVALS(pout); ++m_i) { \ 96 m_p = (short *)DSET_ARRAY(pout, m_i); \ 97 m_f = DSET_BRICK_FACTOR(pout,m_i); if (m_f == 0.0f) m_f = 1.0; \ 98 if (m_p[j]*m_f > max) { imax=m_i; max = m_p[j]*m_f; } \ 99 } \ 100 } 101 102 #define PUT_VEC_AT_VOX(pout, j, dv, bf) { \ 103 int m_i; \ 104 short *m_p; \ 105 for (m_i=0; m_i<DSET_NVALS(pout); ++m_i) { \ 106 m_p = (short *)DSET_ARRAY(pout, m_i); \ 107 if (bf[m_i]!=0.0f) { \ 108 m_p[j] = (short) (dv[m_i] / bf[m_i]); \ 109 } else { \ 110 m_p[j] = (short) (dv[m_i]); \ 111 } \ 112 } \ 113 } 114 115 #define NEW_SHORTYV(par,nsb,nm,pb,view){ \ 116 NEW_SHORTY(par,nsb,nm,pb); \ 117 if (view) {\ 118 if (!strstr(view,"orig")) \ 119 EDIT_dset_items( pb ,ADN_view_type , VIEW_ORIGINAL_TYPE ,ADN_none ) ; \ 120 else if (!strstr(view,"acpc")) \ 121 EDIT_dset_items( pb ,ADN_view_type, VIEW_ACPCALIGNED_TYPE ,ADN_none ); \ 122 else if (!strstr(view,"tlrc")) \ 123 EDIT_dset_items( pb ,ADN_view_type, VIEW_TALAIRACH_TYPE ,ADN_none ) ; \ 124 else SUMA_S_Errv("In NEW_SHORTYV; View of %s is rubbish", view); \ 125 } \ 126 } 127 128 #define NEW_SHORTY(par,nsb,nm,pb){ \ 129 int m_i; \ 130 pb = EDIT_empty_copy(par); \ 131 EDIT_dset_items( pb , \ 132 ADN_prefix , nm , \ 133 ADN_nvals, nsb, \ 134 ADN_ntt, nsb, \ 135 ADN_malloc_type , DATABLOCK_MEM_MALLOC , \ 136 ADN_type , HEAD_ANAT_TYPE , \ 137 ADN_func_type , ANAT_BUCK_TYPE , \ 138 ADN_none ) ; \ 139 /* ADN_view_type , VIEW_ORIGINAL_TYPE , ZSS Sep 28 2012 */ \ 140 for(m_i=0;m_i<nsb;++m_i) EDIT_substitute_brick( pb, m_i, MRI_short, NULL ) ; \ 141 tross_Copy_History( par , pb ) ; \ 142 } 143 144 #define SET_ALL_BRICK_FACTORS(pb, fac) {\ 145 int m_i; \ 146 for(m_i=0;m_i<DSET_NVALS(pb);++m_i) EDIT_BRICK_FACTOR(pb, m_i, (fac)); \ 147 } 148 149 #define NEW_FLOATY(par,nsb,nm,pb){ \ 150 int m_i; \ 151 pb = EDIT_empty_copy(par); \ 152 EDIT_dset_items( pb , \ 153 ADN_prefix , nm , \ 154 ADN_nvals, nsb, \ 155 ADN_ntt, nsb, \ 156 ADN_malloc_type , DATABLOCK_MEM_MALLOC , \ 157 ADN_type , HEAD_ANAT_TYPE , \ 158 ADN_func_type , ANAT_BUCK_TYPE , \ 159 ADN_none ) ; \ 160 for(m_i=0;m_i<nsb;++m_i) EDIT_substitute_brick( pb, m_i, MRI_float, NULL ) ; \ 161 tross_Copy_History( par , pb ) ; \ 162 } 163 164 #define NEW_FLOATYV(par,nsb,nm,pb,fv){ \ 165 int m_i; \ 166 pb = EDIT_empty_copy(par); \ 167 EDIT_dset_items( pb , \ 168 ADN_prefix , nm , \ 169 ADN_nvals, nsb, \ 170 ADN_ntt, nsb, \ 171 ADN_malloc_type , DATABLOCK_MEM_MALLOC , \ 172 ADN_type , HEAD_ANAT_TYPE , \ 173 ADN_func_type , ANAT_BUCK_TYPE , \ 174 ADN_none ) ; \ 175 for(m_i=0;m_i<nsb;++m_i) \ 176 EDIT_substitute_brick( pb, m_i, MRI_float, (m_i==0 && (fv))?(fv):NULL); \ 177 tross_Copy_History( par , pb ) ; \ 178 } 179 180 181 #define EPS 0.000001 182 #define MINP 0.01 /* I tried 0.05, 0.01, and 0.001: See 183 results of @Run.PROB.12class.1 (at 0.01) 184 @Run.PROB.12class.1b (at 0.001), and 185 @Run.PROB.12class.1c (at 0.05) . 186 0.05 is too blunt a cut off, seems to cause too much 187 loss of information. 0.01 is OK, 0.001 seemed to 188 give slightly more stability for CSF for subject 1, 189 But further testing and changes to p_a_GIV_cvfu don't 190 show that, so 0.01 it remains*/ 191 #define SQ2PI 2.506628 192 193 #define IND_1D_2_NORM_3D_index(ijk, IJK, ni, nij, halfN){ \ 194 int m_i=0, m_j=0, m_k=0; \ 195 m_k = ((ijk) / (nij)); \ 196 m_j = ((ijk) % (nij)); \ 197 m_i = ((m_j) % (ni)); \ 198 m_j = ((m_j) / (ni)); \ 199 /* and normalize from -1 to 1 */ \ 200 IJK[0] = (m_i - halfN[0])/halfN[0]; \ 201 IJK[1] = (m_j - halfN[1])/halfN[1]; \ 202 IJK[2] = (m_k - halfN[2])/halfN[2]; \ 203 /* fprintf(stderr,"ijk %d = [%d, %d, %d] = [ %f %f %f]\n", \ 204 ijk, m_i, m_j, m_k, IJK[0], IJK[1], IJK[2]); \ */ \ 205 } 206 207 #define V_NEIGHB_0(IJK,ni, nij, cmask, ijkn) { /* at i-1 */\ 208 static int m_i ;\ 209 m_i = IJK[0]-1; \ 210 ijkn=-1; \ 211 if (m_i >= 0) { \ 212 ijkn = m_i+IJK[1]*ni+IJK[2]*nij; \ 213 if (!IN_MASK(cmask,ijkn)) ijkn = -1; \ 214 } \ 215 } 216 217 #define V_NEIGHB_1(IJK, ni, nij, cmask, nj, ijkn) { /* at j-1 */\ 218 static int m_j ;\ 219 m_j = IJK[1]-1; \ 220 ijkn=-1; \ 221 if (m_j>=0) { \ 222 ijkn = IJK[0]+m_j*ni+IJK[2]*nij; \ 223 if (!IN_MASK(cmask,ijkn)) ijkn = -1; \ 224 } \ 225 } 226 227 #define V_NEIGHB_2(IJK, ni, nij, cmask, ijkn) { /* at i+1 */\ 228 static int m_i; \ 229 m_i = IJK[0]+1; \ 230 ijkn=-1; \ 231 if (m_i<ni) { \ 232 ijkn=m_i+IJK[1]*ni+IJK[2]*nij; \ 233 if (!IN_MASK(cmask,ijkn)) ijkn = -1; \ 234 } \ 235 } 236 237 #define V_NEIGHB_3(IJK, ni, nij, cmask, nj, ijkn) { /* at j+1 */\ 238 static int m_j; \ 239 m_j = IJK[1]+1; \ 240 ijkn=-1; \ 241 if (m_j<nj) { \ 242 ijkn = IJK[0]+m_j*ni+IJK[2]*nij; \ 243 if (!IN_MASK(cmask,ijkn)) ijkn = -1; \ 244 } \ 245 } 246 247 #define V_NEIGHB_4(IJK, ni, nij, cmask, nk, ijkn) { /* at k-1 */\ 248 static int m_k; \ 249 m_k = IJK[2]-1; \ 250 ijkn=-1; \ 251 if (m_k >= 0) { \ 252 ijkn = IJK[0]+IJK[1]*ni+m_k*nij; \ 253 if (!IN_MASK(cmask,ijkn)) ijkn = -1; \ 254 } \ 255 } 256 257 #define V_NEIGHB_5(IJK, ni, nij, cmask, nk, ijkn) { /* at k+1 */\ 258 static int m_k; \ 259 m_k = IJK[2]+1; \ 260 ijkn=-1; \ 261 if (m_k<nk) { \ 262 ijkn = IJK[0]+IJK[1]*ni+m_k*nij; \ 263 if (!IN_MASK(cmask,ijkn)) ijkn = -1; \ 264 } \ 265 } 266 267 #define Vox1D2Vox3D(i1d, ni, nij, IJK) { \ 268 IJK[2] = ((i1d) / (nij)); \ 269 IJK[1] = ((i1d) % (nij)); \ 270 IJK[0] = ((IJK[1]) % (ni)); \ 271 IJK[1] = ((IJK[1]) / (ni)); \ 272 } 273 274 /*Macros to go from 1D to 4D ubyte indexing. 275 For SUMA_COLID_N2RGBA, you will need to pass ints for r g b a 276 even though ubyte is needed for final storage */ 277 #define SUMA_COLID_N2RGBA(n,r,g,b,a) { \ 278 (b) = (n) & (16777215); /* x % 2^24 = x & (2^n-1) */ \ 279 (a) = (n) >> 24; /* divide by 2^24 (256x256x256) */ \ 280 (g) = (b) & (65535); \ 281 (b) = (b) >> 16; \ 282 (r) = (g) & (255); \ 283 (g) = (g) >> 8; \ 284 } 285 #define SUMA_COLID_N2RGBA_slow(n,r,g,b,a) { \ 286 (b) = (n) % (16777216); /* x % 2^24 = x & (2^n-1) */ \ 287 (a) = (n) / 16777216; /* divide by 2^24 (256x256x256) */ \ 288 (g) = (b) % (65536); \ 289 (b) = (b) / 65536; \ 290 (r) = (g) % (256); \ 291 (g) = (g) / 256; \ 292 } 293 #define SUMA_COLID_RGBA2N(r,g,b,a,n) { \ 294 (n) = ((a) << 24) + ((b) << 16) + ((g) << 8) + (r); \ 295 } 296 297 298 #define GET_NEIGHBS_IN_MASK(cmask, ijk, ni, nj, nk, nij, ijkn_vec){ \ 299 static int m_IJK[3]; \ 300 m_IJK[2] = ((ijk) / (nij)); \ 301 m_IJK[1] = ((ijk) % (nij)); \ 302 m_IJK[0] = ((m_IJK[1]) % (ni)); \ 303 m_IJK[1] = ((m_IJK[1]) / (ni)); \ 304 V_NEIGHB_0(m_IJK, ni, nij, cmask, ijkn_vec[0]);/* i - 1 */ \ 305 V_NEIGHB_1(m_IJK, ni, nij, cmask, nj, ijkn_vec[1]);/* j - 1 */ \ 306 V_NEIGHB_2(m_IJK, ni, nij, cmask, ijkn_vec[2]);/* i + 1 */ \ 307 V_NEIGHB_3(m_IJK, ni, nij, cmask, nj, ijkn_vec[3]);/* j + 1 */ \ 308 V_NEIGHB_4(m_IJK, ni, nij, cmask, nk, ijkn_vec[4]);/* k - 1 */ \ 309 V_NEIGHB_5(m_IJK, ni, nij, cmask, nk, ijkn_vec[5]);/* k + 1 */ \ 310 } 311 312 /* THESE TWO ARE IS NOT VALID*/ 313 #define V_ADD_CONTRIB_NOTGOOD(c,ijkn,cijk,P,NP) {\ 314 if (ijkn>=0) { \ 315 NP += 2; \ 316 if (c[ijkn] == cijk) { P += 2; } \ 317 /* No match, no contribution */ \ 318 } else { NP += 1; P += 1; } /* No neighbor, half +ve contribution */ \ 319 } 320 321 #define P_l_GIV_NEIGHBS_NOTGOOD(c, ijkn_vec, cijk, Nvicinity, Pf) {\ 322 static int m_i, m_P, m_NP;\ 323 m_P = 0; m_NP = 0; \ 324 for (m_i=0; m_i<Nvicinity; ++m_i) { \ 325 V_ADD_CONTRIB_NOTGOOD(c,ijkn_vec[m_i],cijk,m_P,m_NP); \ 326 } \ 327 if (m_NP) { Pf= (float)m_P/m_NP; } \ 328 else {Pf = 0.0; } \ 329 } 330 331 #define E_ADD_CONTRIB(c,ijkn,cijk,E,NE) {\ 332 if (ijkn>=0) { \ 333 NE += 1; \ 334 if (c[ijkn] == cijk) { E -= 1; } /* match, least energy */\ 335 else E += 1; /* no match, higher energy */ \ 336 } else { } /* No neighbor, neutral contribution */ \ 337 } 338 339 #define E_l_GIV_NEIGHBS(c, ijkn_vec, cijk, Nvicinity, E) {\ 340 static int m_i, m_E, m_NE;\ 341 m_E = 0; m_NE = 0; \ 342 for (m_i=0; m_i<Nvicinity; ++m_i) { \ 343 E_ADD_CONTRIB(c,ijkn_vec[m_i],cijk,m_E,m_NE); \ 344 } \ 345 if (m_NE) { E = m_E/(double)m_NE; } else {E=0.0;}\ 346 } 347 348 #define AFNI_FEED(cs, sstr, iter, mdset) {\ 349 if (cs->talk_suma) { \ 350 SUMA_SEND_2AFNI SS2A; \ 351 char *opref = SUMA_copy_string(DSET_PREFIX(mdset)); \ 352 char *m_pref = SUMA_append_string("t.",DSET_PREFIX(mdset)); \ 353 char *oid = SUMA_copy_string(DSET_IDCODE_STR(mdset)); \ 354 char lbuf[strlen(sstr)+10]; \ 355 if (Opt->debug > 1) SUMA_S_Notev("Sending %s volume to AFNI, iter %d\n", \ 356 sstr, iter); \ 357 if (iter >=0) sprintf(lbuf, "%s.%d", sstr, iter); \ 358 else sprintf(lbuf, "%s", sstr); \ 359 EDIT_BRICK_LABEL( mdset, 0, lbuf); \ 360 EDIT_dset_items( mdset , ADN_prefix , m_pref, ADN_none); \ 361 strcpy(DSET_IDCODE_STR(mdset), UNIQ_hashcode(m_pref)); \ 362 SS2A.dset = mdset; SS2A.at_sb = iter; \ 363 if (!SUMA_SendToAfni(cs, &SS2A, 1)) { \ 364 SUMA_SL_Err("Failed to send volume to AFNI"); \ 365 cs->afni_Send = NOPE; \ 366 } \ 367 EDIT_dset_items( mdset , ADN_prefix , opref, ADN_none); \ 368 strcpy(DSET_IDCODE_STR(mdset), oid); \ 369 SUMA_free(opref); SUMA_free(oid);\ 370 } \ 371 } 372 373 #define GRID_MISMATCH(a,b) ( (DSET_NX(a) != DSET_NX(b)) \ 374 || (DSET_NY(a) != DSET_NY(b)) \ 375 || (DSET_NZ(a) != DSET_NZ(b)) ) 376 377 #define SUMA_IposBOUND 1 378 #define SUMA_InegBOUND 2 379 #define SUMA_I_HOLE 3 380 #define SUMA_JposBOUND 4 381 #define SUMA_JnegBOUND 8 382 #define SUMA_J_HOLE 12 383 #define SUMA_kposBOUND 16 384 #define SUMA_knegBOUND 32 385 #define SUMA_K_HOLE 48 386 387 /* A macro for SUMA_hist_freq(), requires 388 int m_i0; 389 float m_a; 390 If you change this macro, be sure to reflect 391 the changes in function SUMA_hist_freq() 392 */ 393 #define SUMA_HIST_FREQ(hh, val, fr) { \ 394 m_a = ((val-hh->b[0])/hh->W); \ 395 m_i0 = (int)m_a; \ 396 if (m_i0<0) { fr = hh->cn[0]; } \ 397 else if (m_i0>=hh->K) { fr = hh->cn[hh->K-1]; } \ 398 else { m_a = m_a-m_i0; fr = m_a*hh->cn[m_i0+1]+(1.0-m_a)*hh->cn[m_i0]; } \ 399 } 400 401 402 SUMA_HIST *SUMA_hist(float *v, int n, int Ku, float Wu, 403 float *range, char *label, int ignoreout); 404 SUMA_HIST *SUMA_hist_opt(float *v, int n, int Ku, float Wu, float *range, 405 char *label, int ignoreout, 406 float oscfrqthr, char *methods); 407 SUMA_HIST *SUMA_dset_hist(THD_3dim_dataset *dset, int ia, 408 byte *cmask, char *label, SUMA_HIST *href, 409 int ignoreout, float oscifreq, char *methods); 410 int SUMA_hist_smooth( SUMA_HIST *hh, int N_iter ); 411 float SUMA_hist_oscillation( SUMA_HIST *hh, 412 float minmaxfrac, float oscfracthr, int *N_osci); 413 SUMA_HIST *SUMA_Free_hist(SUMA_HIST *hh); 414 void SUMA_Show_hist(SUMA_HIST *hh, int norm, FILE *out); 415 void SUMA_Show_dist(SUMA_FEAT_DIST *FD, FILE *out); 416 void SUMA_Show_dists(SUMA_FEAT_DISTS *FDV, FILE *out, int level); 417 char *SUMA_dist_info(SUMA_FEAT_DIST *FD, int level); 418 char *SUMA_dists_info(SUMA_FEAT_DISTS *FDV, int level); 419 float SUMA_hist_freq(SUMA_HIST *hh, float vv); 420 double SUMA_hist_value(SUMA_HIST *hh, double vv, char *what); 421 float SUMA_hist_perc_freq(SUMA_HIST *nn, float perc, int norm, int *iperc, 422 float minfreq); 423 double SUMA_val_at_count(SUMA_HIST *hh, double count, int norm, int from_top); 424 char *SUMA_hist_variable(SUMA_HIST *hh); 425 char *SUMA_hist_conditional(SUMA_HIST *hh); 426 char *SUMA_dist_variable(SUMA_FEAT_DIST *hh); 427 char *SUMA_dist_conditional(SUMA_FEAT_DIST *hh); 428 char *SUMA_label_variable(char *label, char c); 429 char *SUMA_label_conditional(char *label, char c); 430 NI_str_array * SUMA_dists_featureset(SUMA_FEAT_DISTS *FDV); 431 NI_str_array * SUMA_dists_classset(SUMA_FEAT_DISTS *FDV); 432 char *SUMA_hist_fname(char *proot, char *variable, char *conditional, 433 int withext); 434 char *SUMA_corrmat_fname(char *proot, char *conditional, int withext); 435 SUMA_FEAT_DIST *SUMA_find_feature_dist(SUMA_FEAT_DISTS *FDV, 436 char *label, char *feature, char *class, 437 int *ifind); 438 SUMA_FEAT_DISTS *SUMA_grow_feature_dists(SUMA_FEAT_DISTS *FDV); 439 SUMA_FEAT_DIST *SUMA_free_dist(SUMA_FEAT_DIST *FD); 440 SUMA_FEAT_DISTS *SUMA_free_dists(SUMA_FEAT_DISTS *FDV); 441 SUMA_FEAT_DISTS *SUMA_add_feature_dist(SUMA_FEAT_DISTS *FDV, 442 SUMA_FEAT_DIST **FDp, 443 int append); 444 SUMA_FEAT_DIST *SUMA_hist_To_dist(SUMA_HIST **hhp, char *thislabel); 445 SUMA_FEAT_DISTS *SUMA_TRAIN_DISTS_To_dists(SUMA_FEAT_DISTS *FDV, 446 NI_element *ndist); 447 SUMA_FEAT_DISTS *SUMA_get_all_dists(char *where); 448 NI_group *SUMA_hist_To_NIhist(SUMA_HIST *hh); 449 SUMA_HIST *SUMA_NIhist_To_hist(NI_group *ngr); 450 int SUMA_write_hist(SUMA_HIST *hh, char *name); 451 SUMA_HIST *SUMA_read_hist(char *name); 452 453 int SUMA_Seg_Write_Dset(char *proot, char *prefi, THD_3dim_dataset *dset, 454 int iter, char *hh); 455 int SUMA_KeyofLabel_Dtable(Dtable *vl_dtable, char *label); 456 void SUMA_ShowClssKeys(char **label, int N_label, int *keys); 457 char *SUMA_LabelsKeys2labeltable_str(char **label, int N_label, int *keys); 458 Dtable *SUMA_LabelsKeys2Dtable (char **label, int N_label, int *keys); 459 460 int get_train_pdist(SEG_OPTS *Opt, char *feat, char *cls, 461 double *par, double *scpar) ; 462 double pdfgam(double x,double ash, double brt); 463 int p_a_GIV_cvfu(SEG_OPTS *Opt, char *feat, char *cls, 464 THD_3dim_dataset *pout); 465 int p_cv_GIV_afu (SEG_OPTS *Opt, char *feat, 466 char *cls, double *d); 467 int p_cv_GIV_A (SEG_OPTS *Opt, char *cls, double *dr); 468 int normalize_p(SEG_OPTS *Opt, THD_3dim_dataset *pout); 469 int is_shorty(THD_3dim_dataset *pset); 470 int set_p_floor(THD_3dim_dataset *pset, float pfl, byte *cmask); 471 SUMA_Boolean SUMA_set_Stat_mix_floor(SUMA_CLASS_STAT *cs, float floor); 472 THD_3dim_dataset *p_C_GIV_A (SEG_OPTS *Opt); 473 THD_3dim_dataset *p_C_GIV_A_omp (SEG_OPTS *Opt); 474 int SUMA_LabelToGroupedIndex(char *cls_str, char **group_clss_lbls, int N_lbls); 475 int SUMA_LabelToGroupedKey(char *cls_str, char **group_clss_lbls, int N_lbls, 476 int *group_keys); 477 int SUMA_GroupLabelMapping (char **clss , int N_clss, 478 char **grpclss, int N_grpclss, 479 int *map, int verb); 480 int SUMA_Regroup_classes (SEG_OPTS *Opt, 481 char **clss_lbls, 482 int N_clss_lbls, 483 int *keys, 484 char **group_classes, 485 int N_group_classes, 486 int * ugroup_keys, 487 byte *cmask, 488 THD_3dim_dataset *pset, 489 THD_3dim_dataset *cset, 490 THD_3dim_dataset **gpset, 491 THD_3dim_dataset **gcset); 492 int SUMA_assign_classes (THD_3dim_dataset *pset, 493 SUMA_CLASS_STAT *cs, 494 byte *cmask, 495 THD_3dim_dataset **csetp); 496 int SUMA_assign_classes_eng(THD_3dim_dataset *pset, 497 char **label, int N_label, int *keys, 498 byte *cmask, 499 THD_3dim_dataset **csetp); 500 int group_mean (SEG_OPTS *Opt, THD_3dim_dataset *aset, 501 byte *mm, THD_3dim_dataset *pset, int N_cl, 502 double *M_v, int scl); 503 THD_3dim_dataset *SUMA_estimate_bias_field (SEG_OPTS *Opt, 504 int polorder, 505 THD_3dim_dataset *aset, 506 THD_3dim_dataset *cset, 507 THD_3dim_dataset *pset, 508 THD_3dim_dataset *pout); 509 int SUMA_estimate_bias_field_Wells (SEG_OPTS *Opta, 510 byte *cmask, SUMA_CLASS_STAT *cs, 511 float fwhm, char *bias_classes, 512 THD_3dim_dataset *Aset, 513 THD_3dim_dataset *pstCgALL, 514 THD_3dim_dataset **Bsetp); 515 int SUMA_apply_bias_field (SEG_OPTS *Opt, 516 THD_3dim_dataset *aset, 517 THD_3dim_dataset *fset, 518 THD_3dim_dataset **pout); 519 THD_3dim_dataset *SUMA_SegEnhanceInitCset(THD_3dim_dataset *aseti, 520 THD_3dim_dataset *cset, 521 byte *cmask, int cmask_count, 522 SUMA_CLASS_STAT *cs, 523 SEG_OPTS *Opt); 524 int bias_stats (SEG_OPTS *Opt, 525 THD_3dim_dataset *aset, THD_3dim_dataset *gset, 526 THD_3dim_dataset *xset, int N_cl); 527 double SUMA_CompareBiasDsets(THD_3dim_dataset *gold_bias, THD_3dim_dataset *bias, 528 byte *cmask, int cmask_count, 529 float thresh, THD_3dim_dataset *prat ); 530 int SUMA_show_Class_Stat(SUMA_CLASS_STAT *cs, char *h, char *fname); 531 int SUMA_dump_Class_Stat(SUMA_CLASS_STAT *cs, char *head, FILE *Out); 532 char *SUMA_Class_Stat_Info(SUMA_CLASS_STAT *cs, char *head); 533 int SUMA_set_Stat(SUMA_CLASS_STAT *cs, char *label, char *pname, double val); 534 double SUMA_get_Stat(SUMA_CLASS_STAT *cs, char *label, char *pname); 535 double *SUMA_get_Stats(SUMA_CLASS_STAT *cs, char *pname); 536 int SUMA_MixFrac_from_ClassStat(SUMA_CLASS_STAT *cs, float *mf); 537 int SUMA_ZeroSamp_from_ClassStat(SUMA_CLASS_STAT *cs); 538 int SUMA_Stat_position (SUMA_CLASS_STAT *cs, char *label, char *pname, int pp[]); 539 SUMA_CLASS_STAT *SUMA_Free_Class_Stat(SUMA_CLASS_STAT *cs); 540 SUMA_CLASS_STAT *SUMA_New_Class_Stat(char **clsl, int N_clsl, int *keys, 541 int nP, NI_str_array *pnames); 542 int SUMA_Class_stats(THD_3dim_dataset *aset, 543 THD_3dim_dataset *cset, 544 byte *cmask, int cmask_count, 545 THD_3dim_dataset *wset, 546 THD_3dim_dataset *pC, 547 THD_3dim_dataset *gold, 548 SUMA_CLASS_STAT *cs, float mix_frac_floor); 549 double SUMA_mixopt_2_mixfrac(char *mixopt, char *label, int key, int N_clss, 550 byte *cmask, THD_3dim_dataset *cset); 551 double pdfnorm(double x, double mean, double stdv); 552 THD_3dim_dataset *SUMA_p_Y_GIV_C_B_O( 553 THD_3dim_dataset *aset, THD_3dim_dataset *cset, 554 byte *cmask, SUMA_CLASS_STAT *cs, 555 THD_3dim_dataset *pygc); 556 int SUMA_MAP_labels(THD_3dim_dataset *aset, 557 byte *cmask, 558 SUMA_CLASS_STAT *cs, int neighopt, 559 THD_3dim_dataset *pC, 560 THD_3dim_dataset **csetp, 561 THD_3dim_dataset **pCgN, 562 SEG_OPTS *Opt); 563 int SUMA_pst_C_giv_ALL(THD_3dim_dataset *aset, 564 byte *cmask, int cmask_count, 565 SUMA_CLASS_STAT *cs, 566 THD_3dim_dataset *pC, THD_3dim_dataset *pCgN, 567 float mrfB, float Temp, byte mix, 568 THD_3dim_dataset **pstCgALLp); 569 int SUMA_CompareSegDsets(THD_3dim_dataset *base, THD_3dim_dataset *seg, 570 byte *cmask, byte mask_by_base, 571 SUMA_CLASS_STAT *cs ); 572 int SUMA_ray_k(int n1D, int ni, int nij, int nk, float *av, byte *ba, 573 float ta[], int da[]); 574 int SUMA_ray_j(int n1D, int ni, int nij, int nj, float *av, byte *ba, 575 float ta[], int da[]); 576 int SUMA_ray_i(int n1D, int ni, int nij, float *av, byte *ba, 577 float ta[], int da[]); 578 int SUMA_ray_unplug_k(int n1D, int ni, int nij, int nk, 579 float *av, byte *ba, int side); 580 int SUMA_ray_unplug_j(int n1D, int ni, int nij, int nj, 581 float *av, byte *ba, int side); 582 int SUMA_ray_unplug_i(int n1D, int ni, int nij, 583 float *av, byte *ba, int side); 584 int SUMA_VolumeInFill(THD_3dim_dataset *aset, 585 THD_3dim_dataset **filledp, 586 int method, int integ, int MxIter, 587 int minhits, int erode, int dilate, float val, 588 byte *mask); 589 int SUMA_Volume_RadFill(THD_3dim_dataset *aset, float *ufv, byte *ucmask, 590 float *ucm, THD_3dim_dataset **filledp, 591 int nplug, int nlin, int fitord, float smooth, int N_off); 592 int SUMA_mri_volume_infill(MRI_IMAGE *imin); 593 int SUMA_mri_volume_infill_zoom(MRI_IMAGE *imin, byte thorough, 594 int integ, int mxiter); 595 int SUMA_mri_volume_infill_solid(MRI_IMAGE *imin, int minhits, 596 int mxiter, int unholize, 597 byte *mask); 598 int SUMA_VolumeBlurInMask(THD_3dim_dataset *aset, 599 byte *cmask, 600 THD_3dim_dataset **blrdp, 601 float FWHM, float unifac, 602 int speed); 603 int SUMA_VolumeBlur(THD_3dim_dataset *aset, 604 byte *cmask, 605 THD_3dim_dataset **blurredp, 606 float FWHM); 607 int SUMA_VolumeLSBlurInMask(THD_3dim_dataset *aset , 608 byte *cmask, 609 THD_3dim_dataset **blurredp, 610 float FWHM, float mxvx); 611 double SUMA_EdgeEnergy(short *a, float af, short *b, float bf, 612 int Ni, int Nj, int Nk, 613 short *c, short c1, short c2, 614 byte *mask, SUMA_CLASS_STAT *cs, 615 int method, short *skel, 616 int *n_en); 617 double SUMA_DsetEdgeEnergy(THD_3dim_dataset *aset, 618 THD_3dim_dataset *cset, 619 byte *mask, 620 THD_3dim_dataset *fset, THD_3dim_dataset *skelset, 621 SUMA_CLASS_STAT *cs, int method, 622 int *UseK, int N_kok); 623 double SUMA_MAP_EdgeEnergy(THD_3dim_dataset *aset, byte *cmask, int cmask_count, 624 THD_3dim_dataset *Bset, SUMA_CLASS_STAT *cs, 625 THD_3dim_dataset *cset, int method, 626 THD_3dim_dataset *priCgAll, THD_3dim_dataset *pCgN, 627 float mrfB, float Temp, float deltamean, float deltastd, 628 SEG_OPTS * Opt); 629 int SUMA_ShortizeProbDset(THD_3dim_dataset **csetp, 630 SUMA_CLASS_STAT *cs, 631 byte *cmask, int cmask_count, 632 SEG_OPTS *Opt, 633 THD_3dim_dataset **psetp); 634 int SUMA_OtherizeProbDset(THD_3dim_dataset *pC, 635 byte *cmask, int cmask_count); 636 int SUMA_FlattenProb(THD_3dim_dataset *pC, 637 byte *cmask, int cmask_count, 638 int mode); 639 int SUMA_AddOther( NI_str_array *clss, int **keys, 640 byte *cmask, int cmask_count, 641 THD_3dim_dataset *cset, THD_3dim_dataset *pstCgALL, 642 THD_3dim_dataset *pCgA, THD_3dim_dataset *pCgL, 643 SUMA_CLASS_STAT *cs); 644 int SUMA_Class_k_Selector( 645 SUMA_CLASS_STAT *cs, char *action, char *value, int *UseK); 646 int SUMA_Class_k_Label_Locator(SUMA_CLASS_STAT *cs, char *label); 647 int SUMA_Class_k_Key_Locator(SUMA_CLASS_STAT *cs, int key); 648 int SUMA_InitDset(THD_3dim_dataset *aset, float *val, int nval, 649 byte *cmask, byte setsf); 650 int SUMA_MergeCpriors(SUMA_CLASS_STAT *cs, byte *cmask, 651 THD_3dim_dataset *Aset, 652 THD_3dim_dataset *priCgA, float wA, 653 THD_3dim_dataset *priCgL, float wL, 654 THD_3dim_dataset **priCgALLp, 655 SEG_OPTS *Opt); 656 int SUMA_SegInitCset(THD_3dim_dataset *aseti, 657 THD_3dim_dataset **csetp, 658 byte *cmask, int cmask_count, 659 char *mixopt, 660 SUMA_CLASS_STAT *cs, 661 SEG_OPTS *Opt); 662 void SUMA_set_SegFunc_debug(int dbg, int vdbg, int *vdbg3, FILE *out); 663 int SUMA_Split_Classes(char **Glbls, int N_Glbls, int *Gkeys, int *Split, 664 THD_3dim_dataset *aset, THD_3dim_dataset *Gcset, 665 byte *cmask, 666 THD_3dim_dataset **Scsetp, SUMA_CLASS_STAT **Scs, 667 SEG_OPTS *Opt); 668 int SUMA_SetDsetLabeltable(THD_3dim_dataset *dset, char **labels, 669 int N_labels, int *keys); 670 671 SUMA_SurfaceObject *SUMA_Mask_Skin(THD_3dim_dataset *iset, int ld, 672 int smooth_final, int shrink_mode, SUMA_COMM_STRUCT *cs); 673 SUMA_SurfaceObject *SUMA_Dset_ConvexHull(THD_3dim_dataset *dset, int isb, 674 float th, byte *umask); 675 SUMA_SurfaceObject *SUMA_ExtractHead_hull(THD_3dim_dataset *iset, 676 float hullvolthr, SUMA_COMM_STRUCT *cs); 677 SUMA_SurfaceObject *SUMA_ExtractHead(THD_3dim_dataset *iset, 678 float hullvolthr, SUMA_COMM_STRUCT *cs); 679 SUMA_SurfaceObject *SUMA_ExtractHead_RS(THD_3dim_dataset *iset, 680 THD_3dim_dataset **urset, SUMA_COMM_STRUCT *cs); 681 SUMA_Boolean SUMA_ShrinkSkullHull2Mask(SUMA_SurfaceObject *SO, 682 THD_3dim_dataset *iset, float thr, 683 int smooth_final, float *under_over_mm, 684 int zero_attractor, 685 SUMA_COMM_STRUCT *cs); 686 SUMA_Boolean SUMA_ShrinkSkullHull(SUMA_SurfaceObject *SO, 687 THD_3dim_dataset *iset, float thr, 688 int use_rs, SUMA_COMM_STRUCT *cs); 689 SUMA_Boolean SUMA_ShrinkHeadSurf(SUMA_SurfaceObject *SO, 690 THD_3dim_dataset *aset, 691 THD_3dim_dataset *arset, 692 float *ucm, 693 SUMA_COMM_STRUCT *cs); 694 SUMA_Boolean SUMA_ShrinkSkullHull_RS(SUMA_SurfaceObject *SO, 695 THD_3dim_dataset *aset, 696 THD_3dim_dataset *arset, float thr, 697 SUMA_COMM_STRUCT *cs) ; 698 SUMA_Boolean SUMA_ShrinkHeadSurf_RS(SUMA_SurfaceObject *SO, 699 THD_3dim_dataset *aset, 700 THD_3dim_dataset *arset, 701 float *ucm, 702 SUMA_COMM_STRUCT *cs); 703 THD_3dim_dataset *SUMA_Dset_FindVoxelsInSurface( 704 SUMA_SurfaceObject *SO, THD_3dim_dataset *iset, 705 SUMA_VOLPAR *vp, char *vpname, 706 char *prefix, int meth, int maskonly); 707 THD_3dim_dataset *SUMA_dset_hist_equalize(THD_3dim_dataset *din, 708 int sb, byte *cmask, SUMA_HIST *hh); 709 710 #endif 711