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;
}
