Skip to content

AFNI/NIfTI Server

Sections
Personal tools
You are here: Home » AFNI » Documentation

Doxygen Source Code Documentation


Main Page   Alphabetical List   Data Structures   File List   Data Fields   Globals   Search  

3dThreetoRGB.c File Reference

#include "mrilib.h"

Go to the source code of this file.


Defines

#define GOOD_TYPE(tt)   ((tt)==MRI_short || (tt)==MRI_byte || (tt)==MRI_float)
#define OPENIT(ds, aa)

Functions

int main (int argc, char *argv[])

Define Documentation

#define GOOD_TYPE tt       ((tt)==MRI_short || (tt)==MRI_byte || (tt)==MRI_float)
 

#define OPENIT ds,
aa   
 

Value:

do{                                                                \
     ds = THD_open_dataset(aa) ;                                    \
     if( !ISVALID_DSET(ds) ){                                       \
       fprintf(stderr,"** Can't open dataset %s\n",aa); exit(1);    \
     }                                                              \
     DSET_load(ds) ;                                                \
     if( !DSET_LOADED(ds) ){                                        \
       fprintf(stderr,"** Can't load dataset %s\n",aa); exit(1);    \
     }                                                              \
 } while(0)

Function Documentation

int main int    argc,
char *    argv[]
 

---------- Adapted from 3dZeropad.c by RWCox - 08 Aug 2001 ----------*

Definition at line 3 of file 3dThreetoRGB.c.

References ADN_datum_all, ADN_func_type, ADN_none, ADN_ntt, ADN_nvals, ADN_prefix, ADN_type, AFNI_logger(), ANAT_SPGR_TYPE, argc, calloc, DSET_BRICK, DSET_BRICK_FACTOR, DSET_BRICK_TYPE, DSET_BRIKNAME, DSET_load, DSET_LOADED, DSET_NVALS, DSET_NX, DSET_NY, DSET_NZ, DSET_unload, DSET_write, EDIT_coerce_scale_type(), EDIT_dset_items(), EDIT_empty_copy(), EDIT_substitute_brick(), free, FUNC_FIM_TYPE, HEAD_ANAT_TYPE, HEAD_FUNC_TYPE, ISVALID_DSET, MRI_IMAGE::kind, machdep(), mainENTRY, MRI_IMAGE::nvox, MRI_IMAGE::nx, MRI_IMAGE::ny, MRI_IMAGE::nz, strtod(), THD_filename_ok(), THD_makemask(), THD_open_dataset(), tross_Copy_History(), and tross_Make_History().

