r11859: Canonicalize whitespace
authorKevin M. Rosenberg <kevin@rosenberg.net>
Fri, 31 Aug 2007 18:04:31 +0000 (18:04 +0000)
committerKevin M. Rosenberg <kevin@rosenberg.net>
Fri, 31 Aug 2007 18:04:31 +0000 (18:04 +0000)
99 files changed:
getopt/getopt.c
getopt/getopt.h
getopt/getopt1.c
helical/dynphm.c
include/array2d.h
include/array2dfile.h
include/backprojectors.h
include/ct.h
include/ctglobals.h
include/ctndicom.h
include/ctsupport.h
include/ezplot.h
include/filter.h
include/fnetorderstream.h
include/fourier.h
include/hashtable.h
include/imagefile.h
include/interpolator.h
include/mpiworld.h
include/phantom.h
include/plotfile.h
include/pol.h
include/procsignal.h
include/projections.h
include/reconstruct.h
include/scanner.h
include/sgp.h
include/timer.h
include/trace.h
libctgraphics/bresenham.cpp
libctgraphics/ezplot.cpp
libctgraphics/ezset.cpp
libctgraphics/ezsupport.cpp
libctgraphics/pol.cpp
libctgraphics/sgp.cpp
libctgraphics/transformmatrix.cpp
libctsim/array2dfile.cpp
libctsim/backprojectors.cpp
libctsim/ctndicom.cpp
libctsim/filter.cpp
libctsim/fourier.cpp
libctsim/imagefile.cpp
libctsim/phantom.cpp
libctsim/procsignal.cpp
libctsim/projections.cpp
libctsim/reconstruct.cpp
libctsim/scanner.cpp
libctsim/trace.cpp
libctsupport/clip.cpp
libctsupport/consoleio.cpp
libctsupport/fnetorderstream.cpp
libctsupport/globalvars.cpp
libctsupport/hashtable.cpp
libctsupport/interpolator.cpp
libctsupport/mathfuncs.cpp
libctsupport/plotfile.cpp
libctsupport/strfuncs.cpp
libctsupport/syserror.cpp
libctsupport/xform.cpp
src/backgroundmgr.cpp
src/backgroundmgr.h
src/backgroundsupr.cpp
src/backgroundsupr.h
src/ctsim.cpp
src/ctsim.h
src/dialogs.cpp
src/dialogs.h
src/dlgezplot.cpp
src/dlgezplot.h
src/dlgprojections.cpp
src/dlgprojections.h
src/dlgreconstruct.cpp
src/dlgreconstruct.h
src/docs.cpp
src/docs.h
src/graph3dview.cpp
src/graph3dview.h
src/threadproj.cpp
src/threadproj.h
src/threadraster.cpp
src/threadraster.h
src/threadrecon.cpp
src/threadrecon.h
src/views.cpp
src/views.h
tools/ctsimtext.cpp
tools/if1.cpp
tools/if2.cpp
tools/ifexport.cpp
tools/ifinfo.cpp
tools/linogram.cpp
tools/mpiworld.cpp
tools/phm2helix.cpp
tools/phm2if.cpp
tools/phm2pj.cpp
tools/pj2if.cpp
tools/pjHinterp.cpp
tools/pjinfo.cpp
tools/pjrec.cpp

index f5632d7..63c2ca2 100644 (file)
@@ -4,7 +4,7 @@
    before changing it!
 
    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
-       Free Software Foundation, Inc.
+        Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public License as
 
 /* This needs to come after some library #include
    to get __GNU_LIBRARY__ defined.  */
-#ifdef __GNU_LIBRARY__
+#ifdef  __GNU_LIBRARY__
 /* Don't include stdlib.h for non-GNU C libraries because some of them
    contain conflicting prototypes for getopt.  */
 # include <stdlib.h>
 # include <unistd.h>
-#endif /* GNU C library.  */
+#endif  /* GNU C library.  */
 
 #ifdef VMS
 # include <unixlib.h>
@@ -81,9 +81,9 @@
    When compiling libc, the _ macro is predefined.  */
 # ifdef HAVE_LIBINTL_H
 #  include <libintl.h>
-#  define _(msgid)     gettext (msgid)
+#  define _(msgid)      gettext (msgid)
 # else
-#  define _(msgid)     (msgid)
+#  define _(msgid)      (msgid)
 # endif
 #endif
 
    Also, when `ordering' is RETURN_IN_ORDER,
    each non-option ARGV-element is returned here.  */
 
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG) 
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
 char *optarg;
 #endif
 
@@ -126,7 +126,7 @@ char *optarg;
    how much of ARGV has been scanned so far.  */
 
 /* 1003.2 says this must be 1 before any call.  */
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG) 
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
 int optind = 1;
 #endif
 
@@ -134,7 +134,7 @@ int optind = 1;
    causes problems with re-calling getopt as programs generally don't
    know that. */
 
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG) 
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
 int __getopt_initialized;
 #else
 extern int __getopt_initialized;
@@ -152,7 +152,7 @@ static char *nextchar;
 /* Callers store zero here to inhibit the error message
    for unrecognized options.  */
 
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG) 
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
 int opterr = 1;
 #endif
 
@@ -160,7 +160,7 @@ int opterr = 1;
    This must be initialized on some systems to avoid linking in the
    system's own getopt implementation.  */
 
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG) 
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
 int optopt = '?';
 #endif
 
@@ -201,13 +201,13 @@ static enum
 /* Value of POSIXLY_CORRECT environment variable.  */
 static char *posixly_correct;
 \f
-#ifdef __GNU_LIBRARY__
+#ifdef  __GNU_LIBRARY__
 /* We want to avoid inclusion of string.h with non-GNU libraries
    because there are many ways it can cause trouble.
    On some systems, it contains special magic macros that don't work
    in GCC.  */
 # include <string.h>
-# define my_index      strchr
+# define my_index       strchr
 #else
 
 # if HAVE_STRING_H
@@ -231,7 +231,7 @@ my_index (str, chr)
   while (*str)
     {
       if (*str == chr)
-       return (char *) str;
+        return (char *) str;
       str++;
     }
   return 0;
@@ -290,15 +290,15 @@ text_set_element (__libc_subinit, store_args_and_env);
 # endif /* text_set_element */
 
 # define SWAP_FLAGS(ch1, ch2) \
-  if (nonoption_flags_len > 0)                                               \
-    {                                                                        \
-      char __tmp = __getopt_nonoption_flags[ch1];                            \
-      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];         \
-      __getopt_nonoption_flags[ch2] = __tmp;                                 \
+  if (nonoption_flags_len > 0)                                                \
+    {                                                                         \
+      char __tmp = __getopt_nonoption_flags[ch1];                             \
+      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
+      __getopt_nonoption_flags[ch2] = __tmp;                                  \
     }
-#else  /* !_LIBC */
+#else   /* !_LIBC */
 # define SWAP_FLAGS(ch1, ch2)
-#endif /* _LIBC */
+#endif  /* _LIBC */
 
 /* Exchange two adjacent subsequences of ARGV.
    One subsequence is elements [first_nonopt,last_nonopt)
@@ -334,57 +334,57 @@ exchange (argv)
   if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
     {
       /* We must extend the array.  The user plays games with us and
-        presents new arguments.  */
+         presents new arguments.  */
       char *new_str = malloc (top + 1);
       if (new_str == NULL)
-       nonoption_flags_len = nonoption_flags_max_len = 0;
+        nonoption_flags_len = nonoption_flags_max_len = 0;
       else
-       {
-         memset (__mempcpy (new_str, __getopt_nonoption_flags,
-                            nonoption_flags_max_len),
-                 '\0', top + 1 - nonoption_flags_max_len);
-         nonoption_flags_max_len = top + 1;
-         __getopt_nonoption_flags = new_str;
-       }
+        {
+          memset (__mempcpy (new_str, __getopt_nonoption_flags,
+                             nonoption_flags_max_len),
+                  '\0', top + 1 - nonoption_flags_max_len);
+          nonoption_flags_max_len = top + 1;
+          __getopt_nonoption_flags = new_str;
+        }
     }
 #endif
 
   while (top > middle && middle > bottom)
     {
       if (top - middle > middle - bottom)
-       {
-         /* Bottom segment is the short one.  */
-         int len = middle - bottom;
-         register int i;
-
-         /* Swap it with the top part of the top segment.  */
-         for (i = 0; i < len; i++)
-           {
-             tem = argv[bottom + i];
-             argv[bottom + i] = argv[top - (middle - bottom) + i];
-             argv[top - (middle - bottom) + i] = tem;
-             SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
-           }
-         /* Exclude the moved bottom segment from further swapping.  */
-         top -= len;
-       }
+        {
+          /* Bottom segment is the short one.  */
+          int len = middle - bottom;
+          register int i;
+
+          /* Swap it with the top part of the top segment.  */
+          for (i = 0; i < len; i++)
+            {
+              tem = argv[bottom + i];
+              argv[bottom + i] = argv[top - (middle - bottom) + i];
+              argv[top - (middle - bottom) + i] = tem;
+              SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+            }
+          /* Exclude the moved bottom segment from further swapping.  */
+          top -= len;
+        }
       else
-       {
-         /* Top segment is the short one.  */
-         int len = top - middle;
-         register int i;
-
-         /* Swap it with the bottom part of the bottom segment.  */
-         for (i = 0; i < len; i++)
-           {
-             tem = argv[bottom + i];
-             argv[bottom + i] = argv[middle + i];
-             argv[middle + i] = tem;
-             SWAP_FLAGS (bottom + i, middle + i);
-           }
-         /* Exclude the moved top segment from further swapping.  */
-         bottom += len;
-       }
+        {
+          /* Top segment is the short one.  */
+          int len = top - middle;
+          register int i;
+
+          /* Swap it with the bottom part of the bottom segment.  */
+          for (i = 0; i < len; i++)
+            {
+              tem = argv[bottom + i];
+              argv[bottom + i] = argv[middle + i];
+              argv[middle + i] = tem;
+              SWAP_FLAGS (bottom + i, middle + i);
+            }
+          /* Exclude the moved top segment from further swapping.  */
+          bottom += len;
+        }
     }
 
   /* Update records for the slots the non-options now occupy.  */
@@ -436,25 +436,25 @@ _getopt_initialize (argc, argv, optstring)
       && argc == original_argc && argv == original_argv)
     {
       if (nonoption_flags_max_len == 0)
-       {
-         if (__getopt_nonoption_flags == NULL
-             || __getopt_nonoption_flags[0] == '\0')
-           nonoption_flags_max_len = -1;
-         else
-           {
-             const char *orig_str = __getopt_nonoption_flags;
-             int len = nonoption_flags_max_len = strlen (orig_str);
-             if (nonoption_flags_max_len < argc)
-               nonoption_flags_max_len = argc;
-             __getopt_nonoption_flags =
-               (char *) malloc (nonoption_flags_max_len);
-             if (__getopt_nonoption_flags == NULL)
-               nonoption_flags_max_len = -1;
-             else
-               memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
-                       '\0', nonoption_flags_max_len - len);
-           }
-       }
+        {
+          if (__getopt_nonoption_flags == NULL
+              || __getopt_nonoption_flags[0] == '\0')
+            nonoption_flags_max_len = -1;
+          else
+            {
+              const char *orig_str = __getopt_nonoption_flags;
+              int len = nonoption_flags_max_len = strlen (orig_str);
+              if (nonoption_flags_max_len < argc)
+                nonoption_flags_max_len = argc;
+              __getopt_nonoption_flags =
+                (char *) malloc (nonoption_flags_max_len);
+              if (__getopt_nonoption_flags == NULL)
+                nonoption_flags_max_len = -1;
+              else
+                memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
+                        '\0', nonoption_flags_max_len - len);
+            }
+        }
       nonoption_flags_len = nonoption_flags_max_len;
     }
   else
@@ -538,7 +538,7 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
   if (optind == 0 || !__getopt_initialized)
     {
       if (optind == 0)
-       optind = 1;     /* Don't scan ARGV[0], the program name.  */
+        optind = 1;     /* Don't scan ARGV[0], the program name.  */
       optstring = _getopt_initialize (argc, argv, optstring);
       __getopt_initialized = 1;
     }
@@ -548,9 +548,9 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
      from the shell indicating it is not an option.  The later information
      is only used when the used in the GNU libc.  */
 #ifdef _LIBC
-# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'              \
-                     || (optind < nonoption_flags_len                        \
-                         && __getopt_nonoption_flags[optind] == '1'))
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'       \
+                      || (optind < nonoption_flags_len                        \
+                          && __getopt_nonoption_flags[optind] == '1'))
 #else
 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
 #endif
@@ -560,76 +560,76 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
       /* Advance to the next ARGV-element.  */
 
       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
-        moved back by the user (who may also have changed the arguments).  */
+         moved back by the user (who may also have changed the arguments).  */
       if (last_nonopt > optind)
-       last_nonopt = optind;
+        last_nonopt = optind;
       if (first_nonopt > optind)
-       first_nonopt = optind;
+        first_nonopt = optind;
 
       if (ordering == PERMUTE)
-       {
-         /* If we have just processed some options following some non-options,
-            exchange them so that the options come first.  */
+        {
+          /* If we have just processed some options following some non-options,
+             exchange them so that the options come first.  */
 
-         if (first_nonopt != last_nonopt && last_nonopt != optind)
-           exchange ((char **) argv);
-         else if (last_nonopt != optind)
-           first_nonopt = optind;
+          if (first_nonopt != last_nonopt && last_nonopt != optind)
+            exchange ((char **) argv);
+          else if (last_nonopt != optind)
+            first_nonopt = optind;
 
-         /* Skip any additional non-options
-            and extend the range of non-options previously skipped.  */
+          /* Skip any additional non-options
+             and extend the range of non-options previously skipped.  */
 
-         while (optind < argc && NONOPTION_P)
-           optind++;
-         last_nonopt = optind;
-       }
+          while (optind < argc && NONOPTION_P)
+            optind++;
+          last_nonopt = optind;
+        }
 
       /* The special ARGV-element `--' means premature end of options.
-        Skip it like a null option,
-        then exchange with previous non-options as if it were an option,
-        then skip everything else like a non-option.  */
+         Skip it like a null option,
+         then exchange with previous non-options as if it were an option,
+         then skip everything else like a non-option.  */
 
       if (optind != argc && !strcmp (argv[optind], "--"))
-       {
-         optind++;
+        {
+          optind++;
 
-         if (first_nonopt != last_nonopt && last_nonopt != optind)
-           exchange ((char **) argv);
-         else if (first_nonopt == last_nonopt)
-           first_nonopt = optind;
-         last_nonopt = argc;
+          if (first_nonopt != last_nonopt && last_nonopt != optind)
+            exchange ((char **) argv);
+          else if (first_nonopt == last_nonopt)
+            first_nonopt = optind;
+          last_nonopt = argc;
 
-         optind = argc;
-       }
+          optind = argc;
+        }
 
       /* If we have done all the ARGV-elements, stop the scan
-        and back over any non-options that we skipped and permuted.  */
+         and back over any non-options that we skipped and permuted.  */
 
       if (optind == argc)
-       {
-         /* Set the next-arg-index to point at the non-options
-            that we previously skipped, so the caller will digest them.  */
-         if (first_nonopt != last_nonopt)
-           optind = first_nonopt;
-         return -1;
-       }
+        {
+          /* Set the next-arg-index to point at the non-options
+             that we previously skipped, so the caller will digest them.  */
+          if (first_nonopt != last_nonopt)
+            optind = first_nonopt;
+          return -1;
+        }
 
       /* If we have come to a non-option and did not permute it,
-        either stop the scan or describe it to the caller and pass it by.  */
+         either stop the scan or describe it to the caller and pass it by.  */
 
       if (NONOPTION_P)
-       {
-         if (ordering == REQUIRE_ORDER)
-           return -1;
-         optarg = argv[optind++];
-         return 1;
-       }
+        {
+          if (ordering == REQUIRE_ORDER)
+            return -1;
+          optarg = argv[optind++];
+          return 1;
+        }
 
       /* We have found another option-ARGV-element.
-        Skip the initial punctuation.  */
+         Skip the initial punctuation.  */
 
       nextchar = (argv[optind] + 1
-                 + (longopts != NULL && argv[optind][1] == '-'));
+                  + (longopts != NULL && argv[optind][1] == '-'));
     }
 
   /* Decode the current option-ARGV-element.  */
@@ -649,7 +649,7 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
 
   if (longopts != NULL
       && (argv[optind][1] == '-'
-         || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+          || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
     {
       char *nameend;
       const struct option *p;
@@ -660,125 +660,125 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
       int option_index;
 
       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
-       /* Do nothing.  */ ;
+        /* Do nothing.  */ ;
 
       /* Test all long options for either exact match
-        or abbreviated matches.  */
+         or abbreviated matches.  */
       for (p = longopts, option_index = 0; p->name; p++, option_index++)
-       if (!strncmp (p->name, nextchar, nameend - nextchar))
-         {
-           if ((unsigned int) (nameend - nextchar)
-               == (unsigned int) strlen (p->name))
-             {
-               /* Exact match found.  */
-               pfound = p;
-               indfound = option_index;
-               exact = 1;
-               break;
-             }
-           else if (pfound == NULL)
-             {
-               /* First nonexact match found.  */
-               pfound = p;
-               indfound = option_index;
-             }
-           else
-             /* Second or later nonexact match found.  */
-             ambig = 1;
-         }
+        if (!strncmp (p->name, nextchar, nameend - nextchar))
+          {
+            if ((unsigned int) (nameend - nextchar)
+                == (unsigned int) strlen (p->name))
+              {
+                /* Exact match found.  */
+                pfound = p;
+                indfound = option_index;
+                exact = 1;
+                break;
+              }
+            else if (pfound == NULL)
+              {
+                /* First nonexact match found.  */
+                pfound = p;
+                indfound = option_index;
+              }
+            else
+              /* Second or later nonexact match found.  */
+              ambig = 1;
+          }
 
       if (ambig && !exact)
-       {
-         if (print_errors)
-           fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
-                    argv[0], argv[optind]);
-         nextchar += strlen (nextchar);
-         optind++;
-         optopt = 0;
-         return '?';
-       }
+        {
+          if (print_errors)
+            fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+                     argv[0], argv[optind]);
+          nextchar += strlen (nextchar);
+          optind++;
+          optopt = 0;
+          return '?';
+        }
 
       if (pfound != NULL)
-       {
-         option_index = indfound;
-         optind++;
-         if (*nameend)
-           {
-             /* Don't test has_arg with >, because some C compilers don't
-                allow it to be used on enums.  */
-             if (pfound->has_arg)
-               optarg = nameend + 1;
-             else
-               {
-                 if (print_errors)
-                   {
-                     if (argv[optind - 1][1] == '-')
-                       /* --option */
-                       fprintf (stderr,
-                                _("%s: option `--%s' doesn't allow an argument\n"),
-                                argv[0], pfound->name);
-                     else
-                       /* +option or -option */
-                       fprintf (stderr,
-                                _("%s: option `%c%s' doesn't allow an argument\n"),
-                                argv[0], argv[optind - 1][0], pfound->name);
-                   }
-
-                 nextchar += strlen (nextchar);
-
-                 optopt = pfound->val;
-                 return '?';
-               }
-           }
-         else if (pfound->has_arg == 1)
-           {
-             if (optind < argc)
-               optarg = argv[optind++];
-             else
-               {
-                 if (print_errors)
-                   fprintf (stderr,
-                          _("%s: option `%s' requires an argument\n"),
-                          argv[0], argv[optind - 1]);
-                 nextchar += strlen (nextchar);
-                 optopt = pfound->val;
-                 return optstring[0] == ':' ? ':' : '?';
-               }
-           }
-         nextchar += strlen (nextchar);
-         if (longind != NULL)
-           *longind = option_index;
-         if (pfound->flag)
-           {
-             *(pfound->flag) = pfound->val;
-             return 0;
-           }
-         return pfound->val;
-       }
+        {
+          option_index = indfound;
+          optind++;
+          if (*nameend)
+            {
+              /* Don't test has_arg with >, because some C compilers don't
+                 allow it to be used on enums.  */
+              if (pfound->has_arg)
+                optarg = nameend + 1;
+              else
+                {
+                  if (print_errors)
+                    {
+                      if (argv[optind - 1][1] == '-')
+                        /* --option */
+                        fprintf (stderr,
+                                 _("%s: option `--%s' doesn't allow an argument\n"),
+                                 argv[0], pfound->name);
+                      else
+                        /* +option or -option */
+                        fprintf (stderr,
+                                 _("%s: option `%c%s' doesn't allow an argument\n"),
+                                 argv[0], argv[optind - 1][0], pfound->name);
+                    }
+
+                  nextchar += strlen (nextchar);
+
+                  optopt = pfound->val;
+                  return '?';
+                }
+            }
+          else if (pfound->has_arg == 1)
+            {
+              if (optind < argc)
+                optarg = argv[optind++];
+              else
+                {
+                  if (print_errors)
+                    fprintf (stderr,
+                           _("%s: option `%s' requires an argument\n"),
+                           argv[0], argv[optind - 1]);
+                  nextchar += strlen (nextchar);
+                  optopt = pfound->val;
+                  return optstring[0] == ':' ? ':' : '?';
+                }
+            }
+          nextchar += strlen (nextchar);
+          if (longind != NULL)
+            *longind = option_index;
+          if (pfound->flag)
+            {
+              *(pfound->flag) = pfound->val;
+              return 0;
+            }
+          return pfound->val;
+        }
 
       /* Can't find it as a long option.  If this is not getopt_long_only,
-        or the option starts with '--' or is not a valid short
-        option, then it's an error.
-        Otherwise interpret it as a short option.  */
+         or the option starts with '--' or is not a valid short
+         option, then it's an error.
+         Otherwise interpret it as a short option.  */
       if (!long_only || argv[optind][1] == '-'
-         || my_index (optstring, *nextchar) == NULL)
-       {
-         if (print_errors)
-           {
-             if (argv[optind][1] == '-')
-               /* --option */
-               fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
-                        argv[0], nextchar);
-             else
-               /* +option or -option */
-               fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
-                        argv[0], argv[optind][0], nextchar);
-           }
-         nextchar = (char *) "";
-         optind++;
-         optopt = 0;
-         return '?';
-       }
+          || my_index (optstring, *nextchar) == NULL)
+        {
+          if (print_errors)
+            {
+              if (argv[optind][1] == '-')
+                /* --option */
+                fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+                         argv[0], nextchar);
+              else
+                /* +option or -option */
+                fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+                         argv[0], argv[optind][0], nextchar);
+            }
+          nextchar = (char *) "";
+          optind++;
+          optopt = 0;
+          return '?';
+        }
     }
 
   /* Look at and handle the next short option-character.  */
@@ -793,188 +793,188 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
 
     if (temp == NULL || c == ':')
       {
-       if (print_errors)
-         {
-           if (posixly_correct)
-             /* 1003.2 specifies the format of this message.  */
-             fprintf (stderr, _("%s: illegal option -- %c\n"),
-                      argv[0], c);
-           else
-             fprintf (stderr, _("%s: invalid option -- %c\n"),
-                      argv[0], c);
-         }
-       optopt = c;
-       return '?';
+        if (print_errors)
+          {
+            if (posixly_correct)
+              /* 1003.2 specifies the format of this message.  */
+              fprintf (stderr, _("%s: illegal option -- %c\n"),
+                       argv[0], c);
+            else
+              fprintf (stderr, _("%s: invalid option -- %c\n"),
+                       argv[0], c);
+          }
+        optopt = c;
+        return '?';
       }
     /* Convenience. Treat POSIX -W foo same as long option --foo */
     if (temp[0] == 'W' && temp[1] == ';')
       {
-       char *nameend;
-       const struct option *p;
-       const struct option *pfound = NULL;
-       int exact = 0;
-       int ambig = 0;
-       int indfound = 0;
-       int option_index;
-
-       /* This is an option that requires an argument.  */
-       if (*nextchar != '\0')
-         {
-           optarg = nextchar;
-           /* If we end this ARGV-element by taking the rest as an arg,
-              we must advance to the next element now.  */
-           optind++;
-         }
-       else if (optind == argc)
-         {
-           if (print_errors)
-             {
-               /* 1003.2 specifies the format of this message.  */
-               fprintf (stderr, _("%s: option requires an argument -- %c\n"),
-                        argv[0], c);
-             }
-           optopt = c;
-           if (optstring[0] == ':')
-             c = ':';
-           else
-             c = '?';
-           return c;
-         }
-       else
-         /* We already incremented `optind' once;
-            increment it again when taking next ARGV-elt as argument.  */
-         optarg = argv[optind++];
-
-       /* optarg is now the argument, see if it's in the
-          table of longopts.  */
-
-       for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
-         /* Do nothing.  */ ;
-
-       /* Test all long options for either exact match
-          or abbreviated matches.  */
-       for (p = longopts, option_index = 0; p->name; p++, option_index++)
-         if (!strncmp (p->name, nextchar, nameend - nextchar))
-           {
-             if ((unsigned int) (nameend - nextchar) == strlen (p->name))
-               {
-                 /* Exact match found.  */
-                 pfound = p;
-                 indfound = option_index;
-                 exact = 1;
-                 break;
-               }
-             else if (pfound == NULL)
-               {
-                 /* First nonexact match found.  */
-                 pfound = p;
-                 indfound = option_index;
-               }
-             else
-               /* Second or later nonexact match found.  */
-               ambig = 1;
-           }
-       if (ambig && !exact)
-         {
-           if (print_errors)
-             fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
-                      argv[0], argv[optind]);
-           nextchar += strlen (nextchar);
-           optind++;
-           return '?';
-         }
-       if (pfound != NULL)
-         {
-           option_index = indfound;
-           if (*nameend)
-             {
-               /* Don't test has_arg with >, because some C compilers don't
-                  allow it to be used on enums.  */
-               if (pfound->has_arg)
-                 optarg = nameend + 1;
-               else
-                 {
-                   if (print_errors)
-                     fprintf (stderr, _("\
+        char *nameend;
+        const struct option *p;
+        const struct option *pfound = NULL;
+        int exact = 0;
+        int ambig = 0;
+        int indfound = 0;
+        int option_index;
+
+        /* This is an option that requires an argument.  */
+        if (*nextchar != '\0')
+          {
+            optarg = nextchar;
+            /* If we end this ARGV-element by taking the rest as an arg,
+               we must advance to the next element now.  */
+            optind++;
+          }
+        else if (optind == argc)
+          {
+            if (print_errors)
+              {
+                /* 1003.2 specifies the format of this message.  */
+                fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+                         argv[0], c);
+              }
+            optopt = c;
+            if (optstring[0] == ':')
+              c = ':';
+            else
+              c = '?';
+            return c;
+          }
+        else
+          /* We already incremented `optind' once;
+             increment it again when taking next ARGV-elt as argument.  */
+          optarg = argv[optind++];
+
+        /* optarg is now the argument, see if it's in the
+           table of longopts.  */
+
+        for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+          /* Do nothing.  */ ;
+
+        /* Test all long options for either exact match
+           or abbreviated matches.  */
+        for (p = longopts, option_index = 0; p->name; p++, option_index++)
+          if (!strncmp (p->name, nextchar, nameend - nextchar))
+            {
+              if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+                {
+                  /* Exact match found.  */
+                  pfound = p;
+                  indfound = option_index;
+                  exact = 1;
+                  break;
+                }
+              else if (pfound == NULL)
+                {
+                  /* First nonexact match found.  */
+                  pfound = p;
+                  indfound = option_index;
+                }
+              else
+                /* Second or later nonexact match found.  */
+                ambig = 1;
+            }
+        if (ambig && !exact)
+          {
+            if (print_errors)
+              fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+                       argv[0], argv[optind]);
+            nextchar += strlen (nextchar);
+            optind++;
+            return '?';
+          }
+        if (pfound != NULL)
+          {
+            option_index = indfound;
+            if (*nameend)
+              {
+                /* Don't test has_arg with >, because some C compilers don't
+                   allow it to be used on enums.  */
+                if (pfound->has_arg)
+                  optarg = nameend + 1;
+                else
+                  {
+                    if (print_errors)
+                      fprintf (stderr, _("\
 %s: option `-W %s' doesn't allow an argument\n"),
-                              argv[0], pfound->name);
-
-                   nextchar += strlen (nextchar);
-                   return '?';
-                 }
-             }
-           else if (pfound->has_arg == 1)
-             {
-               if (optind < argc)
-                 optarg = argv[optind++];
-               else
-                 {
-                   if (print_errors)
-                     fprintf (stderr,
-                              _("%s: option `%s' requires an argument\n"),
-                              argv[0], argv[optind - 1]);
-                   nextchar += strlen (nextchar);
-                   return optstring[0] == ':' ? ':' : '?';
-                 }
-             }
-           nextchar += strlen (nextchar);
-           if (longind != NULL)
-             *longind = option_index;
-           if (pfound->flag)
-             {
-               *(pfound->flag) = pfound->val;
-               return 0;
-             }
-           return pfound->val;
-         }
-         nextchar = NULL;
-         return 'W';   /* Let the application handle it.   */
+                               argv[0], pfound->name);
+
+                    nextchar += strlen (nextchar);
+                    return '?';
+                  }
+              }
+            else if (pfound->has_arg == 1)
+              {
+                if (optind < argc)
+                  optarg = argv[optind++];
+                else
+                  {
+                    if (print_errors)
+                      fprintf (stderr,
+                               _("%s: option `%s' requires an argument\n"),
+                               argv[0], argv[optind - 1]);
+                    nextchar += strlen (nextchar);
+                    return optstring[0] == ':' ? ':' : '?';
+                  }
+              }
+            nextchar += strlen (nextchar);
+            if (longind != NULL)
+              *longind = option_index;
+            if (pfound->flag)
+              {
+                *(pfound->flag) = pfound->val;
+                return 0;
+              }
+            return pfound->val;
+          }
+          nextchar = NULL;
+          return 'W';   /* Let the application handle it.   */
       }
     if (temp[1] == ':')
       {
-       if (temp[2] == ':')
-         {
-           /* This is an option that accepts an argument optionally.  */
-           if (*nextchar != '\0')
-             {
-               optarg = nextchar;
-               optind++;
-             }
-           else
-             optarg = NULL;
-           nextchar = NULL;
-         }
-       else
-         {
-           /* This is an option that requires an argument.  */
-           if (*nextchar != '\0')
-             {
-               optarg = nextchar;
-               /* If we end this ARGV-element by taking the rest as an arg,
-                  we must advance to the next element now.  */
-               optind++;
-             }
-           else if (optind == argc)
-             {
-               if (print_errors)
-                 {
-                   /* 1003.2 specifies the format of this message.  */
-                   fprintf (stderr,
-                            _("%s: option requires an argument -- %c\n"),
-                            argv[0], c);
-                 }
-               optopt = c;
-               if (optstring[0] == ':')
-                 c = ':';
-               else
-                 c = '?';
-             }
-           else
-             /* We already incremented `optind' once;
-                increment it again when taking next ARGV-elt as argument.  */
-             optarg = argv[optind++];
-           nextchar = NULL;
-         }
+        if (temp[2] == ':')
+          {
+            /* This is an option that accepts an argument optionally.  */
+            if (*nextchar != '\0')
+              {
+                optarg = nextchar;
+                optind++;
+              }
+            else
+              optarg = NULL;
+            nextchar = NULL;
+          }
+        else
+          {
+            /* This is an option that requires an argument.  */
+            if (*nextchar != '\0')
+              {
+                optarg = nextchar;
+                /* If we end this ARGV-element by taking the rest as an arg,
+                   we must advance to the next element now.  */
+                optind++;
+              }
+            else if (optind == argc)
+              {
+                if (print_errors)
+                  {
+                    /* 1003.2 specifies the format of this message.  */
+                    fprintf (stderr,
+                             _("%s: option requires an argument -- %c\n"),
+                             argv[0], c);
+                  }
+                optopt = c;
+                if (optstring[0] == ':')
+                  c = ':';
+                else
+                  c = '?';
+              }
+            else
+              /* We already incremented `optind' once;
+                 increment it again when taking next ARGV-elt as argument.  */
+              optarg = argv[optind++];
+            nextchar = NULL;
+          }
       }
     return c;
   }
@@ -988,13 +988,13 @@ getopt (argc, argv, optstring)
      const char *optstring;
 {
   return _getopt_internal (argc, argv, optstring,
-                          (const struct option *) 0,
-                          (int *) 0,
-                          0);
+                           (const struct option *) 0,
+                           (int *) 0,
+                           0);
 }
 #endif
 
-#endif /* Not ELIDE_CODE.  */
+#endif  /* Not ELIDE_CODE.  */
 \f
 #ifdef TEST
 
@@ -1015,51 +1015,51 @@ main (argc, argv)
 
       c = getopt (argc, argv, "abc:d:0123456789");
       if (c == -1)
-       break;
+        break;
 
       switch (c)
-       {
-       case '0':
-       case '1':
-       case '2':
-       case '3':
-       case '4':
-       case '5':
-       case '6':
-       case '7':
-       case '8':
-       case '9':
-         if (digit_optind != 0 && digit_optind != this_option_optind)
-           printf ("digits occur in two different argv-elements.\n");
-         digit_optind = this_option_optind;
-         printf ("option %c\n", c);
-         break;
-
-       case 'a':
-         printf ("option a\n");
-         break;
-
-       case 'b':
-         printf ("option b\n");
-         break;
-
-       case 'c':
-         printf ("option c with value `%s'\n", optarg);
-         break;
-
-       case '?':
-         break;
-
-       default:
-         printf ("?? getopt returned character code 0%o ??\n", c);
-       }
+        {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+          if (digit_optind != 0 && digit_optind != this_option_optind)
+            printf ("digits occur in two different argv-elements.\n");
+          digit_optind = this_option_optind;
+          printf ("option %c\n", c);
+          break;
+
+        case 'a':
+          printf ("option a\n");
+          break;
+
+        case 'b':
+          printf ("option b\n");
+          break;
+
+        case 'c':
+          printf ("option c with value `%s'\n", optarg);
+          break;
+
+        case '?':
+          break;
+
+        default:
+          printf ("?? getopt returned character code 0%o ??\n", c);
+        }
     }
 
   if (optind < argc)
     {
       printf ("non-option ARGV-elements: ");
       while (optind < argc)
-       printf ("%s ", argv[optind++]);
+        printf ("%s ", argv[optind++]);
       printf ("\n");
     }
 
index da0a54a..17450ad 100644 (file)
@@ -27,7 +27,7 @@
 # define _GETOPT_H 1
 #endif
 
-#ifdef __cplusplus
+#ifdef  __cplusplus
 extern "C" {
 #endif
 
@@ -69,9 +69,9 @@ extern int optopt;
    zero.
 
    The field `has_arg' is:
-   no_argument         (or 0) if the option does not take an argument,
-   required_argument   (or 1) if the option requires an argument,
-   optional_argument   (or 2) if the option takes an optional argument.
+   no_argument          (or 0) if the option does not take an argument,
+   required_argument    (or 1) if the option requires an argument,
+   optional_argument    (or 2) if the option takes an optional argument.
 
    If the field `flag' is not NULL, it points to a variable that is set
    to the value given in the field `val' when the option is found, but
@@ -100,10 +100,10 @@ struct option
 
 /* Names for the values of the `has_arg' field of `struct option'.  */
 
-# define no_argument           0
-# define required_argument     1
-# define optional_argument     2
-#endif /* need getopt */
+# define no_argument            0
+# define required_argument      1
+# define optional_argument      2
+#endif  /* need getopt */
 
 
 /* Get definitions and prototypes for functions to process the
@@ -130,7 +130,7 @@ struct option
    arguments to the option '\0'.  This behavior is specific to the GNU
    `getopt'.  */
 
-#if defined __STDC__ 
+#if defined __STDC__
 # ifdef __GNU_LIBRARY__
 /* Many other libraries have conflicting prototypes for getopt, with
    differences in the consts, in stdlib.h.  To avoid compilation
@@ -142,33 +142,33 @@ extern int getopt (int __argc, char *const *__argv, const char *__shortopts);
 
 # ifndef __need_getopt
 extern int getopt_long (int argc, char *const *argv, const char *shortopts,
-                       const struct option *longopts, int *longind);
+                        const struct option *longopts, int *longind);
 extern int getopt_long_only (int __argc, char *const *__argv,
-                            const char *__shortopts,
-                            const struct option *__longopts, int *__longind);
+                             const char *__shortopts,
+                             const struct option *__longopts, int *__longind);
 
 /* Internal only.  Users should not call this directly.  */
 extern int _getopt_internal (int __argc, char *const *__argv,
-                            const char *__shortopts,
-                            const struct option *__longopts, int *__longind,
-                            int __long_only);
+                             const char *__shortopts,
+                             const struct option *__longopts, int *__longind,
+                             int __long_only);
 # endif
 #else /* not __STDC__ */
 extern int getopt ();
 # ifndef __need_getopt
 extern int getopt_long (int argc, char *const *argv, const char *shortopts,
-                       const struct option *longopts, int *longind);
+                        const struct option *longopts, int *longind);
 extern int getopt_long_only (int __argc, char *const *__argv,
-                            const char *__shortopts,
-                            const struct option *__longopts, int *__longind);
+                             const char *__shortopts,
+                             const struct option *__longopts, int *__longind);
 extern int _getopt_internal (int __argc, char *const *__argv,
-                            const char *__shortopts,
-                            const struct option *__longopts, int *__longind,
-                            int __long_only);
+                             const char *__shortopts,
+                             const struct option *__longopts, int *__longind,
+                             int __long_only);
 # endif
 #endif /* __STDC__ */
 
-#ifdef __cplusplus
+#ifdef  __cplusplus
 }
 #endif
 
index 3d264f2..83ce613 100644 (file)
@@ -59,7 +59,7 @@
 #include <stdlib.h>
 #endif
 
-#ifndef        NULL
+#ifndef NULL
 #define NULL 0
 #endif
 
@@ -91,7 +91,7 @@ getopt_long_only (argc, argv, options, long_options, opt_index)
 }
 
 
-#endif /* Not ELIDE_CODE.  */
+#endif  /* Not ELIDE_CODE.  */
 \f
 #ifdef TEST
 
@@ -111,74 +111,74 @@ main (argc, argv)
       int option_index = 0;
       static struct option long_options[] =
       {
-       {"add", 1, 0, 0},
-       {"append", 0, 0, 0},
-       {"delete", 1, 0, 0},
-       {"verbose", 0, 0, 0},
-       {"create", 0, 0, 0},
-       {"file", 1, 0, 0},
-       {0, 0, 0, 0}
+        {"add", 1, 0, 0},
+        {"append", 0, 0, 0},
+        {"delete", 1, 0, 0},
+        {"verbose", 0, 0, 0},
+        {"create", 0, 0, 0},
+        {"file", 1, 0, 0},
+        {0, 0, 0, 0}
       };
 
       c = getopt_long (argc, argv, "abc:d:0123456789",
-                      long_options, &option_index);
+                       long_options, &option_index);
       if (c == -1)
-       break;
+        break;
 
       switch (c)
-       {
-       case 0:
-         printf ("option %s", long_options[option_index].name);
-         if (optarg)
-           printf (" with arg %s", optarg);
-         printf ("\n");
-         break;
-
-       case '0':
-       case '1':
-       case '2':
-       case '3':
-       case '4':
-       case '5':
-       case '6':
-       case '7':
-       case '8':
-       case '9':
-         if (digit_optind != 0 && digit_optind != this_option_optind)
-           printf ("digits occur in two different argv-elements.\n");
-         digit_optind = this_option_optind;
-         printf ("option %c\n", c);
-         break;
-
-       case 'a':
-         printf ("option a\n");
-         break;
-
-       case 'b':
-         printf ("option b\n");
-         break;
-
-       case 'c':
-         printf ("option c with value `%s'\n", optarg);
-         break;
-
-       case 'd':
-         printf ("option d with value `%s'\n", optarg);
-         break;
-
-       case '?':
-         break;
-
-       default:
-         printf ("?? getopt returned character code 0%o ??\n", c);
-       }
+        {
+        case 0:
+          printf ("option %s", long_options[option_index].name);
+          if (optarg)
+            printf (" with arg %s", optarg);
+          printf ("\n");
+          break;
+
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+          if (digit_optind != 0 && digit_optind != this_option_optind)
+            printf ("digits occur in two different argv-elements.\n");
+          digit_optind = this_option_optind;
+          printf ("option %c\n", c);
+          break;
+
+        case 'a':
+          printf ("option a\n");
+          break;
+
+        case 'b':
+          printf ("option b\n");
+          break;
+
+        case 'c':
+          printf ("option c with value `%s'\n", optarg);
+          break;
+
+        case 'd':
+          printf ("option d with value `%s'\n", optarg);
+          break;
+
+        case '?':
+          break;
+
+        default:
+          printf ("?? getopt returned character code 0%o ??\n", c);
+        }
     }
 
   if (optind < argc)
     {
       printf ("non-option ARGV-elements: ");
       while (optind < argc)
-       printf ("%s ", argv[optind++]);
+        printf ("%s ", argv[optind++]);
       printf ("\n");
     }
 
index 4395f02..e350e46 100644 (file)
@@ -3,47 +3,47 @@
 int
 main(int argc, char *argv[])
 {
-       int view, nview; 
-       char filename[128];                                                      
-       
-       float mu1=0. , mu2=6., density, afac, s;
+        int view, nview;
+        char filename[128];
 
-       FILE *fp = (FILE *)NULL;
-       if (argc !=4){ 
-               fprintf(stderr, "Usage: %s iview nview phmfilename\n", argv[0]);        
-               exit (1);
-       }
+        float mu1=0. , mu2=6., density, afac, s;
 
-       view = atoi(argv[1]);
-       nview = atoi(argv[2]);
-       sprintf(filename, "%s", argv[3]);
+        FILE *fp = (FILE *)NULL;
+        if (argc !=4){
+                fprintf(stderr, "Usage: %s iview nview phmfilename\n", argv[0]);
+                exit (1);
+        }
 
-       s = (float)view/((float)(nview-1));
-  
-   if ( s < 7./16. ) 
-               density = mu1; 
+        view = atoi(argv[1]);
+        nview = atoi(argv[2]);
+        sprintf(filename, "%s", argv[3]);
+
+        s = (float)view/((float)(nview-1));
+
+   if ( s < 7./16. )
+                density = mu1;
    else if ( s  > 9./16. )
-       density = mu2;
+        density = mu2;
    else {
-       afac = ( (s - 7./16.) / 2./16.); 
-       density = log(1/((1-afac)*exp(-mu1) + afac * exp(-mu2)));
-   }                                   
-       
-/* 
-       density = mu1 + (mu2-mu1)*s;
-       if (s <=0.5) 
-                       density = mu1; 
-       else
-                       density = mu2; 
+        afac = ( (s - 7./16.) / 2./16.);
+        density = log(1/((1-afac)*exp(-mu1) + afac * exp(-mu2)));
+   }
+
+/*
+        density = mu1 + (mu2-mu1)*s;
+        if (s <=0.5)
+                        density = mu1;
+        else
+                        density = mu2;
  */
-       if ( (fp = fopen(filename, "w"))  == (FILE *)NULL){
-               fprintf(stderr,"Error, can not open file \"tmpphmfile\"\n"); 
-               exit(2);
-       }
-       fprintf(fp, "rectangle 0 0 11.5 11.5 0 0\n");
-       fprintf(fp, "ellipse   0 0 11.4 11.4 0 1\n");
-       fprintf(fp, "ellipse   0 0 1.25 1.25 0 %f\n", density);
+        if ( (fp = fopen(filename, "w"))  == (FILE *)NULL){
+                fprintf(stderr,"Error, can not open file \"tmpphmfile\"\n");
+                exit(2);
+        }
+        fprintf(fp, "rectangle 0 0 11.5 11.5 0 0\n");
+        fprintf(fp, "ellipse   0 0 11.4 11.4 0 1\n");
+        fprintf(fp, "ellipse   0 0 1.25 1.25 0 %f\n", density);
 
-       fclose(fp);     
-       exit(0);
+        fclose(fp);
+        exit(0);
 }
index d9081db..a03ae58 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         array2d.h
+**      Name:         array2d.h
 **      Purpose:      2-dimension array classes
-**     Programmer:   Kevin Rosenberg
-**     Date Started: June 2000
+**      Programmer:   Kevin Rosenberg
+**      Date Started: June 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
 #include "ctsupport.h"
 
 
-template<class T> 
+template<class T>
 class Array2d {
  public:
     Array2d (unsigned int x, unsigned int y)
-       : m_nx(x), m_ny(y), array_data(0)
-       {
-           allocArray();
-       }
+        : m_nx(x), m_ny(y), array_data(0)
+        {
+            allocArray();
+        }
 
     Array2d ()
-       : m_nx(0), m_ny(0), array_data(0)
-       {}
+        : m_nx(0), m_ny(0), array_data(0)
+        {}
 
     ~Array2d ()
-       {
-           deleteArray();
-       }
-    
+        {
+            deleteArray();
+        }
+
     void initSetSize (unsigned int x, unsigned int y)
-       {
-           m_nx = x;
-           m_ny = y;
-           deleteArray();
-           allocArray();
-       }
+        {
+            m_nx = x;
+            m_ny = y;
+            deleteArray();
+            allocArray();
+        }
 
     T** getArray () const
-       { return array_data; }
+        { return array_data; }
 
     T* getColumn (unsigned int x) const
-       { return (array_data ? array_data[x] : NULL); }
+        { return (array_data ? array_data[x] : NULL); }
 
     T getPoint (unsigned int x, unsigned int y) const
-       { return (array_data ? array_data[x][y] : NULL); }
+        { return (array_data ? array_data[x][y] : NULL); }
 
-    unsigned int sizeofPixel () const 
-       {  return sizeof(T); }
+    unsigned int sizeofPixel () const
+        {  return sizeof(T); }
 
     unsigned int sizeofColumn () const
-       { return (sizeof(T) * m_ny); }
+        { return (sizeof(T) * m_ny); }
 
     unsigned int sizeofArray () const
-       { return (sizeof(T) * m_nx * m_ny); }
+        { return (sizeof(T) * m_nx * m_ny); }
 
 
  private:
@@ -82,25 +82,25 @@ class Array2d {
     T** array_data;
 
     void allocArray ()
-       {
-           if (array_data)
-               deleteArray();
+        {
+            if (array_data)
+                deleteArray();
+
+            array_data = new T*[m_nx];
 
-           array_data = new T*[m_nx];
-           
-           for (unsigned int i = 0; i < m_nx; i++)
-               array_data[i] = new T[m_ny];
-       }
+            for (unsigned int i = 0; i < m_nx; i++)
+                array_data[i] = new T[m_ny];
+        }
 
     void deleteArray ()
-       {
-           if (array_data) {
-               for (unsigned int i = 0; i < m_nx; i++)
-                   delete array_data [i];
-               delete array_data;
-               array_data = NULL;
-           }
-       }
+        {
+            if (array_data) {
+                for (unsigned int i = 0; i < m_nx; i++)
+                    delete array_data [i];
+                delete array_data;
+                array_data = NULL;
+            }
+        }
 
 
     Array2d& operator= (const Array2d& rhs); //assignment operator
index ec6251e..2dab6ce 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         array2dfile.h
+**      Name:         array2dfile.h
 **      Purpose:      2-dimension array file class
-**     Programmer:   Kevin Rosenberg
-**     Date Started: June 2000
+**      Programmer:   Kevin Rosenberg
+**      Date Started: June 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -52,53 +52,53 @@ public:
       L_HISTORY = 1,
       L_USER = 2,
   };
-  
-  Array2dFileLabel(); 
-  
+
+  Array2dFileLabel();
+
   Array2dFileLabel(const char* const str, double ctime = 0.);
-  
+
   Array2dFileLabel(const int type, const char* const str, double ctime = 0.);
-  
+
   ~Array2dFileLabel();
-  
+
   const std::string& getLabelString (void) const
   { return m_strLabel; }
-  
+
   kfloat64 getCalcTime (void) const
   { return m_calcTime; }
-  
+
   void setCalcTime (kfloat64 calcTime)
   { m_calcTime = calcTime; }
-  
+
   void setLabelType (int labelType)
   { m_labelType = labelType; }
-  
+
   int getLabelType (void) const
   { return m_labelType; }
-  
+
   std::string& setLabelString (const char* const str)
   { m_strLabel = str; return (m_strLabel); }
-  
+
   std::string& setLabelString (const std::string& str)
   { m_strLabel = str; return (m_strLabel); }
-  
+
   void setDateTime (int year, int month, int day, int hour, int minute, int second);
-  
+
   void getDateTime (int& year, int& month, int& day, int& hour, int& minute, int& second) const;
-  
+
   const std::string& getDateString () const;
-  
+
   void print (std::ostream& os) const;
   void printBrief (std::ostream& os) const;
   void printBrief (std::ostringstream& os) const;
-  
+
   Array2dFileLabel (const Array2dFileLabel& rhs);
-  
+
   Array2dFileLabel& operator= (const Array2dFileLabel& rhs);
-  
+
 private:
   void init (void);
-  
+
   kuint16 m_labelType;
   kuint16 m_year;
   kuint16 m_month;
@@ -108,12 +108,12 @@ private:
   kuint16 m_second;
   std::string m_strLabel;
   kfloat64 m_calcTime;
-  
+
   mutable std::string m_strDate;
 };
 
 
-class Array2dFile 
+class Array2dFile
 {
 public:
   enum {
@@ -127,64 +127,64 @@ public:
       PIXEL_FLOAT32 = 7,
       PIXEL_FLOAT64 = 8,
   };
-  
+
   enum {
     DATA_TYPE_INVALID = 0,
       DATA_TYPE_REAL,
       DATA_TYPE_COMPLEX,
   };
-  
+
   Array2dFile (int nx, int ny, int pixelSize, int pixelFormat = PIXEL_INVALID, int dataType = DATA_TYPE_REAL);
   Array2dFile (void);
   ~Array2dFile ();
-  
+
   void setArraySize (int nx, int ny, int pixelSize, int pixelFormat = PIXEL_INVALID, int dataType = DATA_TYPE_REAL);
-  
+
   void setArraySize (int nx, int ny);
-  
+
   unsigned int getNumLabels (void) const
   { return m_labels.size(); }
-  
+
   const Array2dFileLabel& labelGet (int label_num) const;
-  
+
   void labelAdd (const Array2dFileLabel& label);
-  
+
   void labelAdd (const char* const m_strLabel, double calc_time=0.);
-  
+
   void labelAdd (int type, const char* const m_strLabel, double calc_time=0.);
-  
+
   void labelsCopy (const Array2dFile& file, const char* const idStr = NULL);
-  
+
   void setPixelFormat (int type)
   { m_pixelFormat = type; }
-  
+
   void setPixelSize (int size)
   { m_pixelSize = size; }
-  
+
   kuint32 nx (void) const
   { return m_nx; }
-  
+
   kuint32 ny (void) const
   { return m_ny; }
-  
+
   bool isComplex() const
   { return m_dataType == DATA_TYPE_COMPLEX; }
-  
+
   bool isReal() const
   { return m_dataType == DATA_TYPE_REAL; }
-  
+
   int dataType () const
   { return static_cast<int>(m_dataType); }
-  
+
   void setDataType (int dataType)
   { m_dataType = dataType; }
-  
+
   void setAxisIncrement (double axisIncX, double axisIncY);
-  
+
   bool reallocRealToComplex ();
-  
+
   bool reallocComplexToReal ();
-  
+
   void getPixelValueRange (double& pvmin, double& pvmax) const;
   void setAxisExtent (double minX, double maxX, double minY, double maxY);
   bool getAxisExtent (double& minX, double& maxX, double& minY, double& maxY) const
@@ -197,35 +197,35 @@ public:
   kfloat64 axisIncrementY() const {return m_axisIncrementKnown ? m_axisIncrementY : 0.;}
 
   void arrayDataClear (void);
-  
+
   bool fileRead (const char* const filename);
-  
+
   bool fileRead (const std::string& filename);
-  
+
   bool fileWrite (const char* const filename);
-  
+
   bool fileWrite (const std::string& filename);
-  
-  const std::string& getFilename (void) const 
+
+  const std::string& getFilename (void) const
   {  return m_filename; }
-  
+
   void printLabels (std::ostream& os) const;
   void printLabelsBrief (std::ostream& os) const;
   void printLabelsBrief (std::ostringstream& os) const;
-  
+
   unsigned int nLabels() const
   { return m_labels.size(); }
-  
+
   typedef std::vector<Array2dFileLabel*>::iterator labelIterator;
   typedef std::vector<Array2dFileLabel*>::const_iterator constLabelIterator;
-  
+
 protected:
-        typedef std::vector<Array2dFileLabel*> labelContainer;
-   
+         typedef std::vector<Array2dFileLabel*> labelContainer;
+
    static const kuint16 m_signature;
    kuint16 m_headersize;
    std::string  m_filename;
-   
+
    kuint16 m_pixelSize;
    kuint16 m_pixelFormat;
    kuint16 m_axisIncrementKnown;
@@ -241,33 +241,33 @@ protected:
    kuint16 m_dataType;
    unsigned char** m_arrayData;
    unsigned char** m_imaginaryArrayData;
-   
+
 private:
   void init (void);
-  
+
   bool headerRead (frnetorderstream& fs);
-  
+
   bool headerWrite (frnetorderstream& fs);
-  
+
   bool arrayDataRead (frnetorderstream& fs);
-  
+
   bool arrayDataWrite (frnetorderstream& fs);
-  
+
   bool labelsRead (frnetorderstream& fs);
-  
+
   bool labelsWrite (frnetorderstream& fs);
-  
+
   bool labelSeek (int label_num);
-  
+
   void allocArrays ();
   void freeArrays ();
-  
+
   void allocArray (unsigned char**& rppData);
   void freeArray (unsigned char**& rppData);
-  
+
   Array2dFile (const Array2dFile& rhs);        // copy constructor
   Array2dFile& operator= (const Array2dFile&); // assignment operator
-  
+
 };
 
 
index f34964c..5e897cd 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         backproject.h
+**      Name:         backproject.h
 **      Purpose:      Backprojection classes
-**     Programmer:   Kevin Rosenberg
-**     Date Started: June 2000
+**      Programmer:   Kevin Rosenberg
+**      Date Started: June 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -60,11 +60,11 @@ class Backprojector
   static const int INTERP_3BSPLINE;
 #endif
 
