int VT_ReadInrimHeader( vt_image *image, char *name ) { char *proc = "VT_ReadInrimageHeader"; _image *inr; if ( _VT_DEBUG_ ) { fprintf( stderr, "%s: uses LIBINRIMAGE routines\n", proc ); } if ( _flag_init_readers == 0 ) { _init_readers(); _flag_init_readers = 1; } VT_FreeImage( image ); /* lecture */ inr = _readImageHeader( name ); if( !inr ) { if ( _VT_VERBOSE_ ) fprintf( stderr, "%s: unable to read '%s'\n ", proc, name ); return 0; } strcpy( image->name, name ); if ( _decodeInrHeader( inr, image ) != 1 ) { _freeImage(inr); fprintf( stderr, "%s: unable to decode header of '%s'\n ", proc, name ); return 0; } (void)ImageIO_close( inr ); ImageIO_free( inr ); return 1; }
int writePgmImage(char *name,_image *im ) { char string[256]; int max; unsigned int i; if ( im->xdim <= 0 || im->ydim <= 0 || im->zdim != 1 || im->vdim != 1 ) { fprintf( stderr, "writePgmImage: bad dimensions, unable to write '%s'\n", name ); return -1; } if ( im->wordKind != WK_FIXED || im->sign != SGN_UNSIGNED || ( im->wdim != 1 && im->wdim != 2 ) ) { fprintf( stderr, "writePgmImage: bad type, unable to write '%s'\n", name ); return -1; } if ( 0 ) im->dataMode = DM_ASCII; _openWriteImage( im, name ); if(!im->fd) { fprintf(stderr, "writePgmImage: error: unable to open file \'%s\'\n", name ); return ImageIO_OPENING; } if ( im->dataMode == DM_ASCII ) sprintf( string, "%s\n", PGM_ASCII_MAGIC ); else sprintf( string, "%s\n", PGM_MAGIC ); ImageIO_write( im, string, strlen( string ) ); sprintf( string, "# CREATOR: pnm.c $Revision$ $Date$\n" ); ImageIO_write( im, string, strlen( string ) ); sprintf( string, "%d %d\n", im->xdim, im->ydim ); ImageIO_write( im, string, strlen( string ) ); max = 0; switch ( im->wdim ) { case 1 : { unsigned char *buf = (unsigned char *)im->data; for ( i=0; i<im->xdim*im->ydim; i++, buf++ ) if ( max < *buf ) max = *buf; } break; case 2 : { unsigned short *buf = (unsigned short *)im->data; for ( i=0; i<im->xdim*im->ydim; i++, buf++ ) if ( max < *buf ) max = *buf; } break; } /* max == 0 causes problems for xv */ if ( max == 0 ) max = 1; sprintf( string, "%d\n", max ); ImageIO_write( im, string, strlen( string ) ); if ( im->dataMode == DM_ASCII ) { int i, j, n, size; char *str = (char*)ImageIO_alloc( _LGTH_STRING_+1 ); size = im->xdim * im->ydim * im->zdim * im->vdim; n = ( im->xdim < 16 ) ? im->xdim : 16; i = 0; switch( im->wdim ) { default : /* can not occur */ fprintf( stderr, "writePgmImage: bad type, unable to write '%s'\n", name ); ImageIO_close( im ); im->openMode = OM_CLOSE; return -1; case 1 : { unsigned char *theBuf = ( unsigned char * )im->data; do { memset( str, 0, _LGTH_STRING_ ); for ( j=0; j<n && i<size; j++, i++ ) { sprintf( str+strlen(str), "%d", theBuf[i] ); if ( j<n && i<size ) sprintf( str+strlen(str), " " ); } sprintf( str+strlen(str), "\n" ); if ( ImageIO_write( im, str, strlen( str ) ) <= 0 ) { fprintf(stderr, "writePgmImage: error when writing data in \'%s\'\n", name ); return( -3 ); } } while ( i < size ); } break; case 2 : { unsigned short int *theBuf = ( unsigned short int * )im->data; do { memset( str, 0, _LGTH_STRING_ ); for ( j=0; j<n && i<size; j++, i++ ) { sprintf( str+strlen(str), "%d", theBuf[i] ); if ( j<n && i<size ) sprintf( str+strlen(str), " " ); } sprintf( str+strlen(str), "\n" ); if ( ImageIO_write( im, str, strlen( str ) ) <= 0 ) { fprintf(stderr, "writePgmImage: error when writing data in \'%s\'\n", name ); return( -3 ); } } while ( i < size ); } break; } } else { if ( im->wdim == 1 || ( im->wdim == 2 && max > 255 ) ) { ImageIO_write( im, im->data, im->xdim*im->ydim*im->wdim ); } else { /* 2 octets, but max <= 255 has to be converted on one octet */ unsigned short *buf = (unsigned short *)im->data; unsigned char *tmp = (unsigned char *)ImageIO_alloc( im->xdim*im->ydim ); if ( tmp == NULL ) { fprintf( stderr, "writePgmImage: unable to allocate auxiliary buffer\n" ); return -1; } for ( i=0; i<im->xdim*im->ydim; i++, buf++ ) tmp[i] = (unsigned char)*buf; ImageIO_write( im, tmp, im->xdim*im->ydim ); ImageIO_free( tmp ); } } ImageIO_close( im ); im->openMode = OM_CLOSE; return 1; }
int writePpmImage( char *name,_image *im ) { char string[256]; int max; unsigned int i; if ( im->xdim <= 0 || im->ydim <= 0 || im->zdim != 1 || im->vdim != 3 ) { fprintf( stderr, "writePpmImage: bad dimensions, unable to write '%s'\n", name ); return -1; } if ( im->wordKind != WK_FIXED || im->sign != SGN_UNSIGNED || ( im->wdim != 1 && im->wdim != 2 ) ) { fprintf( stderr, "writePpmImage: bad type, unable to write '%s'\n", name ); return -1; } _openWriteImage( im, name ); if(!im->fd) { fprintf(stderr, "writeInrimage: error: unable to open file \'%s\'\n", name ); return ImageIO_OPENING; } sprintf( string, "%s\n", PPM_MAGIC ); ImageIO_write( im, string, strlen( string ) ); sprintf( string, "# CREATOR: pnm.c $Revision$ $Date$\n" ); ImageIO_write( im, string, strlen( string ) ); sprintf( string, "%d %d\n", im->xdim, im->ydim ); ImageIO_write( im, string, strlen( string ) ); max = 0; switch ( im->wdim ) { case 1 : { unsigned char *buf = (unsigned char *)im->data; for ( i=0; i<im->xdim*im->ydim*3; i++, buf++ ) if ( max < *buf ) max = *buf; } break; case 2 : { unsigned short *buf = (unsigned short *)im->data; for ( i=0; i<im->xdim*im->ydim*3; i++, buf++ ) if ( max < *buf ) max = *buf; } break; } if ( max == 0 ) max = 1; sprintf( string, "%d\n", max ); ImageIO_write( im, string, strlen( string ) ); if ( im->wdim == 1 || ( im->wdim == 2 && max > 255 ) ) { ImageIO_write( im, im->data, im->xdim*im->ydim*3*im->wdim ); } else { /* 2 octets, but max <= 255 has to be converted on one octet */ unsigned short *buf = (unsigned short *)im->data; unsigned char *tmp = (unsigned char *)ImageIO_alloc( im->xdim*im->ydim*3 ); if ( tmp == NULL ) { fprintf( stderr, "writePpmImage: unable to allocate auxiliary buffer\n" ); return -1; } for ( i=0; i<im->xdim*im->ydim*3; i++, buf++ ) tmp[i] = (unsigned char)*buf; ImageIO_write( im, tmp, im->xdim*im->ydim*3 ); ImageIO_free( tmp ); } ImageIO_close( im ); im->openMode = OM_CLOSE; return 1; }
int _readAnalyzeHeader( _image* im, const char* name, struct dsr *analyzeHeader ) { unsigned int i ; /* compile time endianness */ ENDIANNESS ARCHITECTURE_ENDIANNESS = _getEndianness(); if(im->openMode != OM_CLOSE) { ImageIO_read( im, analyzeHeader, sizeof(struct dsr) ); if( analyzeHeader->hk.sizeof_hdr == sizeof(struct dsr) ) { im->endianness = ARCHITECTURE_ENDIANNESS ; } else { _swapAnalyzeHdr( analyzeHeader ); if( analyzeHeader->hk.sizeof_hdr != sizeof(struct dsr) ) { fprintf (stderr, "_readAnalyzeHeader: error: unknown magic (%d)...\n", analyzeHeader->hk.sizeof_hdr ); return -1; } if( ARCHITECTURE_ENDIANNESS == END_LITTLE ) { im->endianness = END_BIG; } else { im->endianness = END_LITTLE; } } if ( analyzeHeader->dime.dim[0] > 4 ) { fprintf (stderr, "_readAnalyzeHeader: error: dimensionality not supported (%d)...\n", analyzeHeader->dime.dim[0] ); return -1; } im->xdim = analyzeHeader->dime.dim[1]; im->ydim = analyzeHeader->dime.dim[2]; im->zdim = analyzeHeader->dime.dim[3]; /* 0 time-points is a convention for one volume only at MNI */ /* Corrected by X. Pennec following a bug report by Irina Kezele at MNI */ if( analyzeHeader->dime.dim[4] == 0 ){ fprintf (stderr, "_readAnalyzeHeader: warning: time dimension / number if volume (dim[4]) is 0. Assuming this means 1 (otherwise there would be no image...). \n"); analyzeHeader->dime.dim[4] = 1; } /* Analyze doesn't support vector images. The forth dimension relates to time. */ if( analyzeHeader->dime.dim[4] != 1 ) { fprintf (stderr, "_readAnalyzeHeader: error: time dimension not supported (%d)...\n", analyzeHeader->dime.dim[4] ); return -1; } im->vectMode = VM_SCALAR; im->vx = analyzeHeader->dime.pixdim[1]; im->vy = analyzeHeader->dime.pixdim[2]; im->vz = analyzeHeader->dime.pixdim[3]; if( im->vx == 0.0 ) im->vx = 1.0 ; if( im->vy == 0.0 ) im->vy = im->vx ; if( im->vz == 0.0 ) im->vz = im->vy ; switch(analyzeHeader->dime.datatype) { case DT_BINARY: case DT_UNSIGNED_CHAR: case DT_SIGNED_SHORT: case DT_SIGNED_INT: case DT_FLOAT: case DT_COMPLEX: case DT_DOUBLE: im->vdim = 1; break ; case DT_RGB: im->vdim = 3; break ; default: fprintf (stderr, "_readAnalyzeHeader: error: data type not supported (%d)...\n", analyzeHeader->dime.datatype ); return -1; } switch(analyzeHeader->dime.datatype) { case DT_BINARY: case DT_UNSIGNED_CHAR: case DT_SIGNED_SHORT: case DT_SIGNED_INT: case DT_RGB: im->wordKind = WK_FIXED; break ; case DT_FLOAT: case DT_COMPLEX: case DT_DOUBLE: im->wordKind = WK_FLOAT; break ; default: fprintf (stderr, "_readAnalyzeHeader: error: data type not supported (%d)...\n", analyzeHeader->dime.datatype ); return -1; } switch(analyzeHeader->dime.datatype) { case DT_BINARY: case DT_UNSIGNED_CHAR: case DT_RGB: im->sign = SGN_UNSIGNED; break ; case DT_SIGNED_SHORT: case DT_SIGNED_INT: case DT_FLOAT: case DT_COMPLEX: case DT_DOUBLE: im->sign = SGN_SIGNED; break ; default: fprintf (stderr, "_readAnalyzeHeader: error: data type not supported (%d)...\n", analyzeHeader->dime.datatype ); return -1; } im->wdim = analyzeHeader->dime.bitpix; if( analyzeHeader->dime.datatype == DT_RGB ) { im->wdim /= 3 ; } if(im->wdim != 8 && im->wdim != 16 && im->wdim != 32 && im->wdim != 64) { fprintf (stderr, "_readAnalyzeHeader: error: pixel size not supported (%d)...\n", analyzeHeader->dime.bitpix ); return -1; } im->wdim >>= 3 ; /* There are 17 optional data fields be careful in the allocation */ im->nuser = 1 + 17 ; im->user = (char **) ImageIO_alloc(im->nuser * sizeof(char *)); for ( i=0; i<im->nuser; i++ ) im->user[i] = NULL; i = 0 ; im->user[i] = (char *) ImageIO_alloc((strlen("Data lost in the Analyze -> ImageIO conversion:") + 1)); sprintf( im->user[i++], "Data lost in the Analyze -> ImageIO conversion:" ); im->user[i] = (char *) ImageIO_alloc((strlen(" descrip: ") + 1 + strlen(analyzeHeader->hist.descrip) )); sprintf( im->user[i++], " descrip: %s", analyzeHeader->hist.descrip ); im->user[i] = (char *) ImageIO_alloc((strlen(" aux_file: ") + 1 + strlen(analyzeHeader->hist.descrip) )); sprintf( im->user[i++], " aux_file: %s", analyzeHeader->hist.descrip ); im->user[i] = (char *) ImageIO_alloc((strlen(" orient: ") + 1+ 2)); sprintf( im->user[i++], " orient: %d", analyzeHeader->hist.orient ); im->user[i] = (char *) ImageIO_alloc((strlen(" originator: ") + 1 + strlen(analyzeHeader->hist.originator) )); sprintf( im->user[i++], " originator: %s", analyzeHeader->hist.originator ); im->user[i] = (char *) ImageIO_alloc((strlen(" generated: ") + 1 + strlen(analyzeHeader->hist.generated) )); sprintf( im->user[i++], " generated: %s", analyzeHeader->hist.generated ); im->user[i] = (char *) ImageIO_alloc((strlen(" scannum: ") + 1 + strlen(analyzeHeader->hist.scannum) )); sprintf( im->user[i++], " scannum: %s", analyzeHeader->hist.scannum ); im->user[i] = (char *) ImageIO_alloc((strlen(" patient_id: ") + 1 + strlen(analyzeHeader->hist.patient_id) )); sprintf( im->user[i++], " patient_id: %s", analyzeHeader->hist.patient_id ); im->user[i] = (char *) ImageIO_alloc((strlen(" exp_date: ") + 1 + strlen(analyzeHeader->hist.exp_date) )); sprintf( im->user[i++], " exp_date: %s", analyzeHeader->hist.exp_date ); im->user[i] = (char *) ImageIO_alloc((strlen(" exp_time: ") + 1 + strlen(analyzeHeader->hist.exp_time) )); sprintf( im->user[i++], " exp_time: %s", analyzeHeader->hist.exp_time ); /* A 32 bit int doesn't print on more than 11 chars */ im->user[i] = (char *) ImageIO_alloc((strlen(" views: ") + 11 + 1)); sprintf( im->user[i++], " views: %d", analyzeHeader->hist.views ); im->user[i] = (char *) ImageIO_alloc((strlen(" vols_added: ") + 11 + 1)); sprintf( im->user[i++], " vols_added: %d", analyzeHeader->hist.vols_added ); im->user[i] = (char *) ImageIO_alloc((strlen(" start_field: ") + 11 + 1)); sprintf( im->user[i++], " start_field: %d", analyzeHeader->hist.start_field ); im->user[i] = (char *) ImageIO_alloc((strlen(" field_skip: ") + 11 + 1)); sprintf( im->user[i++], " field_skip: %d", analyzeHeader->hist.field_skip ); im->user[i] = (char *) ImageIO_alloc((strlen(" omax: ") + 11 + 1)); sprintf( im->user[i++], " omax: %d", analyzeHeader->hist.omax ); im->user[i] = (char *) ImageIO_alloc((strlen(" omin: ") + 11 + 1)); sprintf( im->user[i++], " omin: %d", analyzeHeader->hist.omin ); im->user[i] = (char *) ImageIO_alloc((strlen(" smax: ") + 11 + 1)); sprintf( im->user[i++], " smax: %d", analyzeHeader->hist.smax ); im->user[i] = (char *) ImageIO_alloc((strlen(" smin: ") + 11 + 1)); sprintf( im->user[i++], " smin: %d", analyzeHeader->hist.smin ); /* header is read. close header file and open data file. */ if( name != NULL ) { int length = strlen(name) ; char* data_filename = (char *) ImageIO_alloc(length+4) ; if( strcmp( name+length-4, ".hdr" ) ) { fprintf (stderr, "_readAnalyzeHeader: error: file header extension must be .hdr\n"); ImageIO_free( data_filename ); return -1; } ImageIO_close(im); strcpy(data_filename,name); strcpy(data_filename+length-3, "img.gz"); _openReadImage(im,data_filename); if(!im->fd) { strcpy(data_filename,name); strcpy(data_filename+length-3, "img"); _openReadImage(im,data_filename); if(!im->fd) { fprintf(stderr, "_readAnalyzeHeader: error: unable to open data file \'%s\'\n", data_filename); ImageIO_free( data_filename ); return -1; } } ImageIO_free( data_filename ); } /* check header validity */ if(im->xdim > 0 && im->ydim > 0 && im->zdim > 0 && im->vdim > 0 && im->vx > 0.0 && im->vy > 0.0 && im->vz > 0.0 && (im->wordKind == WK_FLOAT || (im->wordKind == WK_FIXED && im->sign != SGN_UNKNOWN)) && im->endianness != END_UNKNOWN) { return 0; } else return -1; }
int writeAnalyze( char *name, _image* im) { char *outputName; int length, extLength=0, res; length=strlen(name); outputName= (char *)ImageIO_alloc(length+8); if ( strncmp( name+length-4, ".hdr", 4 ) == 0 ) { extLength = 4; } else if ( strncmp( name+length-4, ".img", 4 ) == 0 ) { extLength = 4; } else if ( strncmp( name+length-7, ".img.gz", 7 ) == 0 ) { extLength = 7; } else if ( strncmp( name+length-7, ".hdr.gz", 7 ) == 0 ) { extLength = 7; } strncpy( outputName, name, length-extLength ); if ( strncmp( name+length-7, ".hdr.gz", 7 ) == 0 ) strcpy( outputName+length-extLength, ".hdr.gz" ); else strcpy( outputName+length-extLength, ".hdr" ); _openWriteImage(im, outputName); if( !im->fd ) { fprintf(stderr, "writeAnalyze: error: unable to open file \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return ImageIO_OPENING; } res = writeAnalyzeHeader(im); if ( res < 0 ) { fprintf(stderr, "writeAnalyze: error: unable to write header of \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); ImageIO_close( im ); im->fd = NULL; im->openMode = OM_CLOSE; return( res ); } ImageIO_close(im); strncpy( outputName, name, length-extLength ); if ( strncmp( name+length-3, ".gz", 3 ) == 0 ) { strcpy( outputName+length-extLength, ".img.gz" ); } else { strcpy( outputName+length-extLength, ".img" ); } _openWriteImage(im, outputName); if( !im->fd ) { fprintf(stderr, "writeAnalyze: error: unable to open file \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return ImageIO_OPENING; } res = writeAnalyzeData(im); if (res < 0) { fprintf(stderr, "writeAnalyze: error: unable to write data in \'%s\'\n", outputName ); ImageIO_close( im ); im->fd = NULL; im->openMode = OM_CLOSE; return( res ); } if ( outputName != NULL ) ImageIO_free( outputName ); ImageIO_close( im ); im->fd = NULL; im->openMode = OM_CLOSE; return ( res ); }
int writeGis( char *name, _image* im) { char *outputName; int length, extLength=0, res; length=strlen(name); outputName= (char *)ImageIO_alloc(length+8); if ( strncmp( name+length-4, ".dim", 4 ) == 0 ) { extLength = 4; } else if ( strncmp( name+length-4, ".ima", 4 ) == 0 ) { extLength = 4; } else if ( strncmp( name+length-7, ".ima.gz", 7 ) == 0 ) { extLength = 7; } else if ( strncmp( name+length-7, ".dim.gz", 7 ) == 0 ) { extLength = 7; } strncpy( outputName, name, length-extLength ); if ( strncmp( name+length-7, ".dim.gz", 7 ) == 0 ) strcpy( outputName+length-extLength, ".dim.gz" ); else strcpy( outputName+length-extLength, ".dim" ); _openWriteImage(im, outputName); if( !im->fd ) { fprintf(stderr, "writeGis: error: unable to open file \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return ImageIO_OPENING; } res = writeGisHeader(im); if (res < 0 ) { fprintf(stderr, "writeGis: error: unable to write header of \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); ImageIO_close( im ); im->fd = NULL; im->openMode = OM_CLOSE; return( res ); } ImageIO_close(im); strncpy( outputName, name, length-extLength ); if ( strncmp( name+length-3, ".gz", 3 ) == 0 ) { strcpy( outputName+length-extLength, ".ima.gz" ); } else { strcpy( outputName+length-extLength, ".ima" ); } _openWriteImage(im, outputName); if( !im->fd ) { fprintf(stderr, "writeGis: error: unable to open file \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return ImageIO_OPENING; } if ( im->dataMode == DM_ASCII ) { int i, j, n, size; char *str = (char*)ImageIO_alloc( _LGTH_STRING_+1 ); size = im->xdim * im->ydim * im->zdim * im->vdim; n = ( im->xdim < 16 ) ? im->xdim : 16; i = 0; switch( im->wordKind ) { default : fprintf(stderr, "writeGis: such word kind not handled in ascii mode for file \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return( -3 ); case WK_FIXED : switch ( im->wdim ) { default : fprintf(stderr, "writeGis: such word dim not handled in ascii mode for file \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return( -3 ); case 1 : switch ( im->sign ) { default : fprintf(stderr, "writeGis: such sign not handled in ascii mode for file \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return( -3 ); case SGN_UNSIGNED : { unsigned char *theBuf = ( unsigned char * )im->data; do { memset( str, 0, _LGTH_STRING_ ); for ( j=0; j<n && i<size; j++, i++ ) { sprintf( str+strlen(str), "%d", theBuf[i] ); if ( j<n && i<size ) sprintf( str+strlen(str), " " ); } sprintf( str+strlen(str), "\n" ); res = ImageIO_write( im, str, strlen( str ) ); if ( res <= 0 ) { fprintf(stderr, "writeGis: error when writing data in \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return( -3 ); } } while ( i < size ); } break; case SGN_SIGNED : { char *theBuf = ( char * )im->data; do { memset( str, 0, _LGTH_STRING_ ); for ( j=0; j<n && i<size; j++, i++ ) { sprintf( str+strlen(str), "%d", theBuf[i] ); if ( j<n && i<size ) sprintf( str+strlen(str), " " ); } sprintf( str+strlen(str), "\n" ); res = ImageIO_write( im, str, strlen( str ) ); if ( res <= 0 ) { fprintf(stderr, "writeGis: error when writing data in \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return( -3 ); } } while ( i < size ); } break; } /* end of switch ( im->sign ) */ break; case 2 : switch ( im->sign ) { default : fprintf(stderr, "writeGis: such sign not handled in ascii mode for file \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return( -3 ); case SGN_UNSIGNED : { unsigned short int *theBuf = ( unsigned short int * )im->data; do { memset( str, 0, _LGTH_STRING_ ); for ( j=0; j<n && i<size; j++, i++ ) { sprintf( str+strlen(str), "%d", theBuf[i] ); if ( j<n && i<size ) sprintf( str+strlen(str), " " ); } sprintf( str+strlen(str), "\n" ); res = ImageIO_write( im, str, strlen( str ) ); if ( res <= 0 ) { fprintf(stderr, "writeGis: error when writing data in \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return( -3 ); } } while ( i < size ); } break; case SGN_SIGNED : { short int *theBuf = ( short int * )im->data; do { memset( str, 0, _LGTH_STRING_ ); for ( j=0; j<n && i<size; j++, i++ ) { sprintf( str+strlen(str), "%d", theBuf[i] ); if ( j<n && i<size ) sprintf( str+strlen(str), " " ); } sprintf( str+strlen(str), "\n" ); res = ImageIO_write( im, str, strlen( str ) ); if ( res <= 0 ) { fprintf(stderr, "writeGis: error when writing data in \'%s\'\n", outputName); if ( outputName != NULL ) ImageIO_free( outputName ); return( -3 ); } } while ( i < size ); } break; } /* end of switch ( im->sign ) */ break; } /* end of switch ( im->wdim ) */ } /* end of switch( im->wordKind ) */ ImageIO_free( str ); } else { res = _writeInrimageData(im); } if ( outputName != NULL ) ImageIO_free( outputName ); return res; }
int readGisHeader( const char* name,_image* im) { char *s, *str = NULL; int status; int n=0, nusermax = 20; str = (char*)ImageIO_alloc( _LGTH_STRING_+1 ); if ( !fgetns(str, _LGTH_STRING_, im) ) { ImageIO_free( str ); return -1; } status = sscanf( str,"%d %d %d %d", &(im->xdim), &(im->ydim), &(im->zdim), &(im->vdim) ); switch ( status ) { case 2 : im->zdim = 1; case 3 : im->vdim = 1; case 4 : break; default : fprintf( stderr, "readGisHeader: unable to read dimensions in '%s'\n", name ); ImageIO_free( str ); return -1; } if ( im->vdim > 1 ) { im->vectMode = VM_INTERLACED; } else { im->vectMode = VM_SCALAR; } #define ADD_USER_STRING { \ if ( n == 0 ) { \ im->user = (char**)ImageIO_alloc( nusermax * sizeof( char*) ); \ for ( n=0; n<nusermax; n++ ) im->user[n] = NULL; \ n = 0; \ } \ im->user[n] = (char*)ImageIO_alloc( 1+strlen( s ) ); \ strcpy( im->user[n++], s ); \ } while( fgetns( str, _LGTH_STRING_, im ) != 0 ) { s = str; do { while ( *s == ' ' || *s == '\t' ) s++; if ( !strncmp( s, "-dx ", 4 ) ) { s += 4; status = sscanf( s, "%lf", &(im->vx) ); if ( status != 1 ) { fprintf( stderr, "readGisHeader: error while reading -dx in '%s'\n", s-4 ); *s = '\0'; } else { while ( *s == '.' || (*s >= '0' && *s <= '9') ) s++; } } else if ( !strncmp( s, "-dy ", 4 ) ) { s += 4; status = sscanf( s, "%lf", &(im->vy) ); if ( status != 1 ) { fprintf( stderr, "readGisHeader: error while reading -dy in '%s'\n", s-4 ); *s = '\0'; } else { while ( *s == '.' || (*s >= '0' && *s <= '9') ) s++; } } else if ( !strncmp( s, "-dz ", 4 ) ) { s += 4; status = sscanf( s, "%lf", &(im->vz) ); if ( status != 1 ) { fprintf( stderr, "readGisHeader: error while reading -dz in '%s'\n", s-4 ); *s = '\0'; } else { while ( *s == '.' || (*s >= '0' && *s <= '9') ) s++; } } else if ( !strncmp( s, "-dt ", 4 ) ) { ADD_USER_STRING s += 4; while ( *s == '.' || (*s >= '0' && *s <= '9') ) s++; } else if ( !strncmp( s, "-type ", 6 ) ) { s += 6; if ( !strncmp( s, "U8", 2 ) ) { im->wdim = 1; im->wordKind = WK_FIXED; im->sign = SGN_UNSIGNED; s += 2; } else if ( !strncmp( s, "S8", 2 ) ) { im->wdim = 1; im->wordKind = WK_FIXED; im->sign = SGN_SIGNED; s += 2; } else if ( !strncmp( s, "U16", 3 ) ) { im->wdim = 2; im->wordKind = WK_FIXED; im->sign = SGN_UNSIGNED; s += 3; } else if ( !strncmp( s, "S16", 3 ) ) { im->wdim = 2; im->wordKind = WK_FIXED; im->sign = SGN_SIGNED; s += 3; } else if ( !strncmp( s, "U32", 3 ) ) { im->wdim = 4; im->wordKind = WK_FIXED; im->sign = SGN_UNSIGNED; s += 3; } else if ( !strncmp( s, "S32", 3 ) ) { im->wdim = 4; im->wordKind = WK_FIXED; im->sign = SGN_SIGNED; s += 3; } else if ( !strncmp( s, "FLOAT", 5 ) ) { im->wdim = sizeof( float ); im->wordKind = WK_FLOAT; im->sign = SGN_UNKNOWN; s += 5; } else if ( !strncmp( s, "DOUBLE", 6 ) ) { im->wdim = sizeof( double ); im->wordKind = WK_FLOAT; im->sign = SGN_UNKNOWN; s += 6; } else { fprintf( stderr, "readGisHeader: unknown type '%s'\n", s-6 ); *s = '\0'; } } else if ( !strncmp( s, "-bo ", 4 ) ) { s += 4; if ( !strncmp( s, "ABCD", 4 ) ) { im->endianness = END_BIG; s += 4; } else if ( !strncmp( s, "SUN", 3 ) ) { im->endianness = END_BIG; s += 3; } else if ( !strncmp( s, "DCBA", 4 ) ) { im->endianness = END_LITTLE; s += 4; } else if ( !strncmp( s, "ALPHA", 5 ) ) { im->endianness = END_LITTLE; s += 5; } else { fprintf( stderr, "readGisHeader: unknown byte order '%s'\n", s-4 ); *s = '\0'; } } else if ( !strncmp( s, "-ar ", 4 ) ) { s += 4; if ( !strncmp( s, "SUN", 3 ) ) { im->endianness = END_BIG; s += 3; } else if ( !strncmp( s, "ALPHA", 5 ) ) { im->endianness = END_LITTLE; s += 5; } else { fprintf( stderr, "readGisHeader: unknown architecture '%s'\n", s-4 ); *s = '\0'; } } else if ( !strncmp( s, "-om ", 4 ) ) { s += 4; if ( !strncmp( s, "binar", 5 ) ) { im->dataMode = DM_BINARY; s += 5; } else if ( !strncmp( s, "ascii", 5 ) ) { im->dataMode = DM_ASCII; s += 5; } else { fprintf( stderr, "readGisHeader: unknown data type '%s'\n", s-4 ); ImageIO_free( str ); return -1; } } else { fprintf( stderr, "readGisHeader: unknown indentifier '%s'\n", s ); ADD_USER_STRING *s = '\0'; } } while( *s != '\0' && *s != '\n' ); } ImageIO_free( str ); if ( im->endianness == END_UNKNOWN ) { im->endianness = _getEndianness(); } /* header is read. close header file and open data file. */ if( name != NULL ) { int length = strlen(name) ; char* data_filename = (char *) ImageIO_alloc(length+4) ; if( strcmp( name+length-4, ".dim" ) ) { fprintf (stderr, "readGisHeader: error: file header extension must be .dim\n"); ImageIO_free( data_filename ); return -1; } ImageIO_close(im); /* open data file */ strcpy(data_filename,name); strcpy(data_filename+length-3, "ima.gz"); _openReadImage(im,data_filename); if(!im->fd) { strcpy(data_filename,name); strcpy(data_filename+length-3, "ima"); _openReadImage(im,data_filename); if(!im->fd) { fprintf(stderr, "readGisHeader: error: unable to open data file \'%s\'\n", data_filename); ImageIO_free( data_filename ); return -1; } } ImageIO_free( data_filename ); /* read data if ascii only U8 and S8 */ if ( im->dataMode == DM_ASCII ) { int size = im->xdim * im->ydim * im->zdim * im->vdim * im->wdim; unsigned int n; char *tmp; int ret, iv=0; if ( im->wdim != 1 || im->wordKind != WK_FIXED ) { fprintf(stderr, "readGisHeader: error: unable to read such ascii type\n" ); return -1; } n = 0 ; if ( size <= 0 ) return -1; if(!im->data) { im->data = ( void*) ImageIO_alloc(size); if(!im->data) return -1; } n = 0; str = (char*)ImageIO_alloc( _LGTH_STRING_+1 ); while( fgetns( str, _LGTH_STRING_, im ) != 0 && n < im->xdim * im->ydim * im->zdim * im->vdim ) { tmp = str; while ( *tmp != '\n' && *tmp != '\0' && *tmp != EOF && n < im->xdim * im->ydim * im->zdim * im->vdim ) { /* skip trailing whitespace */ while ( *tmp == ' ' || *tmp == '\t' ) tmp++; if ( *tmp == '\0' || *tmp == '\n' || *tmp == EOF ) continue; /* read a number */ switch ( im->wordKind ) { case WK_FIXED : ret = sscanf( tmp, "%d", &iv ); break; default : ImageIO_free( im->data ); im->data = NULL; ImageIO_free( str ); return -1; } if ( ret != 1 ) { fprintf( stderr, "readGisHeader: error in reading ascii data\n" ); ImageIO_free( im->data ); im->data = NULL; ImageIO_free( str ); return -1; } if ( im->wordKind == WK_FIXED && im->sign == SGN_UNSIGNED && im->wdim == 1 ) { unsigned char *buf = (unsigned char *)im->data; buf += n; if ( iv < 0 ) *buf = (unsigned char)0; else if ( iv > 255 ) *buf = (unsigned char)255; else *buf = (unsigned char)iv; n ++; } else if ( im->wordKind == WK_FIXED && im->sign == SGN_SIGNED && im->wdim == 1 ) { char *buf = (char *)im->data; buf += n; if ( iv < -128 ) *buf = (char)-128; else if ( iv > 127 ) *buf = (char)127; else *buf = (char)iv; n ++; } else if ( im->wordKind == WK_FIXED && im->sign == SGN_UNSIGNED && im->wdim == 2 ) { unsigned short int *buf = (unsigned short int *)im->data; buf += n; if ( iv < 0 ) *buf = (unsigned short int)0; else if ( iv > 65535 ) *buf = (unsigned short int)65535; else *buf = (unsigned short int)iv; n ++; } else if ( im->wordKind == WK_FIXED && im->sign == SGN_SIGNED && im->wdim == 2 ) { short int *buf = (short int *)im->data; buf += n; if ( iv < -32768 ) *buf = (short int)-32768; else if ( iv > 32767 ) *buf = (short int)32767; else *buf = (short int)iv; n ++; } else { ImageIO_free( im->data ); im->data = NULL; ImageIO_free( str ); return -1; } /* skip a number */ while ( (*tmp >= '0' && *tmp <= '9') || *tmp == '.' || *tmp == '-' ) tmp++; } } ImageIO_free( str ); ImageIO_close(im); } } /* check header validity */ if ( im->xdim > 0 && im->ydim > 0 && im->zdim > 0 && im->vdim > 0 && im->vx > 0.0 && im->vy > 0.0 && im->vz > 0.0 && ( im->wordKind == WK_FLOAT || (im->wordKind == WK_FIXED && im->sign != SGN_UNKNOWN) ) && im->endianness != END_UNKNOWN ) { return 0; } return -1; }
int VT_ReadInrimage( vt_image *image, char *name ) { char *proc = "VT_ReadInrimage"; _image *inr; if ( _VT_DEBUG_ ) { fprintf( stderr, "%s: uses LIBINRIMAGE routines\n", proc ); } if ( _flag_init_readers == 0 ) { _init_readers(); _flag_init_readers = 1; } VT_FreeImage( image ); /* lecture */ inr = _readImage( name ); if( !inr ) { if ( _VT_VERBOSE_ ) fprintf( stderr, "%s: unable to read '%s'\n ", proc, name ); return 0; } strcpy( image->name, name ); if ( _decodeInrHeader( inr, image ) != 1 ) { _freeImage(inr); fprintf( stderr, "%s: unable to decode header of '%s'\n ", proc, name ); return 0; } image->buf = inr->data; strcpy( image->name, name ); { unsigned int vol_ptr; int i,j; switch ( image->type ) { case SCHAR : vol_ptr = image->dim.z * image->dim.y * sizeof( s8* ); vol_ptr += image->dim.z * sizeof( s8** ); break; case UCHAR : vol_ptr = image->dim.z * image->dim.y * sizeof( u8* ); vol_ptr += image->dim.z * sizeof( u8** ); break; case SSHORT : vol_ptr = image->dim.z * image->dim.y * sizeof( s16* ); vol_ptr += image->dim.z * sizeof( s16** ); break; case USHORT : vol_ptr = image->dim.z * image->dim.y * sizeof( u16* ); vol_ptr += image->dim.z * sizeof( u16** ); break; case FLOAT : vol_ptr = image->dim.z * image->dim.y * sizeof( r32* ); vol_ptr += image->dim.z * sizeof( r32** ); break; case DOUBLE : vol_ptr = image->dim.z * image->dim.y * sizeof( r64* ); vol_ptr += image->dim.z * sizeof( r64** ); break; case SINT : vol_ptr = image->dim.z * image->dim.y * sizeof( i32* ); vol_ptr += image->dim.z * sizeof( i32** ); break; case UINT : vol_ptr = image->dim.z * image->dim.y * sizeof( u32* ); vol_ptr += image->dim.z * sizeof( u32** ); break; default : if ( _VT_VERBOSE_ ) fprintf( stderr, "%s: unknown image type", proc ); _freeImage(inr); return 0; } image->array = (void***) malloc( (unsigned int)(vol_ptr) ); if ( image->array == NULL ) { if ( _VT_VERBOSE_ ) fprintf( stderr, "%s: private buffer allocation failed", proc ); _freeImage(inr); return 0; } switch ( image->type ) { case SCHAR : { s8 ***z; s8 **zy; s8 *zyx; z = (s8 ***)(image->array); zy = (s8 **)(z + image->dim.z); zyx = (s8 *)(image->buf); /*--- calcul pour le premier indice Z ---*/ for ( i = 0; i < (int)image->dim.z; i ++ ) { *z = zy; z ++; /*--- calcul pour le deuxieme indice Y ---*/ for ( j = 0; j < (int)image->dim.y; j ++ ) { *zy = zyx; zy ++; zyx += image->dim.x * image->dim.v; } }} break; case UCHAR : { u8 ***z; u8 **zy; u8 *zyx; z = (u8 ***)(image->array); zy = (u8 **)(z + image->dim.z); zyx = (u8 *)(image->buf); /*--- calcul pour le premier indice Z ---*/ for ( i = 0; i < (int)image->dim.z; i ++ ) { *z = zy; z ++; /*--- calcul pour le deuxieme indice Y ---*/ for ( j = 0; j < (int)image->dim.y; j ++ ) { *zy = zyx; zy ++; zyx += image->dim.x * image->dim.v; } }} break; case SSHORT : { s16 ***z; s16 **zy; s16 *zyx; z = (s16 ***)(image->array); zy = (s16 **)(z + image->dim.z); zyx = (s16 *)(image->buf); /*--- calcul pour le premier indice Z ---*/ for ( i = 0; i < (int)image->dim.z; i ++ ) { *z = zy; z ++; /*--- calcul pour le deuxieme indice Y ---*/ for ( j = 0; j < (int)image->dim.y; j ++ ) { *zy = zyx; zy ++; zyx += image->dim.x * image->dim.v; } }} break; case USHORT : { u16 ***z; u16 **zy; u16 *zyx; z = (u16 ***)(image->array); zy = (u16 **)(z + image->dim.z); zyx = (u16 *)(image->buf); /*--- calcul pour le premier indice Z ---*/ for ( i = 0; i < (int)image->dim.z; i ++ ) { *z = zy; z ++; /*--- calcul pour le deuxieme indice Y ---*/ for ( j = 0; j < (int)image->dim.y; j ++ ) { *zy = zyx; zy ++; zyx += image->dim.x * image->dim.v; } }} break; case FLOAT : { r32 ***z; r32 **zy; r32 *zyx; z = (r32 ***)(image->array); zy = (r32 **)(z + image->dim.z); zyx = (r32 *)(image->buf); /*--- calcul pour le premier indice Z ---*/ for ( i = 0; i < (int)image->dim.z; i ++ ) { *z = zy; z ++; /*--- calcul pour le deuxieme indice Y ---*/ for ( j = 0; j < (int)image->dim.y; j ++ ) { *zy = zyx; zy ++; zyx += image->dim.x * image->dim.v; } }} break; case DOUBLE : { r64 ***z; r64 **zy; r64 *zyx; z = (r64 ***)(image->array); zy = (r64 **)(z + image->dim.z); zyx = (r64 *)(image->buf); /*--- calcul pour le premier indice Z ---*/ for ( i = 0; i < (int)image->dim.z; i ++ ) { *z = zy; z ++; /*--- calcul pour le deuxieme indice Y ---*/ for ( j = 0; j < (int)image->dim.y; j ++ ) { *zy = zyx; zy ++; zyx += image->dim.x * image->dim.v; } }} break; case SINT : { i32 ***z; i32 **zy; i32 *zyx; z = (i32 ***)(image->array); zy = (i32 **)(z + image->dim.z); zyx = (i32 *)(image->buf); /*--- calcul pour le premier indice Z ---*/ for ( i = 0; i < (int)image->dim.z; i ++ ) { *z = zy; z ++; /*--- calcul pour le deuxieme indice Y ---*/ for ( j = 0; j < (int)image->dim.y; j ++ ) { *zy = zyx; zy ++; zyx += image->dim.x * image->dim.v; } }} break; case UINT : { u32 ***z; u32 **zy; u32 *zyx; z = (u32 ***)(image->array); zy = (u32 **)(z + image->dim.z); zyx = (u32 *)(image->buf); /*--- calcul pour le premier indice Z ---*/ for ( i = 0; i < (int)image->dim.z; i ++ ) { *z = zy; z ++; /*--- calcul pour le deuxieme indice Y ---*/ for ( j = 0; j < (int)image->dim.y; j ++ ) { *zy = zyx; zy ++; zyx += image->dim.x * image->dim.v; } }} break; default : if ( _VT_VERBOSE_ ) fprintf( stderr, "%s: unknown image type", proc ); _freeImage(inr); return 0; } } (void)ImageIO_close( inr ); ImageIO_free( inr ); return 1; }