00004 {
00005    THD_3dim_dataset *dset1,*dset2=NULL,*dset3=NULL , *mset=NULL , *oset ;
00006    MRI_IMAGE *dbr1,*dbr2,*dbr3 ;
00007    float      fac1, fac2, fac3 ;
00008    char *prefix = "rgb" ;
00009    byte *mask=NULL , *rr,*gg,*bb , *rgb ;
00010    float fac=1.0 ;
00011    int iarg=1 , dofim=1 , ii,nvox ;
00012 
00013    if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
00014       printf("Usage #1: 3dThreetoRGB [options] dataset\n"
00015              "Usage #2: 3dThreetoRGB [options] dataset1 dataset2 dataset3\n"
00016              "\n"
00017              "Converts 3 sub-bricks of input to an RGB-valued dataset.\n"
00018              "* If you have 1 input dataset, then sub-bricks [0..2] are\n"
00019              "   used to form the RGB components of the output.\n"
00020              "* If you have 3 input datasets, then the [0] sub-brick of\n"
00021              "   each is used to form the RGB components, respectively.\n"
00022              "* RGB datasets have 3 bytes per voxel, with values ranging\n"
00023              "   from 0..255.\n"
00024              "\n"
00025              "Options:\n"
00026              "  -prefix ppp = Write output into dataset with prefix 'ppp'.\n"
00027              "                 [default='rgb']\n"
00028              "  -scale fac  = Multiply input values by 'fac' before using\n"
00029              "                 as RGB [default=1].  If you have floating\n"
00030              "                 point inputs in range 0..1, then using\n"
00031              "                 '-scale 255' would make a lot of sense.\n"
00032              "  -mask mset  = Only output nonzero values where the mask\n"
00033              "                 dataset 'mset' is nonzero.\n"
00034              "  -fim        = Write result as a 'fim' type dataset.\n"
00035              "                 [this is the default]\n"
00036              "  -anat       = Write result as a anatomical type dataset.\n"
00037              "Notes:\n"
00038              "* Input datasets must be byte-, short-, or float-valued.\n"
00039              "* You might calculate the component datasets using 3dcalc.\n"
00040              "* You can also create RGB-valued datasets in to3d, using\n"
00041              "   2D raw PPM image files as input, or the 3Dr: format.\n"
00042              "* RGB fim overlays are transparent in AFNI in voxels where all\n"
00043              "   3 bytes are zero - that is, it won't overlay solid black.\n"
00044              "* At present, there is limited support for RGB datasets.\n"
00045              "   About the only thing you can do is display them in 2D\n"
00046              "   slice windows in AFNI.\n"
00047              "\n"
00048              "-- RWCox - April 2002\n"
00049             ) ;
00050       exit(0) ;
00051    }
00052 
00053    mainENTRY("3dThreetoRGB main"); machdep(); AFNI_logger("3dThreetoRGB",argc,argv);
00054 
00055    /*-- options --*/
00056 
00057 #define GOOD_TYPE(tt) ((tt)==MRI_short || (tt)==MRI_byte || (tt)==MRI_float)
00058 
00059    while( iarg < argc && argv[iarg][0] == '-' ){
00060 
00061       if( strcmp(argv[iarg],"-prefix") == 0 ){
00062          prefix = argv[++iarg] ;
00063          if( !THD_filename_ok(prefix) ){
00064            fprintf(stderr,"** -prefix %s is illegal!\n",prefix) ;
00065            exit(1) ;
00066          }
00067          iarg++ ; continue ;
00068       }
00069 
00070       if( strcmp(argv[iarg],"-scale") == 0 ){
00071          fac = strtod( argv[++iarg] , NULL ) ;
00072          if( fac <= 0.0 ){
00073            fprintf(stderr,"** -scale %s is illegal!\n",argv[iarg]) ;
00074            exit(1) ;
00075          }
00076          iarg++ ; continue ;
00077       }
00078 
00079       if( strcmp(argv[iarg],"-fim") == 0 ){
00080          dofim = 1 ; iarg++ ; continue ;
00081       }
00082 
00083       if( strcmp(argv[iarg],"-anat") == 0 ){
00084          dofim = 0 ; iarg++ ; continue ;
00085       }
00086 
00087       if( strcmp(argv[iarg],"-mask") == 0 ){
00088          if( mset != NULL ){
00089            fprintf(stderr,"** can't have 2 -mask options!\n"); exit(1);
00090          }
00091          mset = THD_open_dataset( argv[++iarg] ) ;
00092          if( !ISVALID_DSET(mset) ){
00093            fprintf(stderr,"** can't open -mset %s\n",argv[iarg]); exit(1);
00094          }
00095          if( !GOOD_TYPE( DSET_BRICK_TYPE(mset,0) ) ){
00096            fprintf(stderr,"** -mset %s has invalid data type\n",argv[iarg]);
00097            exit(1) ;
00098          }
00099          DSET_load(mset) ;
00100          if( !DSET_LOADED(mset) ){
00101            fprintf(stderr,"** can't load -mset %s\n",argv[iarg]); exit(1);
00102          }
00103          iarg++ ; continue ;
00104       }
00105 
00106       fprintf(stderr,"** ILLEGAL option: %s\n",argv[iarg]) ; exit(1) ;
00107    }
00108 
00109    if( iarg >= argc ){
00110      fprintf(stderr,"** No datasets on command line!?\n"); exit(1);
00111    }
00112 
00113    /*-- read data --*/
00114 
00115 #define OPENIT(ds,aa)                                               \
00116  do{                                                                \
00117      ds = THD_open_dataset(aa) ;                                    \
00118      if( !ISVALID_DSET(ds) ){                                       \
00119        fprintf(stderr,"** Can't open dataset %s\n",aa); exit(1);    \
00120      }                                                              \
00121      DSET_load(ds) ;                                                \
00122      if( !DSET_LOADED(ds) ){                                        \
00123        fprintf(stderr,"** Can't load dataset %s\n",aa); exit(1);    \
00124      }                                                              \
00125  } while(0)
00126 
00127    if( iarg == argc-1 ){   /* one dataset */
00128 
00129      OPENIT(dset1,argv[iarg]) ;
00130 
00131      if( DSET_NVALS(dset1) < 3 ){
00132        fprintf(stderr,"** Dataset %s needs at least 3 sub-bricks!\n",argv[iarg]);
00133        exit(1) ;
00134      }
00135      if( !GOOD_TYPE( DSET_BRICK_TYPE(dset1,0) ) ||
00136          !GOOD_TYPE( DSET_BRICK_TYPE(dset1,1) ) ||
00137          !GOOD_TYPE( DSET_BRICK_TYPE(dset1,2) )   ){
00138        fprintf(stderr,"** ILLEGAL dataset type in %s\n",argv[iarg]); exit(1);
00139      }
00140      dbr1 = DSET_BRICK(dset1,0) ; fac1 = DSET_BRICK_FACTOR(dset1,0) ;
00141      dbr2 = DSET_BRICK(dset1,1) ; fac2 = DSET_BRICK_FACTOR(dset1,1) ;
00142      dbr3 = DSET_BRICK(dset1,2) ; fac3 = DSET_BRICK_FACTOR(dset1,2) ;
00143 
00144    } else if( iarg+2 < argc ){  /* three datasets */
00145 
00146      OPENIT(dset1,argv[iarg])   ;
00147      if( !GOOD_TYPE( DSET_BRICK_TYPE(dset1,0) ) ){
00148        fprintf(stderr,"** ILLEGAL dataset type in %s\n",argv[iarg]) ; exit(1);
00149      }
00150 
00151      OPENIT(dset2,argv[iarg+1]) ;
00152      if( !GOOD_TYPE( DSET_BRICK_TYPE(dset2,0) ) ){
00153        fprintf(stderr,"** ILLEGAL dataset type in %s\n",argv[iarg+1]); exit(1);
00154      }
00155 
00156      OPENIT(dset3,argv[iarg+2]) ;
00157      if( !GOOD_TYPE( DSET_BRICK_TYPE(dset3,0) ) ){
00158        fprintf(stderr,"** ILLEGAL dataset type in %s\n",argv[iarg+2]); exit(1);
00159      }
00160 
00161      dbr1 = DSET_BRICK(dset1,0) ; fac1 = DSET_BRICK_FACTOR(dset1,0) ;
00162      dbr2 = DSET_BRICK(dset2,0) ; fac2 = DSET_BRICK_FACTOR(dset2,0) ;
00163      dbr3 = DSET_BRICK(dset3,0) ; fac3 = DSET_BRICK_FACTOR(dset3,0) ;
00164 
00165      if( dbr1->nx != dbr2->nx || dbr1->nx != dbr3->nx ){
00166        fprintf(stderr,"** Dataset x-axes don't match!\n") ; exit(1) ;
00167      }
00168      if( dbr1->ny != dbr2->ny || dbr1->ny != dbr3->ny ){
00169        fprintf(stderr,"** Dataset y-axes don't match!\n") ; exit(1) ;
00170      }
00171      if( dbr1->nz != dbr2->nz || dbr1->nz != dbr3->nz ){
00172        fprintf(stderr,"** Dataset z-axes don't match!\n") ; exit(1) ;
00173      }
00174 
00175      if( iarg+2 < argc-1 ){
00176        fprintf(stderr,"++ Warning: extra arguments on command line: %s ...\n",
00177                argv[iarg+3] ) ;
00178      }
00179 
00180    } else {                     /* this is bad */
00181 
00182      fprintf(stderr,"** Need either 1 or 3 datasets on command line!\n");
00183      exit(1) ;
00184    }
00185 
00186    /* make a mask, if any */
00187 
00188    if( mset != NULL ){
00189      if( dbr1->nx != DSET_NX(mset) ){
00190        fprintf(stderr,"** Mask and dataset x-axes don't match!\n"); exit(1);
00191      }
00192      if( dbr1->ny != DSET_NY(mset) ){
00193        fprintf(stderr,"** Mask and dataset y-axes don't match!\n"); exit(1);
00194      }
00195      if( dbr1->nz != DSET_NZ(mset) ){
00196        fprintf(stderr,"** Mask and dataset z-axes don't match!\n"); exit(1);
00197      }
00198      mask = THD_makemask( mset , 0 , 1.0,0.0 ) ;
00199      if( mask == NULL ){
00200        fprintf(stderr,"** Can't mask mask!\n"); exit(1);
00201      }
00202      DSET_unload(mset) ;
00203    }
00204 
00205    /* convert input sub-bricks to bytes */
00206 
00207    nvox = dbr1->nvox ;
00208 
00209    rr   = (byte *) calloc(1,nvox) ;
00210    if( fac1 == 0.0 ) fac1 = 1.0 ;
00211    EDIT_coerce_scale_type( nvox , fac*fac1 ,
00212                            dbr1->kind , mri_data_pointer(dbr1) ,
00213                            MRI_byte   , rr                      ) ;
00214 
00215    gg   = (byte *) calloc(1,nvox) ;
00216    if( fac2 == 0.0 ) fac2 = 1.0 ;
00217    EDIT_coerce_scale_type( nvox , fac*fac2 ,
00218                            dbr2->kind , mri_data_pointer(dbr2) ,
00219                            MRI_byte   , gg                      ) ;
00220 
00221    bb   = (byte *) calloc(1,nvox) ;
00222    if( fac3 == 0.0 ) fac3 = 1.0 ;
00223    EDIT_coerce_scale_type( nvox , fac*fac3 ,
00224                            dbr3->kind , mri_data_pointer(dbr3) ,
00225                            MRI_byte   , bb                      ) ;
00226 
00227                        DSET_unload(dset1) ;
00228    if( dset2 != NULL ) DSET_unload(dset2) ;
00229    if( dset3 != NULL ) DSET_unload(dset3) ;
00230 
00231    /* merge inputs to output */
00232 
00233    rgb = (byte *) calloc(1,3*nvox) ;
00234 
00235    if( mask != NULL ){
00236      for( ii=0 ; ii < nvox ; ii++ ){
00237        if( mask[ii] ){
00238          rgb[3*ii  ] = rr[ii] ;
00239          rgb[3*ii+1] = gg[ii] ;
00240          rgb[3*ii+2] = bb[ii] ;
00241        }
00242      }
00243    } else {
00244      for( ii=0 ; ii < nvox ; ii++ ){
00245        rgb[3*ii  ] = rr[ii] ;
00246        rgb[3*ii+1] = gg[ii] ;
00247        rgb[3*ii+2] = bb[ii] ;
00248      }
00249    }
00250 
00251    free(mask) ; free(rr) ; free(gg) ; free(bb) ;
00252 
00253    /* make output dataset */
00254 
00255    oset = EDIT_empty_copy( dset1 ) ;
00256    EDIT_dset_items( oset ,
00257                      ADN_prefix   , prefix   ,
00258                      ADN_datum_all, MRI_rgb  ,
00259                      ADN_nvals    , 1        ,
00260                      ADN_ntt      , 0        ,
00261                      ADN_type     , (dofim) ? HEAD_FUNC_TYPE : HEAD_ANAT_TYPE,
00262                      ADN_func_type, (dofim) ? FUNC_FIM_TYPE  : ANAT_SPGR_TYPE,
00263                     ADN_none ) ;
00264    EDIT_substitute_brick( oset , 0 , MRI_rgb , rgb ) ;
00265 
00266    /* make history */
00267 
00268    tross_Copy_History( oset , dset1 ) ;
00269    tross_Make_History( "3dThreetoRGB", argc,argv, oset ) ;
00270 
00271    DSET_write( oset ) ;
00272    fprintf(stderr,"++ output dataset: %s\n",DSET_BRIKNAME(oset)) ;
00273    exit(0) ;
00274 }
 

Powered by Plone

This site conforms to the following standards: