c_nifti 0.0.1

data/ext/nifticlib/nifticlib-2.0.0/utils/nifti_tool.h

@@ -0,0 +1,163 @@
+#ifndef _NIFTI_TOOL_H_
+#define _NIFTI_TOOL_H_
+
+#define NT_CMD_LEN 2048
+
+typedef struct{
+   int     len;
+   char ** list;
+} str_list;
+
+typedef struct{
+   int     len;
+   int   * list;
+} int_list;
+
+typedef struct{
+            /* action options (flags) */
+   int      check_hdr,  check_nim;
+   int      diff_hdr,   diff_nim;
+   int      disp_hdr,   disp_nim, disp_ana;
+   int      disp_exts,  add_exts, rm_exts;
+   int      mod_hdr,    mod_nim;
+   int      swap_hdr,   swap_ana, swap_old;
+
+   int      strip;               /* strip extras from dataset(s)  */
+   int      cbl, cci;            /* -copy_XXX option flags        */
+   int      dts, dci, dci_lines; /* display collapsed img flags   */
+   int      make_im;             /* create a new image on the fly */
+   int      ci_dims[8];          /* user dims list (last 7 valid) */
+   int      new_dim[8];          /* user dim list for new image   */
+   int      new_datatype;        /* datatype for new image        */
+   int      debug, keep_hist;    /* debug level and history flag  */
+   int      overwrite;           /* overwrite flag                */
+   char *   prefix;              /* for output file               */
+   str_list elist;               /* extension strings             */
+   int_list etypes;              /* extension type list           */
+   str_list flist;               /* fields (to display or modify) */
+   str_list vlist;               /* values (to set fields to)     */
+   str_list infiles;             /* input files                   */
+   char     command[NT_CMD_LEN]; /* for inserting the command     */
+} nt_opts;
+
+#define USE_SHORT      1
+#define USE_FULL       2
+#define USE_HIST       3
+#define USE_FIELD_HDR  4
+#define USE_FIELD_NIM  5
+#define USE_FIELD_ANA  6
+#define USE_DTYPES     7
+#define USE_VERSION    8
+
+#define CHECK_NEXT_OPT(n,m,str)                                       \
+   do { if ( (n) >= (m) ) {                                           \
+           fprintf(stderr,"** option '%s': missing parameter\n",str); \
+           fprintf(stderr,"   consider: 'nifti_tool -help'\n");       \
+           return 1;      }                                           \
+      } while(0)
+
+#define CHECK_NEXT_OPT_MSG(n,m,str,msg)                               \
+   do { if ( (n) >= (m) ) {                                           \
+           fprintf(stderr,"** option '%s': %s\n",str,msg);            \
+           fprintf(stderr,"   consider: 'nifti_tool -help'\n");       \
+           return 1;      }                                           \
+      } while(0)
+
+/*----------------------------------------------------------------------
+ * this structure and definitions will be used to process the nifti_1_header
+ * and nifti_image structure fields (actions disp, diff, mod)
+ *----------------------------------------------------------------------*/
+
+#define NT_FIELD_NAME_LEN  20       /* more than length of longest name */
+#define NT_HDR_NUM_FIELDS  43       /* in the nifti_1_header struct     */
+#define NT_ANA_NUM_FIELDS  47       /* in the  nifti_analyze75 struct   */
+#define NT_NIM_NUM_FIELDS  63       /* in the nifti_image struct        */
+#define NT_DT_STRING      -0xfff    /* some strange number to abuse...  */
+#define NT_DT_POINTER     -0xfef    /* some strange number to abuse...  */
+#define NT_DT_CHAR_PTR    -0xfee    /* another...                       */
+#define NT_DT_EXT_PTR     -0xfed    /* and another...                   */
+
+typedef struct {
+   int  type;                    /* one of the DT_* types from nifti1.h */
+   int  offset;                  /* bytes from the start of the struct  */
+   int  size;                    /* size of one element type            */
+   int  len;                     /* number of elements                  */
+   char name[NT_FIELD_NAME_LEN]; /* actual structure name used          */
+} field_s;
+
+/* for computing the offset from the start of the struct */
+#define NT_OFF(str,field) ((int)( ((char *)&str.field) - ((char *)&str) ))
+
+/* call fill_field() for a single type, name and number of elements */
+/* nstr is the base struct, and fldp is a field pointer */
+#define NT_SFILL(nstr,fldp,type,name,num,rv) do{                   \
+           rv=fill_field(fldp,type,NT_OFF(nstr,name),num,#name);   \
+           fldp++; } while (0)
+
+#define NT_MAKE_IM_NAME "MAKE_IM"
+
+/*----------------------------------------------------------------------*/
+/*-----  prototypes  ---------------------------------------------------*/
+/*----------------------------------------------------------------------*/
+int    act_add_exts   ( nt_opts * opts );
+int    act_cbl        ( nt_opts * opts );  /* copy brick list */
+int    act_cci        ( nt_opts * opts );  /* copy collapsed dimensions */
+int    act_check_hdrs ( nt_opts * opts );  /* check for valid hdr or nim */
+int    act_diff_hdrs  ( nt_opts * opts );
+int    act_diff_nims  ( nt_opts * opts );
+int    act_disp_ci    ( nt_opts * opts );  /* display general collapsed data */
+int    act_disp_exts  ( nt_opts * opts );
+int    act_disp_hdrs  ( nt_opts * opts );
+int    act_disp_nims  ( nt_opts * opts );
+int    act_disp_anas  ( nt_opts * opts );
+int    act_disp_ts    ( nt_opts * opts );  /* display time series */
+int    act_mod_hdrs   ( nt_opts * opts );
+int    act_mod_nims   ( nt_opts * opts );
+int    act_swap_hdrs  ( nt_opts * opts );
+int    act_rm_ext     ( nt_opts * opts );
+int    act_strip      ( nt_opts * opts );  /* strip extras from datasets */
+
+
+field_s * get_hdr_field( char * fname, int show_fail );
+field_s * get_nim_field( char * fname, int show_fail );
+char    * field_type_str (int type);
+
+int diff_hdrs     (nifti_1_header *s0, nifti_1_header *s1, int display);
+int diff_hdrs_list(nifti_1_header *s0, nifti_1_header *s1, str_list *slist,
+                   int display);
+int diff_nims     (nifti_image *s0,nifti_image *s1,        int display);
+int diff_nims_list(nifti_image *s0,nifti_image *s1,str_list *slist,int display);
+
+int add_int          (int_list * ilist, int val);
+int add_string       (str_list * slist, char * str);
+int check_total_size (char *mesg, field_s *fields, int nfields, int tot_size);
+int clear_float_zeros( char * str );
+int diff_field       (field_s *fieldp, void * str0, void * str1, int nfields);
+int disp_nifti1_extension(char *mesg, nifti1_extension * ext, int maxlen);
+int disp_field       (char *mesg,field_s *fp,void *str,int nfields,int header);
+int disp_field_s_list(char * mesg, field_s *, int nfields);
+int disp_nt_opts     (char * mesg, nt_opts * opts);
+int disp_raw_data    (void * data, int type, int nvals, char space,int newline);
+int fill_cmd_string  (nt_opts * opts, int argc, char * argv[]);
+int fill_field       (field_s *fp, int type, int offset, int num, char *name);
+int fill_hdr_field_array(field_s * nh_fields);
+int fill_nim_field_array(field_s * nim_fields);
+int fill_ana_field_array(field_s * ah_fields);
+int modify_all_fields(void *basep, nt_opts *opts, field_s *fields, int flen);
+int modify_field     (void * basep, field_s * field, char * data);
+int process_opts     (int argc, char * argv[], nt_opts * opts);
+int remove_ext_list  (nifti_image * nim, char ** elist, int len);
+int usage            (char * prog, int level);
+int use_full         (char * prog);
+int verify_opts      (nt_opts * opts, char * prog);
+int write_hdr_to_file(nifti_1_header * nhdr, char * fname);
+
+/* wrappers for nifti reading functions (allow MAKE_IM) */
+nifti_image    * nt_image_read (nt_opts * opts, char * fname, int doread);
+nifti_image    * nt_read_bricks(nt_opts * opts, char * fname, int len,
+                                int * list, nifti_brick_list * NBL);
+nifti_1_header * nt_read_header(nt_opts * opts, char * fname, int * swapped,
+                                int check);
+
+
+#endif  /* _NIFTI_TOOL_H_ */

