ana2ecat.c

Go to the documentation of this file.

/*****************************************************************************/
#include "tpcclibConfig.h"
/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#ifdef HAVE_DIRECT_H
#include <direct.h>
#endif
/*****************************************************************************/
#include "libtpcmisc.h"
#include "libtpcimgio.h"
#include "libtpcimgp.h"
/*****************************************************************************/
 
/*****************************************************************************/
/* Local functions */
int imgAnalyzeToEcat(
  char *dbname, char *ecatfile, int flipping, int scanner_type, float zoom,
  int verbose
);
/*****************************************************************************/
 
/*****************************************************************************/
static char *info[] = {
  "Conversion of Analyze 7.5 database(s) to ECAT 7 image volume or ECAT 6.3",
  "image format.",
  " ",
  "Usage: @P [Options] database",
  " ",
  "Options:",
  " -7 or -6",
  "     Images are written in ECAT 7 (default) or 6.3 format.",
  " -O=<output path>",
  "     Data directory for ECAT images; by default current working directory.",
  " -flip=<y|n>",
  "     Override the default and environment variable ANALYZE_FLIP setting",
  "     by always flipping/not flipping image in z-direction (planes).",
  "     If environment variable is not set, then default is y.",
  "     Images are always flipped in x,y-directions.",
  " -stdoptions", // List standard options like --help, -v, etc
  " ",
  "Analyze database can be specified as a path, or filename without extension.",
  "Program reads time frame information from SIF, if SIF is located in",
  "the Analyze database directory and if file is named with *.sif extension.",
  " ",
  "Example:",
  "Conversion of all Analyze files in directory S:\\temp\\neuro to ECAT 7",
  "images in directory C:\\data in PC/Windows:",
  "   C:",
  "   cd \\data",
  "   @P s:\\temp\\neuro",
  " ",
  "Specific extensions to Analyze 7.5 format:",
  " -Scale factor to retain quantitation in image_dimension.funused1",
  " -Isotope halflife (sec) in image_dimension.funused3;",
  "  this does not imply whether data is corrected for decay or not.",
  " -String in data_history.descrip tells whether data is corrected for decay;",
  "  'Decay corrected.' or 'No decay correction.'",
  " ",
  "See also: ecat2ana, eframe, sif2ecat, e7emhdr, e7evhdr, flat2img, nii2ecat",
  " ",
  "Keywords: image, format conversion, ECAT, Analyze",
  0};
/*****************************************************************************/
 
/*****************************************************************************/
/* Turn on the globbing of the command line, since it is disabled by default in
   mingw-w64 (_dowildcard=0); in MinGW32 define _CRT_glob instead, if necessary;
   In Unix&Linux wildcard command line processing is enabled by default. */
/*
#undef _CRT_glob
#define _CRT_glob -1
*/
int _dowildcard = -1;
/*****************************************************************************/
 