-  Backprojector (const Projections& proj, ImageFile& im, const char* const backprojName, 
+  Backprojector (const Projections& proj, ImageFile& im, const char* const backprojName,
     const char* const interpName, const int interpFactor, const ReconstructionROI* pROI);
 
   ~Backprojector ();
-                
+
   void BackprojectView (const double* const viewData, const double viewAngle);
   void PostProcessing();
 
@@ -111,7 +111,7 @@ class Backprojector
 class Backproject
 {
  public:
-    Backproject (const Projections& proj, ImageFile& im, int interpID, const int interpFactor, 
+    Backproject (const Projections& proj, ImageFile& im, int interpID, const int interpFactor,
       const ReconstructionROI* pROI);
 
     virtual ~Backproject ();
@@ -131,10 +131,10 @@ class Backproject
     kint32 ny;
     double detInc;
     double rotScale;
-    int iDetCenter;            // index refering to L=0 projection 
+    int iDetCenter;             // index refering to L=0 projection
     int nDet;
     double xMin, xMax, yMin, yMax;     // Retangular coords of phantom
-    double xInc, yInc; // size of cells
+    double xInc, yInc;  // size of cells
     int m_interpFactor;
     double m_dFocalLength;
     double m_dSourceDetectorLength;
@@ -196,7 +196,7 @@ class BackprojectIntDiff : public BackprojectDiff
   BackprojectIntDiff (const Projections& proj, ImageFile& im, int interpID, const int interpFactor, const ReconstructionROI* pROI)
     :  BackprojectDiff (proj, im, interpID, interpFactor, pROI)
     {}
-  
+
   void BackprojectView (const double* const t, const double view_angle);
 };
 
index 9ee346b..cc121a0 100644 (file)
   #include "png.h"
 #endif
 #ifdef HAVE_G2_H
-extern "C" { 
-#include "g2.h" 
+extern "C" {
+#include "g2.h"
 }
 #ifdef HAVE_X11
 extern "C" {
index 80a94cd..5e063fc 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         ctglobals.h
+**      Name:         ctglobals.h
 **      Purpose:      Global variables for CTSim
-**     Programmer:   Kevin Rosenberg
-**     Date Started: Jan 20001
+**      Programmer:   Kevin Rosenberg
+**      Date Started: Jan 20001
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
index 7817ab4..0a1d0fc 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:           ctndicomp.cpp
+**      Name:           ctndicomp.cpp
 **  Purpose:      Interface to CTN Dicom header
-**     Programmer:   Kevin Rosenberg
-**     Date Started: March 2001
+**      Programmer:   Kevin Rosenberg
+**      Date Started: March 2001
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -78,7 +78,7 @@ private:
   Projections* m_pProjections;
   DCM_OBJECT* m_pFile;
 
-  void loadImage(unsigned short iNRows, unsigned short iNCols, unsigned short iBitsAllocated, 
+  void loadImage(unsigned short iNRows, unsigned short iNCols, unsigned short iBitsAllocated,
             unsigned short iBitsStored, unsigned short iHighBit, unsigned short iPixRep);
 
   void loadProjections();
index 49231ce..e0a8194 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     File Name:      ctsupport.h
-**     Author:         Kevin Rosenberg
-**     Purpose:        Header file for CT support library
-**     Date Started:   Dec. 83
+**      File Name:      ctsupport.h
+**      Author:         Kevin Rosenberg
+**      Purpose:        Header file for CT support library
+**      Date Started:   Dec. 83
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
 #endif
 
 #ifndef TRUE
-#define TRUE   1
+#define TRUE    1
 #endif
 #ifndef FALSE
-#define FALSE  0
+#define FALSE   0
 #endif
-#define OK     TRUE
+#define OK      TRUE
 
 /*----------------------------------------------------------------------*/
 
 
 /*----------------------------------------------------------------------*/
 
-#define        NEWLINE '\n'
-#define        TAB     '\t'
-#define EOS    '\0'
-#define BLANK  ' '
+#define NEWLINE '\n'
+#define TAB     '\t'
+#define EOS     '\0'
+#define BLANK   ' '
 
 /*----------------------------------------------------------------------*/
 
 #define ERR_TRACE -1
-#define ERR_WARNING    0
-#define ERR_SEVERE     1
-#define ERR_FATAL      2
+#define ERR_WARNING     0
+#define ERR_SEVERE      1
+#define ERR_FATAL       2
 
 /*----------------------------------------------------------------------*/
 
 
 /* codes for open command */
 #ifdef MSVC
-#define OPEN_RDONLY  O_RDONLY                  /* other system use standard codes */
-#define OPEN_WRONLY  O_WRONLY                  /* for binary */
+#define OPEN_RDONLY  O_RDONLY                   /* other system use standard codes */
+#define OPEN_WRONLY  O_WRONLY                   /* for binary */
 #define OPEN_RDWR    O_RDWR
 #else
-#define OPEN_RDONLY  0                 /* other system use standard codes */
-#define OPEN_WRONLY  1                 /* for binary */
+#define OPEN_RDONLY  0                  /* other system use standard codes */
+#define OPEN_WRONLY  1                  /* for binary */
 #define OPEN_RDWR    2
 #endif
 
@@ -141,7 +141,7 @@ typedef unsigned char kuint8;
 #endif
 
 
-inline const char* 
+inline const char*
 fileBasename (const char* const filename)
 {
   const char* p = strrchr (filename, '/');
@@ -168,23 +168,23 @@ extern unsigned long int g_lSysErrorMaxCount;
 #include <cmath>
 
 #define PI      3.14159265358979323846
-#define HALFPI  1.57079632679489661923 /* PI divided by 2 */
-#define QUARTPI 0.78539816339744830962 /* PI divided by 4 */
-#define I_PI   0.31830988618379067154  /* Inverse of PI */
-#define I_PID2 0.63661977236758134308  /* Inverse of PID2 */
-#define TWOPI  6.28318530717958647692
+#define HALFPI  1.57079632679489661923  /* PI divided by 2 */
+#define QUARTPI 0.78539816339744830962  /* PI divided by 4 */
+#define I_PI    0.31830988618379067154  /* Inverse of PI */
+#define I_PID2  0.63661977236758134308  /* Inverse of PID2 */
+
+#define TWOPI   6.28318530717958647692
 #define SQRT2   1.414213562373095049
 
-#define F_EPSILON      1.0E-6
-#define D_EPSILON      1.0E-10
+#define F_EPSILON       1.0E-6
+#define D_EPSILON       1.0E-10
 
 #define ASSUMEDZERO  1E-10
 
 typedef double GRFMTX_2D[3][3];
 typedef double GRFMTX_3D[4][4];
 
-inline double 
+inline double
 convertDegreesToRadians (double x)
 { return (x * (PI/180.)); }
 
@@ -245,7 +245,7 @@ inline void minmax_array (const T* array, const int n, T& min, T& max)
 // FUNTION DECLARATIONS
 //////////////////////////////////////////////////////////////
 
-// clip.cpp 
+// clip.cpp
 bool clip_rect (double& x1, double& y1, double& x2, double& y2, const double rect[4]);
 bool clip_segment (double& x1, double& y1, double& x2, double& y2, const double u, const double v);
 bool clip_sector (double& x1, double& y1, double& x2, double& y2, const double u, const double v);
@@ -253,7 +253,7 @@ bool clip_circle (double& x1, double& y1, double& x2, double& y2, const double c
 bool clip_triangle (double& x1, double& y1, double& x2, double& y2, const double u, const double v, const int clip_xaxis);
 
 
-// xform.cpp 
+// xform.cpp
 void indent_mtx2 (GRFMTX_2D m);
 void xlat_mtx2 (GRFMTX_2D m, const double x, const double y);
 void scale_mtx2 (GRFMTX_2D m, const double sx, const double sy);
@@ -274,9 +274,9 @@ void vectorNumericStatistics (std::vector<double> vec, const int nPoints, double
 
 /* screen character codes */
 
-#define SC_BKSP                  8
-#define SC_TAB           9
-#define SC_BLANK       ' '
+#define SC_BKSP           8
+#define SC_TAB            9
+#define SC_BLANK        ' '
 
 
 /* audio.cpp */
@@ -296,17 +296,17 @@ unsigned int cio_kb_waitc(const char *astr, int beep);
 
 // Keyboard Section
 
-#define KEY_BKSP        8
-#define KEY_TAB                 9
-#define KEY_RETURN     13
-#define KEY_ESCAPE     27
+#define KEY_BKSP         8
+#define KEY_TAB          9
+#define KEY_RETURN      13
+#define KEY_ESCAPE      27
 
 // ASCII Section
 
 #define BACKSPACE  8
-// #define LF  0x0A
-// #define CR  0x0D
-#define BELL   0x07
+// #define LF   0x0A
+// #define CR   0x0D
+#define BELL    0x07
 
 #define SQUOTE    '\''
 #define DQUOTE    '\"'
@@ -315,30 +315,30 @@ unsigned int cio_kb_waitc(const char *astr, int beep);
 #define SHARP     '#'
 #define SLASH     '/'
 #define ASTERICK  '*'
-#define COLON    ':'
+#define COLON     ':'
 #define LBRACE    '{'
 #define RBRACE    '}'
-#define LPAREN   '('
+#define LPAREN    '('
 #define RPAREN    ')'
-#define LBRACK   '['
-#define RBRACK   ']'
+#define LBRACK    '['
+#define RBRACK    ']'
 #define LANBRACK  '<'
 #define RANBRACK  '>'
 #define SEMICOL   ';'
 #define UNDERLIN  '_'
-#define COMMA    ','
-#define CARET    '^'
-#define TILDE    '~'
-#define ATSIGN   '@'
+#define COMMA     ','
+#define CARET     '^'
+#define TILDE     '~'
+#define ATSIGN    '@'
 #define AMPERSAND  '&'
-#define EXCLAM   '!'
-#define DOLLAR   '$'
+#define EXCLAM    '!'
+#define DOLLAR    '$'
 #define PERCENT   '%'
-#define PLUS     '+'
-#define HYPHEN   '-'
-#define EQUALS   '='
+#define PLUS      '+'
+#define HYPHEN    '-'
+#define EQUALS    '='
 #define QUESTION  '?'
-#define PERIOD   '.'
+#define PERIOD    '.'
 #define VERTBAR   '|'
 
-#endif /* #ifndef CTSUPPORT_H */
+#endif  /* #ifndef CTSUPPORT_H */
index f60d08f..af9d585 100644 (file)
@@ -41,24 +41,24 @@ public:
   double *x;
   double *y;
   int m_iPointCount;
-  
+
   EZPlotCurve (const double* x, const double* y, int n);
-  
+
   ~EZPlotCurve();
 };
 
 //----------------------------------------------------------------------
-//                            GLOBAL VARIABLES                         
+//                             GLOBAL VARIABLES
 //----------------------------------------------------------------------
 
-// axis definitions 
+// axis definitions
 enum {
-  LINEAR =     1,              // linear axis 
-  LOG,         // logrithmic axis 
-  NOAXIS,      // don't plot axis 
+  LINEAR =      1,              // linear axis
+  LOG,          // logrithmic axis
+  NOAXIS,       // don't plot axis
 };
 
-// tick definitions 
+// tick definitions
 enum {
   ABOVE = 1,
  BELOW,
@@ -66,9 +66,9 @@ enum {
  LEFT,
 };
 
-// line types 
+// line types
 enum {
- NOLINE =      0,
+ NOLINE =       0,
  SOLID,
  DASH,
  DASH1,
@@ -77,7 +77,7 @@ enum {
  DASH4,
 };
 
-// symbol definitions 
+// symbol definitions
 enum {
  SB_CROSS = 1,
  SB_PLUS,
@@ -89,7 +89,7 @@ enum {
 };
 
 enum {
- INSIDE = 1,           // values of o_legendbox 
+ INSIDE = 1,            // values of o_legendbox
  OUTSIDE,
  NOLEGEND,
 };
@@ -101,26 +101,26 @@ struct KeywordCodeTable {
 };
 
 /*-----------------------------------------------------------------------------
-*                              GLOBAL VARIABLES
+*                               GLOBAL VARIABLES
 *
 * Naming Convention:
-*      i_   Internal variable
-*              Not user changable
-*      o_   Option variable
-*              Normal variable that is user modifiable
-*              These variables must always have a valid value
-*      d_   Device variable
-*              Variables controlling devices
+*       i_   Internal variable
+*               Not user changable
+*       o_   Option variable
+*               Normal variable that is user modifiable
+*               These variables must always have a valid value
+*       d_   Device variable
+*               Variables controlling devices
 *      clr_ Color variable
-*              Holds a color value
-*      c_   Character string variable
-*              Contains a character string
-*      v_   Value variable
-*              User modifiable variable associated with the set variable (s_)
-*              These variables do not always have a valid value
-*              These variables change assumption EZPLOT makes about the plot
-*      s_   Set variable.
-*              TRUE if associated value variable (v_) has been set by the user
+*               Holds a color value
+*       c_   Character string variable
+*               Contains a character string
+*       v_   Value variable
+*               User modifiable variable associated with the set variable (s_)
+*               These variables do not always have a valid value
+*               These variables change assumption EZPLOT makes about the plot
+*       s_   Set variable.
+*               TRUE if associated value variable (v_) has been set by the user
 *---------------------------------------------------------------------------*/
 
 #include <vector>
@@ -132,16 +132,16 @@ class SGP;
 class EZPlot {
 private:
   //----------------------------------------------------------------------
-  //                   POL Codes
+  //                    POL Codes
   //----------------------------------------------------------------------
-  
+
   enum {
     S_DATA = 2,
       S_HELP,
       S_EXIT,
       S_CURVE,
       S_SOLID,
-      S_DASH,      
+      S_DASH,
       S_NOLINE,
       S_BLACK,
       S_RED,
@@ -208,10 +208,10 @@ private:
       S_TAG,
       S_TEXTSIZE,
   };
-  
+
   static const struct KeywordCodeTable m_sKeywords[];
   static const int NKEYS;
-  
+
   std::vector<class EZPlotCurve*> m_vecCurves;
   std::vector<int> m_veciColor;
   std::vector<bool> m_vecbColorSet;
@@ -240,118 +240,118 @@ private:
   int m_iCurrentCurve;
 
   // Colors
-  int clr_axis;                        // color of all axis lines 
-  int clr_title;                       // color of main title 
-  int clr_label;                       // color of axis labels 
-  int clr_legend;                      // color of legend box 
-  int clr_grid;                        // color of grid lines 
-  int clr_number;                      // color of axis number labels 
-  
+  int clr_axis;                 // color of all axis lines
+  int clr_title;                        // color of main title
+  int clr_label;                        // color of axis labels
+  int clr_legend;                       // color of legend box
+  int clr_grid;                 // color of grid lines
+  int clr_number;                       // color of axis number labels
+
   // Options
-  double o_xporigin, o_yporigin;       // origin of plot frame in NDC 
-  double o_xlength, o_ylength; // length of plot frame in NDC 
-  
-  std::string c_xlabel;        // label for x axis 
-  std::string c_ylabel;        // label for y axis 
-  std::string c_title;         // title to print above graph 
-  
-  int o_linestyle, o_color;    // style to use for curves all subsequent curves to EZPLOT 
-  int o_xaxis, o_yaxis;                // Specifies where axis & labels are drawn 
-  bool o_grid;                 // Flag to draw a grid at major ticks 
-  bool o_box;                  // Flag to draw a box around the graph 
-  
-  int o_xticks, o_yticks;              // direction to draw tick marks 
-  bool o_xtlabel, o_ytlabel;   // TRUE if label tick marks 
-  
-  int o_xmajortick, o_ymajortick;      // number of major ticks to draw 
-  int o_xminortick, o_yminortick;      // number of minor ticks between major ticks 
-  
-  int o_symbol;                        // Symbol type, (0 = no symbol) 
-  int o_symfreq;                       // frequency to draw symbols at curve points 
-  
-  int o_legendbox;             // controls whether legend is inside or outside of the axis extents 
-  int o_tag;                   // controls whether to draw tag at end of axes 
-  
-  // VALUE & SET variables 
-  double v_xmin, v_xmax, v_ymin, v_ymax;       // user supplied axis endpoints 
-  bool   s_xmin, s_xmax, s_ymin, s_ymax;       // TRUE is endpoint has been set 
-  double v_xtitle, v_ytitle;   // NDC position to plot title 
-  bool   s_xtitle, s_ytitle;   // TRUE if set position for title 
-  double v_xcross, v_ycross;   // position that axes cross 
-  bool   s_xcross, s_ycross;   // TRUE if set axes cross position 
-  double v_xlegend, v_ylegend; // upper-left position of legend box in NDC 
-  bool   s_xlegend, s_ylegend; // TRUE if set position of legend box 
-  int  v_lxfrac, v_lyfrac;     // number of digits to right of decimal place 
-  bool s_lxfrac, s_lyfrac;     // TRUE if set number of fractional digits 
-  double v_textsize;           // size of text in NDC 
-  bool   s_textsize;           // TRUE if user set size of text 
-  
+  double o_xporigin, o_yporigin;        // origin of plot frame in NDC
+  double o_xlength, o_ylength;  // length of plot frame in NDC
+
+  std::string c_xlabel; // label for x axis
+  std::string c_ylabel; // label for y axis
+  std::string c_title;          // title to print above graph
+
+  int o_linestyle, o_color;     // style to use for curves all subsequent curves to EZPLOT
+  int o_xaxis, o_yaxis;         // Specifies where axis & labels are drawn
+  bool o_grid;                  // Flag to draw a grid at major ticks
+  bool o_box;                   // Flag to draw a box around the graph
+
+  int o_xticks, o_yticks;               // direction to draw tick marks
+  bool o_xtlabel, o_ytlabel;    // TRUE if label tick marks
+
+  int o_xmajortick, o_ymajortick;       // number of major ticks to draw
+  int o_xminortick, o_yminortick;       // number of minor ticks between major ticks
+
+  int o_symbol;                 // Symbol type, (0 = no symbol)
+  int o_symfreq;                        // frequency to draw symbols at curve points
+
+  int o_legendbox;              // controls whether legend is inside or outside of the axis extents
+  int o_tag;                    // controls whether to draw tag at end of axes
+
+  // VALUE & SET variables
+  double v_xmin, v_xmax, v_ymin, v_ymax;        // user supplied axis endpoints
+  bool   s_xmin, s_xmax, s_ymin, s_ymax;        // TRUE is endpoint has been set
+  double v_xtitle, v_ytitle;    // NDC position to plot title
+  bool   s_xtitle, s_ytitle;    // TRUE if set position for title
+  double v_xcross, v_ycross;    // position that axes cross
+  bool   s_xcross, s_ycross;    // TRUE if set axes cross position
+  double v_xlegend, v_ylegend;  // upper-left position of legend box in NDC
+  bool   s_xlegend, s_ylegend;  // TRUE if set position of legend box
+  int  v_lxfrac, v_lyfrac;      // number of digits to right of decimal place
+  bool s_lxfrac, s_lyfrac;      // TRUE if set number of fractional digits
+  double v_textsize;            // size of text in NDC
+  bool   s_textsize;            // TRUE if user set size of text
+
   // Global variables
-  double charheight;   // Height of characters in NDC 
-  double charwidth;    // Height of characters in NDC 
-  double  xp_min, xp_max, yp_min, yp_max;      // boundry of plot frame in NDC 
-  double  xa_min, xa_max, ya_min, ya_max;      // extent of axes in NDC 
-  double  xgw_min, xgw_max, ygw_min, ygw_max;  // boundary of graph in input coords 
-  double  xgn_min, xgn_max, ygn_min, ygn_max;  // boundy of graph in NDC 
-  double xt_min, xt_max, yt_min, yt_max;       // boundary of axis ticks 
-  double  xl_min, xl_max, yl_min, yl_max;      // boundary of legend box 
-  double title_row;    // y-coord of title row 
-  double xtl_ofs;              // Offset y-coord of x tick labels from axis 
-  double ytl_ofs;              // Offset x-coord of y tick labels from axis 
-  double xlbl_row;     // row of x label in world coord 
-  double ylbl_col;     // column of y label in world coord 
-  double xw_tickinc, yw_tickinc;       // increment between major ticks in WC 
-  double xn_tickinc, yn_tickinc;       // increment between major ticks in NDC 
-  int x_nint, y_nint;  // number of intervals along x & y axes 
-  int x_fldwid, x_frac;        // numeric field sizes & number of digits   
-  int y_fldwid, y_frac;        // in fraction of number, used for printf() 
-  double xtl_wid, ytl_wid;     // length of ticks labels in NDC 
-  double tl_height;    // height of tick labels in NDC 
-  char x_numfmt[20];   // format to print x tick labels 
-  char y_numfmt[20];   // format to print y tick labels 
-  
+  double charheight;    // Height of characters in NDC
+  double charwidth;     // Height of characters in NDC
+  double  xp_min, xp_max, yp_min, yp_max;       // boundry of plot frame in NDC
+  double  xa_min, xa_max, ya_min, ya_max;       // extent of axes in NDC
+  double  xgw_min, xgw_max, ygw_min, ygw_max;   // boundary of graph in input coords
+  double  xgn_min, xgn_max, ygn_min, ygn_max;   // boundy of graph in NDC
+  double xt_min, xt_max, yt_min, yt_max;        // boundary of axis ticks
+  double  xl_min, xl_max, yl_min, yl_max;       // boundary of legend box
+  double title_row;     // y-coord of title row
+  double xtl_ofs;               // Offset y-coord of x tick labels from axis
+  double ytl_ofs;               // Offset x-coord of y tick labels from axis
+  double xlbl_row;      // row of x label in world coord
+  double ylbl_col;      // column of y label in world coord
+  double xw_tickinc, yw_tickinc;        // increment between major ticks in WC
+  double xn_tickinc, yn_tickinc;        // increment between major ticks in NDC
+  int x_nint, y_nint;   // number of intervals along x & y axes
+  int x_fldwid, x_frac; // numeric field sizes & number of digits
+  int y_fldwid, y_frac; // in fraction of number, used for printf()
+  double xtl_wid, ytl_wid;      // length of ticks labels in NDC
+  double tl_height;     // height of tick labels in NDC
+  char x_numfmt[20];    // format to print x tick labels
+  char y_numfmt[20];    // format to print y tick labels
+
   double m_dVP_xmin, m_dVP_ymin;
   double m_dVP_xmax, m_dVP_ymax;
   double m_dVP_xscale, m_dVP_yscale;
   double m_xWorldScale, m_yWorldScale;
-  
+
   void drawAxes();
   void symbol (int sym, double symwidth, double symheight);
   void make_numfmt(char *fmtstr, int *fldwid, int *nfrac, double min, double max, int nint);
   int axis_scale (double min, double max, int nint, double *minp, double *maxp, int *nintp);
-  
+
   SGP* m_pSGP;
   POL m_pol;
-  
+
   void clearCurves ();
-  
+
   bool ezcmd (const char* const comm);
   bool do_cmd(int lx);
   void bad_option(char *opt);
   void initPlotSettings();
-  
+
   void initKeywords ();
-   
+
   double convertWorldToNDC_X (double x)
   { return xgn_min + (x - xgw_min) * m_xWorldScale; }
-  
+
   double convertWorldToNDC_Y (double y)
   { return ygn_min + (y - ygw_min) * m_yWorldScale; }
-  
+
  public:
    EZPlot ();
    ~EZPlot ();
-   
+
    bool ezset (const std::string& command);
    bool ezset (const char* const command);
-   
+
    void addCurve (const float* x, const double* y, int num);
    void addCurve (const double* x, const float* y, int num);
    void addCurve (const double* x, const double* y, int num);
    void addCurve (const double* y, int n);
    void addCurve (const float* y, int n);
-   
+
    void plot (SGP* pSGP);
-};     
+};
 
 #endif
index 5974e94..2f8567f 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         filter.h
+**      Name:         filter.h
 **      Purpose:      Signal filter header file
-**     Programmer:   Kevin Rosenberg
-**     Date Started: June 2000
+**      Programmer:   Kevin Rosenberg
+**      Date Started: June 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -49,7 +49,7 @@
 class SignalFilter {
  public:
     static const int FILTER_INVALID;
-    static const int FILTER_ABS_BANDLIMIT;     // filter times |x|
+    static const int FILTER_ABS_BANDLIMIT;      // filter times |x|
     static const int FILTER_ABS_SINC;
     static const int FILTER_ABS_G_HAMMING;
     static const int FILTER_ABS_HANNING;
@@ -65,7 +65,7 @@ class SignalFilter {
     static const int DOMAIN_INVALID;
     static const int DOMAIN_FREQUENCY;
     static const int DOMAIN_SPATIAL;
-    
+
     SignalFilter (const char* szFilterName, double dFilterMinimum, double dFilterMaximum, int nFilterPoints, double dBandwidth, double dFilterParam, const char* szDomainName);
 
     SignalFilter (const int idFilter, double dFilterMinimum, double dFilterMaximum, int nFilterPoints, double dBandwidth, double dFilterParam, const int idDomain);
@@ -77,13 +77,13 @@ class SignalFilter {
     double* getFilter (void) const
       { return m_adFilter; }
 
-    bool fail(void) const      {return m_fail;}
+    bool fail(void) const       {return m_fail;}
     const std::string& failMessage(void) const {return m_failMessage;}
 
-    const std::string& nameFilter(void) const  { return m_nameFilter;}
-    const std::string& nameDomain(void) const  { return m_nameDomain;}
-    const int idFilter(void) const     { return m_idFilter;}
-    const int idDomain(void) const     { return m_idDomain;}
+    const std::string& nameFilter(void) const   { return m_nameFilter;}
+    const std::string& nameDomain(void) const   { return m_nameDomain;}
+    const int idFilter(void) const      { return m_idFilter;}
+    const int idDomain(void) const      { return m_idDomain;}
 
     int getNFilterPoints (void) const  { return m_nFilterPoints; }
     const double getFilterMin(void) const {return m_dFilterMin;}
index 158bc3c..876c6a3 100644 (file)
@@ -119,7 +119,7 @@ using std::fstream;
 class fnetorderstream : public fstream {
  public:
   fnetorderstream (const char* filename, std::ios::openmode mode)
-         : fstream (filename, mode) {}
+          : fstream (filename, mode) {}
 
   ~fnetorderstream (void)
       {}
@@ -128,7 +128,7 @@ class fnetorderstream : public fstream {
   virtual void writeInt32 (kuint32 n);
   virtual void  writeFloat32 (kfloat32 n);
   virtual void  writeFloat64 (kfloat64 n);
-  
+
   virtual void  readInt16 (kuint16& n);
   virtual void  readInt32 (kuint32& n);
   virtual void  readFloat32 (kfloat32& n);
@@ -145,7 +145,7 @@ class frnetorderstream : public fnetorderstream {
   virtual void writeInt32 (kuint32 n);
   virtual void writeFloat32 (kfloat32 n);
   virtual void writeFloat64 (kfloat64 n);
-  
+
   virtual void readInt16 (kuint16& n);
   virtual void readInt32 (kuint32& n);
   virtual void readFloat32 (kfloat32& n);
index 5215a3a..f1067dd 100644 (file)
@@ -41,7 +41,7 @@ public:
     static void shuffleFourierToNaturalOrder (fftw_complex* pc, const int n);
     static void shuffleNaturalToFourierOrder (fftw_complex* pc, const int n);
 #endif
-    
+
 // Odd Number of Points
 //   Natural Frequency Order: -(n-1)/2...-1,0,1...(n-1)/2
 //   Fourier Frequency Order: 0, 1..(n-1)/2,-(n-1)/2...-1
@@ -49,7 +49,7 @@ public:
 //   Natural Frequency Order: -n/2...-1,0,1...((n/2)-1)
 //   Fourier Frequency Order: 0,1...((n/2)-1),-n/2...-1
     template<class T>
-    static void shuffleNaturalToFourierOrder (T* pVector, const int n) 
+    static void shuffleNaturalToFourierOrder (T* pVector, const int n)
     {
       T* pTemp = new T [n];
       int i;
@@ -82,7 +82,7 @@ public:
     int i;
     if (isOdd(n)) { // Odd
       int iHalfN = (n - 1) / 2;
-    
+
       pTemp[iHalfN] = pVector[0];
       for (i = 0; i < iHalfN; i++)
         pTemp[i + 1 + iHalfN] = pVector[i + 1];
@@ -96,7 +96,7 @@ public:
       for (i = 0; i < iHalfN - 1; i++)
         pTemp[i + iHalfN + 1] = pVector[i+1];
     }
-  
+
     for (i = 0; i < n; i++)
       pVector[i] = pTemp[i];
     delete pTemp;
index 57b08fa..bfad882 100644 (file)
@@ -1,9 +1,9 @@
 /* FILE IDENTIFICATION
 **
-**     File Name:      hashtable.h
-**     Author:         Kevin Rosenberg
-**     Purpose:        Header file for hash table library
-**     Date Started:   Dec. 2000
+**      File Name:      hashtable.h
+**      Author:         Kevin Rosenberg
+**      Purpose:        Header file for hash table library
+**      Date Started:   Dec. 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -35,11 +35,11 @@ private:
   std::string m_strKeyword;
   int m_iCode;
   class KeywordCodeEntry *m_pNext;
-  
+
   public:
-    
+
     KeywordCodeEntry (const char* const pszKeyword, int iCode);
-    
+
     const char* const getKeyword() const
     { return m_strKeyword.c_str(); }
 
@@ -47,13 +47,13 @@ private:
 
     int getCode () const
     { return m_iCode; }
-    
-    void setCode (int iCode) 
+
+    void setCode (int iCode)
     { m_iCode = iCode; }
-    
+
     void setNext (KeywordCodeEntry* pNext)
     { m_pNext = pNext; }
-    
+
     KeywordCodeEntry* getNext ()
     { return m_pNext; }
 };
@@ -64,19 +64,19 @@ public:
   enum {
     HASHSIZE = 100,
   };
-  
+
   KeywordCodeHashTable()
   { initTable(); }
-  
+
   ~KeywordCodeHashTable()
   { freeTable(); }
-  
+
   void installKeywordCode (const char* const pszKeyword, int iCode);
   KeywordCodeEntry* lookup (const char* const pszKeyword);
-  
+
 private:
   KeywordCodeEntry* m_hashTable[HASHSIZE];
-  
+
   int hash (const char* s);
   void initTable ();
   void freeTable ();
index f300cdb..be59fc1 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         imagefile.h
+**      Name:         imagefile.h
 **      Purpose:      imagefile class header
-**     Programmer:   Kevin Rosenberg
-**     Date Started: June 2000
+**      Programmer:   Kevin Rosenberg
+**      Date Started: June 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -46,7 +46,7 @@
 class F32Image : public Array2dFile
 {
 public:
-  F32Image (int nx, int ny, int dataType = Array2dFile::DATA_TYPE_REAL);     
+  F32Image (int nx, int ny, int dataType = Array2dFile::DATA_TYPE_REAL);
   F32Image (void);
 
   kfloat32** getArray (void)
@@ -238,7 +238,7 @@ public:
   static double redGrayscaleFactor() {return s_dRedGrayscaleFactor;}
   static double greenGrayscaleFactor() {return s_dGreenGrayscaleFactor;}
   static double blueGrayscaleFactor() {return s_dBlueGrayscaleFactor;}
-  static double colorToGrayscale (double r, double g, double b) 
+  static double colorToGrayscale (double r, double g, double b)
   { return r * s_dRedGrayscaleFactor + g * s_dGreenGrayscaleFactor + b * s_dBlueGrayscaleFactor; }
 };
 
index c1f4542..c30dd7d 100644 (file)
@@ -60,16 +60,16 @@ public:
   BilinearInterpolator (T** ppMatrix, unsigned int nx, unsigned int ny)
   : m_ppMatrix(ppMatrix), m_nx(nx), m_ny(ny)
   {}
-  
+
   T interpolate (double dXPos, double dYPos)
 {
   int iFloorX = static_cast<int>(floor(dXPos));
   int iFloorY = static_cast<int>(floor (dYPos));
   double dXFrac = dXPos - iFloorX;
   double dYFrac = dYPos - iFloorY;
-  
+
   T result = 0;
-  
+
   if (iFloorX < 0 || iFloorY < 0 || iFloorX > m_nx-1 || iFloorY > m_ny-1)
     result = 0;
   else if (iFloorX == m_nx - 1 && iFloorY == m_ny - 1)
@@ -80,11 +80,11 @@ public:
       result = static_cast<T>(m_ppMatrix[iFloorX][iFloorY] + dXFrac * (m_ppMatrix[iFloorX+1][iFloorY] - m_ppMatrix[iFloorX][iFloorY]));
   else
     result = static_cast<T>
-      ((1 - dXFrac) * (1 - dYFrac) * m_ppMatrix[iFloorX][iFloorY] + 
-       dXFrac * (1 - dYFrac) * m_ppMatrix[iFloorX+1][iFloorY] + 
+      ((1 - dXFrac) * (1 - dYFrac) * m_ppMatrix[iFloorX][iFloorY] +
+       dXFrac * (1 - dYFrac) * m_ppMatrix[iFloorX+1][iFloorY] +
        dYFrac * (1 - dXFrac) * m_ppMatrix[iFloorX][iFloorY+1] +
        dXFrac * dYFrac * m_ppMatrix[iFloorX+1][iFloorY+1]);
-  
+
   return result;
 }
     };
@@ -97,10 +97,10 @@ private:
   const int m_nAngle;
   const int m_nPos;
   int m_nCenterPos;
-  
+
 public:
   BilinearPolarInterpolator (T** ppMatrix, unsigned int nAngle,
-                            unsigned int nPos)
+                             unsigned int nPos)
   : m_ppMatrix(ppMatrix), m_nAngle(nAngle), m_nPos(nPos)
   {
     if (m_nPos %2)
@@ -115,9 +115,9 @@ public:
   int iFloorPos = static_cast<int>(floor (dPos));
   double dAngleFrac = dAngle - iFloorAngle;
   double dPosFrac = dPos - iFloorPos;
-  
+
   T result = 0;
-  
+
   if (iFloorAngle < -1 || iFloorPos < 0 || iFloorAngle > m_nAngle-1 || iFloorPos > m_nPos-1)
     result = 0;
   else if (iFloorAngle == -1 && iFloorPos == m_nPos-1)
@@ -132,25 +132,25 @@ public:
       int iLowerPos = (m_nPos-1) - iFloorPos;
       int iUpperPos = (m_nPos-1) - (iFloorPos+1);
       result = static_cast<T>
-       ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iFloorAngle][iFloorPos] + 
-        dAngleFrac * (1-dPosFrac) * m_ppMatrix[iUpperAngle][iLowerPos] + 
-        dPosFrac * (1-dAngleFrac) * m_ppMatrix[iFloorAngle][iFloorPos+1] +
-        dAngleFrac * dPosFrac * m_ppMatrix[iUpperAngle][iUpperPos]);
+        ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iFloorAngle][iFloorPos] +
+         dAngleFrac * (1-dPosFrac) * m_ppMatrix[iUpperAngle][iLowerPos] +
+         dPosFrac * (1-dAngleFrac) * m_ppMatrix[iFloorAngle][iFloorPos+1] +
+         dAngleFrac * dPosFrac * m_ppMatrix[iUpperAngle][iUpperPos]);
     } else if (iFloorAngle == -1) {
       int iLowerAngle = m_nAngle - 1;
       int iLowerPos = (m_nPos-1) - iFloorPos;
       int iUpperPos = (m_nPos-1) - (iFloorPos+1);
       result = static_cast<T>
-       ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iLowerAngle][iLowerPos] + 
-        dAngleFrac * (1-dPosFrac) * m_ppMatrix[iFloorAngle+1][iFloorPos] + 
-        dPosFrac * (1-dAngleFrac) * m_ppMatrix[iLowerAngle][iUpperPos] +
-        dAngleFrac * dPosFrac * m_ppMatrix[iFloorAngle+1][iFloorPos+1]);
+        ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iLowerAngle][iLowerPos] +
+         dAngleFrac * (1-dPosFrac) * m_ppMatrix[iFloorAngle+1][iFloorPos] +
+         dPosFrac * (1-dAngleFrac) * m_ppMatrix[iLowerAngle][iUpperPos] +
+         dAngleFrac * dPosFrac * m_ppMatrix[iFloorAngle+1][iFloorPos+1]);
     } else
       result = static_cast<T>
-       ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iFloorAngle][iFloorPos] + 
-        dAngleFrac * (1-dPosFrac) * m_ppMatrix[iFloorAngle+1][iFloorPos] + 
-        dPosFrac * (1-dAngleFrac) * m_ppMatrix[iFloorAngle][iFloorPos+1] +
-        dAngleFrac * dPosFrac * m_ppMatrix[iFloorAngle+1][iFloorPos+1]);
+        ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iFloorAngle][iFloorPos] +
+         dAngleFrac * (1-dPosFrac) * m_ppMatrix[iFloorAngle+1][iFloorPos] +
+         dPosFrac * (1-dAngleFrac) * m_ppMatrix[iFloorAngle][iFloorPos+1] +
+         dAngleFrac * dPosFrac * m_ppMatrix[iFloorAngle+1][iFloorPos+1]);
   }
   return result;
 }
@@ -168,7 +168,7 @@ public:
   BicubicPolyInterpolator (T** ppMatrix, unsigned int nx, unsigned int ny)
   : m_ppMatrix(ppMatrix), m_nx(nx), m_ny(ny)
   {}
-  
+
   T interpolate (double dXPos, double dYPos)
   {
     // int iFloorX = static_cast<int>(floor (dXPos));
@@ -197,11 +197,11 @@ public:
   LinearInterpolator (T* pY, unsigned int n, bool bZeroOutside = true)
   : m_pX(0), m_pY(pY), m_n(n), m_bZeroOutsideRange(bZeroOutside)
   {}
-  
+
   LinearInterpolator (T* pX, T* pY, unsigned int n, bool bZeroOutside = true)
   : m_pX(pX), m_pY(pY), m_n(n), m_bZeroOutsideRange(bZeroOutside)
   {}
-  
+
   double interpolate (double dX, int* piLastFloor = NULL)
   {
     double result = 0;
index 4d66c5f..e0b8d04 100644 (file)
@@ -37,30 +37,30 @@ class MPIWorld
     void setTotalWorkUnits (int totalUnits);
 
     int getRank (void) const
-       { return m_myRank; }
+        { return m_myRank; }
 
     int getNumProcessors (void) const
-       { return m_nProcessors; }
+        { return m_nProcessors; }
 
     int getStartWorkUnit (int rank) const
-       { return m_vStartWorkUnit [rank]; }
+        { return m_vStartWorkUnit [rank]; }
 
     int getEndWorkUnit (int rank) const
       { return m_vEndWorkUnit [rank]; }
 
     int getLocalWorkUnits (int rank) const
-       { return m_vLocalWorkUnits [rank]; }
+        { return m_vLocalWorkUnits [rank]; }
 
     int getMyStartWorkUnit (void) const
-       { return m_vStartWorkUnit [m_myRank]; }
+        { return m_vStartWorkUnit [m_myRank]; }
 
     int getMyEndWorkUnit (void) const
-       { return m_vEndWorkUnit [m_myRank]; }
+        { return m_vEndWorkUnit [m_myRank]; }
 
     int getMyLocalWorkUnits (void) const
-       { return m_vLocalWorkUnits [m_myRank]; }
+        { return m_vLocalWorkUnits [m_myRank]; }
 
-    MPI::Intracomm& getComm() 
+    MPI::Intracomm& getComm()
       { return m_comm; }
 
     void BcastString (string& str);
index 9eb0bf3..9fb9104 100644 (file)
@@ -59,7 +59,7 @@ class PhantomElement
     bool isPointInside (double x, double y, const CoordType coord_type) const;
 
     bool clipLineNormalizedCoords (double& x1, double& y1, double& x2, double& y2) const;
+
     bool clipLineWorldCoords (double& x1, double& y1, double& x2, double& y2) const;
 
     const int nOutlinePoints() const {return m_nPoints;}
@@ -85,22 +85,22 @@ class PhantomElement
     void printDefinition (std::ostringstream& os) const;
 
  private:
-    PhmElemType m_type;             // pelem type (box, ellipse, etc)
-    double m_cx, m_cy;      // center of pelem 
-    double m_u, m_v;                // size of pelem 
-    double m_atten;         // X-ray attenuation coefficient
-    double m_rot;                   // pelem rotation angle (in radians) 
-    double *m_x, *m_y;      // ptr to array of points in obj world coord 
-    int m_nPoints;                  // number of points in outline arrays 
-    double m_xmin, m_xmax, m_ymin, m_ymax;  // pelem limits 
+    PhmElemType m_type;      // pelem type (box, ellipse, etc)
+    double m_cx, m_cy;       // center of pelem
+    double m_u, m_v;                 // size of pelem
+    double m_atten;          // X-ray attenuation coefficient
+    double m_rot;                    // pelem rotation angle (in radians)
+    double *m_x, *m_y;       // ptr to array of points in obj world coord
+    int m_nPoints;                   // number of points in outline arrays
+    double m_xmin, m_xmax, m_ymin, m_ymax;  // pelem limits
     GRFMTX_2D m_xformPhmToObj;        // map from phantom to normalized pelem coords
-    GRFMTX_2D m_xformObjToPhm;        // map from normalized pelem coords to phantom coords 
+    GRFMTX_2D m_xformObjToPhm;        // map from normalized pelem coords to phantom coords
     double* m_xOutline;
     double* m_yOutline;
     double  m_rectLimits[4];
 
     static const int POINTS_PER_CIRCLE;
-    static const double SCALE_PELEM_EXTENT;  // increase pelem limits by 0.5% 
+    static const double SCALE_PELEM_EXTENT;  // increase pelem limits by 0.5%
 
     static const char* const convertTypeToName (PhmElemType iType);
 
@@ -121,8 +121,8 @@ class PhantomElement
 
 typedef enum {
     P_PELEMS,        // Phantom made of PElems
-    P_UNIT_PULSE,   // Special phantom, not made of pelems 
-    P_FILTER     // defined only by this type
+    P_UNIT_PULSE,   // Special phantom, not made of pelems
+    P_FILTER      // defined only by this type
 } PhantomComposition;
 
 
@@ -146,10 +146,10 @@ class Phantom
     ~Phantom ();
 
     void setComposition (PhantomComposition composition)
-       { m_composition = composition; }
+        { m_composition = composition; }
 
     const PhantomComposition getComposition () const
-       { return m_composition; }
+        { return m_composition; }
 
     bool createFromPhantom (const char* const phmName);
 
@@ -164,9 +164,9 @@ class Phantom
     void addPElem (const char* const composition, const double cx, const double cy, const double u, const double v, const double rot, const double atten);
 
     void convertToImagefile (ImageFile& im, double dViewRatio, const int in_nsample, const int trace) const;
-    void convertToImagefile (ImageFile& im, double dViewRatio, const int in_nsample, const int trace, 
+    void convertToImagefile (ImageFile& im, double dViewRatio, const int in_nsample, const int trace,
       const int colStart, const int colCount, bool bStoreAtColumnPos) const;
-    void convertToImagefile (ImageFile& im, int iNX, double dViewRatio, const int in_nsample, const int trace, 
+    void convertToImagefile (ImageFile& im, int iNX, double dViewRatio, const int in_nsample, const int trace,
       const int colStart, const int colCount, int iStorageOffset) const;
 
     void printDefinitions (std::ostream& os) const;
@@ -182,24 +182,24 @@ class Phantom
     void show (SGP& sgp) const;
     void draw (SGP& sgp) const;
 #endif
-    
+
     void addStdHerman ();
     void addStdSheppLogan ();
 
     void print (std::ostream& os) const;
     void print (std::ostringstream& os) const;
 
-    double maxAxisLength () const 
+    double maxAxisLength () const
     {  return maxValue<double> (m_xmax - m_xmin, m_ymax - m_ymin); }
 
-    double getDiameterBoundaryCircle() const 
+    double getDiameterBoundaryCircle() const
     { return SQRT2 * maxAxisLength(); }
 
     const double xmin() const {return m_xmin;}
     const double xmax() const {return m_xmax;}
     const double ymin() const {return m_ymin;}
     const double ymax() const {return m_ymax;}
-         std::list<PhantomElement*>& listPElem() {return m_listPElem;}
+          std::list<PhantomElement*>& listPElem() {return m_listPElem;}
     const std::list<PhantomElement*>& listPElem() const {return m_listPElem;}
     const int nPElem() const {return m_nPElem;}
 
@@ -212,7 +212,7 @@ class Phantom
 
  private:
     PhantomComposition m_composition;
-    int m_nPElem;                          // number of pelems in phantom 
+    int m_nPElem;                           // number of pelems in phantom
     double m_xmin, m_xmax, m_ymin, m_ymax;  // extent of pelems in pelem coordinates
     mutable std::list<PhantomElement*> m_listPElem;      // pelem lists
     std::string m_name;
index 2643081..14da947 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         plotfile.h
+**      Name:         plotfile.h
 **      Purpose:      PlotFile class header
-**     Programmer:   Kevin Rosenberg
-**     Date Started: Dec 2000
+**      Programmer:   Kevin Rosenberg
+**      Date Started: Dec 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -58,7 +58,7 @@
 
 
 
-class PlotFile 
+class PlotFile
 {
 private:
   std::string m_strFilename;
@@ -69,71 +69,71 @@ private:
   int m_iNumColumns;
   int m_iNumRecords;
   bool m_bScatterPlot;
-  
+
   bool headerRead (std::iostream& os);
   bool headerWrite (std::iostream& os);
   bool columnsRead (std::iostream& os);
   bool columnsWrite (std::iostream& os);
-  
+
   void initHeaders ();
-  
+
   PlotFile (const PlotFile& rhs);        // copy constructor
   PlotFile& operator= (const PlotFile&); // assignment operator
-  
+
 public:
   PlotFile (int iNColumns, int iNRecords);
   PlotFile (void);
   ~PlotFile ();
-  
+
   void setCurveSize (int iNCurves, int iNRecords, bool bScatterPlot = false);
-  
+
   void addDescription (const char* const pszDesc)
   { m_vecStrDescriptions.push_back (pszDesc); }
-  
+
   void addEzsetCommand (const char* const pszCmd)
   { m_vecStrEzsetCommands.push_back (pszCmd); }
-  
+
   bool addColumn (int iCol, const double* const pdColumn);
-  
+
   bool addColumn (int iCol, const float* const pdColumn);
-  
+
   void getColumn (int iCol, double *pdColumnData) const;
-  
+
   const std::string& getDate () const
   { return m_strDate; }
-  
+
   int getNumColumns () const
   { return m_iNumColumns; }
-  
+
   int getNumRecords () const
   { return m_iNumRecords; }
-  
+
   bool getIsScatterPlot() const
   { return m_bScatterPlot; }
-  
+
   bool getMinMax (int startingCol, double& min, double& max) const;
-  
+
   bool statistics (int startingCol, double& min, double& max, double& mean, double& mode, double& median, double &stddev) const;
-  
+
   unsigned int getNumDescriptions (void) const
   { return m_vecStrDescriptions.size(); }
-  
+
   const std::string& getDescription (int iDescIndex) const
   { return m_vecStrDescriptions[iDescIndex]; }
-  
+
   unsigned int getNumEzsetCommands (void) const
   { return m_vecStrEzsetCommands.size(); }
-  
+
   const std::string& getEzsetCommand (int iIndex) const
   { return m_vecStrEzsetCommands[iIndex]; }
-  
+
   bool fileRead (const char* const filename);
-  
+
   bool fileWrite (const char* const filename);
-  
-  const std::string& getFilename (void) const 
+
+  const std::string& getFilename (void) const
   {  return m_strFilename; }
-  
+
   void printHeaders (std::ostream& os) const;
   void printHeaders (std::ostringstream& os) const;
   void printHeadersBrief (std::ostream& os) const;
index 5d6a96d..7b75fda 100644 (file)
@@ -1,8 +1,8 @@
 /*****************************************************************************
-**     Name:         pol.h
+**      Name:         pol.h
 **      Purpose:      Header file for Problem Oriented Language Class
-**     Programmer:   Kevin Rosenberg
-**     Date Started: 1984
+**      Programmer:   Kevin Rosenberg
+**      Date Started: 1984
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
 #include <stack>
 
 class POL {
-  
+
   public:
-    
-    // codes for pol_usefile 
+
+    // codes for pol_usefile
     enum {
-      P_USE_STR = 1,           // use string as input source 
-      P_USE_FILE,                // use file as input source 
+      P_USE_STR = 1,            // use string as input source
+      P_USE_FILE,                 // use file as input source
     };
 
-  
+
     POL();
     ~POL();
-    
+
     void init ();
     void addSkipWord (const char* const w);
     void addSkipChar (int c);
@@ -61,10 +61,10 @@ class POL {
     void ungetch (int c);
     int get_inputline (FILE *fp);
     void set_inputline (const char* const line);
-    
+
 
   enum {
-    MAXTOK = 200,              // maximum length of a token 
+    MAXTOK = 200,               // maximum length of a token
       MAXLINE = 1024,       // maximum line length
       MAXIDENT = 20,
       MAXSKIPWORD = 20,
@@ -72,98 +72,98 @@ class POL {
       MIN_INT = -2000000000,
       MAX_INT =  2000000000,
   };
-  
-  // token types 
+
+  // token types
   enum {
-    TT_STRING = 1,  // string token 
-      TT_INT,         // integer token 
-      TT_REAL,                 // floating point token 
-      TT_ALPHA,                // alphabetic token 
-      TT_ALPNUM,               // alphanumeric token 
+    TT_STRING = 1,  // string token
+      TT_INT,         // integer token
+      TT_REAL,                  // floating point token
+      TT_ALPHA,                 // alphabetic token
+      TT_ALPNUM,                // alphanumeric token
       TT_NUMALPHA,
       TT_SPECLCHAR,
-      TT_EOF,         // end of file reached 
-      TT_ERROR,       // error in token, caused by call to wrong type of token reader 
-      TT_BLANK,        // white space token.  pol_tok() skips these 
-      TT_USERTOK,     // user defined token 
+      TT_EOF,         // end of file reached
+      TT_ERROR,       // error in token, caused by call to wrong type of token reader
+      TT_BLANK,        // white space token.  pol_tok() skips these
+      TT_USERTOK,     // user defined token
   };
 
-  
+
 private:
-  
-  // codes for pol_int and pol_float 
-  // if in reject catagory, get new number from terminal 
+
+  // codes for pol_int and pol_float
+  // if in reject catagory, get new number from terminal
   enum {
-    P_FLTINT = 1,       // get a real or integer number 
-      P_BFLTINT,     // get a real or integer number, clip against bounds 
-      P_CBFLTINT,       // get real or int, reject if outside bounds 
-      P_FLT,              // get a real number 
-      P_BFLT,        // get a real, clip against bounds 
-      P_CBFLT,       // get a floating, reject if outside bounds 
-      P_INT,         // get a integer number 
-      P_BINT,        // get a integer, clip against bounds 
-      P_CBINT,       // get a integer, reject if outside bounds 
+    P_FLTINT = 1,        // get a real or integer number
+      P_BFLTINT,     // get a real or integer number, clip against bounds
+      P_CBFLTINT,        // get real or int, reject if outside bounds
+      P_FLT,               // get a real number
+      P_BFLT,        // get a real, clip against bounds
+      P_CBFLT,       // get a floating, reject if outside bounds
+      P_INT,         // get a integer number
+      P_BINT,        // get a integer, clip against bounds
+      P_CBINT,       // get a integer, reject if outside bounds
   };
-  
+
 #define LETTER   'a'
 #define DIGIT    '0'
-  
-  
+
+
 //  typedef std::map<std::string,int> KeywordCodeList;
-  
+
   struct token_st {
-    int ready;                         // TRUE if token is ready 
-  //  std::string tokstr;      // token string 
+    int ready;                          // TRUE if token is ready
+  //  std::string tokstr;       // token string
     char tokstr[MAXTOK+1];
-    int type;                            // type of token 'TT_' 
-    int code;                            // holds code for user defined tokens 
-    double fnum;                       // real value of token 
-    int inum;                      // integer value of token 
+    int type;                             // type of token 'TT_'
+    int code;                             // holds code for user defined tokens
+    double fnum;                        // real value of token
+    int inum;                       // integer value of token
   };
   typedef struct token_st TOKEN;
-  struct token_st token;                               // current token 
-   
-  // Tables words stored with install() & found with lookup() 
-  KeywordCodeHashTable skiptable;              // words to ignore and skip 
-  KeywordCodeHashTable cmdtable;               // pol parameter commands 
-  KeywordCodeHashTable usertable;              // user defined symbols 
-  
+  struct token_st token;                                // current token
+
+  // Tables words stored with install() & found with lookup()
+  KeywordCodeHashTable skiptable;               // words to ignore and skip
+  KeywordCodeHashTable cmdtable;                // pol parameter commands
+  KeywordCodeHashTable usertable;               // user defined symbols
+
   struct metachar {
-    char eoc;          /* end of command character */
-    char str;          /* string delimiter */
-    char com;          /* comment character */
-    char cmd;          /* pol parameter command character */
-    char prg;          /* program load character */
-    char con;          /* continuation across newline character */
-    char out;          /* character that delimits output to terminal */
-    char ter;          /* character indicates insertion of input from terminal */
-    char inb;          /* input from graphics device */
+    char eoc;           /* end of command character */
+    char str;           /* string delimiter */
+    char com;           /* comment character */
+    char cmd;           /* pol parameter command character */
+    char prg;           /* program load character */
+    char con;           /* continuation across newline character */
+    char out;           /* character that delimits output to terminal */
+    char ter;           /* character indicates insertion of input from terminal */
+    char inb;           /* input from graphics device */
   } meta;
-  
-  
+
+
   char m_szSkipChars [MAXSKIPCHAR]; // characters to skip
   bool m_bTrace;
   bool m_bNewlineIsEOC;
-  
+
   struct KeywordCodeList {
     char *keyword;
     int  code;
   };
-  
+
   static const struct KeywordCodeList cmdlist[];
   static const unsigned int NUMCMD;
-  
-  // Internal codes for pol commands 
+
+  // Internal codes for pol commands
   enum {
     PC_EOC = 1,
       PC_STR,
       PC_COM,
       PC_CMD,
       PC_PRG,
-      PC_CON,  
+      PC_CON,
       PC_OUT,
       PC_TER,
-      PC_INB,     
+      PC_INB,
       PC_NL_EOC,
       PC_NL_NEOC,
       PC_TRON,
@@ -171,7 +171,7 @@ private:
       PC_FILE,
       PC_DUMP,
   };
-  
+
   enum {
     INPUT_STREAM = 1,
     INPUT_FILE,
@@ -186,21 +186,21 @@ private:
   enum {
     MAXFILE = 8,
   };
-  
-  int currentf;                /* pointer to current fp */
-  FILE *filep[MAXFILE];                /* == NULL for string input */
-  char *fname[MAXFILE];                /* pointer to filename */
-  
-  char inputline[MAXLINE];             /* current input line */
-  int lineptr;                 /* current position in inputline */
-  
+
+  int currentf;         /* pointer to current fp */
+  FILE *filep[MAXFILE];         /* == NULL for string input */
+  char *fname[MAXFILE];         /* pointer to filename */
+
+  char inputline[MAXLINE];              /* current input line */
+  int lineptr;                  /* current position in inputline */
+
   std::stack<int> m_stackPushBackInput;
 
   bool skipSingleToken (char term[]);
   int tok (struct token_st *token);
   void dumptok (struct token_st *token);
-  
-  
+
+
   int getpol_tok (struct token_st *token);
   int getcmd ();
   int gettok (TOKEN *tok);
@@ -212,7 +212,7 @@ private:
   void eatline ();
   int type (int c);
   int getch (FILE *fp);
-  
+
 };
 
 #endif
index 14b8f6f..9da33e0 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         filter.h
+**      Name:         filter.h
 **      Purpose:      Signal filter header file
-**     Programmer:   Kevin Rosenberg
-**     Date Started: June 2000
+**      Programmer:   Kevin Rosenberg
+**      Date Started: June 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -65,16 +65,16 @@ class ProcessSignal {
       BACKWARD = 1,
     };
 
-    ProcessSignal (const char* szFilterName, const char* szFilterMethodName,double bw, double signalIncrement, 
-      int n, double param, const char* szDomainName, const char* szFilterGenerationName, 
-      const int zeropad, const int preinterpolationFactor, const int iTraceLevel, int iGeometry, 
+    ProcessSignal (const char* szFilterName, const char* szFilterMethodName,double bw, double signalIncrement,
+      int n, double param, const char* szDomainName, const char* szFilterGenerationName,
+      const int zeropad, const int preinterpolationFactor, const int iTraceLevel, int iGeometry,
       double dFocalLength, double dSourceDetectorLength, SGP* pSGP = NULL);
 
     ~ProcessSignal();
 
     void filterSignal (const float input[], double output[]) const;
 
-    bool fail(void) const      {return m_fail;}
+    bool fail(void) const       {return m_fail;}
     const std::string& failMessage(void) const {return m_failMessage;}
 
     void setTraceLevel (int traceLevel) {m_traceLevel = traceLevel; }
@@ -94,7 +94,7 @@ class ProcessSignal {
     static int convertFilterGenerationNameToID (const char* const fgName);
     static const char* convertFilterGenerationIDToName (const int idFG);
     static const char* convertFilterGenerationIDToTitle (const int idFG);
-  
+
     static const int getFilterMethodCount() {return s_iFilterMethodCount;}
     static const char* const* getFilterMethodNameArray() {return s_aszFilterMethodName;}
     static const char* const* getFilterMethodTitleArray() {return s_aszFilterMethodTitle;}
@@ -111,8 +111,8 @@ class ProcessSignal {
     static int addZeropadFactor (int n, int iZeropad);
 
  private:
-        std::string m_nameFilterMethod;
-        std::string m_nameFilterGeneration;
+         std::string m_nameFilterMethod;
+         std::string m_nameFilterGeneration;
     int m_idFilterMethod;
     int m_idFilterGeneration;
     int m_nSignalPoints;
@@ -157,12 +157,12 @@ class ProcessSignal {
     fftw_plan m_complexPlanForward, m_complexPlanBackward;
 #endif
 
-    void init (const int idFilter, int idFilterMethod, double dBandwidth, double dSignalIncrement, 
-      int nSignalPoints, double dFilterParam, const int idDomain, int idFilterGeneration, const int iZeropad, 
-      const int iPreinterpolationFactor, const int iTraceLevel, const int iGeometry, double dFocalLength, 
+    void init (const int idFilter, int idFilterMethod, double dBandwidth, double dSignalIncrement,
+      int nSignalPoints, double dFilterParam, const int idDomain, int idFilterGeneration, const int iZeropad,
+      const int iPreinterpolationFactor, const int iTraceLevel, const int iGeometry, double dFocalLength,
       double dSourceDetectorLength, SGP* pSGP);
 
-    // transforms that use precalculated trig tables, therefore don't 
+    // transforms that use precalculated trig tables, therefore don't
     // require number of data points (n) as an argument
     void finiteFourierTransform (const double input[], std::complex<double> output[], const int direction) const;
     void finiteFourierTransform (const std::complex<double> input[], std::complex<double> output[], const int direction) const;
index 38aea33..79e8f71 100644 (file)
@@ -41,7 +41,7 @@ class fnetorderstream;
 
 
 //used for rebinning divergent beam projections to parallel
-class ParallelRaysumCoordinate {  
+class ParallelRaysumCoordinate {
 public:
   double m_dT;      // Distance from center of origin
   double m_dTheta;  // perpendicular angle to origin
@@ -137,10 +137,10 @@ class Projections
 
   bool convertPolar (ImageFile& rIF, int iInterpolation);
   bool convertFFTPolar (ImageFile& rIF, int iInterpolation, int iZeropad);
-  void calcArrayPolarCoordinates (unsigned int nx, unsigned int ny, double** ppdView, double** ppdDet, 
+  void calcArrayPolarCoordinates (unsigned int nx, unsigned int ny, double** ppdView, double** ppdDet,
     int iNumDetWithZeros, double dZeropadRatio, double dDetInc);
   void interpolatePolar (ImageFileArray& v, ImageFileArray& vImag, unsigned int nx, unsigned int ny, std::complex<double>** ppcDetValue,
-    double** ppdDet, double** ppdView, unsigned int nView, unsigned int nDet, unsigned int nDetWithZeros, 
+    double** ppdDet, double** ppdView, unsigned int nView, unsigned int nDet, unsigned int nDetWithZeros,
     int iInterpolate);
 
   bool reconstruct (ImageFile& im, const char* const filterName, double filt_param, const char* const filterMethodName, const int zeropad, const char* frequencyFilterName, const char* const interpName, int interp_param, const char* const backprojName, const int trace) const;
@@ -174,7 +174,7 @@ class Projections
 
   DetectorArray& getDetectorArray (const int iview)
       { return (*m_projData[iview]); }
-  
+
   const DetectorArray& getDetectorArray (const int iview) const
       { return (*m_projData[iview]); }
 
@@ -183,19 +183,19 @@ class Projections
 
   static bool copyViewData (const char* const filename, std::ostream& os, int startView, int endView);
   static bool copyViewData (const std::string& filename, std::ostream& os, int startView, int endView);
-  
+
  private:
-  int m_headerSize;            // Size of disk file header 
-  int m_geometry;              // Geometry of scanner 
-  class DetectorArray **m_projData;    // Pointer to array of detarray_st pointers 
-  std::string m_remark;                // description of raysum data 
-  int m_nDet;                  // number of detectors in array 
-  int m_nView;                 // number of rotated views 
-  double m_calcTime;           // time required to calculate raysums 
-  double m_rotStart;           // starting view rotation
-  double m_rotInc;             // angle between rotations 
-  double m_detStart;           // distance of beginning detector to center phantom
-  double m_detInc;             // increment between detectors 
+  int m_headerSize;             // Size of disk file header
+  int m_geometry;               // Geometry of scanner
+  class DetectorArray **m_projData;     // Pointer to array of detarray_st pointers
+  std::string m_remark;         // description of raysum data
+  int m_nDet;                   // number of detectors in array
+  int m_nView;                  // number of rotated views
+  double m_calcTime;            // time required to calculate raysums
+  double m_rotStart;            // starting view rotation
+  double m_rotInc;              // angle between rotations
+  double m_detStart;            // distance of beginning detector to center phantom
+  double m_detInc;              // increment between detectors
   double m_dFocalLength;
   double m_dSourceDetectorLength;
   double m_dViewDiameter;
index c09d39d..82d8930 100644 (file)
@@ -1,7 +1,7 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**   Name:        reconstruct.h          Header file for Reconstruction class
+**   Name:         reconstruct.h          Header file for Reconstruction class
 **   Programmer:   Kevin Rosenberg
 **   Date Started: Aug 84
 **
@@ -42,7 +42,7 @@ struct ReconstructionROI {
   double m_dYMax;
 };
 
-class Reconstructor 
+class Reconstructor
 {
  private:
     const Projections& m_rOriginalProj;
@@ -59,16 +59,16 @@ class Reconstructor
     double* m_adPlotXAxis;
 
  public:
-    Reconstructor (const Projections& rProj, ImageFile& rIF, const char* const filterName, double filt_param, 
-      const char* const filterMethodName, const int zeropad, const char* filterGenerationName, 
-      const char* const interpName, int interpFactor, const char* const backprojectName, const int trace, 
+    Reconstructor (const Projections& rProj, ImageFile& rIF, const char* const filterName, double filt_param,
+      const char* const filterMethodName, const int zeropad, const char* filterGenerationName,
+      const char* const interpName, int interpFactor, const char* const backprojectName, const int trace,
       ReconstructionROI* pROI = NULL, bool bRebinToParallel = false, SGP* pSGP = NULL);
 
     ~Reconstructor ();
 
     bool fail() const {return m_bFail;}
     const std::string& failMessage() const {return m_strFailMessage;}
-    
+
     void plotFilter (SGP* pSGP = NULL);
 
     void reconstructAllViews ();
index 8fdf386..7749e49 100644 (file)
@@ -56,9 +56,9 @@ class DetectorArray
       { m_viewAngle = viewAngle; }
 
  private:
-  DetectorValue* m_detValues;  // Pointer to array of values recorded by detector 
-  int m_nDet;                  // Number of detectors in array */
-  double m_viewAngle;           // View angle in radians 
+  DetectorValue* m_detValues;   // Pointer to array of values recorded by detector
+  int m_nDet;                   // Number of detectors in array */
+  double m_viewAngle;           // View angle in radians
 
   DetectorArray& operator=(const DetectorArray& rhs);   // assignment
   DetectorArray (const DetectorArray& rhs);             // copy constructor
@@ -74,12 +74,12 @@ class Scanner
   static const int GEOMETRY_EQUIANGULAR;
   static const int GEOMETRY_LINOGRAM;
 
-  
-  Scanner (const Phantom& phm, const char* const geometryName, int nDet, 
-    int nView, int iOffsetView, int nSample, const double rot_anglen, 
+
+  Scanner (const Phantom& phm, const char* const geometryName, int nDet,
+    int nView, int iOffsetView, int nSample, const double rot_anglen,
     double dFocalLengthRatio, double dCenterDetectorRatio, double dViewRatio, double dScanRatio);
   ~Scanner();
-  
+
   void collectProjections (Projections& proj, const Phantom& phm, const int trace = Trace::TRACE_NONE,
     SGP* pSGP = NULL);
 
@@ -95,7 +95,7 @@ class Scanner
   unsigned int nDet() const {return m_nDet;}
   unsigned int nView() const {return m_nView;}
   unsigned int offsetView() const {return m_iOffsetView;}
-  unsigned int startView() const {return m_startView;} 
+  unsigned int startView() const {return m_startView;}
   double rotInc() const {return m_rotInc;}
   double detInc() const {return m_detInc;}
   double detLen() const {return m_detLen;}
@@ -116,41 +116,41 @@ class Scanner
   static int convertGeometryNameToID (const char* const geometryName);
   static const char* convertGeometryIDToName (const int idGeometry);
   static const char* convertGeometryIDToTitle (const int idGeometry);
-  
+
  private:
   bool m_fail;
   std::string m_failMessage;
   int m_idGeometry;
-  unsigned int m_nDet;         /* Number of detectors in array */
-  unsigned int m_nView;                /* Number of rotated views */
-  unsigned int m_iOffsetView; 
-  unsigned int m_startView; 
-  unsigned int m_nSample;      /* Number of rays per detector */
+  unsigned int m_nDet;          /* Number of detectors in array */
+  unsigned int m_nView;         /* Number of rotated views */
+  unsigned int m_iOffsetView;
+  unsigned int m_startView;
+  unsigned int m_nSample;       /* Number of rays per detector */
   double m_dFocalLength;        // Focal Length, distance from source to center
   double m_dSourceDetectorLength; // Distance from source to detectors
   double m_dCenterDetectorLength; // Distance from center to detectors
   double m_dViewDiameter; // Diameter of area being processed
   double m_dScanDiameter; // Diamer of area being scanned
   double m_dViewRatio;   // View Ratio to diameter phantom
-  double m_dFocalLengthRatio;   // Source to Center Length as ratio to viewDiameter radius 
+  double m_dFocalLengthRatio;   // Source to Center Length as ratio to viewDiameter radius
   double m_dCenterDetectorRatio; // Center to Detector Length as ratio of viewDiameter radius
   double m_dScanRatio;       // Scan length to view length ratio
   double m_dFanBeamAngle;
-  double m_detLen;             // Total length of detector array 
-  double m_rotLen;             // Rotation angle length in radians (norm 2PI)
-  double m_detInc;             // Increment between centers of detectors 
-  double m_rotInc;             // Increment in rotation angle between views 
+  double m_detLen;              // Total length of detector array
+  double m_rotLen;              // Rotation angle length in radians (norm 2PI)
+  double m_detInc;              // Increment between centers of detectors
+  double m_rotInc;              // Increment in rotation angle between views
   double m_detStart;
   double m_dXCenter;            // Center of Phantom
-  double m_dYCenter;            
+  double m_dYCenter;
   double m_dAngularDetIncrement;
   double m_dAngularDetLen;
 
   int m_trace;
   struct {
-    double xd1,yd1,xd2,yd2;    /* Coordinates of detector endpoints */
-    double xs1,ys1,xs2,ys2;    /* Coordinates of source endpoints */
-    double angle;              /* Starting angle */
+    double xd1,yd1,xd2,yd2;     /* Coordinates of detector endpoints */
+    double xs1,ys1,xs2,ys2;     /* Coordinates of source endpoints */
+    double angle;               /* Starting angle */
     double dAngularDet;
   } m_initPos;
 
index ee6594e..7cb3409 100644 (file)
@@ -72,7 +72,7 @@ public:
 #endif
 
   SGPDriver (const char* szWinTitle = "", int xsize = 640, int ysize = 480);
-  
+
   ~SGPDriver ();
 
   int getPhysicalXSize () const
@@ -106,19 +106,19 @@ public:
 class SGP_RGBColor;
 class SGP {
 private:
-  int m_iPhysicalXSize;   // Physical Window size 
+  int m_iPhysicalXSize;   // Physical Window size
   int m_iPhysicalYSize;
   SGPDriver m_driver;
 
-  double xw_min;    // Window extents 
+  double xw_min;    // Window extents
   double yw_min;
   double xw_max;
   double yw_max;
-  double xv_min;    // Viewport extents 
+  double xv_min;    // Viewport extents
   double yv_min;
   double xv_max;
   double yv_max;
-  double viewNDC[4];   // Viewport array for clip_rect() 
+  double viewNDC[4];   // Viewport array for clip_rect()
 
   int m_iCurrentPhysicalX;
   int m_iCurrentPhysicalY;
@@ -134,11 +134,11 @@ private:
   // Master coordinates are coordinates before CTM transformation
   // World coordinates are coordinates defined by setWindow()
   // Normalized device coordinates range from 0. to 1. in both axes
-  TransformationMatrix2D wc_to_ndc;     // World coord to NDC matrix 
-  TransformationMatrix2D mc_to_ndc;     // Master to NDC 
+  TransformationMatrix2D wc_to_ndc;     // World coord to NDC matrix
+  TransformationMatrix2D mc_to_ndc;     // Master to NDC
   TransformationMatrix2D ndc_to_mc;     // NDC to Master
-  TransformationMatrix2D m_ctm;         // Current transfromation matrix 
-  
+  TransformationMatrix2D m_ctm;         // Current transfromation matrix
+
   void calc_transform ();
 
   static SGP_RGBColor s_aRGBColor[];
@@ -152,7 +152,7 @@ private:
 #endif
 
 public:
-  enum {                  // linestyles 
+  enum {                  // linestyles
       LS_NOLINE = 0,
       LS_SOLID = 0xffff,
       LS_DASH1 = 0xff00,
@@ -163,17 +163,17 @@ public:
   };
 
   enum {            // Codes for marker symbols
-      MARKER_POINT = 0,        // small dot 
-      MARKER_SQUARE = 1,       // empty square 
-      MARKER_FSQUARE = 2,      // filled square 
-      MARKER_DIAMOND = 3,      // empty diamond 
-      MARKER_FDIAMOND = 4,     // filled diamond 
-      MARKER_CROSS =  5,       // cross 
-      MARKER_XCROSS = 6,       // x 
-      MARKER_CIRCLE = 7,    // open circle 
-      MARKER_FCIRCLE = 8,      // filled circle 
-      MARKER_BSQUARE = 9,      // big open square 
-      MARKER_BDIAMOND = 10,    // big open diamond 
+      MARKER_POINT = 0, // small dot
+      MARKER_SQUARE = 1,        // empty square
+      MARKER_FSQUARE = 2,       // filled square
+      MARKER_DIAMOND = 3,       // empty diamond
+      MARKER_FDIAMOND = 4,      // filled diamond
+      MARKER_CROSS =  5,        // cross
+      MARKER_XCROSS = 6,        // x
+      MARKER_CIRCLE = 7,    // open circle
+      MARKER_FCIRCLE = 8,       // filled circle
+      MARKER_BSQUARE = 9,       // big open square
+      MARKER_BDIAMOND = 10,     // big open diamond
   };
   enum  { MARK_COUNT = 11, };
   static const unsigned char MARKER_BITMAP[MARK_COUNT][5];
@@ -245,7 +245,7 @@ public:
 
 
 enum {
-    C_BLACK     = 0,     // color codes 
+    C_BLACK     = 0,     // color codes
     C_BLUE      = 1,
     C_GREEN     = 2,
     C_CYAN      = 3,
index f1a063e..a86027e 100644 (file)
@@ -4,7 +4,7 @@
 **      Name:         timer.h
 **      Purpose:      Header file for Timer class
 **      Author:       Kevin Rosenberg
-**      Date Started: Sep 2000 
+**      Date Started: Sep 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -28,7 +28,7 @@
 #ifndef _TIMER_H
 #define _TIMER_H
 
-// pragma line required for Fedora 4 and wxWin 2.4.2 
+// pragma line required for Fedora 4 and wxWin 2.4.2
 #if defined(__GNUG__) && !defined(__APPLE__)
    #pragma implementation "timer.h"
 #endif
@@ -49,33 +49,33 @@ class Timer
 {
  public:
     Timer (void)
-       { m_timeStart = ttime(); }
+        { m_timeStart = ttime(); }
 
     virtual ~Timer (void)
-       {}
+        {}
 
     virtual double timerEnd (void)
       {
-       m_timeEnd = ttime();
-       m_timeElapsed = m_timeEnd - m_timeStart;
-  
-       return (m_timeElapsed);
+        m_timeEnd = ttime();
+        m_timeElapsed = m_timeEnd - m_timeStart;
+
+        return (m_timeElapsed);
       }
 
     virtual void timerReport (const char* const msg) const
       {
-               std::cout << msg << ": " << m_timeElapsed << " seconds" << std::endl;
+                std::cout << msg << ": " << m_timeElapsed << " seconds" << std::endl;
       }
 
     virtual double timerEndAndReport (const char* const msg)
       {
-       double t = timerEnd ();
-       timerReport (msg);
-       return (t);
+        double t = timerEnd ();
+        timerReport (msg);
+        return (t);
       }
 
     double getTimeElapsed (void) const
-       { return m_timeElapsed; }
+        { return m_timeElapsed; }
 
  protected:
     double m_timeStart;
@@ -83,21 +83,21 @@ class Timer
     double m_timeElapsed;
 
     double ttime(void) const
-       {
+        {
 #ifdef HAVE_GETTIMEOFDAY
-           struct timeval now;
-           if (gettimeofday (&now, NULL))
-               return 0;
-           
-           return (now.tv_sec + static_cast<double>(now.tv_usec) / 1000000.);
+            struct timeval now;
+            if (gettimeofday (&now, NULL))
+                return 0;
+
+            return (now.tv_sec + static_cast<double>(now.tv_usec) / 1000000.);
 #elif defined(MSVC)
-               struct _timeb now;
-               _ftime (&now);
-               return (now.time + static_cast<double>(now.millitm) / 1000.);
+                struct _timeb now;
+                _ftime (&now);
+                return (now.time + static_cast<double>(now.millitm) / 1000.);
 #else
-           return 0;
+            return 0;
 #endif
-       }
+        }
 };
 
 
@@ -109,9 +109,9 @@ class TimerMPI : public Timer
 {
  public:
     TimerMPI (MPI::Intracomm& comm)
-       : m_comm(comm)
+        : m_comm(comm)
       {
-         m_timeStart = MPI::Wtime();
+          m_timeStart = MPI::Wtime();
       }
 
     virtual ~TimerMPI (void)
@@ -119,28 +119,28 @@ class TimerMPI : public Timer
 
     virtual double timerEnd (void)
       {
-       m_timeEnd = MPI::Wtime();
-       m_timeElapsed = m_timeEnd - m_timeStart;
-  
-       return (m_timeElapsed);
+        m_timeEnd = MPI::Wtime();
+        m_timeElapsed = m_timeEnd - m_timeStart;
+
+        return (m_timeElapsed);
       }
 
     virtual void timerReport (const char* const msg)
       {
-         if (m_comm.Get_rank() == 0)
-                 std::cout << msg << ": " << m_timeElapsed << " seconds" << std::endl;
+          if (m_comm.Get_rank() == 0)
+                  std::cout << msg << ": " << m_timeElapsed << " seconds" << std::endl;
       }
 
     virtual double timerEndAndReport (const char* const msg)
       {
-       double t = timerEnd ();
-       timerReport (msg);
-       return (t);
+        double t = timerEnd ();
+        timerReport (msg);
+        return (t);
       }
 
     virtual void timerReportAllProcesses (const char* const msg)
       {
-         timerReport (msg);
+          timerReport (msg);
       }
 
  protected:
@@ -151,10 +151,10 @@ class TimerCollectiveMPI : public TimerMPI
 {
  public:
     TimerCollectiveMPI (MPI::Intracomm& comm)
-       : TimerMPI::TimerMPI (comm)
+        : TimerMPI::TimerMPI (comm)
       {
-       m_comm.Barrier();
-       m_timeStart = MPI::Wtime();
+        m_comm.Barrier();
+        m_timeStart = MPI::Wtime();
       }
 
     virtual ~TimerCollectiveMPI (void)
@@ -162,30 +162,30 @@ class TimerCollectiveMPI : public TimerMPI
 
     virtual double timerEnd (void)
       {
-       m_timeEnd = MPI::Wtime();
-       m_timeElapsed = m_timeEnd - m_timeStart;
-       m_comm.Reduce (&m_timeElapsed, &m_timeMin, 1, MPI::DOUBLE, MPI::MIN, 0);
-       m_comm.Reduce (&m_timeElapsed, &m_timeMax, 1, MPI::DOUBLE, MPI::MAX, 0);
-  
-       return (m_timeElapsed);
+        m_timeEnd = MPI::Wtime();
+        m_timeElapsed = m_timeEnd - m_timeStart;
+        m_comm.Reduce (&m_timeElapsed, &m_timeMin, 1, MPI::DOUBLE, MPI::MIN, 0);
+        m_comm.Reduce (&m_timeElapsed, &m_timeMax, 1, MPI::DOUBLE, MPI::MAX, 0);
+
+        return (m_timeElapsed);
       }
 
     virtual double timerEndAndReport (const char* const msg)
       {
-       double t = timerEnd ();
-       timerReport (msg);
-       return (t);
+        double t = timerEnd ();
+        timerReport (msg);
+        return (t);
       }
 
     virtual void timerReport (const char* const msg)
       {
-       if (m_comm.Get_rank() == 0)
-               std::cout << msg << " " << "Minimum=" << m_timeMin << ", Maximum=" << m_timeMax << " seconds" << std::endl;
+        if (m_comm.Get_rank() == 0)
+                std::cout << msg << " " << "Minimum=" << m_timeMin << ", Maximum=" << m_timeMax << " seconds" << std::endl;
       }
 
     virtual void timerReportAllProcesses (const char* const msg)
       {
-               std::cout << msg << ": " << "Minimum=" << m_timeMin << ", Maximum=" << m_timeMax << " seconds (Rank " << m_comm.Get_rank() << ")" << std::endl;
+                std::cout << msg << ": " << "Minimum=" << m_timeMin << ", Maximum=" << m_timeMax << " seconds (Rank " << m_comm.Get_rank() << ")" << std::endl;
       }
 
  private:
index 9ddc0f8..ab53294 100644 (file)
@@ -39,7 +39,7 @@ class Trace
     static const int TRACE_PROJECTIONS;
     static const int TRACE_PLOT;
     static const int TRACE_CLIPPING;
-    
+
     static const int BIT_CONSOLE;
     static const int BIT_PHANTOM;
     static const int BIT_PROJECTIONS;
@@ -47,25 +47,25 @@ class Trace
     static const int BIT_CLIPPING;
 
   Trace (const char* const traceString);
-  
+
   void addTrace (const char* const traceString);
-  
+
   bool isTrace (const char* const traceQuery) const;
-  
+
   int getTraceLevel(void) const { return m_traceLevel; }
-  
+
   static int convertTraceNameToID (const char* traceName);
   static const char* convertTraceIDToTitle (int idTrace);
   static const char* convertTraceIDToName (int idTrace);
-  
+
   static const int getTraceCount() {return s_iTraceCount;}
   static const char** getTraceNameArray() {return s_aszTraceName;}
   static const char** getTraceTitleArray() {return s_aszTraceTitle;}
 
  private:
-  
+
   int m_traceLevel;
-  
+
   bool addTraceElements (const char* const traceString);
 
   static const char* s_aszTraceName[];
index 43c8f34..9bfbd35 100644 (file)
 
 
 
-void 
+void
 bresenham (int x1, int y1, int x2, int y2)
 {
   int delta_x = x2 - x1;
   int dx_abs = (delta_x >= 0 ? delta_x : -delta_x);
-  
+
   int delta_y = y2 - y1;
   int dy_abs = (delta_y >= 0 ? delta_y : -delta_y);
-  
-  // draws a line when abs(dx) >= abs(dy) 
+
+  // draws a line when abs(dx) >= abs(dy)
   if (dx_abs > dy_abs) {
     int count = dx_abs + 1;
     int major_inc = (x1 <= x2 ? 1 : -1);
-    int min_inc = (delta_y >= 0 ? 1 : -1);     // determine direction of minor axis 
-    
+    int min_inc = (delta_y >= 0 ? 1 : -1);     // determine direction of minor axis
+
     int d = dy_abs * 2 - dx_abs;      // Put decision variable in d
     int dinc1 = (dy_abs - dx_abs) * 2;
     int dinc2 = 2 * dy_abs;
-    
+
     bresx (x1, y1, major_inc, d, d1, d2);
   } else {    //For plotting lines with abs(dy) > abs(sx)
     int count = dy_abs + 1;
-    
+
     int major_inc = (y1 <= y2 ? 1 : -1);
     int min_inc = (delta_x >= 0 ? 1 : -1);      // check direction of minor axis
-        
+
     int d = dx_abs * 2 - dy_abs;
     dinc1 = (dx_abs - dy_abs) * 2;
     dinc2 = 2 * dx_abs;
-    
+
     bresy (x1, y1, major_inc, min_inc, count, d, d1, d2);
   }
 }
 
 
-static void 
+static void
 bresx (int x, int y, int majorinc, int minorinc, int count, int d, int d1, int d2)
 {
   do {
     setpixel();
     x += majorinc;
-    
+
     if (d < 0)
       d += dinc2;
     else {
@@ -74,15 +74,15 @@ bresx (int x, int y, int majorinc, int minorinc, int count, int d, int d1, int d
     }
   } while (--count > 0);
 }
-  
-  
-static void 
+
+
+static void
 bresy (int x, int y, int majorinc, int minorinc, int count, int d, int d1, int d2)
 {
   do {
     setpixel();
     y += majorinc;
-    
+
     if (d < 0)
       d += dinc2;
     else {
@@ -91,5 +91,5 @@ bresy (int x, int y, int majorinc, int minorinc, int count, int d, int d1, int d
     }
   } while (--count > 0);
 }
-  
-  
+
+
index 267ad15..099eff5 100644 (file)
@@ -1,7 +1,7 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**    EZPLOT                                   
+**    EZPLOT
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -30,8 +30,8 @@ int snprintf (char *, size_t, const char*, ...);
 #endif
 
 // Defaults
-static const double TICKRATIO = 0.4;   // ratio of minor to major tick lengths
-static const int MAXNUMFMT = 15;       // maximum length of a numeric format 
+static const double TICKRATIO = 0.4;    // ratio of minor to major tick lengths
+static const int MAXNUMFMT = 15;        // maximum length of a numeric format
 static const int DEF_CURVE_CLR = C_RED;
 
 
@@ -42,7 +42,7 @@ EZPlotCurve::EZPlotCurve (const double* xData, const double* yData, int n)
     x[i] = xData[i];
     y[i] = yData[i];
   }
-  
+
   m_iPointCount = n;
 }
 
@@ -53,27 +53,27 @@ EZPlotCurve::~EZPlotCurve ()
 }
 
 
-void 
+void
 EZPlot::addCurve (const double *y, int n)
 {
   double* x = new double [n];
-  
+
   for (int i = 0; i < n; i++)
     x[i] = i;
-  
+
   addCurve (x, y, n);
   delete x;
 }
 
 
-void 
+void
 EZPlot::addCurve (const float *y, int n)
 {
   double* yDouble = new double [n];
-  
+
   for (int i = 0; i < n; i++)
     yDouble[i] = y[i];
-  
+
   addCurve (yDouble, n);
   delete yDouble;
 }
@@ -83,10 +83,10 @@ void
 EZPlot::addCurve (const float x[], const double y[], int num)
 {
   double* dx = new double [num];
-  
+
   for (int i = 0; i < num; i++)
     dx[i] = x[i];
-  
+
   addCurve (dx, y, num);
   delete dx;
 }
@@ -95,12 +95,12 @@ void
 EZPlot::addCurve (const double* const x, const float* const y, int num)
 {
   double* dy = new double [num];
-  
+
   for (int i = 0; i < num; i++)
     dy[i] = y[i];
-  
+
   addCurve (x, dy, num);
-  
+
   delete dy;
 }
 
@@ -110,7 +110,7 @@ EZPlot::addCurve (const double* const x, const double* const y, int num)
 {
   if (num < 1)
     return;
-  
+
   EZPlotCurve* pCurve = new EZPlotCurve (x, y, num);
   m_vecCurves.push_back (pCurve);
 }
@@ -125,7 +125,7 @@ EZPlot::~EZPlot ()
 void
 EZPlot::clearCurves ()
 {
-  for (EZPlotCurveIterator i = m_vecCurves.begin(); i != m_vecCurves.end(); i++)    
+  for (EZPlotCurveIterator i = m_vecCurves.begin(); i != m_vecCurves.end(); i++)
     delete *i;
   m_vecCurves.erase (m_vecCurves.begin(), m_vecCurves.end());
   initPlotSettings();
@@ -152,7 +152,7 @@ EZPlot::EZPlot ()
 
     m_pol.addSkipChar ('=');
 
-    
+
 
     m_pol.usefile (POL::P_USE_STR,"");
 
@@ -178,36 +178,36 @@ EZPlot::initPlotSettings ()
   c_xlabel = "";
   c_ylabel =  "";
   c_title = "";
-  
+
   o_xporigin = 0.0;
   o_yporigin = 0.0;
   o_xlength  = 1.0;
   o_ylength  = 1.0;
-  
+
   o_xaxis = LINEAR;
   o_yaxis = LINEAR;
-  
+
   o_grid = FALSE;
   o_box = FALSE;
-  
+
   o_xmajortick = 10;
   o_ymajortick =  8;
   o_xminortick =  4;
   o_yminortick =  4;
-  
+
   o_color = DEF_CURVE_CLR;
   o_symfreq = 1;
   o_symbol = -1;
   o_linestyle = SGP::LS_SOLID;
-  
+
   o_xtlabel = TRUE;
   o_ytlabel = TRUE;
   o_xticks = BELOW;
   o_yticks = LEFT;
-  
+
   o_legendbox = INSIDE;
   o_tag = FALSE;
-  
+
   s_xtitle   = FALSE;
   s_ytitle   = FALSE;
   s_xcross   = FALSE;
@@ -217,8 +217,8 @@ EZPlot::initPlotSettings ()
   s_xlegend  = FALSE;
   s_ylegend  = FALSE;
   s_textsize = FALSE;
-  
-  clr_axis   = C_LTGRAY;               // set fixed colors 
+
+  clr_axis   = C_LTGRAY;                // set fixed colors
   clr_title  = C_RED;
   clr_label  = C_BLUE;
   clr_legend = C_CYAN;
@@ -374,7 +374,7 @@ EZPlot::getColor (unsigned int iCurve) const
 
 }
 
-    
+
 
 int
 
@@ -392,7 +392,7 @@ EZPlot::getSymbol (unsigned int iCurve) const
 
 }
 
-    
+
 
 int
 
@@ -410,7 +410,7 @@ EZPlot::getSymbolFreq (unsigned int iCurve) const
 
 }
 
-    
+
 
 int
 
@@ -428,7 +428,7 @@ EZPlot::getLinestyle (unsigned int iCurve) const
 
 }
 
-    
+
 
 const std::string*
 
@@ -446,12 +446,12 @@ EZPlot::getLegend (unsigned int iCurve) const
 
 }
 
-    
+
 
 
 
 /* NAME
-*   plot               Plots all curves collected by addCurves ()
+*   plot                Plots all curves collected by addCurves ()
 *
 * SYNOPSIS
 *   plot()
@@ -468,30 +468,30 @@ EZPlot::plot (SGP* pSGP)
 {
   if (m_vecCurves.size() <= 0)
     return;
-  
+
   m_pSGP = pSGP;
 
   m_pSGP->setWindow (0., 0., 1., 1.);
-  
+
   if (s_textsize == TRUE)
     m_pSGP->setTextPointSize (v_textsize);
 
   charheight = m_pSGP->getCharHeight();
   charwidth = m_pSGP->getCharWidth();
-  double symheight = charheight * 0.3;       // size of symbol in NDC 
+  double symheight = charheight * 0.3;       // size of symbol in NDC
   double symwidth = symheight;
+
   const EZPlotCurve& firstCurve = *m_vecCurves[0];
 
   double xmin = firstCurve.x[0];   // extent of curves in world coord
-  double xmax = xmin;       
+  double xmax = xmin;
   double ymin = firstCurve.y[0];
-  double ymax = ymin; 
+  double ymax = ymin;
 
   unsigned int iCurve;
   for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
     const EZPlotCurve* const pCurve = m_vecCurves [iCurve];
-    
+
     for (int ip = 0; ip < pCurve->m_iPointCount; ip++) {
       if (pCurve->x[ip] > xmax)
         xmax = pCurve->x[ip];
@@ -503,27 +503,27 @@ EZPlot::plot (SGP* pSGP)
         ymin = pCurve->y[ip];
     }
   }
-  
-  // extend graph limits for user defined axis cross positions 
+
+  // extend graph limits for user defined axis cross positions
   if (s_xcross == TRUE) {
     if (v_xcross < xmin)
       xmin = v_xcross;
     else if (v_xcross > xmax)
       xmax = v_xcross;
   }
-  
+
   if (s_ycross == TRUE) {
     if (v_ycross < ymin)
       ymin = v_ycross;
     else if (v_ycross > ymax)
       ymax = v_ycross;
   }
-  
-  // find nice endpoints for axes 
+
+  // find nice endpoints for axes
   if (! axis_scale (xmin, xmax, o_xmajortick - 1, &xgw_min, &xgw_max, &x_nint) || ! axis_scale (ymin, ymax, o_ymajortick - 1, &ygw_min, &ygw_max, &y_nint))
     return;
-  
-  // check if user set x-axis extents 
+
+  // check if user set x-axis extents
   if (s_xmin == TRUE) {
     xgw_min = v_xmin;
     x_nint = o_xmajortick - 1;
@@ -532,8 +532,8 @@ EZPlot::plot (SGP* pSGP)
     xgw_max = v_xmax;
     x_nint = o_xmajortick - 1;
   }
-  
-  // check if user set y-axis extents 
+
+  // check if user set y-axis extents
   if (s_ymin == TRUE) {
     ygw_min = v_ymin;
     y_nint = o_ymajortick - 1;
@@ -542,49 +542,49 @@ EZPlot::plot (SGP* pSGP)
     ygw_max = v_ymax;
     y_nint = o_ymajortick - 1;
   }
-  
-  // calculate increment between major axis in world coordinates 
+
+  // calculate increment between major axis in world coordinates
   xw_tickinc = (xgw_max - xgw_min) / x_nint;
   yw_tickinc = (ygw_max - ygw_min) / y_nint;
-  
-  // we have now calcuated xgw_min, xyw_max, ygw_min, & ygw_max 
-  
-  // set the number of decimal point to users' setting or default 
+
+  // we have now calcuated xgw_min, xyw_max, ygw_min, & ygw_max
+
+  // set the number of decimal point to users' setting or default
   // Two formats for numbers: Fixed:    -nnn.f and  Exponent: -n.fffE+eee
   if (s_lxfrac == TRUE)
     x_frac = v_lxfrac;
   else
     x_frac = -1;
-  
+
   if (s_lyfrac == TRUE)
     y_frac = v_lyfrac;
   else
     y_frac = -1;
-  
+
   make_numfmt (x_numfmt, &x_fldwid, &x_frac, xgw_min, xgw_max, x_nint);
   make_numfmt (y_numfmt, &y_fldwid, &y_frac, ygw_min, ygw_max, y_nint);
-  
-  xtl_wid = x_fldwid * charwidth;              // calc size of tick labels 
+
+  xtl_wid = x_fldwid * charwidth;               // calc size of tick labels
   ytl_wid = y_fldwid * charwidth;
   tl_height = charheight;
-  
-  // calculate the extent of the plot frame 
+
+  // calculate the extent of the plot frame
   xp_min = o_xporigin;
   yp_min = o_yporigin;
   xp_max = xp_min + o_xlength;
   yp_max = yp_min + o_ylength;
-  
+
   xp_min = clamp (xp_min, 0., 1.);
   xp_max = clamp (xp_max, 0., 1.);
   yp_min = clamp (yp_min, 0., 1.);
   yp_max = clamp (yp_max, 0., 1.);
-  
-  xa_min = xp_min;             // extent of axes 
+
+  xa_min = xp_min;              // extent of axes
   xa_max = xp_max;
   ya_min = yp_min;
   ya_max = yp_max;
-  
-  // adjust frame for title 
+
+  // adjust frame for title
   title_row = ya_max;;
 
   if (c_title.length() > 0)
@@ -595,9 +595,9 @@ EZPlot::plot (SGP* pSGP)
     ya_max -= 0.7 * charheight;  // allow room for yaxis ticklabel
 
 
-  // calculate legend box boundaries 
-  int max_leg = 0;                     // longest legend in characters 
-  int num_leg = 0;                     // number of legend titles 
+  // calculate legend box boundaries
+  int max_leg = 0;                      // longest legend in characters
+  int num_leg = 0;                      // number of legend titles
 
   for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
     const std::string* pstrLegend = getLegend (iCurve);
@@ -614,11 +614,11 @@ EZPlot::plot (SGP* pSGP)
       }
     }
   }
-  
+
   if (num_leg > 0 && o_legendbox != NOLEGEND) {
-    double leg_width  = (max_leg + 2) * charwidth;     // size of legend box 
+    double leg_width  = (max_leg + 2) * charwidth;      // size of legend box
     double leg_height = num_leg * 3 * charheight;
-    
+
     if (s_xlegend == TRUE)
       xl_max = v_xlegend;
     else {
@@ -627,28 +627,28 @@ EZPlot::plot (SGP* pSGP)
         xa_max -= (leg_width + 0.5 * charwidth);
     }
     xl_min = xl_max - leg_width;
-    
+
     if (s_ylegend == TRUE)
       yl_max = v_ylegend;
     else
       yl_max = ya_max;
-    
+
     yl_min = yl_max - leg_height;
-    
+
     m_pSGP->setColor (clr_legend);
     m_pSGP->drawRect (xl_min, yl_min, xl_max, yl_max);
-    
-    int iLegend = 0;                   // current legend position 
+
+    int iLegend = 0;                    // current legend position
 
     for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
       const std::string* pstrLegend = getLegend (iCurve);
       if (! pstrLegend || pstrLegend->length() == 0)
         continue;
-      
+
       double xmin = xl_min + 1.0 * charwidth;
       double xmax = xl_max - 1.0 * charwidth;
       double y = yl_max - (2.0 + iLegend * 3) * charheight;
-      
+
       m_pSGP->moveAbs (xmin, y + 0.5 * charheight);
 
       m_pSGP->drawText (pstrLegend->c_str());
@@ -670,22 +670,22 @@ EZPlot::plot (SGP* pSGP)
           symbol (iSymbol, symwidth, symheight);
         }
       }
-      ++iLegend;       // move to next legend position 
+      ++iLegend;        // move to next legend position
     }
-  }   // end legend printing 
-  
-  // calculate the extent of the axes 
-  
+  }   // end legend printing
+
+  // calculate the extent of the axes
+
   /*-------------------------*/
   /* adjust frame for labels */
   /*-------------------------*/
-  
-  // X-Label 
+
+  // X-Label
   if (c_xlabel.length() > 0)
     ya_min += 1.5 * charheight;
-  xlbl_row = xp_min;           // put x-label on bottom of plot frame 
-  
-  // Y-Label 
+  xlbl_row = xp_min;            // put x-label on bottom of plot frame
+
+  // Y-Label
   if (c_ylabel.length() > 0) {
 
     m_pSGP->setTextAngle (HALFPI);
@@ -704,19 +704,19 @@ EZPlot::plot (SGP* pSGP)
 
   }
   ylbl_col = xp_min;
-  
+
   /*------------------------------*/
   /* adjust frame for tick labels */
   /*------------------------------*/
-  
-  // Calc offset of tick labels from axes 
+
+  // Calc offset of tick labels from axes
   if (o_xaxis == NOAXIS || o_xtlabel == FALSE)
     xtl_ofs = 0.0;
   else if (o_xticks == BELOW)
     xtl_ofs = -0.5 * charheight;
   else if (o_xticks == ABOVE)
     xtl_ofs = 0.5 * charheight;
-  
+
   if (o_yaxis == NOAXIS || o_ytlabel == FALSE)
     ytl_ofs = 0.0;
   else if (o_yticks == LEFT) {
@@ -731,15 +731,15 @@ EZPlot::plot (SGP* pSGP)
     ytl_ofs = -xExtentMax;
   } else if (o_yticks == RIGHT)
     ytl_ofs = 1.5 * charwidth;
-  
+
   xa_max -= 0.7 * x_fldwid * charwidth; // make room for last x tick label
 
   xt_min = xa_min;
   yt_min = ya_min;
   xt_max = xa_max;
   yt_max = ya_max;
-  
-  // see if need to shrink axis extents and/or tick extents 
+
+  // see if need to shrink axis extents and/or tick extents
   if (xtl_ofs != 0.0 && s_ycross == FALSE) {
     if (o_xticks == BELOW) {
       ya_min += 1.5 * charheight;
@@ -748,9 +748,9 @@ EZPlot::plot (SGP* pSGP)
       ya_min += 0.0;
       yt_min = ya_min + 1.5 * charheight;
     }
-  } else   // noaxis, no t-labels, or user set cross 
+  } else   // noaxis, no t-labels, or user set cross
     yt_min = ya_min;
-  
+
   if (ytl_ofs != 0.0 && s_xcross == FALSE) {
     if (o_yticks == LEFT) {
       xa_min += 2*charwidth - ytl_ofs; // (2 + y_fldwid) * charwidth;
@@ -762,59 +762,59 @@ EZPlot::plot (SGP* pSGP)
   } else
     xt_min = xa_min;
 
-  // decrease size of graph, if necessary, to accommadate space 
-  // between axis boundary and boundary of ticks 
-  double x_added_ticks = 0; // number of tick spaces added to axis 
+  // decrease size of graph, if necessary, to accommadate space
+  // between axis boundary and boundary of ticks
+  double x_added_ticks = 0; // number of tick spaces added to axis
   double y_added_ticks = 0;
   if (o_xaxis == NOAXIS || o_xtlabel == FALSE)
     x_added_ticks = 0;
   if (o_yaxis == NOAXIS || o_ytlabel == FALSE)
     y_added_ticks = 0;
-  
+
   if (o_grid == TRUE) {
     if (x_added_ticks < 0)
       x_added_ticks = 2;
     if (y_added_ticks < 0)
       y_added_ticks = 2;
   }
-  
+
   if (x_added_ticks < 0) {
     if (o_yticks == LEFT || s_ycross)
       x_added_ticks = 1;
     else
       x_added_ticks = 2;
   }
-  
+
   if (y_added_ticks < 0) {
     if (o_xticks == BELOW || s_xcross)
       y_added_ticks = 1;
     else
       y_added_ticks = 2;
   }
-  
+
   xn_tickinc = (xt_max - xt_min) / (x_nint + x_added_ticks);
   yn_tickinc = (yt_max - yt_min) / (y_nint + y_added_ticks);
-  
+
   xt_min += 0.5 * x_added_ticks * xn_tickinc;
   xt_max -= 0.5 * x_added_ticks * xn_tickinc;
   yt_min += 0.5 * y_added_ticks * yn_tickinc;
   yt_max -= 0.5 * y_added_ticks * yn_tickinc;
-  
+
   xgn_min = xt_min;
   xgn_max = xt_max;
   ygn_min = yt_min;
   ygn_max = yt_max;
-  
+
   //------------------------------------------------------------------------
-  
+
   m_xWorldScale = (xgn_max - xgn_min) / (xgw_max - xgw_min);
   m_yWorldScale = (ygn_max - ygn_min) / (ygw_max - ygw_min);
-  
-  // PLOT CURVES 
-  
+
+  // PLOT CURVES
+
   m_pSGP->setLineStyle (SGP::LS_SOLID);
   drawAxes();
-  
+
 
   double clipRect[4];
 
@@ -824,7 +824,7 @@ EZPlot::plot (SGP* pSGP)
 
   for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
     const EZPlotCurve* const pCurve = m_vecCurves [iCurve];
-    
+
 
     m_pSGP->setColor (getColor (iCurve));
 
@@ -851,7 +851,7 @@ EZPlot::plot (SGP* pSGP)
         }
         x1 = x2;
         y1 = y2;
-      } 
+      }
     }
     if (iSym > 0) {
       int iSymFreq = getSymbolFreq (iCurve);
@@ -871,43 +871,43 @@ EZPlot::plot (SGP* pSGP)
           }
         }
     }
-  }  
+  }
 }
 
 
 /* NAME
-*   drawAxes                   INTERNAL routine to draw axis & label them
+*   drawAxes                    INTERNAL routine to draw axis & label them
 *
 * SYNOPSIS
 *   drawAxes()
 */
 
 
-void 
+void
 EZPlot::drawAxes()
 {
-  double xticklen = 0, yticklen = 0; // length of ticks in NDC 
-  double minorinc;             // increment between minor axes 
-  double xaxispos, yaxispos;   // crossing of axes
+  double xticklen = 0, yticklen = 0; // length of ticks in NDC
+  double minorinc;              // increment between minor axes
+  double xaxispos, yaxispos;    // crossing of axes
   double x, y, x2, y2;
-  bool axis_near;      // TRUE if axis too close to print t-label 
+  bool axis_near;       // TRUE if axis too close to print t-label
   int i, j;
   char str[256];
   char *numstr;
-  
+
   m_pSGP->setTextSize (charheight);
   m_pSGP->setTextColor (1, -1);
-  
+
   if (o_xticks == ABOVE)
     xticklen = 0.5 * charheight;
   else if (o_xticks == BELOW)
     xticklen = -0.5 * charheight;
-  
+
   if (o_yticks == RIGHT)
     yticklen = charwidth;
   else if (o_yticks == LEFT)
     yticklen = -charwidth;
-  
+
   if (c_title.length() > 0) {
     double wText, hText;
     m_pSGP->setTextSize (charheight * 2.0);
@@ -917,7 +917,7 @@ EZPlot::drawAxes()
     m_pSGP->drawText (c_title);
     m_pSGP->setTextSize (charheight);
   }
-  
+
   if (o_grid == TRUE || o_box == TRUE) {
     m_pSGP->setColor (clr_axis);
     m_pSGP->moveAbs (xa_min, ya_min);
@@ -926,30 +926,30 @@ EZPlot::drawAxes()
     m_pSGP->lineAbs (xa_min, ya_max);
     m_pSGP->lineAbs (xa_min, ya_min);
   }
-  
-  // calculate position of axes 
-  
-  // x-axis 
-  if (s_ycross == TRUE) {      // convert users' world-coord 
-    xaxispos = convertWorldToNDC_Y (v_ycross);// axis to its position in NDC 
+
+  // calculate position of axes
+
+  // x-axis
+  if (s_ycross == TRUE) {       // convert users' world-coord
+    xaxispos = convertWorldToNDC_Y (v_ycross);// axis to its position in NDC
     x = convertWorldToNDC_X (xgw_min);
   } else
     xaxispos = ya_min;
-  
-  // y-axis 
-  if (s_xcross == TRUE) {      // convert users' world-coord 
-    yaxispos = convertWorldToNDC_X (v_xcross);// axis to its NDC position 
+
+  // y-axis
+  if (s_xcross == TRUE) {       // convert users' world-coord
+    yaxispos = convertWorldToNDC_X (v_xcross);// axis to its NDC position
     y = convertWorldToNDC_Y (ygw_min);
   } else
     yaxispos = xa_min;
-  
+
   /*-------------*/
   /* draw x-axis */
   /*-------------*/
-  
+
   if (o_xaxis == LINEAR) {
-    // draw axis line 
-    
+    // draw axis line
+
     m_pSGP->setColor (clr_axis);
     if (o_tag && !o_grid && !o_box && s_xcross) {
       m_pSGP->moveAbs (xa_min, xaxispos - charheight);
@@ -961,7 +961,7 @@ EZPlot::drawAxes()
       m_pSGP->moveAbs (xa_max, xaxispos - charheight);
       m_pSGP->lineAbs (xa_max, xaxispos + charheight);
     }
-    
+
     if (o_grid == TRUE) {
       m_pSGP->setColor (clr_grid);
       for (i = 0; i <= x_nint; i++) {
@@ -980,7 +980,7 @@ EZPlot::drawAxes()
     m_pSGP->drawText (c_xlabel);
     m_pSGP->setTextSize (charheight);
     minorinc = xn_tickinc / (o_xminortick + 1);
-    
+
     for (i = 0; i <= x_nint; i++) {
       x = xt_min + xn_tickinc * i;
       m_pSGP->setColor (clr_axis);
@@ -1002,7 +1002,7 @@ EZPlot::drawAxes()
           if (o_yticks == LEFT && d <= 0 && d > -0.9 * xn_tickinc)
             axis_near = TRUE;
         }
-        
+
         if (o_xtlabel == TRUE && axis_near == FALSE) {
           snprintf (str, sizeof(str), x_numfmt, xgw_min + xw_tickinc * i);
           numstr = str_skip_head (str, " ");
@@ -1013,15 +1013,15 @@ EZPlot::drawAxes()
           m_pSGP->drawText (numstr);
         }
     }
-  }            // X - Axis 
-  
-  
+  }             // X - Axis
+
+
   /*--------*/
   /* y-axis */
   /*--------*/
-  
+
   if (o_yaxis == LINEAR) {
-    
+
     m_pSGP->setColor (clr_axis);
     if (o_tag && !o_grid && !o_box && s_ycross) {
       m_pSGP->moveAbs (yaxispos - charwidth, ya_min);
@@ -1033,7 +1033,7 @@ EZPlot::drawAxes()
       m_pSGP->moveAbs (yaxispos - charwidth, ya_max);
       m_pSGP->lineAbs (yaxispos + charwidth, ya_max);
     }
-    
+
     if (o_grid == TRUE) {
       m_pSGP->setColor (clr_grid);
       for (i = 0; i <= y_nint; i++) {
@@ -1056,7 +1056,7 @@ EZPlot::drawAxes()
     m_pSGP->setTextAngle (0.0);
     m_pSGP->setTextSize (charheight);
     minorinc = yn_tickinc / (o_yminortick + 1);
-    
+
     for (i = 0; i <= y_nint; i++) {
       y = yt_min + yn_tickinc * i;
       m_pSGP->setColor (clr_axis);
@@ -1090,16 +1090,16 @@ EZPlot::drawAxes()
           m_pSGP->drawText (str);
         }
     }
-  }            // Y - Axis
+  }             // Y - Axis
 }
 
 
-void 
+void
 EZPlot::symbol (int sym, double symwidth, double symheight)
 {
   if (sym <= 0)
     return;
-  
+
   if (sym == SB_CROSS) {
     m_pSGP->markerRel (0, 0);
 //    m_pSGP->moveRel (-0.5 * symwidth, -0.5 * symheight);
@@ -1138,34 +1138,34 @@ EZPlot::symbol (int sym, double symwidth, double symheight)
 
 
 /* NAME
-*    axis_scale                        calculates graph axis scaling
+*    axis_scale                 calculates graph axis scaling
 *
 *  SYNOPSIS:
-*    retval = axis_scale (min, max, nint, minp, maxp, nintp, 
-*                         rec_total, rec_frac)
+*    retval = axis_scale (min, max, nint, minp, maxp, nintp,
+*                          rec_total, rec_frac)
 *
 *    INPUT:
-*      double min         Smallest value to plot
-*      double max         Largest value to plot
-*      int    nint        Number of intervals desired
+*       double min         Smallest value to plot
+*       double max         Largest value to plot
+*       int    nint        Number of intervals desired
 *
 *    OUTPUT:
-*      int   retval       FALSE if illegal parameters, else TRUE
-*      double *minp       Minimum graph value
-*      double *maxp       Maximum graph value
-*      int    *nintp      Number of intervals for graph
+*       int   retval       FALSE if illegal parameters, else TRUE
+*       double *minp       Minimum graph value
+*       double *maxp       Maximum graph value
+*       int    *nintp      Number of intervals for graph
 *      int    *rec_total  Recommended field width for printing out the number
-*      int    *rec_frac   Recommended number of digits for print fraction
+*       int    *rec_frac   Recommended number of digits for print fraction
 */
 
-int 
+int
 EZPlot::axis_scale (double min, double max, int nint, double *minp, double *maxp, int *nintp)
 {
   if (min >= max || nint < 1) {
     sys_error (ERR_WARNING, "Invalid params: min=%lf, max=%lf, num intervals=%d [axis_scale]", min, max, nint);
     return (FALSE);
   }
-  
+
   double eps = 0.025;
   double a = fabs(min);
   if (fabs(min) < fabs(max))
@@ -1207,47 +1207,47 @@ loop:
     scale = scale * 10.0;
     goto loop;
   }
-  
+
   *minp *= scale;
   *maxp *= scale;
-  
+
   return (TRUE);
 }
 
 
 /* NAME
-*   make_numfmt                Make a numeric format string
+*   make_numfmt         Make a numeric format string
 *
 * SYNOPSIS
 *   make_numfmt (fmtstr, fldwid, nfrac, min, max, nint)
-*   char *fmtstr               Returned format string for printf()
-*   int  *fldwid               Returned field width
-*   int  *nfrac                If < 0, then calculate best number of
-*                              fraction places & return that value
-*                              If >= 0, then use that number of places
-*   double min                 Minimum value
-*   double max                 Maximum value
-*   int nint                   Number of intervals between min & max
+*   char *fmtstr                Returned format string for printf()
+*   int  *fldwid                Returned field width
+*   int  *nfrac         If < 0, then calculate best number of
+*                               fraction places & return that value
+*                               If >= 0, then use that number of places
+*   double min                  Minimum value
+*   double max                  Maximum value
+*   int nint                    Number of intervals between min & max
 *
 * DESCRIPTION
 *   This  routine is written as an INTERNAL routine for EZPLOT
 */
 
-static inline double 
+static inline double
 my_trunc (double x)
 {
   double integer;
-  
+
   modf (x, &integer);
-  
+
   return (integer);
 }
 
-void 
+void
 EZPlot::make_numfmt (char *fmtstr, int *fldwid, int *nfrac, double minval, double maxval, int nint)
 {
   int wid, frac, expon;
-  
+
   double delta = (maxval - minval) / nint;
   double absmin = fabs(minval);
   double absmax = fabs(maxval);
@@ -1256,44 +1256,44 @@ EZPlot::make_numfmt (char *fmtstr, int *fldwid, int *nfrac, double minval, doubl
 
     absmax = absmin;
   double logt = log10( absmax );
-  
-  if (fabs(logt) >= 6) {               // use exponential format 
+
+  if (fabs(logt) >= 6) {                // use exponential format
     if (fabs(logt) > 99)
-      expon = 5;               //  E+102 
+      expon = 5;                //  E+102
     else
-      expon = 4;               //  E+00 
-    
-    if (*nfrac < 0) {          // calculate frac 
-      delta /= pow (10., floor(logt)); // scale delta 
+      expon = 4;                //  E+00
+
+    if (*nfrac < 0) {           // calculate frac
+      delta /= pow (10., floor(logt));  // scale delta
       frac = static_cast<int>(fabs(my_trunc(log10(delta)))) + 1;
       if (frac < 1)
-        frac = 1;              // to be safe, add decimal pt 
-    } else                     // use users' frac 
+        frac = 1;               // to be safe, add decimal pt
+    } else                      // use users' frac
       frac = *nfrac;
-    
+
     wid = 2 + frac + expon;
     if (minval < 0. || maxval < 0.)
       ++wid;
     sprintf (fmtstr, "%s%d%s%d%s", "%", wid, ".", frac, "g");
-  } else {                     // use fixed format 
+  } else {                      // use fixed format
     wid = static_cast<int>(my_trunc(logt)) + 1;
     if (wid < 1)
       wid = 1;
     if (minval < 0. || maxval < 0.)
       ++wid;
-    
-    if (*nfrac < 0) {          // calculate frac 
+
+    if (*nfrac < 0) {           // calculate frac
       if (delta >= 0.999999)
-        frac = 1;              // add a decimal pt to be safe 
+        frac = 1;               // add a decimal pt to be safe
       else
         frac = static_cast<int>(fabs(my_trunc(log10(delta)))) + 1;
-    } else                     // use users' frac 
+    } else                      // use users' frac
       frac = *nfrac;
-    
+
     wid += 1 + frac;
     sprintf (fmtstr, "%s%d%s%d%s", "%", wid, ".", frac, "f");
   }
-  
+
   *fldwid = wid;
   *nfrac = frac;
 }
index 6cc4e94..872d4e9 100644 (file)
@@ -1,7 +1,7 @@
 /*****************************************************************************
 **  FILE IDENTIFICATION
 **
-**      EZSET - Parameter control for EZPLOT           
+**      EZSET - Parameter control for EZPLOT
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -33,19 +33,19 @@ EZPlot::ezset (const std::string& command)
   return ezset (command.c_str());
 }
 
-bool 
+bool
 EZPlot::ezset (const char* const command)
 {
 
     return ezcmd (command);
 }
 
-bool 
+bool
 EZPlot::ezcmd (const char* const comm)
 {
   m_pol.usefile (POL::P_USE_STR, "");
   m_pol.set_inputline (comm);
-  
+
   char str [POL::MAXTOK+1];
   int code;
   bool retval = true;
@@ -56,8 +56,8 @@ EZPlot::ezcmd (const char* const comm)
   }
   else
     retval = do_cmd (code);
-  
-  m_pol.closefile();                   /* close input string file */
+
+  m_pol.closefile();                    /* close input string file */
   return (retval);
 }
 
@@ -69,7 +69,7 @@ EZPlot::do_cmd (int lx)
   char strIn [1024];
   int n;
   double f;
-  
+
   switch (lx) {
   case S_TEXTSIZE:
     if (m_pol.readFloat (&f, POL::TT_REAL, FALSE, 0.0, 0.0) == TRUE) {
@@ -187,7 +187,7 @@ EZPlot::do_cmd (int lx)
     }
     if (m_iCurrentCurve < 0)
       o_linestyle = ls;
-    else 
+    else
       setLinestyle (m_iCurrentCurve, ls);
     break;
   case S_NOLINE:
@@ -200,7 +200,7 @@ EZPlot::do_cmd (int lx)
       if (n >= 0) {
         if (m_iCurrentCurve < 0)
           o_color = n;
-        else 
+        else
           setColor (m_iCurrentCurve, n);
       } else
         bad_option("The color you picked");
@@ -296,7 +296,7 @@ EZPlot::do_cmd (int lx)
             sym = n;
           if (m_iCurrentCurve < 0)
             o_symfreq = sym;
-          else 
+          else
             setSymbolFreq (m_iCurrentCurve, sym);
         }
       } else if (m_pol.readWord ("none",4) == TRUE) {
@@ -309,7 +309,7 @@ EZPlot::do_cmd (int lx)
       if (n > 0)
         m_iCurrentCurve = n - 1;
     } else {
-      if (m_pol.readWord ("all",3) == TRUE) 
+      if (m_pol.readWord ("all",3) == TRUE)
         m_iCurrentCurve = -1;
     }
     break;
@@ -376,14 +376,14 @@ EZPlot::do_cmd (int lx)
     fprintf (stderr, "Unimplemented EZPLOT command\n");
     break;
   }
-  
+
   m_pol.reader ();
   return (true);
 }
 
 
 
-void 
+void
 EZPlot::bad_option (char *opt)
 {
   sys_error (ERR_WARNING, "INVALID option: %s", opt);
@@ -391,92 +391,92 @@ EZPlot::bad_option (char *opt)
 
 
 //----------------------------------------------------------------------
-//                     KEYWORDS / CODES TABLE
+//                      KEYWORDS / CODES TABLE
 //----------------------------------------------------------------------
 const struct KeywordCodeTable EZPlot::m_sKeywords[] =
 {
-  {"solid",    S_SOLID},
+  {"solid",     S_SOLID},
   {"dash", S_DASH},
   {"curve", S_CURVE},
-  {"noline",   S_NOLINE},
-  {"black",    S_BLACK},
-  {"red",              S_RED},
-  {"blue",             S_BLUE},
-  {"green",    S_GREEN},
-  {"pen",              S_PEN},
-  {"symbol",   S_SYMBOL},
-  {"every",    S_EVERY},    
-  {"none",             S_NONE},  
-  {"legend",   S_LEGEND},
-  {"xlegend",  S_XLEGEND},
-  {"ylegend",  S_YLEGEND},
-  
-  {"xlin",             S_XLIN},
-  {"ylin",             S_YLIN},
-  {"xlog",             S_XLOG},
-  {"ylog",             S_YLOG},
-  {"xlabel",   S_XLABEL},
-  {"ylabel",   S_YLABEL},
-  {"xlength",  S_XLENGTH},
-  {"ylength",  S_YLENGTH},
-  
-  {"xticks",   S_XTICKS},
-  {"yticks",   S_YTICKS},
-  {"above",    S_ABOVE},
-  {"label",    S_LABEL},
-  {"below",    S_BELOW},
-  {"nolabel",  S_NOLABEL},
-  {"right",    S_RIGHT},
-  {"left",             S_LEFT},
-  
-  {"xautoscale",       S_XAUTOSCALE},
-  {"yautoscale",       S_YAUTOSCALE},
-  {"xmin",             S_XMIN},
-  {"ymin",             S_YMIN},
-  {"xmax",             S_XMAX},
-  {"ymax",             S_YMAX},
-  {"lxfrac",   S_LXFRAC},
-  {"lyfrac",   S_LYFRAC},
-  {"xcross",   S_XCROSS},
-  {"ycross",   S_YCROSS},
-  {"noxaxis",  S_NOXAXIS},
-  {"noyaxis",  S_NOYAXIS},
-  {"xporigin", S_XPORIGIN},
-  {"yporigin", S_YPORIGIN},
-  {"title",    S_TITLE},
-  {"xtitle",   S_XTITLE},
-  {"ytitle",   S_YTITLE},
-  
-  {"replot",   S_REPLOT},
-  {"clear",    S_CLEAR},
-  {"store",    S_STORE},
-  {"restore",  S_RESTORE},
-  {"amark",    S_AMARK},
-  {"units",    S_UNITS},
-  {"inches",   S_INCHES},
-  {"user",             S_USER},
-  
-  {"data",             S_DATA},
-  {"help",             S_HELP},
-  {"exit",             S_EXIT},
-  
-  {"box",              S_BOX},
-  {"nobox",    S_NOBOX},
-  {"grid",             S_GRID},
-  {"nogrid",   S_NOGRID},
-  {"major",    S_MAJOR},
-  {"minor",    S_MINOR},
-  {"color",    S_COLOR},
-  {"legendbox",        S_LEGENDBOX},
-  
-  {"no",               S_NO},
-  
-  {"textsize", S_TEXTSIZE},
+  {"noline",    S_NOLINE},
+  {"black",     S_BLACK},
+  {"red",               S_RED},
+  {"blue",              S_BLUE},
+  {"green",     S_GREEN},
+  {"pen",               S_PEN},
+  {"symbol",    S_SYMBOL},
+  {"every",     S_EVERY},
+  {"none",              S_NONE},
+  {"legend",    S_LEGEND},
+  {"xlegend",   S_XLEGEND},
+  {"ylegend",   S_YLEGEND},
+
+  {"xlin",              S_XLIN},
+  {"ylin",              S_YLIN},
+  {"xlog",              S_XLOG},
+  {"ylog",              S_YLOG},
+  {"xlabel",    S_XLABEL},
+  {"ylabel",    S_YLABEL},
+  {"xlength",   S_XLENGTH},
+  {"ylength",   S_YLENGTH},
+
+  {"xticks",    S_XTICKS},
+  {"yticks",    S_YTICKS},
+  {"above",     S_ABOVE},
+  {"label",     S_LABEL},
+  {"below",     S_BELOW},
+  {"nolabel",   S_NOLABEL},
+  {"right",     S_RIGHT},
+  {"left",              S_LEFT},
+
+  {"xautoscale",        S_XAUTOSCALE},
+  {"yautoscale",        S_YAUTOSCALE},
+  {"xmin",              S_XMIN},
+  {"ymin",              S_YMIN},
+  {"xmax",              S_XMAX},
+  {"ymax",              S_YMAX},
+  {"lxfrac",    S_LXFRAC},
+  {"lyfrac",    S_LYFRAC},
+  {"xcross",    S_XCROSS},
+  {"ycross",    S_YCROSS},
+  {"noxaxis",   S_NOXAXIS},
+  {"noyaxis",   S_NOYAXIS},
+  {"xporigin",  S_XPORIGIN},
+  {"yporigin",  S_YPORIGIN},
+  {"title",     S_TITLE},
+  {"xtitle",    S_XTITLE},
+  {"ytitle",    S_YTITLE},
+
+  {"replot",    S_REPLOT},
+  {"clear",     S_CLEAR},
+  {"store",     S_STORE},
+  {"restore",   S_RESTORE},
+  {"amark",     S_AMARK},
+  {"units",     S_UNITS},
+  {"inches",    S_INCHES},
+  {"user",              S_USER},
+
+  {"data",              S_DATA},
+  {"help",              S_HELP},
+  {"exit",              S_EXIT},
+
+  {"box",               S_BOX},
+  {"nobox",     S_NOBOX},
+  {"grid",              S_GRID},
+  {"nogrid",    S_NOGRID},
+  {"major",     S_MAJOR},
+  {"minor",     S_MINOR},
+  {"color",     S_COLOR},
+  {"legendbox", S_LEGENDBOX},
+
+  {"no",                S_NO},
+
+  {"textsize",  S_TEXTSIZE},
 };
 
 const int EZPlot::NKEYS = (sizeof(EZPlot::m_sKeywords) / sizeof (struct KeywordCodeTable));
 
-void 
+void
 EZPlot::initKeywords ()
 {
   for (int i = 0; i < NKEYS; i++)
index 1d5563f..7888384 100644 (file)
@@ -1,8 +1,8 @@
 /*****************************************************************************
-**     Name:          ezsupport.h
-**     Function:      Support routines for EZPlot library
-**     Programmer:    Kevin Rosenberg
-**     Date Started:  1-22-85
+**      Name:          ezsupport.h
+**      Function:      Support routines for EZPlot library
+**      Programmer:    Kevin Rosenberg
+**      Date Started:  1-22-85
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
index 42ddf3e..f433e5f 100644 (file)
@@ -1,7 +1,7 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**   POL - Problem Oriented Language                   
+**   POL - Problem Oriented Language
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
 
 
 const struct POL::KeywordCodeList POL::cmdlist[] = {
-  {    "eoc",  PC_EOC,},
-  {    "str",  PC_STR,},
-  {    "com",  PC_COM,},
-  {    "cmd",  PC_CMD,},
-  {    "prg",  PC_PRG,},
-  {    "con",  PC_CON,},
-  {    "out",  PC_OUT,},
-  {    "ter",  PC_TER,},
-  {    "inb",  PC_INB,},
-  
-  {    "nl_eoc",PC_NL_EOC,},
-  {    "nl_neoc", PC_NL_NEOC,},
-  {    "tron",  PC_TRON,},
-  {    "troff", PC_TROFF,},
-  {    "file",  PC_FILE,},
-  {    "dump",  PC_DUMP,},
+  {     "eoc",  PC_EOC,},
+  {     "str",  PC_STR,},
+  {     "com",  PC_COM,},
+  {     "cmd",  PC_CMD,},
+  {     "prg",  PC_PRG,},
+  {     "con",  PC_CON,},
+  {     "out",  PC_OUT,},
+  {     "ter",  PC_TER,},
+  {     "inb",  PC_INB,},
+
+  {     "nl_eoc",PC_NL_EOC,},
+  {     "nl_neoc", PC_NL_NEOC,},
+  {     "tron",  PC_TRON,},
+  {     "troff", PC_TROFF,},
+  {     "file",  PC_FILE,},
+  {     "dump",  PC_DUMP,},
 };
 
 const unsigned int POL::NUMCMD = (sizeof(POL::cmdlist) / sizeof (struct POL::KeywordCodeList));
@@ -63,7 +63,7 @@ POL::~POL()
 {
 }
 
-void 
+void
 POL::init ()
 {
   meta.eoc    = SEMICOL;
@@ -75,15 +75,15 @@ POL::init ()
   meta.out    = DOLLAR;
   meta.ter    = PERCENT;
   meta.inb    = LBRACK;
-  
+
   m_bNewlineIsEOC = true;
   m_szSkipChars[0] = EOS;
-  
-  
+
+
   for (unsigned int i = 0; i < NUMCMD; i++)
     cmdtable.installKeywordCode (cmdlist[i].keyword, cmdlist[i].code);
-  
-  token.ready = false;         // no token read yet 
+
+  token.ready = false;          // no token read yet
 }
 
 
@@ -92,10 +92,10 @@ POL::init ()
 * char *w - word for pol to ignore and skip over in input
 *
 * tok() compares all tokens to words given to this routine. If it finds it,
-* it will immediately read another token. 
+* it will immediately read another token.
 */
 
-void 
+void
 POL::addSkipWord (const char* const w)
 {
   skiptable.installKeywordCode (w, 0);
@@ -105,7 +105,7 @@ POL::addSkipWord (const char* const w)
 *
 * skip all characters that appear in string s
 */
-void 
+void
 POL::addSkipChar (int c)
 {
   int n = strlen (m_szSkipChars);
@@ -131,16 +131,16 @@ POL::addKeyword (const char* const str, int code)
 /* get_word - matches tokens on a letter by letter basis
 *
 * char *search - string to search for
-* int  nlet    - maximum number of chars to search for match
+* int  nlet     - maximum number of chars to search for match
 */
 
-bool 
+bool
 POL::readWord (char *search, int nlet)
 {
   tok (&token);
   if (m_bTrace)
     sys_error (ERR_TRACE, "POL matching current token %s against word %s\n", token.tokstr, search);
-  
+
   if (strncasecmp (search, token.tokstr, nlet) == 0) {
     dumptok (&token);
     return (true);
@@ -149,21 +149,21 @@ POL::readWord (char *search, int nlet)
 }
 
 /* usertok (str,code)
-*      see if current token is a user defined token set with install()
+*       see if current token is a user defined token set with install()
 *
 *    char *str - token string as read from input
 *    int *code - returned code for user defined symbol
 *    return value - true if current token has been user defined
-*                   false if current token is not user defined
+*                    false if current token is not user defined
 */
 bool
 POL::readUserToken (char *str, int *code)
 {
   tok (&token);
-  
+
   if (m_bTrace)
     sys_error (ERR_TRACE, "POL checking if current token '%s' is user defined\n", token.tokstr);
-  
+
   if (token.type == TT_USERTOK) {
     *code = token.code;
     strcpy (str, token.tokstr);
@@ -184,7 +184,7 @@ bool
 POL::readString (char *str)
 {
   tok (&token);
-  
+
   if (token.type == TT_STRING) {
     strcpy (str, token.tokstr);
     dumptok (&token);
@@ -195,31 +195,31 @@ POL::readString (char *str)
 
 /* integer - test for an integer
 *
-* int *n:      returned integer value
+* int *n:       returned integer value
 * int typecode = TT_INT if accept only integer values
-*              = TT_REAL if accept both real and integer values
+*               = TT_REAL if accept both real and integer values
 * int boundcode= true if force to lie between boundries
-*              = false can take any value it likes
-* int bb1:     lower bound
-* int bb2:     upper bound
+*               = false can take any value it likes
+* int bb1:      lower bound
+* int bb2:      upper bound
 */
-bool 
+bool
 POL::readInteger (int *n, int typecode, bool boundcode, int bb1, int bb2)
 {
   tok (&token);
-  
+
   if (m_bTrace)
     sys_error (ERR_TRACE, "POL checking if current token %s is an integer\n", token.tokstr);
-  
+
   if (token.type == TT_INT || token.type == TT_REAL) {
-          if (boundcode) {
+           if (boundcode) {
        if (token.inum < bb1)
          *n = bb1;
        else if (token.inum > bb2)
          *n = bb2;
        else
          *n = token.inum;
-           } else
+            } else
         *n = token.inum;
       dumptok (&token);
       return (true);
@@ -232,19 +232,19 @@ bool
 POL::readFloat (double *n, double typecode, bool boundcode, double bb1, double bb2)
 {
   tok (&token);
-  
+
   if (m_bTrace)
     sys_error (ERR_TRACE, "POL checking if current token %s is an floating point number\n", token.tokstr);
-  
+
   if (token.type == TT_INT || token.type == TT_REAL) {
-          if (boundcode) {
+           if (boundcode) {
        if (token.fnum < bb1)
          *n = bb1;
        else if (token.fnum > bb2)
          *n = bb2;
        else
          *n = token.fnum;
-           } else
+            } else
         *n = token.fnum;
       dumptok (&token);
       return (true);
@@ -254,49 +254,49 @@ POL::readFloat (double *n, double typecode, bool boundcode, double bb1, double b
 }
 
 /*----------------------------------------------------------------------*/
-/* skip() - skip over any token except for end of command sequence     */
-/*                                                                     */
-/*             returns true if succesful skip                          */
-/*             returns false if already at end of command or EOF       */
+/* skip() - skip over any token except for end of command sequence      */
+/*                                                                      */
+/*              returns true if succesful skip                          */
+/*              returns false if already at end of command or EOF       */
 /*----------------------------------------------------------------------*/
 
-bool 
+bool
 POL::skipTokens()
 {
-  char term[5];                /* string of characters not to skip */
-  
+  char term[5];         /* string of characters not to skip */
+
   term[0] = meta.eoc;
   if (m_bNewlineIsEOC) {
     term[1] = NEWLINE;
     term[2] = EOS;
   } else
     term[1] = EOS;
-  
+
   return (skipSingleToken (term));
 }
 
-void 
+void
 POL::reader()
 {
   while (skipTokens())
     ;
-  
-  dumptok (&token);            /* skip end of command token */
+
+  dumptok (&token);             /* skip end of command token */
 }
 
 /* skiptok (term) - skip a token unless the first character of a token is
-*                  in the string of terminators, term.
+*                   in the string of terminators, term.
 * char *term - string of termination characters, don't skip these characters
-*              skiptok() also does NOT skip TT_EOF
+*               skiptok() also does NOT skip TT_EOF
 * returns (true) if succesful skip of a token
 * returns (false) if didn't skip, read termination character or TT_EOF
 */
 
-bool 
+bool
 POL::skipSingleToken (char term[])
 {
   tok (&token);
-  
+
   if (token.type == TT_EOF
     || (token.type == TT_SPECLCHAR && strchr(term, token.tokstr[0]) != NULL))
     return (false);
@@ -306,7 +306,7 @@ POL::skipSingleToken (char term[])
   }
 }
 
-int 
+int
 POL::tok (struct token_st *token)
 {
   if (token->ready == false)
@@ -317,7 +317,7 @@ POL::tok (struct token_st *token)
     return (token->type);
 }
 
-void 
+void
 POL::dumptok (struct token_st *token)
 {
   if (token->ready == false)
@@ -325,15 +325,15 @@ POL::dumptok (struct token_st *token)
   token->ready = false;
 }
 
-int 
+int
 POL::getpol_tok (struct token_st *token)
 {
   KeywordCodeEntry* sym;
-  
+
   token->ready = false;
 nexttok:
   gettok (token);
-  
+
   if (token->type == TT_BLANK)
     goto nexttok;
   if (token->type == TT_SPECLCHAR) {
@@ -345,7 +345,7 @@ nexttok:
       getcmd();
       goto nexttok;
     }
-    if (token->tokstr[0] == meta.com) {                /* skip comment */
+    if (token->tokstr[0] == meta.com) {         /* skip comment */
       eatline ();
       goto nexttok;
     }
@@ -354,48 +354,48 @@ nexttok:
       fputs (token->tokstr, stderr);
       goto nexttok;
     }
-    if (token->tokstr[0] == meta.con) {                /* continuation across NEWLINE */
+    if (token->tokstr[0] == meta.con) {         /* continuation across NEWLINE */
       while (lookchar() == BLANK || lookchar() == TAB)
         inchar();
       if (lookchar() == NEWLINE)
         inchar();
     }
-    if (token->tokstr[0] == meta.ter) {                /* get input from terminal */
+    if (token->tokstr[0] == meta.ter) {         /* get input from terminal */
       usefile (P_USE_FILE, "");
       tok (token);
       closefile();
       return (token->type);
     }
   }
-  
+
   /* look for filler words */
-  
-  if (skiptable.lookup (token->tokstr) != NULL)        /* ignore words in skip table */
+
+  if (skiptable.lookup (token->tokstr) != NULL) /* ignore words in skip table */
     goto nexttok;
-  
+
   /* look for user defined symbols */
-  
+
   if ((sym = usertable.lookup (token->tokstr)) != NULL) {
     token->type = TT_USERTOK;
     token->code = sym->getCode();
   } else
     token->code = 0;
-  
+
   if (m_bTrace)
     sys_error (ERR_TRACE, "POL read token '%s', type = %d\n", token->tokstr, token->type);
-  
+
   return (token->type);
 }
 
 
-int 
+int
 POL::getcmd()
 {
   int tt, found;
   char str[MAXTOK+1];
   KeywordCodeEntry *cmd;
   TOKEN tok;
-  
+
   tt = getalpha (str, MAXTOK);
   if (tt == TT_ERROR) {
     sys_error (ERR_WARNING, "Error in POL parameter command");
@@ -410,33 +410,33 @@ POL::getcmd()
     found = false;
     switch (cmd->getCode()) {
     case PC_TRON:
-                   m_bTrace = true;
+                    m_bTrace = true;
         found = true;
         break;
     case PC_TROFF:
-                   m_bTrace = false;
+                    m_bTrace = false;
         found = true;
         break;
     case PC_FILE:
-                   found = true;
+                    found = true;
         tt = gettok (&tok);
         usefile (P_USE_FILE, tok.tokstr);
         break;
     case PC_NL_EOC:
-                   found = true;
+                    found = true;
         m_bNewlineIsEOC = true;
         break;
     case PC_NL_NEOC:
-                   found = true;
+                    found = true;
         m_bNewlineIsEOC = false;
         break;
     case PC_DUMP:
-                   found = true;
+                    found = true;
         printf("eoc = %c  str = %c  com = %c  cmd = %c  prg = %c\n",
           meta.eoc, meta.str, meta.com, meta.cmd, meta.prg);
         printf("con = %c  out = %c  ter = %c  inb = %c\n",
           meta.con, meta.out, meta.ter, meta.inb);
-        break; 
+        break;
     }
     if (found == false) {
       tt = gettok (&tok);
@@ -445,7 +445,7 @@ POL::getcmd()
         return (false);
       }
       switch(cmd->getCode()) {
-                   case PC_EOC:
+                    case PC_EOC:
           meta.eoc = tok.tokstr[0];
           break;
         case PC_STR:
@@ -475,39 +475,39 @@ POL::getcmd()
         default:
           printf("command not implemented\n");
           break;
-      }                                /* switch (tok->type) */
-    }                                  /* if (found == false) */
-    reader();                  /* clean up command */
-  }                                    /* if legal command */
-  
+      }                         /* switch (tok->type) */
+    }                                   /* if (found == false) */
+    reader();                   /* clean up command */
+  }                                     /* if legal command */
+
   return (true);
 }
 
 
-int 
+int
 POL::gettok (TOKEN *tok)
 {
   int c, toktype;
   int inum;
   double fnum;
-  int toksiz = MAXTOK;         /* maximum length of token string */
-  
+  int toksiz = MAXTOK;          /* maximum length of token string */
+
   while ((c = inchar()) == BLANK || c == TAB)
     ;
   ungetch (c);
-  
+
   c = lookchar();
   toktype = type(c);
-  
+
   fnum = 0.0;
   inum = 0;
-  
-  if (c == BLANK || c == TAB) {                        /* skip white space */
+
+  if (c == BLANK || c == TAB) {                 /* skip white space */
     getblank(tok->tokstr, toksiz);
     toktype = TT_BLANK;
   } else if (toktype == LETTER) {
     toktype = getalpha (tok->tokstr, toksiz);
-  } else if (c == meta.str) {                  /* quoted string */
+  } else if (c == meta.str) {                   /* quoted string */
     getquote (tok->tokstr, toksiz);
     toktype = TT_STRING;
   } else if (type(c) == DIGIT || c == PLUS || c == HYPHEN || c == PERIOD) {
@@ -521,7 +521,7 @@ POL::gettok (TOKEN *tok)
     tok->tokstr[1] = EOS;
     toktype = TT_SPECLCHAR;
   }
-  
+
   tok->type = toktype;
   tok->ready = true;
   if (tok->type == TT_REAL || tok->type == TT_INT) {
@@ -531,37 +531,37 @@ POL::gettok (TOKEN *tok)
     tok->fnum = 0.0;
     tok->inum = 0;
   }
-  
+
   return (toktype);
 }
 
 
-void 
+void
 POL::getblank (char *s, int toksiz)
 {
   int c;
-  
+
   while ((c = inchar()) == BLANK || c == TAB)
     ;
   ungetch(c);
-  
+
   s[0] = BLANK;
   s[1] = EOS;
 }
 
 
-int 
+int
 POL::getalpha (char *s, int toksiz)
 {
   int i, chartype, alphatype;
-  
+
   if (type(lookchar()) != LETTER) {
     s[0] = EOS;
     return (TT_ERROR);
   }
-  
+
   alphatype = TT_ALPHA;
-  for (i = 0; i < toksiz; i++) {               /* get alphanumeric token */
+  for (i = 0; i < toksiz; i++) {                /* get alphanumeric token */
     s[i] = inchar();
     chartype = type (s[i]);
     if (chartype != LETTER && chartype != DIGIT)
@@ -570,36 +570,36 @@ POL::getalpha (char *s, int toksiz)
       alphatype = TT_ALPNUM;
   }
   ungetch(s[i]);
-  
+
   if (i >= toksiz)
     sys_error (ERR_SEVERE, "POL token too long.");
-  
-  s[i] = EOS;                  /* terminate token */
+
+  s[i] = EOS;                   /* terminate token */
   return (alphatype);
 }
 
 
 /* getquote - get quoted string from file */
 /* have already gotten delimiter in qs[0] */
-void 
+void
 POL::getquote (char *qs, int toksiz)
 {
   int delim;
-  
-  delim = inchar();                    /* char = delimiter */
+
+  delim = inchar();                     /* char = delimiter */
   getescape(qs, delim, toksiz);
 }
 
 
-void 
-POL::getescape (       /* reads up to delim */
+void
+POL::getescape (        /* reads up to delim */
                 char *s,
                 int delim,
                 int toksiz
                 )
 {
   int i, c;
-  
+
   for (i = 0; (c = inchar()) != delim; i++) {
     if (c == NEWLINE) {
       sys_error (ERR_WARNING, "Missing closing delimiter.");
@@ -613,9 +613,9 @@ POL::getescape (    /* reads up to delim */
       ungetch(c);
       sys_error (ERR_SEVERE, "end of file inside quotation");
       break;
-    } else if (c == BSLASH) {  /* escape character */
+    } else if (c == BSLASH) {   /* escape character */
       s[i++] = c;
-      c = inchar();            /* get escaped character */
+      c = inchar();             /* get escaped character */
     }
     s[i] = c;
   }
@@ -623,7 +623,7 @@ POL::getescape (    /* reads up to delim */
 }
 
 
-bool 
+bool
 POL::readText (char *str, int lim)
 {
   int c;
@@ -634,36 +634,36 @@ POL::readText (char *str, int lim)
     str[0] = 0;
     return false;
   }
-  
+
   int i;
   for (i = 0; i < lim && (c = inchar()) != EOF && c != NEWLINE; i++)
     str[i] = c;
   ungetch (c);
   str[i] = 0;
-  
+
   return true;
 }
 
 //----------------------------------------------
-// Get a number for gettok()                   
+// Get a number for gettok()
 //----------------------------------------------
 
-int 
-POL::getnumber 
+int
+POL::getnumber
 (
- char str[],                           /* string to return token in */
- int strsize,                          /* maximum length of token string */
- double *fnum,                         /* floating point value of number read */
- int *inum                             /* integer value of number read */
+ char str[],                            /* string to return token in */
+ int strsize,                           /* maximum length of token string */
+ double *fnum,                          /* floating point value of number read */
+ int *inum                              /* integer value of number read */
  )
 {
   int sp = 0;
   double sign = 1.0;
-  bool isSigned = false;               /* true if number prefixed by '+' or '-' */ 
+  bool isSigned = false;                /* true if number prefixed by '+' or '-' */
   *fnum = 0.0;
   *inum = 0;
   str[0] = EOS;
-  
+
   int c = inchar();
   if (c == HYPHEN) {
     str[sp++] = c;
@@ -685,13 +685,13 @@ POL::getnumber
     return (TT_ERROR);
   } else
     ungetch (c);
-  
+
   if (isSigned) {
     c = lookchar();
     if (c == PERIOD) {
-      inchar();                /* get period */
-      c = lookchar();          /* look at character past period */
-      ungetch (PERIOD);        /* put back period */
+      inchar();         /* get period */
+      c = lookchar();           /* look at character past period */
+      ungetch (PERIOD); /* put back period */
       if (type(c) != DIGIT) {
         str[sp] = EOS;
         return (TT_SPECLCHAR);
@@ -701,15 +701,15 @@ POL::getnumber
       return (TT_SPECLCHAR);
     }
   }
-  
+
   double whole = 0.0;
   while (type(c = inchar()) == DIGIT) {
     if (sp < strsize)
       str[sp++] = c;
     whole = 10.0 * whole + (c - '0');
   }
-  ungetch (c);         /* put back non-numeric character */
-  
+  ungetch (c);          /* put back non-numeric character */
+
   if (c != PERIOD && tolower(c) != 'e') {
     str[sp] = EOS;
     *fnum = whole * sign;
@@ -721,16 +721,16 @@ POL::getnumber
       *inum = (int) *fnum;
     return (TT_INT);
   }
-  
+
   if (lookchar() == PERIOD) {
     inchar();
     if (sp < strsize)
       str[sp++] = PERIOD;
   }
-  
+
   double frac = 0.0;
   double powerof10 = 10.0;
-  
+
   while (type(c = inchar()) == DIGIT) {
     if (sp < strsize)
       str[sp++] = c;
@@ -738,7 +738,7 @@ POL::getnumber
     powerof10 *= 10.0;
   }
   ungetch (c);
-  
+
   double exp = 0.0;
   double expsign = 1.0;
   c = inchar();
@@ -756,13 +756,13 @@ POL::getnumber
         str[sp++] = c;
       expsign = -1.0;
     } else if (type(c) != DIGIT) {
-      --sp;                            /* erase 'e' */
+      --sp;                             /* erase 'e' */
       ungetch (c);
       ungetch ('e');
       goto getnumexit;
     } else
       ungetch(c);
-    
+
     exp = 0;
     while (type(c = inchar()) == DIGIT) {
       if (sp < strsize)
@@ -771,7 +771,7 @@ POL::getnumber
     }
     ungetch (c);
   }
-  
+
 getnumexit:
   str[sp] = EOS;
   *fnum = sign * (whole + frac) * pow (10.0, expsign * exp);
@@ -784,18 +784,18 @@ getnumexit:
   return (TT_REAL);
 }
 
-void 
+void
 POL::eatline ()
 {
   char term [2];
-  
+
   term[0] = NEWLINE;
   term[1] = EOS;
   skipSingleToken (term);
 }
 
-// return type of ASCII character 
-int 
+// return type of ASCII character
+int
 POL::type (int c)
 {
   if (isalpha(c) || c == UNDERLIN)
@@ -808,30 +808,30 @@ POL::type (int c)
 
 
 //----------------------------------------------------------------------
-//                             POL INPUT                               
+//                              POL INPUT
 //----------------------------------------------------------------------
 
 
 /* usefile - set source of POL input
 *
 *    int source - source of input
-*                 P_USE_STR  - have POL use strings as input
-*                 P_USE_FILE - use file.  filename is in str
+*                  P_USE_STR  - have POL use strings as input
+*                  P_USE_FILE - use file.  filename is in str
 *
 */
 
-void 
+void
 POL::usefile (int source, char *fn)
 {
   FILE *fp;
-  
+
   ++currentf;
   if (currentf >= MAXFILE) {
     --currentf;
     sys_error (ERR_SEVERE, "files nested too deeply");
     return;
   }
-  
+
   while (! m_stackPushBackInput.empty())
     m_stackPushBackInput.pop();
 
@@ -850,7 +850,7 @@ POL::usefile (int source, char *fn)
   }
 }
 
-void 
+void
 POL::closefile()
 {
   if (currentf >= 0) {
@@ -865,37 +865,37 @@ POL::closefile()
 /*-----------------------------*/
 
 
-int 
+int
 POL::lookchar()
 {
   int c;
-  
+
   c = inchar();
   ungetch (c);
   return (c);
 }
 
-int 
+int
 POL::inchar()
 {
   int c = 0;
-  
+
   if (currentf < 0)
     return (EOF);
-  
+
   while (currentf >= 0 && (c = getch(filep[currentf])) == EOF && filep[currentf] != NULL) {
     closefile ();
   }
-  
+
   return (c);
 }
 
 /*--------------------------------------------------------------*/
-/* getch - get a (possibly pushed back) character              */
-/*        if fp == NULL, then get character from inputline     */
+/* getch - get a (possibly pushed back) character               */
+/*         if fp == NULL, then get character from inputline     */
 /*--------------------------------------------------------------*/
 
-int 
+int
 POL::getch (FILE *fp)
 {
   int c;
@@ -914,19 +914,19 @@ POL::getch (FILE *fp)
     }
   } else
     c = fgetc(fp);
-  
+
   return (c);
 }
 
-// push character back on input 
-void 
+// push character back on input
+void
 POL::ungetch (int c)
 {
   m_stackPushBackInput.push (c);
 }
 
 
-int 
+int
 POL::get_inputline (FILE *fp)
 {
   while (! m_stackPushBackInput.empty())
@@ -939,7 +939,7 @@ POL::get_inputline (FILE *fp)
     return (OK);
 }
 
-void 
+void
 POL::set_inputline (const char* const line)
 {
   while (! m_stackPushBackInput.empty())
index 65095c8..305a630 100644 (file)
@@ -1,8 +1,8 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:       sgp.cpp             Simple Graphics Package
-**     Programmer: Kevin Rosenberg
+**      Name:       sgp.cpp             Simple Graphics Package
+**      Programmer: Kevin Rosenberg
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -71,7 +71,7 @@ SGPDriver::SGPDriver (const char* szWinTitle, int xsize, int ysize)
 SGPDriver::~SGPDriver ()
 {
 #if HAVE_G2_H
-  if (isG2()) 
+  if (isG2())
     g2_close (m_idG2);
 #endif
 }
@@ -99,7 +99,7 @@ SGP::SGP (const SGPDriver& driver)
   setViewport (0., 0., 1., 1.);
   moveAbs (0., 0.);
   stylusNDC (0., 0., false);
-  
+
   setTextAngle (0.);
   setTextPointSize (12);
   setColor (C_BLACK);
@@ -130,7 +130,7 @@ SGP::initFromDC (wxDC* pDC)
     m_driver.idWX()->SetFont (*m_pFont);
     double dTestCharHeight = m_driver.idWX()->GetCharHeight();
     m_dPointsPerPixel = iTestPointSize / dTestCharHeight;
-       m_driver.idWX()->SetBackground (*wxWHITE_BRUSH);
+        m_driver.idWX()->SetBackground (*wxWHITE_BRUSH);
   }
 }
 #endif
@@ -209,7 +209,7 @@ SGP::pointNDC (double x, double y)
 // NAME
 //    clear     Clear Window
 
-void 
+void
 SGP::eraseWindow ()
 {
 #if HAVE_G2_H
@@ -218,25 +218,25 @@ SGP::eraseWindow ()
 #endif
 #if HAVE_WXWINDOWS
   if (m_driver.isWX()) {
-       wxBrush brushWhite;
-       brushWhite.SetColour(255,255,255);
-       m_driver.idWX()->SetBackground(brushWhite);
-       m_driver.idWX()->Clear();
-       m_driver.idWX()->SetBackground(wxNullBrush);
+        wxBrush brushWhite;
+        brushWhite.SetColour(255,255,255);
+        m_driver.idWX()->SetBackground(brushWhite);
+        m_driver.idWX()->Clear();
+        m_driver.idWX()->SetBackground(wxNullBrush);
 #if 1
-       wxPen pen;
-       pen.SetColour(255,255,255);
-       m_driver.idWX()->SetBrush (brushWhite);
-       m_driver.idWX()->DrawRectangle (0, 0, m_iPhysicalXSize, m_iPhysicalYSize);
-       m_driver.idWX()->SetBrush (wxNullBrush);
+        wxPen pen;
+        pen.SetColour(255,255,255);
+        m_driver.idWX()->SetBrush (brushWhite);
+        m_driver.idWX()->DrawRectangle (0, 0, m_iPhysicalXSize, m_iPhysicalYSize);
+        m_driver.idWX()->SetBrush (wxNullBrush);
 #endif
   }
 #endif
 }
 
 // NAME
-//     sgp2_window             Set window in world coordinates
+//      sgp2_window             Set window in world coordinates
+
 
 void
 SGP::setWindow (double xmin, double ymin, double xmax, double ymax)
@@ -245,7 +245,7 @@ SGP::setWindow (double xmin, double ymin, double xmax, double ymax)
     sys_error (ERR_WARNING, "Minimum > Maximum [sgp2_window]");
     return;
   }
-  
+
   xw_min = xmin;
   yw_min = ymin;
   xw_max = xmax;
@@ -255,7 +255,7 @@ SGP::setWindow (double xmin, double ymin, double xmax, double ymax)
 
 
 // NAME
-//     sgp2_viewport                   Set viewport in NDC
+//      sgp2_viewport                   Set viewport in NDC
 
 void
 SGP::setViewport (double xmin, double ymin, double xmax, double ymax)
@@ -264,14 +264,14 @@ SGP::setViewport (double xmin, double ymin, double xmax, double ymax)
     sys_error (ERR_WARNING, "Minimum > Maximum [sgp2_viewport]");
     return;
   }
-    
+
   xv_min = xmin;
   yv_min = ymin;
   xv_max = xmax;
   yv_max = ymax;
   m_bRecalcTransform = true;
-  
-  viewNDC[0] = xmin;                   // Array for clip_rect() 
+
+  viewNDC[0] = xmin;                    // Array for clip_rect()
   viewNDC[1] = ymin;
   viewNDC[2] = xmax;
   viewNDC[3] = ymax;
@@ -297,7 +297,7 @@ SGP::getWindow (double& xmin, double& ymin, double& xmax, double& ymax)
 
 
 // NAME
-//     frameViewport           draw box around viewport
+//      frameViewport           draw box around viewport
 
 void
 SGP::frameViewport (void)
@@ -326,7 +326,7 @@ SGP::setTextColor (int iFGcolor, int iBGcolor)
 #endif
 }
 
-void 
+void
 SGP::setColor (int icol)
 {
   if (icol >= 0 && icol < s_iRGBColorCount) {
@@ -346,7 +346,7 @@ SGP::setColor (int icol)
   }
 }
 
-void 
+void
 SGP::setPenWidth (int iWidth)
 {
   if (iWidth >= 0) {
@@ -429,9 +429,9 @@ SGP::setMarker (int idMarker)
 }
 
 //==============================================================
-// set line style.  Pass 16 bit repeating pattern              
+// set line style.  Pass 16 bit repeating pattern
 //==============================================================
-void 
+void
 SGP::setLineStyle (int style)
 {
   m_iLinestyle = style;
@@ -467,10 +467,10 @@ SGP::setLineStyle (int style)
 }
 
 //==============================================================
-// absolute draw to                                            
+// absolute draw to
 //*==============================================================
 
-void 
+void
 SGP::lineAbs (double x, double y)
 {
   if (m_bRecalcTransform)
@@ -483,30 +483,30 @@ SGP::lineAbs (double x, double y)
   double x2 = x;
   double y2 = y;
   mc_to_ndc.transformPoint (&x2, &y2);
-  
-  if (clip_rect (x1, y1, x2, y2, viewNDC) == true) { // clip to viewport 
+
+  if (clip_rect (x1, y1, x2, y2, viewNDC) == true) { // clip to viewport
     stylusNDC (x1, y1, false);  // move to first point
-    stylusNDC (x2, y2, true);  // draw to second point 
+    stylusNDC (x2, y2, true);  // draw to second point
   }
 
   m_dCurrentWorldX = x;
   m_dCurrentWorldY = y;
 }
 
-void 
+void
 SGP::moveAbs (double x, double y)
 {
     m_dCurrentWorldX = x;
-    m_dCurrentWorldY = y;                      /* moves are not clipped */
+    m_dCurrentWorldY = y;                       /* moves are not clipped */
 }
 
-void 
+void
 SGP::lineRel (double x, double y)
 {
   lineAbs (x + m_dCurrentWorldX, y + m_dCurrentWorldY);
 }
 
-void 
+void
 SGP::moveRel (double x, double y)
 {
   moveAbs (x + m_dCurrentWorldX, y + m_dCurrentWorldY);
@@ -593,7 +593,7 @@ SGP::getCharHeight ()
   if (m_driver.isWX()) {
     dHeight = m_driver.idWX()->GetCharHeight();
     dHeight /= static_cast<double>(m_iPhysicalYSize);
-         dHeight /= (yv_max - yv_min); // scale to viewport;
+          dHeight /= (yv_max - yv_min); // scale to viewport;
   }
 #endif
   dHeight *= (yw_max - yw_min);  // scale to world coordinates
@@ -609,7 +609,7 @@ SGP::getCharWidth ()
   if (m_driver.isWX()) {
     dWidth = m_driver.idWX()->GetCharWidth();
     dWidth /= static_cast<double>(m_iPhysicalXSize);
-         dWidth /= (xv_max - xv_min); // scale to viewport
+          dWidth /= (xv_max - xv_min); // scale to viewport
   }
 #endif
   dWidth *= (xw_max - xw_min); //scale to world coordinates
@@ -622,7 +622,7 @@ SGP::setTextAngle (double angle)
   m_dTextAngle = convertRadiansToDegrees(angle);
 }
 
-void 
+void
 SGP::polylineAbs (double x[], double y[], int n)
 {
   if (m_bRecalcTransform)
@@ -633,16 +633,16 @@ SGP::polylineAbs (double x[], double y[], int n)
   double x2 = x[1], y2 = y[1];
   mc_to_ndc.transformPoint (&x2, &y2);
 
-  double xt = x2;      // don't pass (x2,y2) to clip, we need them 
-  double yt = y2;      // as the beginning point of the next line 
+  double xt = x2;       // don't pass (x2,y2) to clip, we need them
+  double yt = y2;       // as the beginning point of the next line
 
   if (clip_rect (x1, y1, xt, yt, viewNDC)) {
     stylusNDC (x1, y1, false);
     stylusNDC (xt, yt, true);
   }
-  
+
   for (int i = 2; i < n; i++) {
-    x1 = x2; y1 = y2;                  // NDC endpoint of last line 
+    x1 = x2; y1 = y2;                   // NDC endpoint of last line
     x2 = x[i];  y2 = y[i];
     mc_to_ndc.transformPoint (&x2, &y2);
     xt = x2;
@@ -655,7 +655,7 @@ SGP::polylineAbs (double x[], double y[], int n)
 }
 
 
-void 
+void
 SGP::markerAbs (double x, double y)
 {
   if (m_bRecalcTransform)
@@ -664,20 +664,20 @@ SGP::markerAbs (double x, double y)
   double xndc = x;
   double yndc = y;
   mc_to_ndc.transformPoint (&xndc, &yndc);
-  markerNDC (xndc, yndc); 
+  markerNDC (xndc, yndc);
   m_dCurrentWorldX = x;
   m_dCurrentWorldY = y;
 }
 
 
-void 
+void
 SGP::markerRel (double x, double y)
 {
   markerAbs (x + m_dCurrentWorldX, y + m_dCurrentWorldY);
 }
 
 
-void 
+void
 SGP::pointAbs (double x, double y)
 {
   if (m_bRecalcTransform)
@@ -690,7 +690,7 @@ SGP::pointAbs (double x, double y)
 }
 
 
-void 
+void
 SGP::pointRel (double x, double y)
 {
   pointAbs (x + m_dCurrentWorldX, y + m_dCurrentWorldY);
@@ -703,7 +703,7 @@ SGP::drawText (const std::string& rsMessage)
   drawText (rsMessage.c_str());
 }
 
-void 
+void
 SGP::drawText (const char *pszMessage)
 {
   if (m_bRecalcTransform)
@@ -713,7 +713,7 @@ SGP::drawText (const char *pszMessage)
   double yndc = m_dCurrentWorldY;
   mc_to_ndc.transformPoint (&xndc, &yndc);
 
-  stylusNDC (xndc, yndc, false);            // move to location 
+  stylusNDC (xndc, yndc, false);            // move to location
 
 #if HAVE_G2_H
   if (m_driver.isG2()) {
@@ -730,12 +730,12 @@ SGP::drawText (const char *pszMessage)
 
 
 // NAME
-//   drawRect                          Draw box in graphics mode
+//   drawRect                           Draw box in graphics mode
 //
 // SYNOPSIS
 //   drawbox (xmin, ymin, xmax, ymax)
-//   double xmin, ymin                 Lower left corner of box
-//   double xmax, ymax                 Upper left corner of box
+//   double xmin, ymin                  Lower left corner of box
+//   double xmax, ymax                  Upper left corner of box
 //
 // NOTES
 //   This routine leaves the current position of graphic cursor at lower
@@ -744,27 +744,27 @@ SGP::drawText (const char *pszMessage)
 void
 SGP::drawRect (double xmin, double ymin, double xmax, double ymax)
 {
-       moveAbs (xmin, ymin);
-       lineAbs (xmax, ymin);
-       lineAbs (xmax, ymax);
-       lineAbs (xmin, ymax);
-       lineAbs (xmin, ymin);
+        moveAbs (xmin, ymin);
+        lineAbs (xmax, ymin);
+        lineAbs (xmax, ymax);
+        lineAbs (xmin, ymax);
+        lineAbs (xmin, ymin);
 }
 
 // FUNCTION
-// sgp2_circle - draw circle of radius r at current center             
-void 
+// sgp2_circle - draw circle of radius r at current center
+
+void
 SGP::drawCircle (const double r)
 {
-       drawArc (r, 0.0, TWOPI);
+        drawArc (r, 0.0, TWOPI);
 }
 
 //==============================================================
-// draw arc around current center.  angles in radius   
+// draw arc around current center.  angles in radius
 //==============================================================
 
-void 
+void
 SGP::drawArc (const double r, double start, double stop)
 {
   if (start > stop) {
@@ -778,7 +778,7 @@ SGP::drawArc (const double r, double start, double stop)
 
   double x = r * cos (start);
   double y = r * sin (start);
-  moveAbs (xCent + x, yCent + y);          // move from center to start of arc 
+  moveAbs (xCent + x, yCent + y);          // move from center to start of arc
 
   const double thetaIncrement = (5 * (TWOPI / 360));  // 5 degree increments
   double cosTheta = cos (thetaIncrement);
@@ -798,7 +798,7 @@ SGP::drawArc (const double r, double start, double stop)
   double yp = s * x + c * y;
   lineAbs (xCent + xp, yCent + yp);
 
-  moveAbs (xCent, yCent);              // move back to center of circle 
+  moveAbs (xCent, yCent);               // move back to center of circle
 }
 
 
@@ -838,14 +838,14 @@ SGP::transformMCtoNDC (double xIn, double yIn, double* x, double* y)
 
 
 // NAME
-//     calc_transform                  Calculate transform matrices
+//      calc_transform                  Calculate transform matrices
 
 void
 SGP::calc_transform ()
 {
   double scaleX = (xv_max - xv_min) / (xw_max - xw_min);
   double scaleY = (yv_max - yv_min) / (yw_max - yw_min);
-    
+
   wc_to_ndc.setIdentity();
   wc_to_ndc.mtx[0][0] = scaleX;
   wc_to_ndc.mtx[2][0] = xv_min - scaleX * xw_min;
@@ -865,7 +865,7 @@ SGP::ctmClear ()
   calc_transform();
 }
 
-void 
+void
 SGP::ctmSet (const TransformationMatrix2D& m)
 {
   m_ctm = m;
@@ -883,7 +883,7 @@ SGP::preTranslate  (double x, double y)
 }
 
 
-void 
+void
 SGP::postTranslate (double x, double y)
 {
     TransformationMatrix2D m;
@@ -893,7 +893,7 @@ SGP::postTranslate (double x, double y)
 }
 
 
-void 
+void
 SGP::preScale (double sx, double sy)
 {
     TransformationMatrix2D m;
@@ -903,7 +903,7 @@ SGP::preScale (double sx, double sy)
 }
 
 
-void 
+void
 SGP::postScale (double sx, double sy)
 {
     TransformationMatrix2D m;
@@ -914,7 +914,7 @@ SGP::postScale (double sx, double sy)
 }
 
 
-void 
+void
 SGP::preRotate (double theta)
 {
     TransformationMatrix2D m;
@@ -925,7 +925,7 @@ SGP::preRotate (double theta)
 }
 
 
-void 
+void
 SGP::postRotate (double theta)
 {
     TransformationMatrix2D m;
@@ -935,7 +935,7 @@ SGP::postRotate (double theta)
 }
 
 
-void 
+void
 SGP::preShear (double shrx, double shry)
 {
     TransformationMatrix2D m;
@@ -945,7 +945,7 @@ SGP::preShear (double shrx, double shry)
 }
 
 
-void 
+void
 SGP::postShear (double shrx, double shry)
 {
     TransformationMatrix2D m;
@@ -960,19 +960,19 @@ SGP::postShear (double shrx, double shry)
 ////////////////////////////////////////////////////////////////////////
 
 // Pixel patterns of marker symbols (1x1 to 5x5 matrix)
-const unsigned char SGP::MARKER_BITMAP[MARK_COUNT][5] = 
-{
-    {'\000', '\000', '\010', '\000', '\000'},    // small dot 
-    {'\000', '\034', '\024', '\034', '\000'},    // empty square 
-    {'\000', '\034', '\034', '\034', '\000'},    // filled square 
-    {'\000', '\010', '\024', '\010', '\000'},    // empty diamond 
-    {'\000', '\010', '\034', '\010', '\000'},    // filled diamond 
-    {'\010', '\010', '\076', '\010', '\010'},    // cross 
-    {'\000', '\024', '\010', '\024', '\000'},    // X 
-    {'\034', '\042', '\042', '\042', '\034'},    // open circle 
-    {'\034', '\076', '\076', '\076', '\034'},    // filled circle 
-    {'\076', '\042', '\042', '\042', '\076'},    // big open square 
-    {'\010', '\024', '\042', '\024', '\010'},    // big open diamond 
+const unsigned char SGP::MARKER_BITMAP[MARK_COUNT][5] =
+{
+    {'\000', '\000', '\010', '\000', '\000'},    // small dot
+    {'\000', '\034', '\024', '\034', '\000'},    // empty square
+    {'\000', '\034', '\034', '\034', '\000'},    // filled square
+    {'\000', '\010', '\024', '\010', '\000'},    // empty diamond
+    {'\000', '\010', '\034', '\010', '\000'},    // filled diamond
+    {'\010', '\010', '\076', '\010', '\010'},    // cross
+    {'\000', '\024', '\010', '\024', '\000'},    // X
+    {'\034', '\042', '\042', '\042', '\034'},    // open circle
+    {'\034', '\076', '\076', '\076', '\034'},    // filled circle
+    {'\076', '\042', '\042', '\042', '\076'},    // big open square
+    {'\010', '\024', '\042', '\024', '\010'},    // big open diamond
 };
 
 
index 912226e..65ec828 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:       transformmatrix.cpp
-**     Function:   Transform Matrix routine for graphic library
-**     Programmer: Kevin Rosenberg
-**     Date Started:   1-22-85
+**      Name:       transformmatrix.cpp
+**      Function:   Transform Matrix routine for graphic library
+**      Programmer: Kevin Rosenberg
+**      Date Started:   1-22-85
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -37,7 +37,7 @@ TransformationMatrix2D::TransformationMatrix2D (double m[3][3])
   mtx[2][0] = m[2][0]; mtx[2][1] = m[2][1]; mtx[2][2] = m[2][2];
 }
 
-void 
+void
 TransformationMatrix2D::setTranslate (double x, double y)
 {
   setIdentity();
@@ -46,7 +46,7 @@ TransformationMatrix2D::setTranslate (double x, double y)
 }
 
 
-void 
+void
 TransformationMatrix2D::setScale (double sx, double sy)
 {
   setIdentity();
@@ -55,7 +55,7 @@ TransformationMatrix2D::setScale (double sx, double sy)
 }
 
 
-void 
+void
 TransformationMatrix2D::setShear (double shrx, double shry)
 {
   setIdentity();
@@ -63,7 +63,7 @@ TransformationMatrix2D::setShear (double shrx, double shry)
   mtx[0][1] = shry;
 }
 
-void 
+void
 TransformationMatrix2D::setRotate (double theta)
 {
     double s = sin (theta);
@@ -76,7 +76,7 @@ TransformationMatrix2D::setRotate (double theta)
 }
 
 
-void 
+void
 TransformationMatrix2D::setIdentity ()
 {
     mtx[0][0] = 1.;  mtx[0][1] = 0.;  mtx[0][2] = 0.;
@@ -93,18 +93,18 @@ TransformationMatrix2D::invert () const
   double determ = determinant ();
   if (fabs(determ) < 1E-6) {
     sys_error (ERR_WARNING, "Determinant = %g [TransformationMatrix2D::invert]", determ);
-       print (std::cout);
-       std::cout << std::endl;
+        print (std::cout);
+        std::cout << std::endl;
   }
 
   b[0][0] =  (mtx[1][1] * mtx[2][2] - mtx[2][1] * mtx[1][2]) / determ;
   b[1][0] = -(mtx[1][0] * mtx[2][2] - mtx[2][0] * mtx[1][2]) / determ;
   b[2][0] =  (mtx[1][0] * mtx[2][1] - mtx[2][0] * mtx[1][1]) / determ;
-  
+
   b[0][1] = -(mtx[0][1] * mtx[2][2] - mtx[2][1] * mtx[0][2]) / determ;
   b[1][1] =  (mtx[0][0] * mtx[2][2] - mtx[2][0] * mtx[0][2]) / determ;
   b[2][1] = -(mtx[0][0] * mtx[2][1] - mtx[2][0] * mtx[0][1]) / determ;
-      
+
   b[0][2] =  (mtx[0][1] * mtx[1][2] - mtx[1][1] * mtx[0][2]) / determ;
   b[1][2] = -(mtx[0][0] * mtx[1][2] - mtx[1][0] * mtx[0][2]) / determ;
   b[2][2] =  (mtx[0][0] * mtx[1][1] - mtx[1][0] * mtx[0][1]) / determ;
@@ -113,7 +113,7 @@ TransformationMatrix2D::invert () const
 }
 
 
-double 
+double
 TransformationMatrix2D::determinant () const
 {
   return
@@ -123,7 +123,7 @@ TransformationMatrix2D::determinant () const
 }
 
 
-void 
+void
 TransformationMatrix2D::transformPoint (double* pX, double *pY) const
 {
   double x = *pX * mtx[0][0] + *pY * mtx[1][0] + mtx[2][0];
@@ -136,9 +136,9 @@ TransformationMatrix2D::transformPoint (double* pX, double *pY) const
 void
 TransformationMatrix2D::print (std::ostream& ostr) const
 {
-       std::cout << mtx[0][0] << " " << mtx[0][1] << " " << mtx[0][2] << std::endl;
-       std::cout << mtx[1][0] << " " << mtx[1][1] << " " << mtx[1][2] << std::endl;
-       std::cout << mtx[2][0] << " " << mtx[2][1] << " " << mtx[2][2] << std::endl;
+        std::cout << mtx[0][0] << " " << mtx[0][1] << " " << mtx[0][2] << std::endl;
+        std::cout << mtx[1][0] << " " << mtx[1][1] << " " << mtx[1][2] << std::endl;
+        std::cout << mtx[2][0] << " " << mtx[2][1] << " " << mtx[2][2] << std::endl;
 }
 
 
@@ -150,9 +150,9 @@ const TransformationMatrix2D operator* (const TransformationMatrix2D& a, const T
 
     for (int row = 0; row < 3; row++)
       for (int col = 0; col < 3; col++) {
-       c[row][col] = 0.;
-       for (int calc = 0; calc < 3; calc++)
-         c[row][col] += a.mtx[row][calc] * b.mtx[calc][col];
+        c[row][col] = 0.;
+        for (int calc = 0; calc < 3; calc++)
+          c[row][col] += a.mtx[row][calc] * b.mtx[calc][col];
       }
 
     return TransformationMatrix2D (c);
index 3e1662a..a38dda3 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**     Name:         array2dfile.cpp
+**      Name:         array2dfile.cpp
 **      Purpose:      2-dimension array file class
-**     Programmer:   Kevin Rosenberg
-**     Date Started: June 2000
+**      Programmer:   Kevin Rosenberg
+**      Date Started: June 2000
 **
 **  This is part of the CTSim program
 **  Copyright (c) 1983-2001 Kevin Rosenberg
@@ -57,7 +57,7 @@ Array2dFileLabel::init (void)
   m_second = lt->tm_sec;
 }
 
-Array2dFileLabel::Array2dFileLabel() 
+Array2dFileLabel::Array2dFileLabel()
 {
   init();
 }
@@ -66,7 +66,7 @@ Array2dFileLabel::Array2dFileLabel(const char* const str, double ctime)
 : m_strLabel (str)
 {
   init();
-  
+
   m_labelType = L_USER;
   m_calcTime = ctime;
 }
@@ -75,7 +75,7 @@ Array2dFileLabel::Array2dFileLabel(const int type, const char* const str, double
 :  m_strLabel (str)
 {
   init();
-  
+
   m_labelType = type;
   m_calcTime = ctime;
 }
@@ -84,7 +84,7 @@ Array2dFileLabel::~Array2dFileLabel()
 {
 }
 
-void 
+void
 Array2dFileLabel::setDateTime (int year, int month, int day, int hour, int minute, int second)
 {
   m_year = year;
@@ -95,7 +95,7 @@ Array2dFileLabel::setDateTime (int year, int month, int day, int hour, int minut
   m_second = second;
 }
 
-void 
+void
 Array2dFileLabel::getDateTime (int& year, int& month, int& day, int& hour, int& minute, int& second) const
 {
   year = m_year;
@@ -106,7 +106,7 @@ Array2dFileLabel::getDateTime (int& year, int& month, int& day, int& hour, int&
   second = m_second;
 }
 
-const std::string& 
+const std::string&
 Array2dFileLabel::getDateString (void) const
 {
   char szDate [128];
@@ -134,7 +134,7 @@ Array2dFileLabel::operator= (const Array2dFileLabel& rhs)
   m_strLabel = rhs.m_strLabel;
   m_year = rhs.m_year; m_month = rhs.m_month; m_day = rhs.m_day;
   m_hour = rhs.m_hour; m_minute = rhs.m_minute; m_second = rhs.m_second;
-  
+
   return (*this);
 }
 
@@ -276,10 +276,10 @@ Array2dFile::reallocRealToComplex ()
 
 
 
-void 
+void
 Array2dFile::allocArrays ()
 {
-  if (m_arrayData) 
+  if (m_arrayData)
     freeArray (m_arrayData);
   if (m_imaginaryArrayData)
     freeArray (m_imaginaryArrayData);
@@ -299,15 +299,15 @@ Array2dFile::allocArray (unsigned char**& rppData)
     rppData[i] = new unsigned char [columnBytes];
 }
 
-void 
+void
 Array2dFile::freeArrays ()
 {
-  if (m_arrayData) 
+  if (m_arrayData)
     freeArray (m_arrayData);
-  
-  if (m_imaginaryArrayData) 
+
+  if (m_imaginaryArrayData)
     freeArray (m_imaginaryArrayData);
-  
+
 }
 
 void
@@ -330,7 +330,7 @@ bool
 Array2dFile::fileWrite (const char* const filename)
 {
   m_filename = filename;
-  
+
   frnetorderstream fs (m_filename.c_str(), std::ios::out | std::ios::in | std::ios::trunc | std::ios::binary);
   if (fs.fail()) {
     sys_error (ERR_WARNING, "Error opening file %s for writing [fileCreate]", m_filename.c_str());
@@ -338,13 +338,13 @@ Array2dFile::fileWrite (const char* const filename)
   }
   if (! headerWrite(fs))
     return false;
-  
+
   if (! arrayDataWrite (fs))
     return false;
-  
+
   if (! labelsWrite (fs))
     return false;
-  
+
   return true;
 }
 
@@ -358,25 +358,25 @@ bool
 Array2dFile::fileRead (const char* const filename)
 {
   m_filename = filename;
-  
+
   frnetorderstream fs (m_filename.c_str(), std::ios::out | std::ios::in | std::ios::binary);
 
   if (fs.fail()) {
     sys_error (ERR_WARNING, "Unable to open file %s [fileRead]", m_filename.c_str());
     return false;
   }
-  
+
   if (! headerRead(fs))
     return false;
-  
+
   allocArrays ();
-  
+
   if (! arrayDataRead(fs))
     return false;;
-  
+
   if (! labelsRead (fs))
     return false;
-  
+
   return true;
 }
 
@@ -388,7 +388,7 @@ Array2dFile::setAxisIncrement (double incX, double incY)
   m_axisIncrementY = incY;
 }
 
-void 
+void
 Array2dFile::setAxisExtent (double minX, double maxX, double minY, double maxY)
 {
   m_axisExtentKnown = true;
@@ -405,10 +405,10 @@ Array2dFile::headerRead (frnetorderstream& fs)
     sys_error (ERR_WARNING, "Tried to read header with file closed [headerRead]");
     return false;
   }
-  
+
   fs.seekg (0);
   kuint16 file_signature;
-  
+
   fs.readInt16 (m_headersize);
   fs.readInt16 (file_signature);
   fs.readInt16 (m_pixelFormat);
@@ -427,7 +427,7 @@ Array2dFile::headerRead (frnetorderstream& fs)
   fs.readFloat64 (m_maxY);
   fs.readFloat64 (m_offsetPV);
   fs.readFloat64 (m_scalePV);
-  
+
   int read_m_headersize = fs.tellg();
   if (read_m_headersize != m_headersize) {
     sys_error (ERR_WARNING, "Read m_headersize %d != file m_headersize %d", read_m_headersize, m_headersize);
@@ -437,7 +437,7 @@ Array2dFile::headerRead (frnetorderstream& fs)
     sys_error (ERR_WARNING, "File signature %d != true signature %d", file_signature, m_signature);
     return false;
   }
-  
+
   return ! fs.fail();
 }
 
@@ -449,9 +449,9 @@ Array2dFile::headerWrite (frnetorderstream& fs)
     sys_error (ERR_WARNING, "Tried to write header with ! fs");
     return false;
   }
-  
+
   m_numFileLabels = m_labels.size();
-  
+
   fs.seekp (0);
   fs.writeInt16 (m_headersize);
   fs.writeInt16 (m_signature);
@@ -471,11 +471,11 @@ Array2dFile::headerWrite (frnetorderstream& fs)
   fs.writeFloat64 (m_maxY);
   fs.writeFloat64 (m_offsetPV);
   fs.writeFloat64 (m_scalePV);
-  
+
   m_headersize = static_cast<kuint16>(fs.tellp());
   fs.seekp (0);
   fs.writeInt16 (m_headersize);
-  
+
   return ! fs.fail();
 }
 
@@ -487,10 +487,10 @@ Array2dFile::arrayDataWrite (frnetorderstream& fs)
     sys_error (ERR_WARNING, "Tried to arrayDataWrite with !fs");
     return false;
   }
-  
-  if (! m_arrayData) 
+
+  if (! m_arrayData)
     return false;
-  
+
   fs.seekp (m_headersize);
   int columnSize = m_ny * m_pixelSize;
   for (unsigned int ix = 0; ix < m_nx; ix++) {
@@ -501,7 +501,7 @@ Array2dFile::arrayDataWrite (frnetorderstream& fs)
         fs.write (reinterpret_cast<const char*>(ptrColumn), m_pixelSize);
         ptrColumn += m_pixelSize;
       }
-    } else 
+    } else
       fs.write (reinterpret_cast<const char*>(ptrColumn), columnSize);
   }
   if (m_dataType == DATA_TYPE_COMPLEX) {
@@ -513,11 +513,11 @@ Array2dFile::arrayDataWrite (frnetorderstream& fs)
           fs.write (reinterpret_cast<const char*>(ptrColumn), m_pixelSize);
           ptrColumn += m_pixelSize;
         }
-      } else 
+      } else
         fs.write (reinterpret_cast<const char*>(ptrColumn), columnSize);
     }
   }
-  
+
   return true;
 }
 
@@ -529,10 +529,10 @@ Array2dFile::arrayDataRead (frnetorderstream& fs)
     sys_error (ERR_WARNING, "Tried to arrayDataRead with ! fs");
     return false;
   }
-  
+
   if (! m_arrayData)
     return false;
-  
+
   fs.seekg (m_headersize);
   int columnSize = m_ny * m_pixelSize;
   for (unsigned int ix = 0; ix < m_nx; ix++) {
@@ -542,7 +542,7 @@ Array2dFile::arrayDataRead (frnetorderstream& fs)
         fs.read (reinterpret_cast<char*>(ptrColumn), m_pixelSize);
         ConvertReverseNetworkOrder (ptrColumn, m_pixelSize);
         ptrColumn += m_pixelSize;
-      } 
+      }
     } else
       fs.read (reinterpret_cast<char*>(ptrColumn), columnSize);
   }
@@ -554,12 +554,12 @@ Array2dFile::arrayDataRead (frnetorderstream& fs)
           fs.read (reinterpret_cast<char*>(ptrColumn), m_pixelSize);
           ConvertReverseNetworkOrder (ptrColumn, m_pixelSize);
           ptrColumn += m_pixelSize;
-        } 
+        }
       } else
         fs.read (reinterpret_cast<char*>(ptrColumn), columnSize);
     }
   }
-  
+
   return true;
 }
 
@@ -570,11 +570,11 @@ Array2dFile::labelsRead (frnetorderstream& fs)
   fs.seekg (pos);
   if (fs.fail())
     return false;
-  
+
   for (int i = 0; i < m_numFileLabels; i++) {
     kuint16 labelType, year, month, day, hour, minute, second;
     kfloat64 calcTime;
-    
+
     fs.readInt16 (labelType);
     fs.readInt16 (year);
     fs.readInt16 (month);
@@ -583,20 +583,20 @@ Array2dFile::labelsRead (frnetorderstream& fs)
     fs.readInt16 (minute);
     fs.readInt16 (second);
     fs.readFloat64 (calcTime);
-    
+
     kuint16 strLength;
     fs.readInt16 (strLength);
     char* pszLabelStr = new char [strLength+1];
     fs.read (pszLabelStr, strLength);
     pszLabelStr[strLength] = 0;
-    
+
     Array2dFileLabel* pLabel = new Array2dFileLabel (labelType, pszLabelStr, calcTime);
     delete pszLabelStr;
-    
+
     pLabel->setDateTime (year, month, day, hour, minute, second);
     m_labels.push_back (pLabel);
   }
-  
+
   return true;
 }
 
@@ -605,7 +605,7 @@ Array2dFile::labelsWrite (frnetorderstream& fs)
 {
   off_t pos = m_headersize + m_arraySize;
   fs.seekp (pos);
-  
+
   for (constLabelIterator l = m_labels.begin(); l != m_labels.end(); l++) {
     const Array2dFileLabel& label = **l;
     kuint16 labelType = label.getLabelType();
@@ -613,11 +613,11 @@ Array2dFile::labelsWrite (frnetorderstream& fs)
     const char* const labelString = label.getLabelString().c_str();
     int year, month, day, hour, minute, second;
     kuint16 yearBuf, monthBuf, dayBuf, hourBuf, minuteBuf, secondBuf;
-    
+
     label.getDateTime (year, month, day, hour, minute, second);
     yearBuf = year; monthBuf = month; dayBuf = day;
     hourBuf = hour; minuteBuf = minute; secondBuf = second;
-    
+
     fs.writeInt16 (labelType);
     fs.writeInt16 (yearBuf);
     fs.writeInt16 (monthBuf);
@@ -630,7 +630,7 @@ Array2dFile::labelsWrite (frnetorderstream& fs)
     fs.writeInt16 (strlength);
     fs.write (labelString, strlength);
   }
-  
+
   return true;
 }
 
@@ -645,7 +645,7 @@ void
 Array2dFile::labelAdd (int type, const char* const lstr, double calc_time)
 {
   Array2dFileLabel label (type, lstr, calc_time);
-  
+
   labelAdd (label);
 }
 
@@ -654,7 +654,7 @@ void
 Array2dFile::labelAdd (const Array2dFileLabel& label)
 {
   Array2dFileLabel* pLabel = new Array2dFileLabel(label);
-  
+
   m_labels.push_back (pLabel);
 }
 
@@ -673,7 +673,7 @@ Array2dFile::labelsCopy (const Array2dFile& copyFile, const char* const pszId)
   }
 }
 
-void 
+void
 Array2dFile::arrayDataClear (void)
 {
   if (m_arrayData) {
@@ -693,7 +693,7 @@ Array2dFile::printLabels (std::ostream& os) const
 {
   for (constLabelIterator l = m_labels.begin(); l != m_labels.end(); l++) {
     const Array2dFileLabel& label = **l;
-    
+
     label.print (os);
     os << std::endl;
   }
@@ -704,7 +704,7 @@ Array2dFile::printLabelsBrief (std::ostream& os) const
 {
   for (constLabelIterator l = m_labels.begin(); l != m_labels.end(); l++) {
     const Array2dFileLabel& label = **l;
-    
+
     label.printBrief (os);
   }
 }
@@ -714,7 +714,7 @@ Array2dFile::printLabelsBrief (std::ostringstream& os) const
 {
   for (constLabelIterator l = m_labels.begin(); l != m_labels.end(); l++) {
     const Array2dFileLabel& label = **l;
-    
+
     label.printBrief (os);
   }
 }
index 2d0d60c..5ea5327 100644 (file)
@@ -1,7 +1,7 @@
 /*****************************************************************************
 ** FILE IDENTIFICATION
 **
-**   Name:        backprojectors.cpp         Classes for backprojection
+**   Name:         backprojectors.cpp         Classes for backprojection
 **   Programmer:   Kevin Rosenberg
 **   Date Started: June 2000
 **
@@ -33,7 +33,7 @@ const int Backprojector::BPROJ_TABLE = 1;
 const int Backprojector::BPROJ_DIFF = 2;
 const int Backprojector::BPROJ_IDIFF = 3;
 
-const char* const Backprojector::s_aszBackprojectName[] = 
+const char* const Backprojector::s_aszBackprojectName[] =
 {
   "trig",
   "table",
@@ -41,7 +41,7 @@ const char* const Backprojector::s_aszBackprojectName[] =
   "idiff",
 };
 
-const char* const Backprojector::s_aszBackprojectTitle[] = 
+const char* const Backprojector::s_aszBackprojectTitle[] =
 {
   "Direct Trigometric",
   "Trigometric Table",
@@ -63,7 +63,7 @@ const int Backprojector::INTERP_2BSPLINE = 6;
 const int Backprojector::INTERP_3BSPLINE = 7;
 #endif
 
-const char* const Backprojector::s_aszInterpName[] = 
+const char* const Backprojector::s_aszInterpName[] =
 {
   "nearest",
   "linear",
@@ -79,7 +79,7 @@ const char* const Backprojector::s_aszInterpName[] =
 #endif
 };
 
-const char* const Backprojector::s_aszInterpTitle[] = 
+const char* const Backprojector::s_aszInterpTitle[] =
 {
   "Nearest",
   "Linear",
@@ -99,23 +99,23 @@ const int Backprojector::s_iInterpCount = sizeof(s_aszInterpName) / sizeof(const
 
 
 
-Backprojector::Backprojector (const Projections& proj, ImageFile& im, const char* const backprojName, 
+Backprojector::Backprojector (const Projections& proj, ImageFile& im, const char* const backprojName,
                               const char* const interpName, const int interpFactor, const ReconstructionROI* pROI)
 {
   m_fail = false;
   m_pBackprojectImplem = NULL;
-  
+
   initBackprojector (proj, im, backprojName, interpName, interpFactor, pROI);
 }
 
-void 
+void
 Backprojector::BackprojectView (const double* const viewData, const double viewAngle)
 {
   if (m_pBackprojectImplem != NULL)
     m_pBackprojectImplem->BackprojectView (viewData, viewAngle);
 }
 
-void 
+void
 Backprojector::PostProcessing()
 {
   if (m_pBackprojectImplem != NULL)
@@ -131,11 +131,11 @@ Backprojector::~Backprojector ()
 //     Backproject* projector = selectBackprojector (...)
 //
 // PURPOSE
-//     Selects a backprojector based on BackprojType 
+//     Selects a backprojector based on BackprojType
 //     and initializes the backprojector
 
 bool
-Backprojector::initBackprojector (const Projections& proj, ImageFile& im, const char* const backprojName, 
+Backprojector::initBackprojector (const Projections& proj, ImageFile& im, const char* const backprojName,
                                   const char* const interpName, const int interpFactor, const ReconstructionROI* pROI)
 {
   m_nameBackproject = backprojName;
@@ -153,15 +153,15 @@ Backprojector::initBackprojector (const Projections& proj, ImageFile& im, const
     m_failMessage = "Invalid interpolation name ";
     m_failMessage += interpName;
   }
-  
+
   if (m_fail || m_idBackproject == BPROJ_INVALID || m_idInterpolation == INTERP_INVALID) {
     m_fail = true;
     return false;
   }
-  
+
   if (proj.geometry() == Scanner::GEOMETRY_EQUILINEAR)
     m_pBackprojectImplem = static_cast<Backproject*>(new BackprojectEquilinear(proj, im, m_idInterpolation, interpFactor, pROI));
-  else if (proj.geometry() == Scanner::GEOMETRY_EQUIANGULAR) 
+  else if (proj.geometry() == Scanner::GEOMETRY_EQUIANGULAR)
     m_pBackprojectImplem = static_cast<Backproject*>(new BackprojectEquiangular(proj, im, m_idInterpolation, interpFactor, pROI));
   else if (proj.geometry() == Scanner::GEOMETRY_PARALLEL) {
     if (m_idBackproject == BPROJ_TRIG)
@@ -177,7 +177,7 @@ Backprojector::initBackprojector (const Projections& proj, ImageFile& im, const
     m_failMessage = "Unable to select a backprojection method [Backprojector::initBackprojector]";
     return false;
   }
-  
+
   return true;
 }
 
@@ -186,13 +186,13 @@ int
 Backprojector::convertBackprojectNameToID (const char* const backprojName)
 {
   int backprojID = BPROJ_INVALID;
-  
+
   for (int i = 0; i < s_iBackprojectCount; i++)
     if (strcasecmp (backprojName, s_aszBackprojectName[i]) == 0) {
       backprojID = i;
       break;
     }
-    
+
     return (backprojID);
 }
 
@@ -200,10 +200,10 @@ const char*
 Backprojector::convertBackprojectIDToName (int bprojID)
 {
   static const char *bprojName = "";
-  
+
   if (bprojID >= 0 && bprojID < s_iBackprojectCount)
     return (s_aszBackprojectName[bprojID]);
-  
+
   return (bprojName);
 }
 
@@ -211,10 +211,10 @@ const char*
 Backprojector::convertBackprojectIDToTitle (const int bprojID)
 {
   static const char *bprojTitle = "";
-  
+
   if (bprojID >= 0 && bprojID < s_iBackprojectCount)
     return (s_aszBackprojectTitle[bprojID]);
-  
+
   return (bprojTitle);
 }
 
@@ -223,13 +223,13 @@ int
 Backprojector::convertInterpNameToID (const char* const interpName)
 {
   int interpID = INTERP_INVALID;
-  
+
   for (int i = 0; i < s_iInterpCount; i++)
     if (strcasecmp (interpName, s_aszInterpName[i]) == 0) {
       interpID = i;
       break;
     }
-    
+
     return (interpID);
 }
 
@@ -237,10 +237,10 @@ const char*
 Backprojector::convertInterpIDToName (const int interpID)
 {
   static const char *interpName = "";
-  
+
   if (interpID >= 0 && interpID < s_iInterpCount)
     return (s_aszInterpName[interpID]);
-  
+
   return (interpName);
 }
 
@@ -248,10 +248,10 @@ const char*
 Backprojector::convertInterpIDToTitle (const int interpID)
 {
   static const char *interpTitle = "";
-  
+
   if (interpID >= 0 && interpID < s_iInterpCount)
     return (s_aszInterpTitle[interpID]);
-  
+
   return (interpTitle);
 }
 
@@ -263,31 +263,31 @@ Backprojector::convertInterpIDToTitle (const int interpID)
 // PURPOSE
 //   Pure virtual base class for all backprojectors.
 
-Backproject::Backproject (const Projections& proj, ImageFile& im, int interpType, const int interpFactor, 
+Backproject::Backproject (const Projections& proj, ImageFile& im, int interpType, const int interpFactor,
                           const ReconstructionROI* pROI)
 : proj(proj), im(im), interpType(interpType), m_interpFactor(interpFactor), m_bPostProcessingDone(false)
 {
   detInc = proj.detInc();
   nDet = proj.nDet();
-  iDetCenter = (nDet - 1) / 2; // index refering to L=0 projection 
-  
+  iDetCenter = (nDet - 1) / 2;  // index refering to L=0 projection
+
   if (proj.geometry() == Scanner::GEOMETRY_PARALLEL)
     rotScale = PI / proj.nView(); // scale by number of PI rotations
   else if (proj.geometry() == Scanner::GEOMETRY_EQUIANGULAR || proj.geometry() == Scanner::GEOMETRY_EQUILINEAR)
     rotScale =  (2 * PI) / proj.nView(); // scale by number of 2PI rotations
   else
     sys_error (ERR_SEVERE, "Invalid geometry type %d [Backproject::Backproject]", proj.geometry());
-  
+
   v = im.getArray();
   nx = im.nx();
   ny = im.ny();
   im.arrayDataClear();
-  
+
   xMin = -proj.phmLen() / 2;      // Retangular coords of phantom
   xMax = xMin + proj.phmLen();
   yMin = -proj.phmLen() / 2;
   yMax = yMin + proj.phmLen();
-  
+
   if (pROI) {
     if (pROI->m_dXMin > xMin)
       xMin = pROI->m_dXMin;
@@ -310,9 +310,9 @@ Backproject::Backproject (const Projections& proj, ImageFile& im, int interpType
     }
   }
 
-  xInc = (xMax - xMin) / nx;   // size of cells
+  xInc = (xMax - xMin) / nx;    // size of cells
   yInc = (yMax - yMin) / ny;
-  
+
   im.setAxisIncrement (xInc, yInc);
   im.setAxisExtent (xMin, xMax, yMin, yMax);
 
@@ -352,7 +352,7 @@ void Backproject::errorIndexOutsideDetector (int ix, int iy, double theta, doubl
   os << "xMin=" << xMin << ", xMax=" << xMax << ", xInc=" << xInc << "\n";
   os << "yMin=" << yMin << ", yMax=" << yMax << ", yInc=" << yInc << "\n";
   os << "iDetPos index outside bounds: " << iDetPos << " [backprojector]";;
-  
+
   sys_error (ERR_WARNING, os.str().c_str());
 #endif
 }
@@ -368,33 +368,33 @@ void
 BackprojectTrig::BackprojectView (const double* const filteredProj, const double view_angle)
 {
   double theta = view_angle;
-  
+
   CubicPolyInterpolator* pCubicInterp = NULL;
   if (interpType == Backprojector::INTERP_CUBIC)
     pCubicInterp = new CubicPolyInterpolator (filteredProj, nDet);
-  
-  double x = xMin + xInc / 2;  // Rectang coords of center of pixel 
+
+  double x = xMin + xInc / 2;   // Rectang coords of center of pixel
   for (int ix = 0; ix < nx; x += xInc, ix++) {
     double y = yMin + yInc / 2;
     for (int iy = 0; iy < ny; y += yInc, iy++) {
       double r = sqrt (x * x + y * y);   // distance of cell from center
       double phi = atan2 (y, x);         // angle of cell from center
       double L = r * cos (theta - phi);  // position on detector
-      
+
       if (interpType == Backprojector::INTERP_NEAREST) {
         int iDetPos = iDetCenter + nearest<int> (L / detInc); // calc'd index in the filter raysum array
-        
+
         if (iDetPos >= 0 && iDetPos < nDet)
           v[ix][iy] += rotScale * filteredProj[iDetPos];
       } else if (interpType == Backprojector::INTERP_LINEAR) {
-        double p = L / detInc; // position along detector
+        double p = L / detInc;  // position along detector
         double pFloor = floor (p);
         int iDetPos = iDetCenter + static_cast<int>(pFloor);
-        double frac = p - pFloor;      // fraction distance from det
+        double frac = p - pFloor;       // fraction distance from det
         if (iDetPos >= 0 && iDetPos < nDet - 1)
           v[ix][iy] += rotScale * ((1-frac) * filteredProj[iDetPos] + frac * filteredProj[iDetPos+1]);
       } else if (interpType == Backprojector::INTERP_CUBIC) {
-        double p = iDetCenter + (L / detInc);  // position along detector
+        double p = iDetCenter + (L / detInc);   // position along detector
         if (p >= 0 && p < nDet)
           v[ix][iy] += rotScale * pCubicInterp->interpolate (p);
       }
@@