OSErr writeHeader( IMAGE *im, char *basename ) /* creates an analyze style header based on the struct im */ { FILE *f; char buff[256]; dsr theDSR; OSErr error = noErr; sprintf( buff, "%s.hdr", basename ); f = fopen( buff, "wb" ); if( !f ) { return WRITE_ERROR; } error = EmptyAnaHdr( &theDSR, "From Signa", im->dim.scanspacing, im->dim.x, im->dim.y, im->dim.n_slices, im->dim.timePts, axial ); if( error ) ILError( error, "Creating analyze header" ); if( pcByteOrder() ) { error = swapHdrBytes( &theDSR ); if( error ) ILError( error, "swapping header bytes" ); printf( "\nWARNING: Computer and data differ in byte order\n" ); } error = ck_fwrite( &theDSR, sizeof( dsr ), 1, f ); if( error ) ILError( error, buff ); ck_fclose( f ); return error; }
int main( int argc, char **argv ) { IMAGE im; dsr myDSR; short tmp; FILE *fp; char inName[256], outName[256]; OSErr error = noErr; printf( "%s - Treat times points in an analyze header as slices\n", argv[0] ); printf( "WARNING -- this tool will overwrite the original header\n" ); if( argc == 1 ) { printf( "Enter the name of an analyze image file ( xxx.img ): " ); scanf( "%s", inName ); } else { strcpy( inName, argv[1] ); } error = UC_Readheader( inName, &im ); ILError( error, "reading input header" ); tmp = im.dim.n_slices; im.dim.n_slices = im.dim.timePts; im.dim.timePts = tmp; error = dsrFromIMAGE( &im, &myDSR ); ILError( error, "Creating analyze header" ); strcpy( outName, inName ); sprintf( strrchr( outName, '.' ), ".hdr" ); printf( "Header will be overwritten to %s\n", outName ); error = ck_fopen( &fp, outName, "wb" ); ILError( error, "opening output header" ); error = ck_fwrite( &myDSR, sizeof( dsr ), 1, fp ); ILError( error, "writing analyze header" ); error = ck_fclose( fp ); ILError( error, "closing header file" ); return 0; }
OSErr MoreAnalyzeHeader( char *name ) { OSErr error = noErr; FILE *hdrFile; dsr theDSR; error = ck_fopen( &hdrFile, name, "rb" ); RETURNONERROR; error = ck_fread( &theDSR, sizeof( dsr ), 1, hdrFile ); RETURNONERROR; if( theDSR.dime.dim[0] != 4 || // check byte order consistency theDSR.hk.sizeof_hdr != sizeof( dsr ) ) { swapHdrBytes( &theDSR ); } ShowAnalyzeHeader( &theDSR, stdout, name ); error = ck_fclose( hdrFile ); return error; }
/* interpret an edit command */ static bool edit (struct line_filter *left, char const *lname, lin lline, lin llen, struct line_filter *right, char const *rname, lin rline, lin rlen, FILE *outfile) { for (;;) { int cmd0, cmd1; bool gotcmd = false; cmd1 = 0; /* Pacify `gcc -W'. */ while (! gotcmd) { if (putchar ('%') != '%') perror_fatal (_("write failed")); ck_fflush (stdout); cmd0 = skip_white (); switch (cmd0) { case '1': case '2': case 'l': case 'r': case 's': case 'v': case 'q': if (skip_white () != '\n') { give_help (); flush_line (); continue; } gotcmd = true; break; case 'e': cmd1 = skip_white (); switch (cmd1) { case '1': case '2': case 'b': case 'd': case 'l': case 'r': if (skip_white () != '\n') { give_help (); flush_line (); continue; } gotcmd = true; break; case '\n': gotcmd = true; break; default: give_help (); flush_line (); continue; } break; case EOF: if (feof (stdin)) { gotcmd = true; cmd0 = 'q'; break; } /* Fall through. */ default: flush_line (); /* Fall through. */ case '\n': give_help (); continue; } } switch (cmd0) { case '1': case 'l': lf_copy (left, llen, outfile); lf_skip (right, rlen); return true; case '2': case 'r': lf_copy (right, rlen, outfile); lf_skip (left, llen); return true; case 's': suppress_common_lines = true; break; case 'v': suppress_common_lines = false; break; case 'q': return false; case 'e': { int fd; if (tmpname) tmp = fopen (tmpname, "w"); else { if ((fd = temporary_file ()) < 0) perror_fatal ("mkstemp"); tmp = fdopen (fd, "w"); } if (! tmp) perror_fatal (tmpname); switch (cmd1) { case 'd': if (llen) { if (llen == 1) fprintf (tmp, "--- %s %ld\n", lname, (long int) lline); else fprintf (tmp, "--- %s %ld,%ld\n", lname, (long int) lline, (long int) (lline + llen - 1)); } /* Fall through. */ case '1': case 'b': case 'l': lf_copy (left, llen, tmp); break; default: lf_skip (left, llen); break; } switch (cmd1) { case 'd': if (rlen) { if (rlen == 1) fprintf (tmp, "+++ %s %ld\n", rname, (long int) rline); else fprintf (tmp, "+++ %s %ld,%ld\n", rname, (long int) rline, (long int) (rline + rlen - 1)); } /* Fall through. */ case '2': case 'b': case 'r': lf_copy (right, rlen, tmp); break; default: lf_skip (right, rlen); break; } ck_fclose (tmp); { int wstatus; int werrno = 0; ignore_SIGINT = true; checksigs (); { #if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK) char *command = xmalloc (quote_system_arg (0, editor_program) + 1 + strlen (tmpname) + 1); sprintf (command + quote_system_arg (command, editor_program), " %s", tmpname); wstatus = system (command); if (wstatus == -1) werrno = errno; free (command); #else pid_t pid; pid = vfork (); if (pid == 0) { char const *argv[3]; int i = 0; argv[i++] = editor_program; argv[i++] = tmpname; argv[i] = 0; execvp (editor_program, (char **) argv); _exit (errno == ENOENT ? 127 : 126); } if (pid < 0) perror_fatal ("fork"); while (waitpid (pid, &wstatus, 0) < 0) if (errno == EINTR) checksigs (); else perror_fatal ("waitpid"); #endif } ignore_SIGINT = false; check_child_status (werrno, wstatus, EXIT_SUCCESS, editor_program); } { char buf[SDIFF_BUFSIZE]; size_t size; tmp = ck_fopen (tmpname, "r"); while ((size = ck_fread (buf, SDIFF_BUFSIZE, tmp)) != 0) { checksigs (); ck_fwrite (buf, size, outfile); } ck_fclose (tmp); } return true; } default: give_help (); break; } } }
int main (int argc, char *argv[]) { int opt; char const *prog; exit_failure = EXIT_TROUBLE; initialize_main (&argc, &argv); program_name = argv[0]; setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); c_stack_action (cleanup); prog = getenv ("EDITOR"); if (prog) editor_program = prog; diffarg (DEFAULT_DIFF_PROGRAM); /* parse command line args */ while ((opt = getopt_long (argc, argv, "abBdEHiI:lo:stvw:W", longopts, 0)) != -1) { switch (opt) { case 'a': diffarg ("-a"); break; case 'b': diffarg ("-b"); break; case 'B': diffarg ("-B"); break; case 'd': diffarg ("-d"); break; case 'E': diffarg ("-E"); break; case 'H': diffarg ("-H"); break; case 'i': diffarg ("-i"); break; case 'I': diffarg ("-I"); diffarg (optarg); break; case 'l': diffarg ("--left-column"); break; case 'o': output = optarg; break; case 's': suppress_common_lines = true; break; case 't': diffarg ("-t"); break; case 'v': version_etc (stdout, "sdiff", PACKAGE_NAME, PACKAGE_VERSION, "Thomas Lord", (char *) 0); check_stdout (); return EXIT_SUCCESS; case 'w': diffarg ("-W"); diffarg (optarg); break; case 'W': diffarg ("-w"); break; case DIFF_PROGRAM_OPTION: diffargv[0] = optarg; break; case HELP_OPTION: usage (); check_stdout (); return EXIT_SUCCESS; case STRIP_TRAILING_CR_OPTION: diffarg ("--strip-trailing-cr"); break; case TABSIZE_OPTION: diffarg ("--tabsize"); diffarg (optarg); break; default: try_help (0, 0); } } if (argc - optind != 2) { if (argc - optind < 2) try_help ("missing operand after `%s'", argv[argc - 1]); else try_help ("extra operand `%s'", argv[optind + 2]); } if (! output) { /* easy case: diff does everything for us */ if (suppress_common_lines) diffarg ("--suppress-common-lines"); diffarg ("-y"); diffarg ("--"); diffarg (argv[optind]); diffarg (argv[optind + 1]); diffarg (0); execvp (diffargv[0], (char **) diffargv); perror_fatal (diffargv[0]); } else { char const *lname, *rname; FILE *left, *right, *out, *diffout; bool interact_ok; struct line_filter lfilt; struct line_filter rfilt; struct line_filter diff_filt; bool leftdir = diraccess (argv[optind]); bool rightdir = diraccess (argv[optind + 1]); if (leftdir & rightdir) fatal ("both files to be compared are directories"); lname = expand_name (argv[optind], leftdir, argv[optind + 1]); left = ck_fopen (lname, "r"); rname = expand_name (argv[optind + 1], rightdir, argv[optind]); right = ck_fopen (rname, "r"); out = ck_fopen (output, "w"); diffarg ("--sdiff-merge-assist"); diffarg ("--"); diffarg (argv[optind]); diffarg (argv[optind + 1]); diffarg (0); trapsigs (); #if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK) { size_t cmdsize = 1; char *p, *command; int i; for (i = 0; diffargv[i]; i++) cmdsize += quote_system_arg (0, diffargv[i]) + 1; command = p = xmalloc (cmdsize); for (i = 0; diffargv[i]; i++) { p += quote_system_arg (p, diffargv[i]); *p++ = ' '; } p[-1] = 0; errno = 0; diffout = popen (command, "r"); if (! diffout) perror_fatal (command); free (command); } #else { int diff_fds[2]; # if HAVE_WORKING_VFORK sigset_t procmask; sigset_t blocked; # endif if (pipe (diff_fds) != 0) perror_fatal ("pipe"); # if HAVE_WORKING_VFORK /* Block SIGINT and SIGPIPE. */ sigemptyset (&blocked); sigaddset (&blocked, SIGINT); sigaddset (&blocked, SIGPIPE); sigprocmask (SIG_BLOCK, &blocked, &procmask); # endif diffpid = vfork (); if (diffpid < 0) perror_fatal ("fork"); if (! diffpid) { /* Alter the child's SIGINT and SIGPIPE handlers; this may munge the parent. The child ignores SIGINT in case the user interrupts the editor. The child does not ignore SIGPIPE, even if the parent does. */ if (initial_handler (handler_index_of_SIGINT) != SIG_IGN) signal_handler (SIGINT, SIG_IGN); signal_handler (SIGPIPE, SIG_DFL); # if HAVE_WORKING_VFORK /* Stop blocking SIGINT and SIGPIPE in the child. */ sigprocmask (SIG_SETMASK, &procmask, 0); # endif close (diff_fds[0]); if (diff_fds[1] != STDOUT_FILENO) { dup2 (diff_fds[1], STDOUT_FILENO); close (diff_fds[1]); } execvp (diffargv[0], (char **) diffargv); _exit (errno == ENOENT ? 127 : 126); } # if HAVE_WORKING_VFORK /* Restore the parent's SIGINT and SIGPIPE behavior. */ if (initial_handler (handler_index_of_SIGINT) != SIG_IGN) signal_handler (SIGINT, catchsig); if (initial_handler (handler_index_of_SIGPIPE) != SIG_IGN) signal_handler (SIGPIPE, catchsig); else signal_handler (SIGPIPE, SIG_IGN); /* Stop blocking SIGINT and SIGPIPE in the parent. */ sigprocmask (SIG_SETMASK, &procmask, 0); # endif close (diff_fds[1]); diffout = fdopen (diff_fds[0], "r"); if (! diffout) perror_fatal ("fdopen"); } #endif lf_init (&diff_filt, diffout); lf_init (&lfilt, left); lf_init (&rfilt, right); interact_ok = interact (&diff_filt, &lfilt, lname, &rfilt, rname, out); ck_fclose (left); ck_fclose (right); ck_fclose (out); { int wstatus; int werrno = 0; #if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK) wstatus = pclose (diffout); if (wstatus == -1) werrno = errno; #else ck_fclose (diffout); while (waitpid (diffpid, &wstatus, 0) < 0) if (errno == EINTR) checksigs (); else perror_fatal ("waitpid"); diffpid = 0; #endif if (tmpname) { unlink (tmpname); tmpname = 0; } if (! interact_ok) exiterr (); check_child_status (werrno, wstatus, EXIT_FAILURE, diffargv[0]); untrapsig (0); checksigs (); exit (WEXITSTATUS (wstatus)); } } return EXIT_SUCCESS; /* Fool `-Wall'. */ }
int G2A (int argc, char *argv[] ) { char origname[128]; // original name char newname [128]; // renumbered name char command [255]; // command buffer char *TempName; char *numstring; char ImageName[128]; int counter = 0; int number; char *p; char nameFileName[255]; char analyzeFileName[255]; char headerFileName[255]; char baseName[255]; short verbose = true; FILE *nameFile; FILE *TempFile; FILE *dataFile; FILE *procFile; FILE *headerFile; FILE *inFile; int i; IMAGE im; short count; short *dataBuff; Boolean DebugMode = false; static char id[] = "$Revision: 1.21 $$Date: 2006/06/09 18:40:34 $"; OSErr error = noErr; if( argc < 2 ) { print_usage( argv[0] ); } // setup an output file name, based on the last input file name sprintf( baseName, "%s", argv[argc-1] ); // output file name p = strrchr( baseName, 'I' ); *p = '\0'; // null terminate error = OpenProcFile( argc, argv, baseName, id, &procFile ); ILError( error, "Opening Proc file" ); sprintf( nameFileName, "%s.NAME_FILE", baseName ); fprintf( procFile, "Associated name file ... %s\n", nameFileName ); sprintf( headerFileName, "%s.GenesisHdrs", baseName ); fprintf( procFile, "Associated headers file ... %s\n", headerFileName ); // corrected names will be stored temporarily in nameFile error = CreateTempFile( &TempFile, &TempName ); ILError( error, TempName ); // use UC_ReadHeader to determine image dimensions, etc... error = UC_Readheader( argv[argc-1], &im ); if( error ) ILError( error, "Read Image" ); // rename the files and create name list into the file called TempName for( i=argc-1; i>0; i-- ) { strcpy( origname, argv[i] ); strcpy( newname, argv[i] ); numstring = strrchr( newname, 'I' ) + 1; number = atoi( numstring ); sprintf( numstring, "%0.3d.MR", number ); fprintf( TempFile, "%s\n", newname ); if( strcmp( origname, newname ) || DebugMode ) { if( verbose ) { printf( "i:%d\t%s --> %s\n", i, origname, newname ); } sprintf( command, "mv %s %s\n", origname, newname ); fprintf( procFile, "\tRenamed %s to %s\n", origname, newname ); system( command ); } } error = ck_fclose( TempFile ); ILError( error, TempName ); // Sort the contents of the temporary nameFile and place it into the permanent version sprintf( command, "sort %s > %s", TempName, nameFileName ); system( command ); if( false ) { DBG( command ); printf( "\nContents of name file\n" ); sprintf( command, "cat %s", nameFileName ); DBG( command ); system( command ); } // now, place the name of the header file at the beginning of a file */ error = CreateTempFile( &TempFile, &TempName ); ILError ( error, TempName ); fprintf( TempFile, "%s\n", headerFileName ); error = ck_fclose( TempFile ); ILError( error, TempName ); // add the file names to the end sprintf( command, "cat %s >> %s\n", nameFileName, TempName ); system( command ); // and rename this file sprintf( command, "mv %s %s\n", TempName, nameFileName ); system( command ); if( false ) { printf( "new Contents of name file" ); sprintf( command, "cat %s", nameFileName ); DBG( command ); system( command ); } im.dim.n_slices = argc - 1; error = CreateHeader( ANALYZE, &im, baseName ); if( error ) ILError( error, "Writing Header" ); sprintf( analyzeFileName, "%s.img", baseName ); error = ck_fopen( &dataFile, analyzeFileName, "wb" ); ILError( error, "data file" ); error = ck_fopen( &nameFile, nameFileName, "rb" ); ILError( error, "name file" ); error = ck_fopen( &headerFile, headerFileName, "wb" ); ILError( error, "header file" ); if( im.dim.x * im.dim.y * sizeof(short) < SIGHDRSIZE ) { dataBuff = (short *)ck_malloc( SIGHDRSIZE, "data buffer" ); } else { dataBuff = (short *)ck_malloc( im.dim.x * im.dim.y * sizeof(short), "data buffer" ); } count = fscanf( nameFile, "%s", headerFileName ); // just read past this. count = fscanf( nameFile, "%s", ImageName ); if( false ) { DBG( ImageName ); } printf( "\n\tPatience for a moment\n" ); while( count>0 ) { printf( "%d of %d complete\n", counter++, argc - 1 ); error = ck_fopen( &inFile, ImageName, "rb" ); ILError( error, "Opening image" ); error = ck_fread ( dataBuff, sizeof( char ), SIGHDRSIZE, inFile ); ILError( error, "Reading header" ); error = ck_fwrite( dataBuff, sizeof( char ), SIGHDRSIZE, headerFile ); ILError( error, "Writing image header" ); error = ck_fread ( dataBuff, sizeof( short ), im.dim.x * im.dim.y, inFile ); ILError( error, "Reading image data" ); error = ck_fwrite( dataBuff, sizeof( short ), im.dim.x * im.dim.y, dataFile ); ILError( error, "Writing image data" ); ck_fclose( inFile ); count = fscanf( nameFile, "%s", ImageName ); } printf( "\n\nCreated Analyze (4D) file: %s\n", analyzeFileName ); printf( "\tSave these files!: %s and %s\n\n", nameFileName, headerFileName ); printf( "To create corresponding genesis images from an analyze file named XXX.img, use:\n" ); printf( "\tAnalyze2Genesis -n %s -i XXX.img\n", nameFileName ); free( dataBuff ); error = ck_fclose( headerFile ); if( error ) ILError( error, headerFileName ); error = ck_fclose( nameFile ); if( error ) ILError( error, nameFileName ); error = ck_fclose( dataFile ); if( error ) ILError( error, analyzeFileName ); error = ck_fclose( procFile ); if( error ) ILError( error, "proc file" ); return error; }
int main(int argc, char **argv) { static char id[] = "$Revision: 1.5 $$Date: 2002/09/10 22:14:51 $"; char *invec, *outvec; /* image vectors */ int timePt; short rows = 0; short cols = 0; int slices; long MultImSize; /* size of one image */ short SmallX, SmallY; /* X and Y size of single image from multi-display */ int argp=EOF; char *in_fname = NULL; char *out_basename = NULL; char out_fname[128], procfname[128]; FILE *imFile; FILE *procFile; IMAGE im; short dSize; char typeString[40]; OSErr error = noErr; while ( (argp=getopt(argc,argv,"o:i:r:c:h?")) != EOF ) { switch( argp ) { case 'o': out_basename = optarg; break; case 'i': in_fname = optarg; break; case 'c': cols = atoi( optarg ); break; case 'r': rows = atoi( optarg ); break; case 'h': case '?': default: print_usage( argv[0] ); exit( -1 ); break; } } if( !out_basename || !in_fname || !rows || !cols ) { print_usage( argv[0] ); exit(-1); } error = UC_Readheader(in_fname, &im); if( error ) { ILError( error, "Reading Header" ); } switch( im.file_type ) { case BSHORT: dSize = get_datasize( T_USHORT ); sprintf( typeString, "bshort" ); break; case BUCHAR: dSize = get_datasize( T_UCHAR ); sprintf( typeString, "buchar" ); break; case BFLOAT: dSize = get_datasize( T_FLOAT ); sprintf( typeString, "bfloat" ); break; default: ILError( DATA_OUT_OF_RANGE, "unknown type" ); } /* Parse output file name and create proc file name */ strcpy( procfname, out_basename ); MultImSize= im.dim.x*im.dim.y; SmallX = im.dim.x / cols; SmallY = im.dim.y / rows; slices = rows * cols; /* Buffer allocation */ invec = ( char *)ck_malloc( MultImSize * dSize, "image vector" ); outvec = ( char *)ck_malloc( SmallX * SmallY * slices * dSize, "output vector" ); imFile = errfopen( in_fname, "rb" ); error = OpenProcFile( argc, argv, procfname, id, &procFile ); ILError( error, "Opening Proc file" ); for( timePt = 0; timePt < im.dim.timePts; timePt++ ) { int theSlice = 0; error = UC_Readimage( imFile, &im, invec, theSlice, timePt ); if( error ) { ILError( error, "Reading image" ); } // fool unmdisplay by treating all input as char error = unmdisplay( outvec, invec, SmallX * dSize, SmallY, slices, T_UCHAR ); if( error ) { ILError( error, "unmdisplay" ); } if( im.dim.timePts > 1 ) { sprintf( out_fname, "%s.%0.3d", out_basename, timePt+1 ); } else { sprintf( out_fname, "%s", out_basename ); } fprintf( procFile, "\tCreated %s.%s\n", out_fname, typeString ); error = WriteMGHImage( outvec, out_fname, SmallX, SmallY, (short)slices, im.data_type ); if( error ) { ILError( error, "Writing output image" ); } } error = ck_fclose( imFile ); if( error ) ILError( error, "input file" ); error = ck_fclose( procFile ); if( error ) ILError( error, "proc file" ); free( outvec ); free( invec ); return 0; }
OSErr RunMain( int argc, char **argv, char *id ) { OSErr error = noErr; error = InitializeUserVariables(); RETURNONERROR; error = ProcessCommandLine( argc, argv ); RETURNONERROR; error = OpenProcFile( argc, argv, u.OutFileName, id, &u.ProcFile ); RETURNONERROR; /* read in the input image header */ error = UC_Readheader( u.InFileName, &u.inIm ); RETURNONERROR; memcpy( &u.outIm, &u.inIm, sizeof( IMAGE )); // copy the input header to the output header u.inIm.data_type = T_FLOAT; // all operations on float error = OutBaseNameFromOutName( u.OutFileName, u.OutBaseName ); RETURNONERROR; error = ck_fopen( &u.inFile, u.InFileName, "rb" ); RETURNONERROR; error = ck_fopen( &u.TEFile, u.TEFileName, "r" ); RETURNONERROR; error = FindOutputType( u.OutFileName, &u.outIm.file_type, &u.outIm.data_type ); RETURNONERROR; // Only floating point output types can be supported at this time. if( u.outIm.file_type == ANALYZE ) { u.outIm.data_type = T_FLOAT; } if( u.outIm.data_type != T_FLOAT ) { printf( "Only floating point output types are accepted\n" ); return 0; } error = ck_fopen( &u.outFile, u.OutFileName, "wb" ); RETURNONERROR; /* do something */ error = T2Fit( u.inFile, u.outFile ); RETURNONERROR; error = ck_fclose( u.TEFile ); RETURNONERROR; error = ck_fclose( u.inFile ); RETURNONERROR; error = ck_fclose( u.outFile ); RETURNONERROR; /* Change elements of output IMAGE (e.g., number of images/slices/timePts ) */ error = AdjustOutputIMAGE( &u.outIm ); RETURNONERROR; error = CreateHeader( u.outIm.file_type, &u.outIm, u.OutBaseName ); RETURNONERROR; /* dump processing file contents */ ck_fclose( u.ProcFile ); return error; }
int main( int argc, char **argv) { /* sample command lines -i bdv.bshort -o junk.bshort -V -# 16 */ OSErr error = noErr; static char id[] = "$Revision: 1.2 $$Date: 2002/09/10 22:06:02 $"; char headerName[ NAME_SIZE ]; char *extension; char ofName[ NAME_SIZE ]; int OutOrder; error = ProcessCommandLine( argc, argv ); ILError( error, "error in command line" ); extension = strrchr( u.InFileName, '.' ); if( !strlen(extension) ) { printf( "Input file name error\n" ); return 0; } if( !equalString( extension, ".bfloat" )) { printf( "This utility works only on bfloat images!\n" ); return 0; } // strcpy( headerName, u.InFileName, NAME_SIZE ); strcpy( headerName, u.InFileName ); //zrinka 09/10/02 extension = strrchr( headerName, '.' ); if( !strlen(extension) ) { printf( "Input file name error\n" ); return 0; } sprintf( extension, ".hdr" ); u.inFile = errfopen( headerName, "r" ); fscanf( u.inFile, "%d%d%d%d", &u.id.ys, &u.id.xs, &u.id.zs, &u.id.ByteOrder ); // error = ck_fclose( u.inFile, "input header" ); error = ck_fclose( u.inFile ); //zrinka 09/10/02 u.inFile = errfopen( u.InFileName, "rb" ); strcpy( ofName, u.OutFileName ); strcat( ofName, ".bfloat" ); u.outFile = errfopen( ofName, "wb" ); error = DoSwap( u.inFile, u.outFile ); ILError( error, argv[0] ); error = ck_fclose( u.inFile ); ILError( error, "infile" ); error = ck_fclose( u.outFile ); ILError( error, "infile" ); strcpy( ofName, u.OutFileName ); strcat( ofName, ".hdr" ); u.outFile = errfopen( ofName, "w" ); if( u.id.ByteOrder == 1 ) { // pc-dec bytOrder OutOrder = 0; } else { OutOrder = 1; } fprintf( u.outFile, "%d %d %d %d", u.id.ys, u.id.xs, u.id.zs, OutOrder ); error = ck_fclose( u.outFile ); ILError( error, "main" ); }