/*****************************************************************************/
int main(int argc, char **argv)
{
  int      ai, help=0, version=0, verbose=1;
  int      ret, n, errorNr=0, flipping, anaNr=0;
  int      scanner_type=0, outFormat=7;
  float    zoom=-1.0;
  char     ecatdir[FILENAME_MAX], dbdir[FILENAME_MAX], ecatfile[FILENAME_MAX];
  char     temp[FILENAME_MAX], dbname[FILENAME_MAX], *cptr;
  DIR     *dp;
  struct dirent *de;
 
 
  /*
   *  Get arguments
   */
  if(argc==1) {tpcPrintUsage(argv[0], info, stderr); return(1);}
  ecatdir[0]=dbdir[0]=ecatfile[0]=(char)0;
  flipping=anaFlipping();
  /* Options */
  for(ai=1; ai<argc; ai++) if(*argv[ai]=='-') { /* options */
    cptr=argv[ai]+1; if(*cptr=='-') cptr++; if(cptr==NULL) continue;
    if(tpcProcessStdOptions(argv[ai], &help, &version, &verbose)==0) continue;
    if(strncasecmp(cptr, "FLIP=", 5)==0) {
      cptr+=5; if(*cptr=='n' || *cptr=='N') {flipping=0; continue;}
      else if(*cptr=='y' || *cptr=='Y') {flipping=1; continue;}
    } else if(strncasecmp(cptr, "ZOOM=", 5)==0) {
      cptr+=5; zoom=atof_dpi(cptr); if(zoom>0.0) continue;
    } else if(strncmp(cptr, "7", 1)==0) {
      outFormat=7; continue;
    } else if(strncmp(cptr, "6", 1)==0) {
      outFormat=6; continue;
    } else if(strncasecmp(cptr, "SCANNER=", 8)==0) {
      cptr+=8; 
      if(*cptr=='9') {scanner_type=SCANNER_ECAT931; continue;}
      if(*cptr=='A' || *cptr=='a') {scanner_type=SCANNER_ADVANCE; continue;}
      if(strcasecmp(cptr, "HRRT")==0) {
        scanner_type=SCANNER_HRRT;
        fprintf(stderr, "Warning: HRRT not fully supported.\n");
        continue;
      }
      if(strncasecmp(cptr, "HR", 2)==0) {scanner_type=SCANNER_HRPLUS; continue;}
    } else if(strncasecmp(cptr, "O=", 2)==0) {
      cptr+=2;
      if(strlen(cptr)>0) strcpy(ecatdir, cptr); else strcpy(ecatdir, ".");
      continue;
    }
    fprintf(stderr, "Error: invalid option '%s'\n", argv[ai]);
    return(1);
 
  } else break;
  
  /* Print help or version? */
  if(help==2) {tpcHtmlUsage(argv[0], info, ""); return(0);}
  if(help) {tpcPrintUsage(argv[0], info, stdout); return(0);}
  if(version) {tpcPrintBuild(argv[0], stdout); return(0);}
 
  /* Process other arguments, starting from the first non-option */
  for(; ai<argc; ai++) {
    if(!dbdir[0]) {
      strcpy(dbdir, argv[ai]); continue;
    }
    fprintf(stderr, "Error: invalid argument '%s'\n", argv[ai]);
    return(1);
  }
 
  /* Is something missing? */
  if(!dbdir[0]) {
    fprintf(stderr, "Error: Analyze database was not given."); 
    return(1);
  }
  /* Output path is current working path by default */
  if(!ecatdir[0]) strcpy(ecatdir, ".");
 
  /* In verbose mode print arguments and options */
  if(verbose>1) {
    printf("flipping := %d\n", flipping);
    printf("zoom := %g\n", zoom);
    printf("scanner_type := %d\n", scanner_type);
    printf("outFormat := %d\n", outFormat);
    printf("ecatdir := %s\n", ecatdir);
  }
  if(verbose>2) IMG_TEST=ANALYZE_TEST=verbose-2; else IMG_TEST=ANALYZE_TEST=0;
  if(verbose>0) {
    if(flipping==0) printf("image(s) will not be flipped in z-direction.\n");
    else printf("image(s) will be flipped in z-direction.\n");
  }
 
 
  /*
   *  Create output directory, if necessary
   */
  if(ecatdir[0]) {
    if(access(ecatdir, 0) == -1) {
      if(verbose>0) fprintf(stdout, "Creating subdirectory %s\n", ecatdir);
#ifdef HAVE_MKDIR2
      ret=mkdir(ecatdir, 00775);
#elif defined HAVE_MKDIR1
      ret=mkdir(ecatdir);
#elif defined HAVE__MKDIR
      ret=_mkdir(ecatdir);
#else
      ret=1;
#endif
      if(ret!=0) {
        fprintf(stderr, "Error: cannot created subdirectory.\n");
        return(2);
      }
    }
  } else strcpy(ecatdir, ".");
 
 
  /*
   *  Read and convert Analyze images
   */
  dp=opendir(dbdir);
  
  if(dp==NULL) {
    /* This is not a directory, or there is no read permission */
    /* Check if this is an Analyze database name with or without extension */
    strcpy(dbname, dbdir); anaRemoveFNameExtension(dbname);
    if(anaExists(dbname)==0) {
      fprintf(stderr, "Error: cannot open Analyze image or directory %s\n",
              dbdir);
      return(3);
    }
    /* Check that this is not actually NIfTI */
    ret=niftiExists(dbname, NULL, NULL, NULL, NULL, 0, NULL);
    if(ret!=0) {
      fprintf(stderr, "Error: %s contains NIfTI, not Analyze image\n", dbdir);
      return(3);
    }
    /* It seems to be an Analyze file, so proceed with conversion */
 
    /*
     *  Make ECAT filename
     */
    cptr=strrchr(dbname, '/'); if(cptr==NULL) cptr=strrchr(dbname, '\\');
    if(cptr!=NULL) cptr++; else cptr=dbname;
#ifdef WIN32
    snprintf(ecatfile, FILENAME_MAX, "%s\\%s", ecatdir, cptr);
#else
    snprintf(ecatfile, FILENAME_MAX, "%s/%s", ecatdir, cptr);
#endif
    if(outFormat==6) strcat(ecatfile, ".img"); else strcat(ecatfile, ".v");
    if(verbose>2) printf("  ECAT filename: '%s'\n", ecatfile);
    /* Check if file exists: ECAT 6.3 file (without .hdr) can be overwritten,
       but existing Analyze file (.img with .hdr) should lead to an error */
    strcpy(temp, ecatfile); anaRemoveFNameExtension(temp);
    if(anaExists(temp)) {
      fprintf(stderr, "  Error: %s would be overwritten.\n", ecatfile);
      fprintf(stdout, "  No conversion is done for %s\n", dbname);
      fflush(stdout); fflush(stderr);
      errorNr++; return(4);
    }
    /* Remove existing ECAT file */
    if(access(ecatfile, 0)!=-1 && remove(ecatfile)!=0) {
      fprintf(stderr, "Error: cannot overwrite %s\n", ecatfile);
      errorNr++; return(5);      
    }
 
 
    /*
     *  Read Analyze file and write ECAT image frame-by-frame
     */
    if(verbose>0) fprintf(stdout, "%s :\n", dbname);
    anaNr++;
    if(verbose>0) printf("  processing Analyze image\n");
    ret=imgAnalyzeToEcat(dbname, ecatfile, flipping, scanner_type, zoom, 
                         verbose-1);
    if(ret!=STATUS_OK) {
      fprintf(stderr, "Error: %s\n", imgStatus(ret)); //if(TEST) imgInfo(&img);
      return(11);
    }
    if(verbose>0)
      fprintf(stdout, "  Image saved in ECAT format in %s\n", ecatfile);
    return(0); // finished.
  }
 
 
  /* Directory was previously opened succesfully: */
  /* Conversion of all Analyzes images in the specified path */
  while((de=readdir(dp))!=NULL) {
    if(verbose>6) printf("'%s'\n", de->d_name);
    /* Remove trailing slashes */
    ret=strlen(dbdir)-1;
    if(dbdir[ret]=='/' || dbdir[ret]=='\\') dbdir[ret]=(char)0;
 
    /*
     *  Make Analyze database name
     */
    /* Check that filename extension is .hdr */
    n=strlen(de->d_name);
    if(n<5 || strcmp((de->d_name)+n-4, ".hdr")!=0) continue;
    /* Make Analyze database name */
    strcpy(temp, de->d_name); temp[n-4]=(char)0;
#ifdef WIN32
    snprintf(dbname, FILENAME_MAX, "%s\\%s", dbdir, temp);
#else
    snprintf(dbname, FILENAME_MAX, "%s/%s", dbdir, temp);
#endif
    /* Check that Analyze database exists (also .img) */
    if(anaExists(dbname)==0) continue;
    if(verbose>0) fprintf(stdout, "%s :\n", dbname); 
    anaNr++;
    /* Check that this is not actually NIfTI */
    ret=niftiExists(dbname, NULL, NULL, NULL, NULL, 0, NULL);
    if(ret!=0) {
      fprintf(stderr, "  Error: %s is NIfTI image\n", dbname);
      continue;
    }
 
    /*
     *  Make ECAT filename
     */
#ifdef WIN32
    snprintf(ecatfile, FILENAME_MAX, "%s\\%s", ecatdir, temp);
#else
    snprintf(ecatfile, FILENAME_MAX, "%s/%s", ecatdir, temp);
#endif
    if(outFormat==6) strcat(ecatfile, ".img"); else strcat(ecatfile, ".v");
    if(verbose>1) printf("  ECAT filename: '%s'\n", ecatfile);
    
    
    /* Check if file exists: ECAT 6.3 file (without .hdr) can be overwritten,
       but existing Analyze file (.img with .hdr) should lead to an error */
    strcpy(temp, ecatfile); anaRemoveFNameExtension(temp);
    if(anaExists(temp)) {
      fprintf(stderr, "  Error: %s would be overwritten.\n", ecatfile);
      fprintf(stdout, "  No conversion is done for %s\n", dbname);
      fflush(stdout); fflush(stderr);
      errorNr++; continue;
    }
    
    /* Remove existing ECAT file */
    if(access(ecatfile, 0)!=-1 && remove(ecatfile)!=0) {
      fprintf(stderr, "Error: cannot overwrite %s\n", ecatfile);
      errorNr++; continue;      
    }
 
    /*
     *  Read Analyze file and write ECAT image frame-by-frame
     */
    if(verbose>0) printf("  processing Analyze image\n");
    ret=imgAnalyzeToEcat(dbname, ecatfile, flipping, scanner_type, zoom, 
                         verbose-1);
    if(ret!=STATUS_OK) {
      fprintf(stderr, "Error: %s\n", imgStatus(ret)); //if(TEST) imgInfo(&img);
      errorNr++; continue;
    }
    if(verbose>0)
      fprintf(stdout, "  Image saved in ECAT format in %s\n", ecatfile);
 
  } /* next Analyze image */
  closedir(dp);
  if(anaNr==0) {
    fprintf(stderr, "Error: no Analyze files were found in %s\n", dbdir);
    return(2);
  }
 
  return(errorNr);
}
/*****************************************************************************/
 