data/ext/nifticlib/nifticlib-2.0.0/znzlib/CMakeLists.txt

@@ -0,0 +1,31 @@
+#File Generated by Hans J. Johnson
+#Please contact hans-johnson@uiowa.edu for making enhancments/corrections
+PROJECT(ZNZLIB)
+SET(ZNZLIB_SRC znzlib.c)
+INCLUDE_REGULAR_EXPRESSION("^.*$")
+
+SET(NIFTI_ZNZLIB_NAME ${PACKAGE_PREFIX}znz)
+
+ADD_LIBRARY(${NIFTI_ZNZLIB_NAME} ${ZNZLIB_SRC} )
+TARGET_LINK_LIBRARIES( ${NIFTI_ZNZLIB_NAME} ${NIFTI_ZLIB_LIBRARIES} )
+
+# Set library version if building shared libs.
+IF (BUILD_SHARED_LIBS)
+  SET_TARGET_PROPERTIES(${NIFTI_ZNZLIB_NAME} PROPERTIES ${NIFTI_LIBRARY_PROPERTIES})
+ENDIF (BUILD_SHARED_LIBS)
+
+
+IF(NOT NIFTI_INSTALL_NO_LIBRARIES)
+  INSTALL(TARGETS ${NIFTI_ZNZLIB_NAME}
+    RUNTIME DESTINATION ${NIFTI_INSTALL_BIN_DIR} COMPONENT RuntimeLibraries
+    LIBRARY DESTINATION ${NIFTI_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
+    ARCHIVE DESTINATION ${NIFTI_INSTALL_LIB_DIR} COMPONENT Development)
+ENDIF(NOT NIFTI_INSTALL_NO_LIBRARIES)
+
+IF(NOT NIFTI_INSTALL_NO_DEVELOPMENT)
+  FILE(GLOB __files "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
+  INSTALL(FILES ${__files}
+    DESTINATION ${NIFTI_INSTALL_INCLUDE_DIR}
+    COMPONENT Development)
+ENDIF(NOT NIFTI_INSTALL_NO_DEVELOPMENT)
+

data/ext/nifticlib/nifticlib-2.0.0/znzlib/Makefile

@@ -0,0 +1,33 @@
+include ../Makefile
+
+PROJNAME = znzlib
+
+INCFLAGS = $(ZLIB_INC)
+
+SRCS=znzlib.c
+OBJS=znzlib.o
+
+TESTXFILES = testprog
+
+depend:	
+	$(RM) -f depend.mk
+	$(MAKE) depend.mk
+
+depend.mk:
+	$(CC) $(DEPENDFLAGS) $(INCFLAGS) $(SRCS) >> depend.mk
+
+lib: libznz.a
+
+test: $(TESTXFILES)
+
+znzlib.o: znzlib.c znzlib.h
+	$(CC) -c $(CFLAGS) $(USEZLIB) $(INCFLAGS) $<
+
+libznz.a: $(OBJS)
+	$(AR) -r libznz.a $(OBJS)
+	$(RANLIB) $@
+
+testprog: libznz.a testprog.c
+	$(CC) $(CFLAGS) $(LDFLAGS) -o testprog testprog.c $(ZLIB_LIBS)
+
+include depend.mk

data/ext/nifticlib/nifticlib-2.0.0/znzlib/znzlib.c

@@ -0,0 +1,322 @@
+/** \file znzlib.c
+    \brief Low level i/o interface to compressed and noncompressed files.
+        Written by Mark Jenkinson, FMRIB
+
+This library provides an interface to both compressed (gzip/zlib) and
+uncompressed (normal) file IO.  The functions are written to have the
+same interface as the standard file IO functions.
+
+To use this library instead of normal file IO, the following changes
+are required:
+ - replace all instances of FILE* with znzFile
+ - change the name of all function calls, replacing the initial character
+   f with the znz  (e.g. fseek becomes znzseek)
+   one exception is rewind() -> znzrewind()
+ - add a third parameter to all calls to znzopen (previously fopen)
+   that specifies whether to use compression (1) or not (0)
+ - use znz_isnull rather than any (pointer == NULL) comparisons in the code
+   for znzfile types (normally done after a return from znzopen)
+ 
+NB: seeks for writable files with compression are quite restricted
+
+ */
+
+#include "znzlib.h"
+
+/*
+znzlib.c  (zipped or non-zipped library)
+
+*****            This code is released to the public domain.            *****
+
+*****  Author: Mark Jenkinson, FMRIB Centre, University of Oxford       *****
+*****  Date:   September 2004                                           *****
+
+*****  Neither the FMRIB Centre, the University of Oxford, nor any of   *****
+*****  its employees imply any warranty of usefulness of this software  *****
+*****  for any purpose, and do not assume any liability for damages,    *****
+*****  incidental or otherwise, caused by any use of this document.     *****
+
+*/
+
+
+/* Note extra argument (use_compression) where 
+   use_compression==0 is no compression
+   use_compression!=0 uses zlib (gzip) compression
+*/
+
+znzFile znzopen(const char *path, const char *mode, int use_compression)
+{
+  znzFile file;
+  file = (znzFile) calloc(1,sizeof(struct znzptr));
+  if( file == NULL ){
+     fprintf(stderr,"** ERROR: znzopen failed to alloc znzptr\n");
+     return NULL;
+  }
+
+  file->nzfptr = NULL;
+
+#ifdef HAVE_ZLIB
+  file->zfptr = NULL;
+
+  if (use_compression) {
+    file->withz = 1;
+    if((file->zfptr = gzopen(path,mode)) == NULL) {
+        free(file);
+        file = NULL;
+    }
+  } else {
+#endif
+
+    file->withz = 0;
+    if((file->nzfptr = fopen(path,mode)) == NULL) {
+      free(file);
+      file = NULL;
+    }
+
+#ifdef HAVE_ZLIB
+  }
+#endif
+
+  return file;
+}
+
+
+znzFile znzdopen(int fd, const char *mode, int use_compression)
+{
+  znzFile file;
+  file = (znzFile) calloc(1,sizeof(struct znzptr));
+  if( file == NULL ){
+     fprintf(stderr,"** ERROR: znzdopen failed to alloc znzptr\n");
+     return NULL;
+  }
+#ifdef HAVE_ZLIB
+  if (use_compression) {
+    file->withz = 1;
+    file->zfptr = gzdopen(fd,mode);
+    file->nzfptr = NULL;
+  } else {
+#endif
+    file->withz = 0;
+#ifdef HAVE_FDOPEN
+    file->nzfptr = fdopen(fd,mode);
+#endif
+#ifdef HAVE_ZLIB
+    file->zfptr = NULL;
+  };
+#endif
+  return file;
+}
+
+
+int Xznzclose(znzFile * file)
+{
+  int retval = 0;
+  if (*file!=NULL) {
+#ifdef HAVE_ZLIB
+    if ((*file)->zfptr!=NULL)  { retval = gzclose((*file)->zfptr); }
+#endif
+    if ((*file)->nzfptr!=NULL) { retval = fclose((*file)->nzfptr); }
+                                                                                
+    free(*file);
+    *file = NULL;
+  }
+  return retval;
+}
+
+
+/* we already assume ints are 4 bytes */
+#undef ZNZ_MAX_BLOCK_SIZE
+#define ZNZ_MAX_BLOCK_SIZE (1<<30)
+
+size_t znzread(void* buf, size_t size, size_t nmemb, znzFile file)
+{
+  size_t     remain = size*nmemb;
+  char     * cbuf = (char *)buf;
+  unsigned   n2read;
+  int        nread;
+
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) {
+    /* gzread/write take unsigned int length, so maybe read in int pieces
+       (noted by M Hanke, example given by M Adler)   6 July 2010 [rickr] */
+    while( remain > 0 ) {
+       n2read = (remain < ZNZ_MAX_BLOCK_SIZE) ? remain : ZNZ_MAX_BLOCK_SIZE;
+       nread = gzread(file->zfptr, (void *)cbuf, n2read);
+       if( nread < 0 ) return nread; /* returns -1 on error */
+
+       remain -= nread;
+       cbuf += nread;
+
+       /* require reading n2read bytes, so we don't get stuck */
+       if( nread < (int)n2read ) break;  /* return will be short */
+    }
+
+    /* warn of a short read that will seem complete */
+    if( remain > 0 && remain < size )
+       fprintf(stderr,"** znzread: read short by %u bytes\n",(unsigned)remain);
+
+    return nmemb - remain/size;   /* return number of members processed */
+  }
+#endif
+  return fread(buf,size,nmemb,file->nzfptr);
+}
+
+size_t znzwrite(const void* buf, size_t size, size_t nmemb, znzFile file)
+{
+  size_t     remain = size*nmemb;
+  char     * cbuf = (char *)buf;
+  unsigned   n2write;
+  int        nwritten;
+
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) {
+    while( remain > 0 ) {
+       n2write = (remain < ZNZ_MAX_BLOCK_SIZE) ? remain : ZNZ_MAX_BLOCK_SIZE;
+       nwritten = gzwrite(file->zfptr, (void *)cbuf, n2write);
+
+       /* gzread returns 0 on error, but in case that ever changes... */
+       if( nwritten < 0 ) return nwritten;
+
+       remain -= nwritten;
+       cbuf += nwritten;
+
+       /* require writing n2write bytes, so we don't get stuck */
+       if( nwritten < (int)n2write ) break;
+    }
+
+    /* warn of a short write that will seem complete */
+    if( remain > 0 && remain < size )
+      fprintf(stderr,"** znzwrite: write short by %u bytes\n",(unsigned)remain);
+
+    return nmemb - remain/size;   /* return number of members processed */
+  }
+#endif
+  return fwrite(buf,size,nmemb,file->nzfptr);
+}
+
+long znzseek(znzFile file, long offset, int whence)
+{
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) return (long) gzseek(file->zfptr,offset,whence);
+#endif
+  return fseek(file->nzfptr,offset,whence);
+}
+
+int znzrewind(znzFile stream)
+{
+  if (stream==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  /* On some systems, gzrewind() fails for uncompressed files.
+     Use gzseek(), instead.               10, May 2005 [rickr]
+
+     if (stream->zfptr!=NULL) return gzrewind(stream->zfptr);
+  */
+
+  if (stream->zfptr!=NULL) return (int)gzseek(stream->zfptr, 0L, SEEK_SET);
+#endif
+  rewind(stream->nzfptr);
+  return 0;
+}
+
+long znztell(znzFile file)
+{
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) return (long) gztell(file->zfptr);
+#endif
+  return ftell(file->nzfptr);
+}
+
+int znzputs(const char * str, znzFile file)
+{
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) return gzputs(file->zfptr,str);
+#endif
+  return fputs(str,file->nzfptr);
+}
+
+
+char * znzgets(char* str, int size, znzFile file)
+{
+  if (file==NULL) { return NULL; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) return gzgets(file->zfptr,str,size);
+#endif
+  return fgets(str,size,file->nzfptr);
+}
+
+
+int znzflush(znzFile file)
+{
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) return gzflush(file->zfptr,Z_SYNC_FLUSH);
+#endif
+  return fflush(file->nzfptr);
+}
+
+
+int znzeof(znzFile file)
+{
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) return gzeof(file->zfptr);
+#endif
+  return feof(file->nzfptr);
+}
+
+
+int znzputc(int c, znzFile file)
+{
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) return gzputc(file->zfptr,c);
+#endif
+  return fputc(c,file->nzfptr);
+}
+
+
+int znzgetc(znzFile file)
+{
+  if (file==NULL) { return 0; }
+#ifdef HAVE_ZLIB
+  if (file->zfptr!=NULL) return gzgetc(file->zfptr);
+#endif
+  return fgetc(file->nzfptr);
+}
+
+#if !defined (WIN32)
+int znzprintf(znzFile stream, const char *format, ...)
+{
+  int retval=0;
+  char *tmpstr;
+  va_list va;
+  if (stream==NULL) { return 0; }
+  va_start(va, format);
+#ifdef HAVE_ZLIB
+  if (stream->zfptr!=NULL) {
+    int size;  /* local to HAVE_ZLIB block */
+    size = strlen(format) + 1000000;  /* overkill I hope */
+    tmpstr = (char *)calloc(1, size);
+    if( tmpstr == NULL ){
+       fprintf(stderr,"** ERROR: znzprintf failed to alloc %d bytes\n", size);
+       return retval;
+    }
+    vsprintf(tmpstr,format,va);
+    retval=gzprintf(stream->zfptr,"%s",tmpstr);
+    free(tmpstr);
+  } else 
+#endif
+  {
+   retval=vfprintf(stream->nzfptr,format,va);
+  }
+  va_end(va);
+  return retval;
+}
+
+#endif
+