Doxygen Source Code Documentation
mri_write.c File Reference
#include "mrilib.h"#include <signal.h>Go to the source code of this file.
Defines | |
| #define | HEADER (28*256) |
Functions | |
| int | mri_write (char *fname, MRI_IMAGE *im) |
| int | mri_write_7D (char *fname, MRI_IMAGE *im) |
| int | mri_write_pnm (char *fname, MRI_IMAGE *im) |
| int | mri_write_1D (char *fname, MRI_IMAGE *im) |
| int | mri_write_ascii (char *fname, MRI_IMAGE *im) |
| int | mri_write_raw (char *fname, MRI_IMAGE *im) |
| int | mri_write_jpg (char *fname, MRI_IMAGE *im) |
Define Documentation
|
|
|
Function Documentation
|
||||||||||||
|
Definition at line 15 of file mri_write.c. References ENTRY, free, MRI_IMAGE::kind, malloc, mri_data_pointer(), MRI_IS_2D, mri_write_7D(), mri_write_pnm(), MRI_IMAGE::nx, MRI_IMAGE::ny, MRI_IMAGE::pixel_size, and RETURN. Referenced by AB_interp(), get_line_opt(), ISQ_saver_CB(), main(), SFIM_write_avs(), and write_images().
00016 {
00017 FILE *imfile ;
00018 void *data ;
00019 int dsize , noheader = FALSE ;
00020
00021 ENTRY("mri_write") ;
00022
00023 /* bad inputs? */
00024
00025 if( im == NULL || fname == NULL || *fname == '\0' ) RETURN(0) ;
00026
00027 /* special cases */
00028
00029 if( ! MRI_IS_2D(im) ){ RETURN(mri_write_7D ( fname , im )) ; }
00030 if( im->kind == MRI_rgb ){ RETURN(mri_write_pnm( fname , im )) ; }
00031 if( im->kind == MRI_byte ){ RETURN(mri_write_pnm( fname , im )) ; }
00032
00033 /* open the file for output */
00034
00035 if( strcmp(fname,"-") != 0 ){
00036 imfile = fopen( fname , "r" ) ;
00037 if( imfile != NULL ){
00038 fclose( imfile ) ;
00039 fprintf(stderr,"(FAILED) attempt to overwrite file %s\n",fname) ;
00040 RETURN(0) ;
00041 }
00042 }
00043
00044 if( strcmp(fname,"-") != 0 )
00045 imfile = fopen( fname , "w" ) ;
00046 else
00047 imfile = stdout ; /* 18 Apr 2005: write to stdout instead */
00048
00049 if( imfile == NULL ){
00050 fprintf( stderr , "couldn't open for output file %s\n" , fname ) ;
00051 RETURN(0) ;
00052 }
00053
00054 /*** possibly write MRI header, unless a standard image type ***/
00055
00056 dsize = im->pixel_size * im->nx * im->ny ;
00057
00058 if( im->kind == MRI_short ){
00059 switch( dsize ){
00060 default: noheader = FALSE ; break ;
00061
00062 case 8192: /* raw 64x64 short */
00063 case 32768: /* raw 128x128 short */
00064 case 131072: /* raw 256x256 short */
00065 case 524288: /* raw 512x512 short -- RWC 3/21/95 */
00066 case 2097152: /* raw 1024x1024 short -- RWC 3/21/95 */
00067 noheader = TRUE ;
00068 break ;
00069 }
00070 } else if( im->kind == MRI_byte ){
00071 switch( dsize ){
00072 default: noheader = FALSE ; break ;
00073
00074 case 4096: /* raw 64x64 byte -- RWC 3/21/95 */
00075 case 16384: /* raw 128x128 byte -- RWC 3/21/95 */
00076 case 65536: /* raw 256x256 8-bit -- Matthew Belmonte March 1995 */
00077 case 262144: /* raw 512x512 byte -- RWC 3/21/95 */
00078 case 1048576: /* raw 1024x1024 byte -- RWC 3/21/95 */
00079 noheader = TRUE ;
00080 break ;
00081 }
00082 }
00083
00084 if( !noheader ) fprintf( imfile , "MRI %d %d %d\n" ,
00085 im->kind , im->nx , im->ny ) ;
00086
00087 /*** special case: add Signa 4.x header (of all zeros) ***/
00088
00089 if( noheader && dsize == 131072 && im->kind == MRI_short ){
00090 #define HEADER (28*256)
00091 int ii ;
00092 short * qq ;
00093 qq = (short *) malloc(sizeof(short)*HEADER) ; /* header 256 x 256 */
00094 for( ii=0 ; ii < HEADER ; ii++ ) qq[ii] = 0 ;
00095 fwrite( qq , sizeof(short) , HEADER , imfile ) ;
00096 free(qq) ;
00097 }
00098
00099 /*** write rest of data now ***/
00100
00101 data = mri_data_pointer( im ) ;
00102 fwrite( data , im->pixel_size , im->nx * im->ny , imfile ) ;
00103
00104 if( imfile != stdout ) fclose( imfile ) ;
00105 RETURN(1) ;
00106 }
|
|
||||||||||||
|
Definition at line 239 of file mri_write.c. References ENTRY, fim, mri_free(), mri_transpose(), mri_write_ascii(), MRI_IMAGE::nz, and RETURN. Referenced by GRA_handle_keypress(), GRA_refwrite_choose_CB(), main(), MASKAVE_main(), and process_1ddata().
00240 {
00241 MRI_IMAGE *fim ;
00242 int jj ;
00243
00244 ENTRY("mri_write_1D") ;
00245
00246 if( fname == NULL || strlen(fname) == 0 ||
00247 im == NULL || im->nz > 1 ) RETURN( 0 );
00248
00249 fim = mri_transpose( im ) ;
00250 jj = mri_write_ascii( fname , fim ) ;
00251 mri_free(fim) ;
00252 RETURN( jj );
00253 }
|
|
||||||||||||
|
Definition at line 110 of file mri_write.c. References ENTRY, MRI_IMAGE::kind, mri_data_pointer(), MRI_DIMENSIONALITY, MRI_IMAGE::nt, MRI_IMAGE::nu, MRI_IMAGE::nv, MRI_IMAGE::nvox, MRI_IMAGE::nw, MRI_IMAGE::nx, MRI_IMAGE::ny, MRI_IMAGE::nz, MRI_IMAGE::pixel_size, and RETURN. Referenced by mri_write().
00111 {
00112 FILE *imfile ;
00113 void *data ;
00114
00115 ENTRY("mri_write_7D") ;
00116
00117 if( im == NULL ) RETURN( 0 );
00118
00119 imfile = fopen( fname , "r" ) ;
00120 if( imfile != NULL ){
00121 fclose( imfile ) ;
00122 fprintf(stderr,"(FAILED) attempt to overwrite file %s\n",fname) ;
00123 RETURN( 0 );
00124 }
00125
00126 imfile = fopen( fname , "w" ) ;
00127
00128 if( imfile == NULL ){
00129 fprintf( stderr , "couldn't open for output file %s\n" , fname ) ;
00130 RETURN( 0 );
00131 }
00132
00133 /*** write MR7 header ***/
00134
00135 switch( MRI_DIMENSIONALITY(im) ){
00136 default:
00137 case 1:
00138 fprintf( imfile , "MR1 %d %d\n" ,
00139 im->kind , im->nx ) ;
00140 break ;
00141
00142 case 2:
00143 fprintf( imfile , "MR2 %d %d %d\n" ,
00144 im->kind , im->nx,im->ny ) ;
00145 break ;
00146
00147 case 3:
00148 fprintf( imfile , "MR2 %d %d %d %d\n" ,
00149 im->kind , im->nx,im->ny,im->nz ) ;
00150 break ;
00151
00152 case 4:
00153 fprintf( imfile , "MR2 %d %d %d %d %d\n" ,
00154 im->kind , im->nx,im->ny,im->nz,im->nt ) ;
00155 break ;
00156
00157 case 5:
00158 fprintf( imfile , "MR2 %d %d %d %d %d %d\n" ,
00159 im->kind , im->nx,im->ny,im->nz,im->nt,im->nu ) ;
00160 break ;
00161
00162 case 6:
00163 fprintf( imfile , "MR2 %d %d %d %d %d %d %d\n" ,
00164 im->kind , im->nx,im->ny,im->nz,im->nt,im->nu,im->nv ) ;
00165 break ;
00166
00167 case 7:
00168 fprintf( imfile , "MR2 %d %d %d %d %d %d %d %d\n" ,
00169 im->kind , im->nx,im->ny,im->nz,im->nt,im->nu,im->nv,im->nw ) ;
00170 break ;
00171 }
00172
00173 /*** write rest of data now ***/
00174
00175 data = mri_data_pointer( im ) ;
00176 fwrite( data , im->pixel_size , im->nvox , imfile ) ;
00177 fclose( imfile ) ;
00178
00179 RETURN( 1 );
00180 }
|
|
||||||||||||
|
------------------------ Only good for 1D and 2D images ---------------------------* Definition at line 257 of file mri_write.c. References ENTRY, i, MRI_IMAGE::kind, MRI_BYTE_PTR, MRI_COMPLEX_PTR, MRI_DOUBLE_PTR, MRI_FLOAT_PTR, MRI_INT_PTR, MRI_RGB_PTR, MRI_SHORT_PTR, MRI_IMAGE::nx, MRI_IMAGE::ny, MRI_IMAGE::nz, r, and RETURN. Referenced by GRA_refwrite_choose_CB(), main(), and mri_write_1D().
00258 {
00259 int ii , jj , nx , ny ;
00260 FILE *imfile ;
00261
00262 ENTRY("mri_write_ascii") ;
00263
00264 if( fname == NULL || strlen(fname) == 0 ||
00265 im == NULL || im->nz > 1 ) RETURN( 0 );
00266
00267 if( strcmp(fname,"-") == 0 ){
00268 imfile = stdout ;
00269 } else {
00270 imfile = fopen( fname , "r" ) ;
00271 if( imfile != NULL ){
00272 fclose( imfile ) ;
00273 fprintf(stderr,"(FAILED) attempt to overwrite file %s\n",fname) ;
00274 RETURN( 0 );
00275 }
00276 imfile = fopen( fname , "w" ) ;
00277 if( imfile == NULL ){
00278 fprintf( stderr , "couldn't open for output file %s\n" , fname ) ;
00279 RETURN( 0 );
00280 }
00281 }
00282
00283 nx = im->nx ; ny = im->ny ;
00284
00285 for( jj=0 ; jj < ny ; jj++ ){
00286
00287 switch( im->kind ){
00288
00289 case MRI_float:{
00290 float *iar = MRI_FLOAT_PTR(im) + (jj*nx) ;
00291 for( ii=0 ; ii < nx ; ii++ )
00292 fprintf(imfile," %14.7g",iar[ii]) ;
00293 }
00294 break ;
00295
00296 case MRI_short:{
00297 short *iar = MRI_SHORT_PTR(im) + (jj*nx) ;
00298 for( ii=0 ; ii < nx ; ii++ )
00299 fprintf(imfile," %6d",iar[ii]) ;
00300 }
00301 break ;
00302
00303 case MRI_byte:{
00304 byte *iar = MRI_BYTE_PTR(im) + (jj*nx) ;
00305 for( ii=0 ; ii < nx ; ii++ )
00306 fprintf(imfile," %3d",iar[ii]) ;
00307 }
00308 break ;
00309
00310 case MRI_int:{
00311 int *iar = MRI_INT_PTR(im) + (jj*nx) ;
00312 for( ii=0 ; ii < nx ; ii++ )
00313 fprintf(imfile," %6d",iar[ii]) ;
00314 }
00315 break ;
00316
00317 case MRI_double:{
00318 double *iar = MRI_DOUBLE_PTR(im) + (jj*nx) ;
00319 for( ii=0 ; ii < nx ; ii++ )
00320 fprintf(imfile," %14.7g",iar[ii]) ;
00321 }
00322 break ;
00323
00324 case MRI_complex:{
00325 complex *iar = MRI_COMPLEX_PTR(im) + (jj*nx) ;
00326 for( ii=0 ; ii < nx ; ii++ )
00327 fprintf(imfile," %14.7g %14.7g",iar[ii].r,iar[ii].i) ;
00328 }
00329 break ;
00330
00331 case MRI_rgb:{
00332 byte *iar = MRI_RGB_PTR(im) + (3*jj*nx) ;
00333 for( ii=0 ; ii < nx ; ii++ )
00334 fprintf(imfile," %3d %3d %3d",iar[3*ii],iar[3*ii+1],iar[3*ii+2]) ;
00335 }
00336 break ;
00337 }
00338
00339 fprintf(imfile,"\n") ;
00340 }
00341
00342 if( imfile != stdout ) fclose(imfile) ;
00343 RETURN( 1 );
00344 }
|
|
||||||||||||
|
Definition at line 380 of file mri_write.c. References free, MRI_IMAGE::kind, malloc, MRI_BYTE_PTR, MRI_RGB_PTR, MRI_IMAGE::nvox, MRI_IMAGE::nx, MRI_IMAGE::ny, pclose, popen, and THD_find_executable(). Referenced by mri_write_pnm().
00381 {
00382 char *pg , *jpfilt ;
00383 FILE *fp ;
00384
00385 if( fname == NULL || *fname == '\0' || im == NULL ) return 0 ;
00386 if( im->kind != MRI_rgb && im->kind != MRI_byte ) return 0 ;
00387
00388 pg = THD_find_executable( "cjpeg" ) ;
00389 if( pg == NULL ) return 0 ;
00390
00391 jpfilt = (char *)malloc( sizeof(char)*(strlen(pg)+strlen(fname)+32) ) ;
00392 sprintf( jpfilt , "%s -quality 95 > %s" , pg , fname ) ;
00393 #ifndef CYGWIN
00394 signal( SIGPIPE , SIG_IGN ) ;
00395 #endif
00396 fp = popen( jpfilt , "w" ) ;
00397 if( fp == NULL ){ free((void *)jpfilt); return 0 ;}
00398
00399 if( im->kind == MRI_rgb ){
00400 fprintf(fp,"P6\n%d %d\n255\n" , im->nx,im->ny ) ;
00401 fwrite( MRI_RGB_PTR(im), sizeof(byte), 3*im->nvox, fp ) ;
00402 } else if( im->kind == MRI_byte ){
00403 fprintf(fp,"P5\n%d %d\n255\n" , im->nx,im->ny ) ;
00404 fwrite( MRI_BYTE_PTR(im), sizeof(byte), im->nvox, fp ) ;
00405 }
00406 (void) pclose(fp) ;
00407 free((void *)jpfilt) ; return 1 ;
00408 }
|
|
||||||||||||
|
Definition at line 184 of file mri_write.c. References ENTRY, MRI_IMAGE::kind, MRI_BYTE_PTR, MRI_RGB_PTR, mri_write_jpg(), MRI_IMAGE::nvox, MRI_IMAGE::nx, MRI_IMAGE::ny, MRI_IMAGE::nz, RETURN, and STRING_HAS_SUFFIX. Referenced by AFNI_finalize_saveim_CB(), GRA_file_pixmap(), ISQ_saver_CB(), ISQ_snapfile(), main(), mri_write(), RCREND_finalize_saveim_CB(), and REND_finalize_saveim_CB().
00185 {
00186 FILE *imfile ;
00187 void *data ;
00188 int dsize , noheader = FALSE ;
00189
00190 ENTRY("mri_write_pnm") ;
00191
00192 if( im == NULL ) RETURN( 0 );
00193 if( im->nz > 1 ) RETURN( 0 );
00194 if( im->kind != MRI_byte && im->kind != MRI_rgb ) RETURN( 0 );
00195
00196 if( STRING_HAS_SUFFIX(fname,".jpg") ){ /* 15 Apr 2005 */
00197 RETURN( mri_write_jpg(fname,im) ) ;
00198 }
00199
00200 if( strcmp(fname,"-") != 0 ){
00201 imfile = fopen( fname , "r" ) ;
00202 if( imfile != NULL ){
00203 fclose( imfile ) ;
00204 fprintf(stderr,"(FAILED) attempt to overwrite file %s\n",fname) ;
00205 RETURN( 0 );
00206 }
00207 }
00208
00209 if( strcmp(fname,"-") != 0 )
00210 imfile = fopen( fname , "w" ) ;
00211 else
00212 imfile = stdout ; /* 18 Apr 2005: write to stdout */
00213
00214 if( imfile == NULL ){
00215 fprintf( stderr , "couldn't open for output file %s\n" , fname ) ;
00216 RETURN( 0 );
00217 }
00218
00219 switch( im->kind ){
00220
00221 case MRI_byte:
00222 fprintf( imfile , "P5\n%d %d\n255\n" , im->nx,im->ny ) ; /* header */
00223 fwrite( MRI_BYTE_PTR(im), sizeof(byte), im->nvox, imfile ) ; /* bytes */
00224 break ;
00225
00226 case MRI_rgb:
00227 fprintf( imfile , "P6\n%d %d\n255\n" , im->nx,im->ny ) ; /* header */
00228 fwrite( MRI_RGB_PTR(im), sizeof(byte), 3*im->nvox, imfile ) ; /* bytes */
00229 break ;
00230
00231 }
00232
00233 if( imfile != stdout ) fclose( imfile ) ;
00234 RETURN( 1 );
00235 }
|
|
||||||||||||
|
Definition at line 350 of file mri_write.c. References ENTRY, mri_data_pointer(), MRI_IMAGE::nvox, MRI_IMAGE::pixel_size, and RETURN. Referenced by main().
00351 {
00352 FILE *imfile ;
00353 void *data ;
00354 int dsize ;
00355
00356 ENTRY("mri_write_raw") ;
00357
00358 if( im == NULL || fname == NULL || fname[0] == '\0' ) RETURN( 0 );
00359
00360 dsize = im->pixel_size * im->nvox ;
00361 data = mri_data_pointer( im ) ;
00362
00363 if( dsize <= 0 || data == NULL ) RETURN( 0 );
00364
00365 imfile = fopen( fname , "w" ) ;
00366
00367 if( imfile == NULL ){
00368 fprintf(stderr,"** Can't open for output: %s\n",fname) ; RETURN( 0 );
00369 }
00370
00371 fwrite( data , 1 , dsize , imfile ) ;
00372 fclose( imfile ) ;
00373 RETURN( 1 );
00374 }
|