/*****************************************************************************/

int imgAnalyzeToEcat(
  char *dbname,
  char *ecatfile,
  int flipping,
  int scanner_type,
  float zoom,
  int verbose
) {
  IMG img;
  int zi, fi, ret, file_format=0;
 
  if(verbose>0) printf("\nimgAnalyzeToEcat(%s, %s)\n", dbname, ecatfile);
  /* Check the arguments */
  if(dbname==NULL || ecatfile==NULL) return STATUS_FAULT;
 
  /* Read the first frame */
  imgInit(&img); fi=0;
  ret=imgReadAnalyzeFirstFrame(dbname, &img);
  if(ret!=STATUS_OK) {imgEmpty(&img); return ret;}
  do {
    fi++;
    if(verbose>1) printf("    frame %d\n", fi);
    /* Set header information */
    if(fi==0) // must be saved for reading next frame
      file_format=img._fileFormat;
    if(scanner_type>0) imgSetScanner(&img, scanner_type);
    if(zoom>0.0) img.zoom=zoom;
    for(zi=0; zi<img.dimz; zi++) img.planeNumber[zi]=zi+1;
    if(verbose>10) imgInfo(&img);
    if(flipping!=anaFlipping()) imgFlipPlanes(&img);
    /* Write the frame in ECAT format */
    img._fileFormat=0;
    ret=imgWriteFrame(ecatfile, fi, &img, 0); //printf("ret := %d\n", ret);
    if(ret!=STATUS_OK) break;
    if(verbose>2) printf("    frame written.\n");
    /* Try to read the next frame */
    img._fileFormat=file_format;
    ret=imgReadAnalyzeFrame(dbname, fi+1, &img, 0);
  } while(ret==0);
  imgEmpty(&img);
  if(verbose>0 && ret==STATUS_NOMATRIX) {
    fprintf(stdout, "  %d frame(s) processed.\n", fi);
  }
  if(ret!=STATUS_OK && ret!=STATUS_NOMATRIX) {
    remove(ecatfile); return ret;
  }
  /*if(verbose>2)
    fprintf(stdout, "  Image saved in ECAT format in %s\n", ecatfile);*/
  return STATUS_OK;
}
/*****************************************************************************/
 
/*****************************************************************************/