doNextNote.py

#!/usr/bin/env python
#*********************************************************************
#                                                        19 March 2013
#               Andrew J. Worth
#               andy@neuromorphometrics.com
#
#               Neuromorphometrics
#               22 Westminster Street
#               Somerville, MA  02144-1630  USA
#
#               http://neuromorphometrics.com
#
#*********************************************************************
#*                                                                   *
#*  (c) Copyright 2013 Neuromorphometrics      All rights reserved   *
#*                                                                   *
#*********************************************************************
# 09 September 2013 - Copied from NMM/Subscription/2012/bin
#-------------------------------------------------------------------------------
# Usage String:
"""
SYNOPSIS
 
    RunAll.py [-h] [-v,--verbose] [--version] 
    
    Short for Run All commands over All scans
 
DESCRIPTION
 
    Runs a bunch of stuff (or not) on the scans in the current project.
    The possible scans are defined in ScanList.py.
    Purpose: select scans, set variables and run commands on selected scans.

  #############
  #  Commands
  #############
  #
  # Commands (in bin/Cmds) can do things in 5 places:
  # 1) Settings    - (import) Set variables/defaults for this command
  # 2) Before Loop - Initialize() create directories, etc. Build HeaderExtra
  #      In Loop   - G.PID,G.SCN, etc. are set, do command for specific scan
  # 3)     Part 1  - SayIt() return string for InfoExtra to print on CSV line 
  # 4)     Part 2  - DoIt() to current scan, print output lines, etc.
  # 5) After loop  - Finalize(): clean up, etc. after command
 
RUN WITH:
 
    ./bin/RunAll.py
 
EXIT STATUS
 
    Exit codes: none
 
AUTHOR
 
    Andrew J. Worth
    andy@neuromorphometrics.com
     
    Neuromorphometrics, Inc.
    22 Westminster Street
    Somerville, MA  02144-1630  USA
     
    http://Neuromorphometrics.com
 
LICENSE
    (c) Copyright 2013-14 Neuromorphometrics, Inc.   All rights reserved.
 
VERSION
"""
Dash80 = "--------------------------------------------------------------------------------"
 
import sys
import os
import re
import glob
import fnmatch
import filecmp
import shutil
import traceback
import optparse
import time
from datetime import timedelta, datetime
import xml.etree.ElementTree as ET

# Commands found in this bin directory:
import G            # Globals!

#===============================================================================
def main ():

  global options, args, AvgTime

  FullPathToMe = os.path.realpath(__file__)
  #print "FullPathToMe ", FullPathToMe 
  SplitFullPathToMe = os.path.split(FullPathToMe)
  PathToMe = SplitFullPathToMe[0]
  #print "PathToMe = ", PathToMe 
  ME       = SplitFullPathToMe[1]
  #print "ME       = ", ME

  #---------------------------------------------------------------------------
  # What scans to run on
  G.OnlyOneScan    = 0 # that one scan specified in ScanList (for testing)
                       #   must be included in one of the DoDeliv lists

  G.DoRandomList   = 0 # full list specified in ScanList, all others off
  G.DoOrigList     = 0 # full list specified in ScanList, all others off
  G.DoFlipList     = 0 # full list specified in ScanList, all others off
  G.DoDontFlipList = 0 # full list specified in ScanList, all others off

  # DoDeliv lists: (each one on will be included) This is the Default
  G.DoDeliv1 = 1
  G.DoDeliv2 = 1
  G.DoDeliv3 = 0

  if options.ScanList == 'OnlyOne':
    G.OnlyOneScan = 1
  elif options.ScanList == 'Random':
    G.DoRandomList = 1
  elif options.ScanList == 'Flip':
    G.DoFlipList = 1
  elif options.ScanList == 'DontFlip':
    G.DoDontFlipList = 1
  elif options.ScanList == 'Orig':
    G.DoOrigList = 1
  elif options.ScanList != '':
    print "Bad -ScanList option: ", options.ScanList
    print "  use: OnlyOne Random Flip DontFlip or Orig"
    sys.exit()

  #---------------------------------------------------------------------------
  # Options: set 'Do...' variable to 1 to make it happen.  If they are all 0
  #          then just list information each for scan.

  # What to print on the InfoExtra line for each scan (order is imprtant):
  DoShowGroup         = 0 # GRP
  DoShowSource        = 0 # SRC
  DoShowMeta          = 0 # META
  DoShowAge           = 0 # Subject's age
  DoShowLabelCount    = 1 # Number of labels in status/alllabel_SEG.txt
  DoShowCheckedOut    = 0 # If checked out, show who has it (does NOT sync)
  DoShowSegDone       = 0 # If basic seg done, show who did it (does NOT sync)
  DoShowAtlasDone     = 1 # reports if CheckWithAtlas has been done
  DoShowOrigInfo      = 0 # Original file information (PTID,seriesID,imageID...)
  DoShowOrigFile      = 0 # Original file name
  DoShowLandmarks     = 0 # List landmarks from otl/seg_Landmarks.xml file
  DoSeeIfLabelIsIn    = 0 # show # of the specified voxel type (uses ROI)
  DoShowNIfTIInfo     = 0 # after all else, print slice res, etc. with scan

  # What to print on separate new lines for each scan:
  DoShowPath          = 0 # print path on new line after the above line
  DoSeeWhatsIn        = 0 # show count of all voxel values in result NIfTI files

  DoRunNVM            = 0 # Run NVM on all scans
  RunNVM_Args         = ''# '-outlineMult 1' # '-dontCrop'

  DoRunSegScript      = 1 # Run NVM with given script on all scans
                          # Note: include spaces in Args!
  #RunSegScript_Script = 'xml/segmentation/2.03.e1.exteriors.xml'
  #RunSegScript_NVMArgs= ''
  #RunSegScript_PreReq = 'status/Done_2.03.01.ExteriorAutoContours.txt'
  #RunSegScript_DidIt  = 'Done_2.03.02.GenerateExtOutlines.txt'
  #RunSegScript_Script = 'xml/segmentation/2.10.e1.CerebralWhitematter.xml'
  #RunSegScript_NVMArgs= ''
  #RunSegScript_PreReq = 'status/Done_2.10.01.WMAutoContours.txt'
  #RunSegScript_DidIt  = 'Done_2.10.02.GenerateWMOutlines.txt'
  #RunSegScript_Script = 'xml/segmentation/2.11.e1.CerebellarWhitematter.xml'
  #RunSegScript_NVMArgs= '' # ' -noUI '
  #RunSegScript_AddArgs= '' # ' -R '
  #RunSegScript_PreReq = 'status/Done_2.11.01.CBWMAutoContours.txt'
  #RunSegScript_DidIt  = 'Done_2.11.02.GenerateCBWMOutlines.txt'
  #RunSegScript_Notes  = '' # G.SEG_ will be prepended
  #RunSegScript_Script = 'xml/tests/NoteVitaminE.xml'
  #RunSegScript_NVMArgs= '' # ' -noUI '
  #RunSegScript_AddArgs= ' -skipTar -skipCheckInOut ' # ' -R '
  #RunSegScript_PreReq = 'status/Done_1.2.PostitionalNormalization.txt'
  #RunSegScript_DidIt  = 'Done_Test-NoteVitaminE.txt'
  #RunSegScript_Notes  = 'Notations.VitaminE.xml' # G.SEG_ will be prepended
  #RunSegScript_Script = 'xml/tests/GetPosNormInfo.xml'
  #RunSegScript_NVMArgs= ' -noUI ' # ' -noUI '
  #RunSegScript_AddArgs= ' -skipCheckInOut ' # ' -R ' ' -skipCheckInOut '
  #RunSegScript_PreReq = 'status/Done_1.2.PostitionalNormalization.txt'
  #RunSegScript_DidIt  = 'Done_Test-GetPosNormInfo.txt'
  #RunSegScript_Notes  = '' # G.SEG_ will be prepended
  #RunSegScript_Script = 'xml/tests/GetPosNormInfo.xml'
  #RunSegScript_NVMArgs= ' -noUI ' # ' -noUI '
  #RunSegScript_AddArgs= ' -skipTar -skipCheckInOut ' # ' -R '
  #RunSegScript_PreReq = ''
  #RunSegScript_DidIt  = 'Done_Test-GetPosNormInfo.txt'
  #RunSegScript_Notes  = '' # G.SEG_ will be prepended
  #RunSegScript_Initial= 'echo "Nothing going on here"'
  #RunSegScript_PreReq = 'status/Done_2.BasicSegmentation.txt'
  #RunSegScript_AddArgs= ' -skipTar -skipCheckInOut ' # ' -R '
  #RunSegScript_Script = 'xml/postprocessing/5.1.e1.CalcVolumes.xml'
  #RunSegScript_NVMArgs= ' -dontCrop -noUI -voxCountMethod 0 '
  #RunSegScript_Notes  = '' # G.SEG_ will be prepended
  #RunSegScript_DidIt  = 'Done_5.1.CalculateVolumes.txt'
  #RunSegScript_Final  = 'bin/totalVolumes.py'
  #RunSegScript_Initial= 'echo "Nothing going on here"'
  #RunSegScript_PreReq = 'status/Done_5.3.PrepareScanforAtlas.txt'
  #RunSegScript_AddArgs= ' -skipTar -skipCheckInOut ' # ' -R '
  #RunSegScript_Script = 'xml/qualityassurance/4.5.e1.FixMonkey.xml'
  #RunSegScript_NVMArgs= ' -noUI '
  #RunSegScript_Notes  = '' # G.SEG_ will be prepended
  #RunSegScript_DidIt  = 'Done_4.5.e1.FixMonkey.txt'
  #RunSegScript_Final  = ''
  #RunSegScript_Initial= 'echo "Nothing going on here"'
  #RunSegScript_PreReq = 'status/Done_4.6.e1.CheckWithAtlas.txt'
  #RunSegScript_AddArgs= ' -skipTar -skipCheckInOut ' # ' -R '
  #RunSegScript_Script = 'xml/qualityassurance/4.6.CheckWithAtlas.xml'
  #RunSegScript_NVMArgs= '' # ' -noUI '
  #RunSegScript_Notes  = '' # G.SEG_ will be prepended
  #RunSegScript_DidIt  = 'Done_4.6.CheckWithAtlas.txt'
  #RunSegScript_Final  = ''
  #RunSegScript_OnlyOne= True
  RunSegScript_Initial= 'echo "Nothing going on here"'
  RunSegScript_PreReq = ''
  RunSegScript_NStatus= 'Possible_Error' # only run if this is in a Note
  RunSegScript_AddArgs= ' -skipTar -skipCheckInOut ' # ' -R '
  RunSegScript_Script = 'xml/qualityassurance/4.7.NextNote.xml'
  RunSegScript_NVMArgs= '' # ' -noUI '
  RunSegScript_Notes  = 'Notations_volPerSlice.xml' # G.SEG_ will be prepended
  RunSegScript_DidIt  = 'Done_4.7.e1.NextNote.txt'
  RunSegScript_Final  = ''
  RunSegScript_OnlyOne= True

  DoStatus            = 0 # Check PID/SCN/status/Done_?.xxxxxxx.txt files

  DoMakeLabelList     = 0 # Call getalllabel.csh to make status/alllabel_SEG.txt
  DoShowLabelList     = 0 # show status/alllabel_SEG.txt
  DoPlotVolPerSlice   = 0 # call plotVolPerSlice.py for csv files in 
                          # ./Volumes/*_Slice.csv
  DoPlotAllVolPerAgeG = 0 # call plotVolPerSlice.py for csv files in 
                          # ./Volumes/AgeGroup*/*_Slice.csv
  AgeGThresh = [0, 199, 399, 700] # divide into 3 groups
  DoNoteVPSOutliers   = 0 # call noteVolPerSliceOutliers.py

  DoCopyOrigToScan1   = 0 # Copy original scan to Data/####/1/ and set up
  DoRun52             = 0 # Run NVM Step 5.2: Save as NIFTI
  DoUntarNIfTI        = 0 # if not done, untar Result NIfTI files
  DoACITMap           = 0 # Change Result NIfTI mapping using oldToNewLabelMap
  DoFlipLeftRight     = 0 # Change Result NIfTI mapping using flipLRLabelMap
  DoAutoWMparc        = 0 # Run labelWMbyLobe on output from ACITMap
  DoShowOneROI        = 0 # use VMP to show only labels=ROI in NIfTI files
  DoInstallOrig       = 0 # copy bias corrected scans into Data
  DoInstallRelease    = 0 # copy NIFTI files from Results to Results_{DATE} and
                          #  also over to server.
  DoGitIgnores        = 0 # Copies template .gitignore files to scan directories
  DoRemoveLabels      = 0 # keep all but the following labels:
  RmLabelList         = ['Right Cerebral Exterior', \
                         'Left Cerebral Exterior']
  DoRun53             = 0 # Run NVM to save NIfTI files to make atlas
  DoCheckAtlasPrep    = 0 # Check that all is ready to make atlas
  DoMakeAtlas         = 0 # Create ProbAtlas with given scans
  DoWarpAtlasToScan   = 0 # Warp ProbAtlas to each given scan
  DoSaveSulciAsNIFTI  = 0 # Save Sulci as NIFTI for ProbAtlas for given scans
  DoAddSulciToAtlas   = 0 # Add Sulci to ProbAtlas for given scans
  DoPlotASPdebug      = 0 # 

  Do3DcgsPic          = 0 # Show cingulate sulcus

  # Occasional or one-time commands:
  DoArchive           = 0 # Copy Everything to Archive, give short reason first
  DoCompare           = 0 # Compare otl or log or status  with different version
  DoSandboxScans      = 0 # copy all scans to sandbox
  DoCopyNIFTItoSand   = 0 # copy NIFTI folders to sandbox too
  DoMakeInitACITMap   = 0 # create initial ./Data/oldToNewLabelMap.txt

  DoCheckOut          = 0 # 
  DoCheckIn           = 0 # 

  DoTemplate          = 0 # (Search for and copy this to add a new command)

  # For commands that need a specific label number, here it is:
  ROI = "71" # "Cerebellar Vermal Lobules I-V"
  ROI = "41" # "Left Cerebellum White Matter"
  ROI = "42" # Right Cerebral Exterior
  ROI = "43" # Left Cerebral Exterior

  #---------------------------------------------------------------------------
  # Generally needed stuff (always needed in multiple places)

  #---------------------------------------------------------------------------
  # Possibly needed stuff (will be turned on below if needed)
  DoGetInfoFileInfo    = 0 # Gets slice res, etc. from Info File
  DoGetNIFTIheaderInfo = 0 # Gets slice res, etc. from NIfTI header
  DoGetVoxelCounts     = 0 # generate NIfTIPath/voxelCounts.txt
  DoGetOrigInfo        = 0 # Gets original ID from Meta data

  #===========================================================================
  # 1) Settings    - (import) Set variables/defaults for this command
  #===========================================================================

  #---------------------------------------------------------------------------
  # Init Strings:
  HeaderExtra = "" # after G.PID, G.SCN, add this to header

  # NOTE: the order of the following must match the ordering of commands
  # inside the loop (part 1) because the order stuff of HeaderExtra needs
  # to match the order of corresponding stuff in InfoExtra

  #...........................................................................
  if DoShowGroup == 1:
    HeaderExtra += ",   Group   "

  #...........................................................................
  if DoShowSource == 1:
    HeaderExtra += ", Source"

  #...........................................................................
  if DoShowAge == 1:
    HeaderExtra += ", Age"

  #...........................................................................
  if DoShowMeta == 1:
    HeaderExtra += ",         Meta        "

  #...........................................................................
  if DoShowLabelCount == 1:
    HeaderExtra += ", #lbl"

  #...........................................................................
  if DoShowCheckedOut == 1:
    HeaderExtra += ",   checked out     "

  #...........................................................................
  if DoShowSegDone == 1:
    HeaderExtra += ",  basic seg done?  "

  #...........................................................................
  if DoShowAtlasDone == 1:
    HeaderExtra += ", AtlasCheck run?, AtlasCheck done?"

  #...........................................................................
  if DoShowOrigInfo == 1:
      
    HeaderExtra += ", MNUM,   SNUM "
    #HeaderExtra +=", Cols, Rows, Slis,  ColRes,   RowRes,   SliRes,  " + \
    #              "Type, Offset"

  #...........................................................................
  if DoShowOrigFile == 1:
    HeaderExtra += ", Original Info File "

  #...........................................................................
  if DoShowLandmarks == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoShowLandmarks (settings)"
    import Landmarks
    # Add each landmark to header
    for LM in Landmarks.AllLand.split():
      HeaderExtra += ', '+LM
    # if DoShowLandmarks

  #...........................................................................
  # Count the number of a specific voxel values in result NIfTI files
  if DoSeeIfLabelIsIn == 1:
    DoGetNIFTIheaderInfo = 1 # Gets slice res, etc. from NIfTI header
    DoGetVoxelCounts = 1 # generate NIfTIPath/voxelCounts.txt
    HeaderExtra += ", label, found"

  #...........................................................................
  if DoShowNIfTIInfo == 1:
    DoGetNIFTIheaderInfo = 1
    HeaderExtra +=", Cols, Rows, Slis,  ColRes,   RowRes,   SliRes,  " + \
                  "Type, Offset"

  #...........................................................................
  if DoShowOneROI == 1:
    DoGetNIFTIheaderInfo = 1

  #...........................................................................
  # Count the number of all voxel values in result NIfTI files
  if DoSeeWhatsIn == 1:
    DoGetVoxelCounts = 1 # generate NIfTIPath/voxelCounts.txt
    DoGetNIFTIheaderInfo = 1 # Gets slice res, etc. from NIfTI header

  #...........................................................................
  if DoCopyOrigToScan1 == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoCopyOrigToScan1 (settings)"
    print 'DoCopyOrigToScan1: nothing going on here. '
    # if DoCopyOrigToScan1

  #...........................................................................
  if DoCheckAtlasPrep == 1 or DoMakeAtlas == 1:
    DoGetInfoFileInfo = 1 # Gets slice res, etc. from Info File
    import MakeAtlas
  if DoCheckAtlasPrep == 1:
    HeaderExtra += ", Atlas Prep?"

  #...........................................................................
  if DoWarpAtlasToScan == 1:
    DoGetInfoFileInfo = 1 # Gets slice res, etc. from Info File
    import cmds.WarpAtlasToScan

  #...........................................................................
  if DoAddSulciToAtlas == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoAddSulciToAtlas (settings)"
    DoGetInfoFileInfo = 1 # Gets slice res, etc. from Info File
    import MakeAtlas
    # Modify MakeAtlas variables for this particular case:
    MakeAtlas.InitFLAGS  = ' -onlyThisStruc 8 ' # cingulate (sulcus)
    MakeAtlas.NIFTIextra = '_sulc'
    MakeAtlas.PARAMARGS  = ' -param JaccardThresh 0.0 '
    # if DoAddSulciToAtlas

  #...........................................................................
  if DoPlotASPdebug == 1:
    import PlotASPdebug
    # if DoPlotASPdebug 

  #...........................................................................
  if DoACITMap == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoACITMap (settings)"
    DoGetInfoFileInfo = 1 # Gets slice res, etc. from Info File
    # if DoACITMap

  #...........................................................................
  if DoFlipLeftRight == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoFlipLeftRight (settings)"
    DoGetInfoFileInfo = 1 # Gets slice res, etc. from Info File
    # if DoFlipLeftRight

  #...........................................................................
  if DoAutoWMparc == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoAutoWMparc (settings)"
    DoGetInfoFileInfo = 1 # Gets slice res, etc. from Info File
    # if DoAutoWMparc

  #...........................................................................
  if DoCompare == 1:
    cmpName = 'ACIT_Siemens_CIBM_FromGreg_11Dec2013'
    cmpName = 'ACIT_Siemens_CIBM_FromGreg_22Dec2013'
    if G.VerboseLevel >= 1:
      print ME + ": Running DoCompare %s (settings)" % (cmpName)
    # if DoCompare 

  #...........................................................................
  if DoMakeLabelList == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoMakeLabelList (settings)"
    LabelListFile = 'getalllabel.data.txt'
    # if DoMakeLabelList 

  #...........................................................................
  if DoRunNVM == 1:
    import Cmds.RunNVM
    Cmds.RunNVM.Args = RunNVM_Args

  #...........................................................................
  if DoStatus == 1:
    import Cmds.Status

  #...........................................................................
  if DoRunSegScript == 1:
    import Cmds.RunSegScript
    Cmds.RunSegScript.Initial   = RunSegScript_Initial
    Cmds.RunSegScript.PreReq    = RunSegScript_PreReq
    Cmds.RunSegScript.NStatus   = RunSegScript_NStatus
    Cmds.RunSegScript.Args      = RunSegScript_AddArgs
    Cmds.RunSegScript.SegScript = RunSegScript_Script
    Cmds.RunSegScript.NVMArgs   = RunSegScript_NVMArgs
    Cmds.RunSegScript.Notes     = RunSegScript_Notes  
    Cmds.RunSegScript.DidIt     = RunSegScript_DidIt
    Cmds.RunSegScript.Final     = RunSegScript_Final
    Cmds.RunSegScript.OnlyOne   = RunSegScript_OnlyOne

  #...........................................................................
  if DoCheckOut == 1:
    import Cmds.CheckOut

  #...........................................................................
  if DoCheckIn == 1:
    import Cmds.CheckIn

  #...........................................................................
  if DoTemplate == 1:
    import Cmds.Template

  #---------------------------------------------------------------------------
  # General Settings and Defaults
  #

  G.WorkingDirectory = os.getcwd()

  TooLongToWait = 5 # seconds

  #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  import ScanList
  #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  splitProject = ScanList.PROJECT.split('/')
  #print "splitProject  = ",splitProject 
  Project = splitProject[-1]
  ProjectPath = splitProject[0]
  ii = 1
  while ii < len(splitProject)-1:
    ProjectPath += '/' + splitProject[ii]
    ii += 1
  splitSandbox = ScanList.SANDBOX.split('/')
  #print "splitSandbox  = ",splitSandbox 
  Sandbox = splitSandbox[-1]
  SandboxPath = splitSandbox[0]
  ii = 1
  while ii < len(splitSandbox)-1:
    SandboxPath += '/' + splitSandbox[ii]
    ii += 1

  if G.VerboseLevel >= 1:
    print ''
    print '--------------------------------------------------------------------'
    print 'Project          = ', Project
    print 'ProjectPath      = ', ProjectPath
    print 'Sandbox          = ', Sandbox
    print 'SandboxPath      = ', SandboxPath
    print 'DATAVERSION      = ', ScanList.DATAVERSION 
    print 'ME               = ', ME 
    print 'VERSION          = ', G.Version
    print 'WorkingDirectory = ', G.WorkingDirectory 
    print 'PathToMe         = ', PathToMe 
    print 'YYYYMMDD_HHMMSS  = ', G.YYYYMMDD_HHMMSS
    if G.VerboseLevel >= 2:
      print 'YYMMDDHHMM       = ', G.YYMMDDHHMM
      print 'TimeLeftFile     = ', G.TimeLeftFile 
    print '--------------------------------------------------------------------'
    print ''
    print 'sys.version:'
    print sys.version
    print ''

  #===========================================================================
  # 2) Before Loop - Initialize() create directories, etc. Build HeaderExtra
  #===========================================================================

  #...........................................................................
  if DoCopyOrigToScan1 == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoCopyOrigToScan1 (before loop)"
    if os.access('./Data',os.F_OK) == False:
      print 'Making the "Data" directory'
      os.mkdir('Data')
    else:
      print 'The "Data" directory already exists'
    # if DoCopyOrigToScan1 

  #...........................................................................
  if DoUntarNIfTI == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoUntarNIfTI (before loop)"
    if os.access('./Results',os.F_OK) == False:
      print 'Making the "Results" directory'
      os.mkdir('Results')
    # if DoUntarNIfTI 

  #...........................................................................
  if DoACITMap == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoACITMap (before loop)"
    fn = "./Data/oldToNewLabelMap.txt"
    if os.access(fn,os.F_OK):
      print 'Read to do DoACITMap, %s does exist.' % (fn)
    else:
      print 'Cannot do DoACITMap, %s does not exist.' % (fn)
      DoACITMap = 0
    # if DoACITMap 

  #...........................................................................
  if DoFlipLeftRight == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoFlipLeftRight (before loop)"
    fn = "./Data/flipLRLabelMap.txt"
    if os.access(fn,os.F_OK):
      print 'Read to do DoFlipLeftRight, %s does exist.' % (fn)
    else:
      print 'Cannot do DoFlipLeftRight, %s does not exist.' % (fn)
      DoFlipLeftRight = 0
    # if DoFlipLeftRight 

  #...........................................................................
  if DoAutoWMparc == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoAutoWMparc (before loop)"
    fn = "./Data/PUtoWMlabelMap.txt"
    if os.access(fn,os.F_OK):
      print 'Read to do DoAutoWMparc, %s does exist.' % (fn)
    else:
      print 'Cannot do DoAutoWMparc, %s does not exist.' % (fn)
      DoAutoWMparc = 0
    # if DoAutoWMparc 

  #...........................................................................
  if DoInstallRelease == 1:
     if G.VerboseLevel >= 1:
       print ME + ": Running DoInstallRelease (before loop)"
     ResultDirName = './Results_' + G.YYYYMMDD_HHMMSS
     if os.access('ResultDirName',os.F_OK) == False:
       print 'Creating new Result directory: ', ResultDirName
       os.mkdir(ResultDirName)
     else:
       print 'new Result directory: ', ResultDirName, ' Already Exists!'
       sys.exit()
      # if DoInstallRelease

  #.........................................................................
  if DoArchive == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoArchive (before loop)"
    # Make sure main Archive directory exists
    if os.access(G.Archive,os.F_OK) == False:
      print 'Creating main Archive directory'
      os.mkdir(G.Archive)
    Ans = raw_input('Describe why this Archive is happening \n'+
                    '   (short, no spaces, to add to file name): ')
    ArchiveDirName = G.Archive+'/'+G.YYYYMMDD_HHMMSS+'_'+Ans
    if os.access(ArchiveDirName,os.F_OK) == False:
      print "Creating Archive directory: ", ArchiveDirName 
      os.mkdir(ArchiveDirName)
    else:
      print 'Archive directory ',ArchiveDirName, ' already exists!'
    Dirs = "SegMentor MetaData bin nvm_preferences.xml"
    for dir in Dirs.split():
      cmd = 'tar zcf '+ArchiveDirName+'/'+dir+'.tgz '+dir
      print cmd
      os.system(cmd)
    cmd = 'tar zcf '+ArchiveDirName+'/Data.tgz Data/*.xml'
    print cmd
    os.system(cmd)
  # if DoArchive

  #...........................................................................
  if DoMakeAtlas == 1 or DoAddSulciToAtlas == 1:
    MakeAtlas.Initialize()

  #...........................................................................
  if DoWarpAtlasToScan == 1:
    cmds.WarpAtlasToScan.Initialize()

  #...........................................................................
  if DoGetInfoFileInfo == 1:
    import Info

  #...........................................................................
  if DoPlotASPdebug == 1:
    PlotASPdebug.Initialize()

  #...........................................................................
  if DoShowLandmarks == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoShowLandmarks (before loop)"
    Landmarks.Initialize()
    # if DoShowLandmarks

  #...........................................................................
  if DoMakeInitACITMap == 1:
    print " "
    print "---------------------------------------------------"
    print ME + ": Running DDoMakeInitACITMap (before loop)"
    # Print warning if file is already present and stop
    fn = "./Data/oldToNewLabelMap.txt"
    if os.access(fn,os.F_OK):
      print "Hey, %s already exists.  I won't touch it." % (fn)
    else: # go ahead and make the file
      f = open(fn,'w')
      for n in range (207):
        f.write(str(n)+' 0\n')
      f.close()
    print "---------------------------------------------------"
    print " "
    # if DoMakeInitACITMap

  #...........................................................................
  if DoGitIgnores == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoGitIgnores in SegMentor/ (before loop)"
    # Individual .gitignore files
    t = 'bin/Templates/gitAttributes_Project'
    print t
    shutil.copyfile(t,'./.gitattributes')
    t = 'bin/Templates/gitIgnore_Project'
    print t
    shutil.copyfile(t,'./.gitignore')
    t = 'bin/Templates/gitIgnore_bin'
    print t
    shutil.copyfile(t,'bin/.gitignore')
 
    if G.VerboseLevel >= 1:
      print ME + ": Running DoGitIgnores for SegMentor/ (before loop)"
    # Put all .gitignore files in SegMentor/
    fdefault = 'bin/Templates/gitIgnore_SegMentor_default'
    for root, dirs, files in os.walk("./SegMentor"):
      print "root, ", root
      print "dirs, ", dirs
      print "files, ", files
      print "Checking %s" % (root)
      foundOne = False
      for afile in files:
        print "  file %s" % (afile)
        if afile == '.gitignore':
          foundOne = True
          isDiff = filecmp.cmp(root+'/'+afile, fdefault)
          if isDiff == False:
            print afile, "different:"
            fullFile = root+'/'+afile
            f = open(fullFile,'r')
            print f.read()
            f.close()
            print "overwriteing"
            shutil.copyfile(fdefault,fullFile)
          else:
            print "    same"
      #IF
      if foundOne == False:
        print ".gitignore not found, copying"
        shutil.copyfile(fdefault,root+'/.gitignore')
    # if DoGitIgnores

  #...........................................................................
  if DoCompare == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoCompare (before loop)"
    fullCmpName = "Archive/"+cmpName
    if os.access(fullCmpName,os.F_OK) == False:
      print "           Can't run because directory to compare "\
            "is missing: ", fullCmpName 
    else:
      print "           Ready to compare with ", fullCmpName 
    # if DoCompare

  #...........................................................................
  if DoMakeLabelList == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoMakeLabelList (before loop)"
    # Check if data file already exists
    SavedLabelListFile = 'none'
    if os.access(LabelListFile,os.F_OK) == True:
      # Save file temporarily
      SavedLabelListFile = LabelListFile + '.saved.' + G.YYMMDDHHMM
      if G.VerboseLevel >= 1:
        print "           Temporarily renaming %s to %s." % \
              (LabelListFile,SavedLabelListFile)
      os.rename(LabelListFile,SavedLabelListFile)
    # if DoMakeLabelList

  #...........................................................................
  if DoPlotAllVolPerAgeG == 1:
    s = ME + ': Running DoPlotAllVolPerAgeG (before loop)\n'
    G.TimeLeftFileP.write(s)
    if G.VerboseLevel >= 1:
      print s
    numAG = len(AgeGThresh)
    for AG in range(numAG-1):
      theDir = 'Volumes/AgeG'+str(AG)
      if os.access(theDir,os.F_OK):
        print 'theDir',theDir,'already exists, deleting it'
        cmd = 'rm -rf '+theDir
        print 'cmd is:',cmd
        os.system(cmd)
      cmd = 'mkdir -p '+theDir
      print 'cmd is:',cmd
      os.system(cmd)
    # if DoPlotAllVolPerAgeG

  #...........................................................................
  if DoRunNVM == 1:
    HeaderExtra += Cmds.RunNVM.Initialize()

  #...........................................................................
  if DoStatus == 1:
    HeaderExtra += Cmds.Status.Initialize()

  #...........................................................................
  if DoRunSegScript == 1:
    HeaderExtra += Cmds.RunSegScript.Initialize()

  #...........................................................................
  if DoCheckOut == 1:
    HeaderExtra += Cmds.CheckOut.Initialize()

  #...........................................................................
  if DoCheckIn == 1:
    HeaderExtra += Cmds.CheckIn.Initialize()

  #...........................................................................
  if DoTemplate == 1:
    HeaderExtra += Cmds.Template.Initialize()

  #---------------------------------------------------------------------------
  if G.VerboseLevel >= 1:
    print '\nHeader:'

  # Main Header info for each scan
  Header = "PID, SCN, SEG" + HeaderExtra
  print Header

  #sys.exit()

  if G.VerboseLevel >= 1:
    print ''
    print '===================================================================='
    print '                             Main Loop                              '
    print '===================================================================='
    print ''

  #for s in G.SCANLIST:
  #  print s
  G.TotalNumScans = len(G.SCANLIST)/3
  ListNum = 0
  G.SBJ   = 0
  SumTime = 0.0
  PrintingTimeLeft = False
  while ListNum < len(G.SCANLIST):

    if G.OnlyOneScan == 1: # then skip to the one and only
      # ScanList.THEONLYSCAN  = [ 1123, 3, "glm" ]
      while G.SCANLIST[G.SBJ*3+0] != ScanList.THEONLYSCAN[0] or \
            G.SCANLIST[G.SBJ*3+1] != ScanList.THEONLYSCAN[1] or \
            G.SCANLIST[G.SBJ*3+2] != ScanList.THEONLYSCAN[2]:
        if G.VerboseLevel >= 1:
          print "Skipping ", G.SCANLIST[G.SBJ*3+0],"looking for "\
                 ,ScanList.THEONLYSCAN[0]
        G.SBJ += 1
        ListNum += 3
    #print G.SBJ*3 , len(G.SCANLIST)
    if G.SBJ*3 >= len(G.SCANLIST):
      print "ERROR: Could not find one and only scan, ", ScanList.THEONLYSCAN[0]
      sys.exit(1)

    loopStart = time.time()
    G.PID  = G.SCANLIST[G.SBJ*3+0]  # NMM Patient/Subject ID
    G.SCN  = G.SCANLIST[G.SBJ*3+1]  # NMM Scan number
    G.SEG  = G.SCANLIST[G.SBJ*3+2]  # NMM Segmenter Prefix
    G.OPTH = G.OPATHLIST[G.SBJ]     # Original scan path (#s 1 & 2)
    G.GRP  = G.GROUPLIST[G.SBJ]     # Group e.g. C16AD1 (deliverable 1)
    G.SRC  = G.METADLIST[G.SBJ*2+0] # Data source e.g. "OASIS" or "CANDI"
    G.META = G.METADLIST[G.SBJ*2+1] # Meta data .csv file

    if options.segPrefix != '':
      G.SEG = options.segPrefix
      if G.VerboseLevel > 0:
        print "Overriding G.SEG with '" + G.SEG + "'"

    G.SBJ += 1
    ListNum += 3

    # These string versions will be used everywhere:
    G.PIDs         = str(G.PID)
    G.SCNs         = str(G.SCN)
    G.PIDSpaceSCNs = G.PIDs + " " + G.SCNs
    G.PIDSlashSCNs = G.PIDs + "/" + G.SCNs
    G.PID_SCNs     = G.PIDs + "_" + G.SCNs
    G.PID_SCN_SEGs = G.PIDs+"_"+G.SCNs+"_"+G.SEG

    #===========================================================================
    # 3) In Loop Part 1: SayIt() return string for InfoExtra to print CSV line 
    #===========================================================================

    #---------------------------------------------------------------------------
    # Strings to build for each scan:
    InfoExtra         = "" # after G.PID, G.SCN, print this

    # Set path to the inside the scan directory:
    G.ScanPath = "./Data/"+G.PIDSlashSCNs+"/"

    # Set up path to info file:
    G.InfoFile = G.PID_SCNs + ".xml"
    G.InfoPath = G.ScanPath
    G.FullInfoPath = G.InfoPath + G.InfoFile

    # Set up path to NIfTI result file:
    G.NIfTIFile = G.PID_SCN_SEGs + ".nii"
    G.NIfTIPath = "Results/Data/"+G.PIDSlashSCNs+"/NIFTI/"
    G.FullNIfTIPath = G.NIfTIPath + G.NIfTIFile

    # Set up path to result tgz file:
    G.TGZFile = G.PID_SCNs + ".tgz"
    G.TGZPath = "Results/"
    G.FullTGZPath = G.TGZPath + G.TGZFile

    # Set up path to result tgz file:
    G.OFile = "unknown" + ".nii" # will be completed later
    G.OPath = G.OPTH + "/"
    G.FullOPath = G.OPath + G.OFile

    # Set up path to Meta data .csv file
    G.MetaPath = './MetaData/' + G.SRC + '/'
    G.FullMetaPath = G.MetaPath + G.META 

    #.........................................................................
    if DoGetOrigInfo == 1:
      s = ME + ': Running DoGetOrigInfo for %s\n' % ( G.PIDSpaceSCNs )
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      findme = re.compile('^'+G.PIDs)
      #print G.FullMetaPath
      of = open(G.FullMetaPath,'r')
      cmdOutput = ''
      for line in of:
        if findme.search(line):
          cmdOutput = line
      if cmdOutput == '':
        print G.PIDs + ' not found'
      of.close()
      cmdOutSplit = cmdOutput.split(',')
      #print cmdOutSplit 
      #print len(cmdOutSplit)
 
      MNUM      = ''
      SNUM      = ''
      RepeatPID = ''
      if len(cmdOutSplit) == 11:
        MNUM      = cmdOutSplit[1]
        SNUM      = cmdOutSplit[2]
        RepeatPID = cmdOutSplit[4].rstrip()
        if G.VerboseLevel >= 2:
          print "MNUM      = ", MNUM
          print "SNUM      = ", SNUM
          print "RepeatPID = ", RepeatPID
          print "G.OPTH    = ", G.OPTH
 
        # Set up path to original info file:
        FullOrigPath = G.OPTH + '/' + G.PIDs + '/1/' + G.PIDs + '_1.xml'
 
        OrigPath = os.path.dirname(FullOrigPath)
        OrigFile = os.path.basename(FullOrigPath)
        if G.VerboseLevel >= 2:
          print "FullOrigPath = ", FullOrigPath
          print "OrigPath = ", OrigPath
          print "OrigFile = ", OrigFile
        G.OFile = OrigFile
        G.FullOPath = G.OPath + G.OFile
 
        #cmd = "cat " + FullOrigPath
        #print "cmd is ", cmd
        #os.system(cmd)

        if False:
          aFile = open(G.FullOPath)
          cmdOutput = aFile.read()
          print cmdOutput
          aFile.close()
          if G.VerboseLevel >= 2:
            print cmdOutput
          cmdLines = cmdOutput.splitlines()
          Cols = 0
          Rows = 0
          Slis = 0
          ColRes = 0.0
          RowRes = 0.0
          SliRes = 0.0
          DataType = -1
          VoxOffset = -1
          for line in cmdLines:
            print "line is ", line
            #print "line.find is ", line.find('pixdim')
            lineWords = line.split()
            #print lineWords
            if len(lineWords)>0:
              #print lineWords[0]
   
              #if lineWords[0] == 'dim' and lineWords[1] == '40':
              if lineWords[1] == '40':
                #print "found it in ", line
                Cols = int(lineWords[4])
                Rows = int(lineWords[5])
                Slis = int(lineWords[6])
   
              #if lineWords[0] == 'pixdim' and lineWords[1] == '76':
              if lineWords[1] == '76':
                #print "found it in ", line
                ColRes = float(lineWords[4])
                RowRes = float(lineWords[5])
                SliRes = float(lineWords[6])
   
              # datatype
              if lineWords[1] == '70':
                DataType = int(lineWords[3])
   
              # vox_offset
              if lineWords[1] == '108':
                VoxOffset = int(float(lineWords[3]))
   
      else:
        print "ERROR: FullOrigPath = 'NotFound'"
        print "len(cmdOutSplit)", len(cmdOutSplit)
        print "cmdOutSplit", cmdOutSplit
        FullOrigPath = 'NotFound'

    #.........................................................................
    if DoGetNIFTIheaderInfo == 1:
      assert os.access(G.FullNIfTIPath,os.F_OK)
      cmd = "nifti_tool -disp_hdr -infiles " + G.FullNIfTIPath
      aFile = os.popen(cmd)
      cmdOutput = aFile.read()
      if G.VerboseLevel >= 2:
        print cmdOutput
      cmdLines = cmdOutput.splitlines()
      aFile.close()
      Cols = 0
      Rows = 0
      Slis = 0
      ColRes = 0.0
      RowRes = 0.0
      SliRes = 0.0
      DataType = -1
      VoxOffset = -1
      for line in cmdLines:
        #print "line is ", line
        #print "line.find is ", line.find('pixdim')
        lineWords = line.split()
        #print lineWords
        if len(lineWords)>0:
          #print lineWords[0]
 
          #if lineWords[0] == 'dim' and lineWords[1] == '40':
          if lineWords[1] == '40':
            #print "found it in ", line
            Cols = int(lineWords[4])
            Rows = int(lineWords[5])
            Slis = int(lineWords[6])
 
          #if lineWords[0] == 'pixdim' and lineWords[1] == '76':
          if lineWords[1] == '76':
            #print "found it in ", line
            ColRes = float(lineWords[4])
            RowRes = float(lineWords[5])
            SliRes = float(lineWords[6])
 
          # datatype
          if lineWords[1] == '70':
            DataType = int(lineWords[3])
 
          # vox_offset
          if lineWords[1] == '108':
            VoxOffset = int(float(lineWords[3]))

    #.........................................................................
    # Get scan information from 'info file' Data/PID/SCN/PID_SCN.xml
    if DoGetInfoFileInfo == 1:
      Info.DoIt()

    #.........................................................................
    if DoGetVoxelCounts == 1:
      if G.VerboseLevel >= 1:
        print ME + ": Running DoGetVoxelCounts"
      # If count file already exists, see if it needs to be re-made
      YesDo = False
      FullCountPath = G.NIfTIPath+'voxelCounts.txt'
      if os.access(FullCountPath,os.F_OK):
        CountmodtimeSec = os.path.getmtime(FullCountPath)
        CountmodtimeStr = time.ctime(CountmodtimeSec)
        #print  "CountmodtimeStr = ", CountmodtimeStr
        NIfTImodtimeSec = os.path.getmtime(G.FullNIfTIPath)
        NIfTImodtimeStr = time.ctime(NIfTImodtimeSec)
        #print  "NIfTImodtimeStr = ", NIfTImodtimeStr 
        if CountmodtimeSec < NIfTImodtimeSec: # then count is older, re-make it
          YesDo = True
      else:
        YesDo = True
      if YesDo:
        cmd = "changeLabels show " + G.FullNIfTIPath + \
         " " + str(Cols) + \
         " " + str(Rows) + \
         " " + str(Slis) + \
         " " + str(VoxOffset) + " > " + FullCountPath
        #print "cmd is ", cmd
        os.system(cmd)

      # And do the same for the simplified NIFTI file
      YesDo = False
      FullCountPath = G.NIfTIPath+'voxelCounts_simp.txt'
      if os.access(FullCountPath,os.F_OK):
        CountmodtimeSec = os.path.getmtime(FullCountPath)
        CountmodtimeStr = time.ctime(CountmodtimeSec)
        #print  "CountmodtimeStr = ", CountmodtimeStr
        NIfTImodtimeSec = os.path.getmtime(G.FullNIfTIPath)
        NIfTImodtimeStr = time.ctime(NIfTImodtimeSec)
        #print  "NIfTImodtimeStr = ", NIfTImodtimeStr 
        if CountmodtimeSec < NIfTImodtimeSec: # then count is older, re-make it
          YesDo = True
      else:
        YesDo = True
      if YesDo:
        simpNIfTI = G.NIfTIPath+G.PID_SCN_SEGs + "_simp.nii"
        cmd = "changeLabels show " + simpNIfTI + \
         " " + str(Cols) + \
         " " + str(Rows) + \
         " " + str(Slis) + \
         " " + str(VoxOffset) + " > " + FullCountPath
        #print "cmd is ", cmd
        os.system(cmd)
    # if DoGetVoxelCounts

    #.........................................................................
    # Set Scan Info to print
    #.........................................................................
 
    FirstPart = "%d, %d, %s" % (G.PID, G.SCN, G.SEG)

    #.........................................................................
    if DoShowGroup == 1:
      InfoExtra +=  ",%11s" % (G.GRP)

    #.........................................................................
    if DoShowSource == 1:
      InfoExtra +=  ",%7s" % (G.SRC)

    #.........................................................................
    if DoShowAge == 1:
      cmd = 'grep '+G.PIDs+' '+G.FullMetaPath
      #print cmd
      aFile = os.popen(cmd)
      cmdOutput = aFile.read()
      aFile.close()
      cmdOutSplit = cmdOutput.split(',')
      #print cmdOutSplit
      age = cmdOutSplit[8].rstrip()
      #print age
      InfoExtra +=  ", %3s" % (age)
      #print "exiting."
      #sys.exit()

    #.........................................................................
    if DoShowMeta == 1:
      InfoExtra +=  ",%21s" % (G.META)

    #.........................................................................
    if DoShowLabelCount == 1:
      fromName = 'alllabel_'+G.SEG
      toName   = G.ScanPath + 'status/'+fromName+'.txt'
      if os.access(toName,os.F_OK) == True:
        cmd = 'tail -1 '+toName
        aFile = os.popen(cmd)
        cmdOutput = aFile.read()
        aFile.close()
        cmdOutSplit = cmdOutput.split()
        if len(cmdOutSplit) == 4:
          InfoExtra +=  ", %4s" % (cmdOutSplit[0])
        else:
          InfoExtra +=  ", huh?"
      else:
        InfoExtra +=  ",     "

    #.........................................................................
    if DoShowCheckedOut == 1:
      isDoneTF,last14Lines = G.GetStatus('0','CheckScanOut')
      if isDoneTF:
        #print 'YES!'
        cmdOutput = 'huh?       '
        findme = re.compile(' nvmG_User ')
        for line in last14Lines.splitlines():
          if findme.search(line):
            cmdOutput = line.split()[2]
      else:
        if last14Lines == '':
          #print 'no, and no status file either!'
          cmdOutput = 'no way     '
        else:
          #print 'no!'
          cmdOutput = 'no         '
      InfoExtra +=  ",%18s " % (cmdOutput)

    #.........................................................................
    if DoShowSegDone == 1:
      isDoneTF,last14Lines = G.GetStatus('2','Basic Segmentation')
      if isDoneTF:
        #print 'YES!'
        cmdOutput = 'huh?       '
        findme = re.compile(' nvmG_Version ')
        for line in last14Lines.splitlines():
          if findme.search(line):
            cmdOutput = line.split()[2:]
        if cmdOutput[0] == 'Version':
          vers = cmdOutput[1] # not used
          usr = 'who?'
          findme = re.compile(' nvmG_User ')
          for line in last14Lines.splitlines():
            if findme.search(line):
              usr = line.split()[2]
          cmdOutput = usr
        elif cmdOutput[0] == 'doMakeLabelList.py':
          cmdOutput = '#lbl==15    '
        else:
          cmdOutput = "error"
      else:
        if last14Lines == '':
          #print 'no, and no status file either!'
          cmdOutput = 'no way     '
        else:
          #print 'no!'
          cmdOutput = 'no         '
      InfoExtra +=  ",%18s " % (cmdOutput)

    #.........................................................................
    if DoShowAtlasDone == 1:
      isDoneTF,last14Lines = G.GetStatus('4.6.e1','CheckWithAtlas')
      if isDoneTF:
        #print 'YES!'
        cmdOutput = 'huh?       '
        findme = re.compile('Date/Time:')
        for line in last14Lines.splitlines():
          #print line
          if findme.search(line):
            cmdOutput = line.split()[1]
        #print 'cmdOutput =',cmdOutput
      else:
        if last14Lines == '':
          #print 'no, and no status file either!'
          cmdOutput = 'no status file'
        else:
          #print 'no!'
          cmdOutput = 'no         '
      InfoExtra +=  ",%16s" % (cmdOutput)
      isDoneTF,last14Lines = G.GetStatus('4.6','CheckWithAtlas')
      if isDoneTF:
        #print 'YES!'
        cmdOutput = 'huh?       '
        findme = re.compile('Date/Time:')
        for line in last14Lines.splitlines():
          #print line
          if findme.search(line):
            cmdOutput = line.split()[1]
        #print 'cmdOutput =',cmdOutput
      else:
        if last14Lines == '':
          #print 'no, and no status file either!'
          cmdOutput = 'no status file'
        else:
          #print 'no!'
          cmdOutput = 'no         '

      InfoExtra +=  ",%17s" % (cmdOutput)
      #print 'Exiting early!'
      #sys.exit()

    #.........................................................................
    if DoShowOrigInfo == 1:
      InfoExtra +=  ",%7s,%10s" % (MNUM, SNUM)
      #InfoExtra +=  ", %d,  %d,  %d,  %f, %f, %f, %d,    %d" % \
      #         (Cols, Rows, Slis, ColRes, RowRes, SliRes, DataType, VoxOffset)

    #.........................................................................
    if DoShowOrigFile == 1:
      InfoExtra +=  ",%s" % (OrigFile)

    #.........................................................................
    if DoShowLandmarks == 1:
      if G.VerboseLevel >= 1:
        print ME + ": Running DoShowLandmarks (in loop)"
      Landmarks.DoIt()
      InfoExtra += Landmarks.FinalMessage
      # if DoShowLandmarks

    #.........................................................................
    if DoSeeIfLabelIsIn == 1:
      cmd = "grep ' " + ROI + " ' " + G.NIfTIPath + "voxelCounts.txt "
      #print "cmd is ", cmd
      aFile = os.popen(cmd)
      cmdOutput = aFile.read()
      aFile.close()
      cmdOutSplit = cmdOutput.split()
      #print cmdOutSplit 
      #print len(cmdOutSplit)
      if len(cmdOutSplit) >= 2:
        InfoExtra += ",%5s ,%5s " % (cmdOutSplit[0], cmdOutSplit[1])
      else:
        InfoExtra += ",      ,      "


    #.........................................................................
    if DoShowNIfTIInfo == 1:
      InfoExtra +=  ", %d,  %d,  %d,  %f, %f, %f, %d,    %d" % \
               (Cols, Rows, Slis, ColRes, RowRes, SliRes, DataType, VoxOffset)

    #.........................................................................
    if DoCheckAtlasPrep == 1:
      MakeAtlas.CheckPrep()
      if MakeAtlas.Hunkydory:
        InfoExtra +=  ',       Ready'
      else:
        InfoExtra +=  ',   Not Ready'

    #.........................................................................
    if DoStatus == 1:
      InfoExtra += Cmds.Status.SayIt()

    #.........................................................................
    if DoRunSegScript == 1:
      InfoExtra += Cmds.RunSegScript.SayIt()

    #.........................................................................
    if DoCheckOut == 1:
      InfoExtra += Cmds.CheckOut.SayIt()

    #.........................................................................
    if DoCheckIn == 1:
      InfoExtra += Cmds.CheckIn.SayIt()

    #.........................................................................
    if DoTemplate == 1:
      InfoExtra += Cmds.Template.SayIt()

    #.........................................................................
    # Print Scan Info - Strings and files are created above and will be
    #                   shown here.
    #.........................................................................
    if G.VerboseLevel >= 1:
      print ""
      print Dash80
      print Header
 
    WholeLine = FirstPart + InfoExtra

    # Here it is, the MAIN PRINT STATEMENT!  Can you believe it?  Wow.
    print WholeLine

    if G.VerboseLevel >= 1:
      print Dash80 
      print ""
      print "ScanPath      ", G.ScanPath 
      print "FullInfoPath  ", G.FullInfoPath 
      print "FullNIfTIPath ", G.FullNIfTIPath
      print "FullTGZPath   ", G.FullTGZPath 
      print "FullOrigPath  ", G.FullOPath
      print ""

    #===========================================================================
    # 4) In Loop Part 2 - DoIt() to current scan, print output lines, etc.
    #===========================================================================

    #...........................................................................
    if DoShowPath:
      print "Original path  =", G.OPTH

    #...........................................................................
    if DoSeeWhatsIn == 1:
      # Show the whole file
      n = G.NIfTIPath + "voxelCounts.txt"
      print "What's in ", n
      f = open(n, 'r')
      o = f.read()
      f.close()
      print o
      n = G.NIfTIPath + 'voxelCounts_simp.txt'
      print "What's in ", n
      f = open(n, 'r')
      o = f.read()
      f.close()
      print o

    #.........................................................................
    if DoCopyOrigToScan1 == 1:
      if G.VerboseLevel >= 1:
        print ME + ": Running DoCopyOrigToScan1 (in loop)"
      ThisScanPath = "./Data/"+ G.PIDs + "/1/"
      if os.access(ThisScanPath,os.F_OK) == False:
        print 'Scan directory '+ ThisScanPath +' does not exist, copying scan'
        PINAME    = "ACIT_Siemens_CIBM"
        STUDYNAME = "ADNI30"
        PARAMARGS = "-skipcount -nii -noasp -comment " +PINAME+ "/" +STUDYNAME
        cmd = "prenvm -D "+ PARAMARGS +" "+ PINAME +"/"+ STUDYNAME +" "+ \
              G.PIDs +" new "+ OrigPath +" "+ OrigFile
        print cmd
        os.system(cmd)
        # Get preference file if not already here
        if os.access("./nvm_preferences.xml",os.F_OK) == False:
          cmd = "cp NMM/" +PINAME+ "/" +STUDYNAME+ "/nvm_preferences.xml ."
          print cmd
          os.system(cmd)
        cmd = "mv NMM/" +PINAME+ "/" +STUDYNAME+ "/Data/" +G.PIDs+ " ./Data"
        print cmd
        os.system(cmd)
      else:
        print 'The scan already exists! Not gonna re-makeit.'
      # if DoCopyOrigToScan1

    #.........................................................................
    # Run NVM Step 5.2: Save as NIFTI
    if DoRun52 == 1:
      s = ME + ': Running DoRun52 for %s\n' % ( G.PIDSpaceSCNs+" "+G.SEG )
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      cmd = "./SegMentor/xml/postprocessing/5.2.run.csh " + \
             G.PIDSpaceSCNs+" "+G.SEG
      print cmd
      os.system(cmd)

    #.........................................................................
    if DoUntarNIfTI == 1:
      s = ME + ': Running DoUntarNIfTI for %s\n' % ( G.PIDSpaceSCNs )
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      # tar zxf ./Result/1131_1.tgz
      cmd = "cd Results ; tar zxf " + G.PID_SCNs + ".tgz"
      print cmd
      os.system(cmd)
      # if DoUntarNIfTI

    #.........................................................................
    if DoACITMap == 1:
      s = ME + ': Running DoACITMap for %s\n' % ( G.PIDSpaceSCNs )
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      # changeLabels labelMap.txt in.nii out.nii cols rows slis 352
      # (352 is proper offset for .nii files)
      mapPath = "../../../../../Data/oldToNewLabelMap.txt"
      newNIfTIFile = G.PID_SCN_SEGs + "_simp1.nii"
      cmd = "cd "+G.NIfTIPath+" ; changeLabels "+mapPath+ " " +\
            G.NIfTIFile+ " " +newNIfTIFile+ \
            " " + str(Info.Cols) + \
            " " + str(Info.Rows) + \
            " " + str(Info.Slis) + \
            " 352" 
      print cmd
      os.system(cmd)
      # if DoACITMap 

    #.........................................................................
    if DoFlipLeftRight == 1:
      s = ME + ': Running DoFlipLeftRight for %s\n' % ( G.PIDSpaceSCNs )
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      # changeLabels labelMap.txt in.nii out.nii cols rows slis 352
      # (352 is proper offset for .nii files)
      mapPath = "../../../../../Data/flipLRLabelMap.txt"
      flipNIfTIFile = G.PID_SCN_SEGs + "_flipped.nii"
      cmd = "cd "+G.NIfTIPath+" ; mv "+G.NIfTIFile+' '+flipNIfTIFile+' ; '\
            +"changeLabels "+mapPath+ " " +\
            " " +flipNIfTIFile+ \
            " " +G.NIfTIFile+ \
            " " + str(Info.Cols) + \
            " " + str(Info.Rows) + \
            " " + str(Info.Slis) + \
            " 352" 
      print cmd
      os.system(cmd)
      # if DoFlipLeftRight 

    #.........................................................................
    if DoAutoWMparc == 1:
      s = ME + ': Running DoAutoWMparc for %s\n' % ( G.PIDSpaceSCNs )
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      # labelWMbyLobe 50 51 PUtoWMlabelMap.txt 47 46 1002_2_glm_simp.nii new.nii
      #               cols rows slis 352
      # (352 is proper offset for .nii files)
      mapPath = "../../../../../Data/PUtoWMlabelMap.txt"
      simpNIfTIFile = G.PID_SCN_SEGs + "_simp1.nii"
      newNIfTIFile = G.PID_SCN_SEGs + "_simp.nii"
      cmd = "cd "+G.NIfTIPath+" ; labelWMbyLobe 44 45 "+mapPath+ " 47 46 " +\
            simpNIfTIFile+ " " +newNIfTIFile+ \
            " " + str(Info.Cols) + \
            " " + str(Info.Rows) + \
            " " + str(Info.Slis) + \
            " 352" 
      print cmd
      os.system(cmd)
      # if DoAutoWMparc 

    #.........................................................................
    if DoShowOneROI == 1:
      s = ME + ': Running DoShowOneROI '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      cmd = "changeLabels l=" +str(ROI)+ " " + G.FullNIfTIPath + \
       " " + G.NIfTIPath + "OneROI.bshort" + \
       " " + str(Cols) + \
       " " + str(Rows) + \
       " " + str(Slis) + \
       " " + str(VoxOffset)
      print "cmd is ", cmd
      os.system(cmd)
      # Create .hdr file for the above .bshort
      f = open(G.NIfTIPath + 'OneROI.hdr', 'w')
      s = str(Cols) + ' ' + str(Rows) + ' ' + str(Slis) + ' 0'
      f.write(s+'\n')
      f.close()
      cmd = "vmp -ul " + G.NIfTIPath + 'OneROI.bshort'
      print "cmd is ", cmd
      os.system(cmd)
      #sys.exit()

    #.........................................................................
    if DoInstallOrig == 1:
      s = ME + ': Running DoInstallOrig '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      newDir = './Data/'+G.PIDs
      if os.access(newDir,os.F_OK) == False:
        cmd = 'mkdir ' + newDir
        print cmd
        os.system(cmd)
      newDir = './Data/'+G.PIDSlashSCNs
      if os.access(newDir,os.F_OK) == False:
        fromDir = 'NMM/'+Project+'/Data/'+G.PIDSlashSCNs
        cmd = 'cp -r ' + fromDir + ' ' + './Data/' + G.PIDSlashSCNs
        print cmd
        os.system(cmd)
      else:
        print 'Ignoring', G.PIDSpaceSCNs, 'because it is already there.'
      # if DoInstallOrig

    #.........................................................................
    if DoInstallRelease == 1:
      s = ME + ': Running DoInstallRelease\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      cmd = 'cp ' + G.FullTGZPath + ' ' + ResultDirName + '/' + G.TGZFile 
      print cmd
      os.system(cmd)
      # if DoInstallRelease

    #.........................................................................
    if DoGitIgnores == 1:
      s = ME + ': Running DoGitIgnores for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      # First the DATA/PID directory:
      ignores = \
       './bin/Templates/gitIgnore_PID ./ '
      ig = ignores.split()
      ii = 0
      while ii < len(ig):
        PIDPath = "./Data/"+G.PIDs+"/"
        ff = PIDPath + ig[ii+1]
        if os.access(ff,os.F_OK) == False:
          print ff, "is missing, which is okay, or is it?"
        else:
          gg = ff+'.gitignore'
          if os.access(gg,os.F_OK) == False:
            cmd = 'cp ' + ig[ii] +' '+ gg
            print cmd
            os.system(cmd)
            #cmd = 'cvs add ' + G.ScanPath+ig[ii+1]
            #print cmd
            #os.system(cmd)
          else:
            print gg, "is already there."
        ii += 2

      # Now the DATA/PID/SCN directory:
      ignores = \
       './bin/Templates/gitIgnore_SCN ./ '+\
       './bin/Templates/gitIgnore_default img/ '+\
       './bin/Templates/gitIgnore_default log/ '+\
       './bin/Templates/gitIgnore_otl otl/ '+\
       './bin/Templates/gitIgnore_default status/ '+\
       './bin/Templates/gitIgnore_warpedAtlas_glm warpedAtlas_glm/ '
      ig = ignores.split()
      ii = 0
      while ii < len(ig):
        ff = G.ScanPath+ig[ii+1]
        if os.access(ff,os.F_OK) == False:
          print ff, "is missing, which is okay."
        else:
          gg = ff+'.gitignore'
          if os.access(gg,os.F_OK) == False:
            cmd = 'cp ' + ig[ii] +' '+ gg
            print cmd
            os.system(cmd)
            #cmd = 'cvs add ' + G.ScanPath+ig[ii+1]
            #print cmd
            #os.system(cmd)
          else:
            print gg, "is already there."
        ii += 2
      # if DoGitIgnores

    #.........................................................................
    if DoRemoveLabels == 1:
      s = ME + ': Running DoRemoveLabels for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      # Make old directory to keep original outline files
      old1DirName = 'oldRM_'+G.YYYYMMDD_HHMMSS
      fullOld1DirName = 'Data/'+G.PIDSlashSCNs+'/otl/'+old1DirName
      cmd = 'mkdir '+fullOld1DirName
      print cmd
      os.system(cmd)
      # Make temp directories to hold intermediate results
      tempDirList = [ ]
      numLabels = len(RmLabelList)
      for ii in range(1,numLabels):
        tempDirList.append('oldTemp'+str(ii)+'_'+G.YYYYMMDD_HHMMSS)
        fullOld2DirName = 'Data/'+G.PIDSlashSCNs+'/otl/'+tempDirList[ii-1]
        cmd = 'mkdir '+fullOld2DirName
        print cmd
        os.system(cmd)
      #print tempDirList
      cmd = 'cd Data/'+G.PIDSlashSCNs+'/otl ' \
            '; ls '+G.SEG+'[0-9].xml '+ \
                    G.SEG+'[0-9][0-9].xml '+ \
                    G.SEG+'[0-9][0-9][0-9].xml'
      print cmd
      os.system(cmd)
      aFile = os.popen(cmd)
      cmdOutput = aFile.read()
      aFile.close()
      cmdOutSplit = cmdOutput.split()
      #print cmdOutSplit
      for otlFile in cmdOutSplit:
        cmd = 'cd Data/'+G.PIDSlashSCNs+'/otl ; '+\
              'mv '+otlFile+' '+old1DirName
        print cmd
        os.system(cmd)
        ii = 0
        lastDirName = old1DirName
        for theDir in tempDirList:
          cmd = 'cd Data/'+G.PIDSlashSCNs+'/otl ; '+\
              'extractAllButLabelled.py '+lastDirName+'/'+otlFile+\
              ' "'+RmLabelList[ii]+'" '+' > '+theDir+'/'+otlFile
          print cmd
          os.system(cmd)
          lastDirName = theDir
          ii += 1
        cmd = 'cd Data/'+G.PIDSlashSCNs+'/otl ; '+\
              'extractAllButLabelled.py '+lastDirName+'/'+otlFile+\
              ' "'+RmLabelList[ii]+'" '+' > '+otlFile
        print cmd
        os.system(cmd)
        #print "breaking..."
        #break
        #print "that's all"
        #sys.exit()
      for theDir in tempDirList:
        fullPathAndDir = 'Data/'+G.PIDSlashSCNs+'/otl/'+theDir
        print 'shutil.rmtree('+fullPathAndDir+')'
        shutil.rmtree(fullPathAndDir)
      print "that's all"
      sys.exit()
      # if DoRemoveLabels

    #.........................................................................
    if DoArchive == 1:
      s = ME + ': Running DoArchive for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      cmd = 'tar zcf ' + ArchiveDirName + '/' + G.PID_SCNs + '.tgz ' + \
            'Data/' + G.PIDSlashSCNs + '/' + G.PID_SCNs + '.xml ' + \
            'Data/' + G.PIDSlashSCNs + '/otl ' + \
            'Data/' + G.PIDSlashSCNs + '/status '
      print cmd
      os.system(cmd)

    #.........................................................................
    if DoSandboxScans == 1:
      s = ME + ': Running DoSandboxScans for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      cmd = "copyToSandbox " + G.PIDSpaceSCNs +" "+ Sandbox
      print cmd
      os.system(cmd)
      # if DoSandboxScans

    #.........................................................................
    if DoCopyNIFTItoSand == 1:
      s = ME + ': Running DoCopyNIFTItoSand for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      NIFTIdir = os.path.expanduser(SandboxPath)+'/'+Sandbox+\
                    '/Data/'+G.PIDSlashSCNs+'/NIFTI'
      #print "NIFTIdir is ", NIFTIdir 
      if os.access(NIFTIdir,os.F_OK) == False:
        print 'Creating directory: ', NIFTIdir
        os.mkdir(NIFTIdir)
      else:
        print 'new directory:', NIFTIdir , 'Already Exists!'
      cmd = 'cd ./Data/'+G.PIDSlashSCNs+'/NIFTI/ ; ' +\
            'cp '+G.PID_SCN_SEGs+'* ' + NIFTIdir 
      print cmd
      os.system(cmd)
      # if DoCopyNIFTItoSand

    #.........................................................................
    if DoRun53 == 1:
      s = ME + ': Running DoRun53 (in loop) for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      cmd = "./SegMentor/xml/postprocessing/5.3.run.csh " + G.PIDSpaceSCNs 
      print cmd
      os.system(cmd)
      # if DoRun53

    #.........................................................................
    if DoCheckAtlasPrep == 1:
      if MakeAtlas.CheckPrepMessage != '':
        print MakeAtlas.CheckPrepMessage 

    #.........................................................................
    if DoSaveSulciAsNIFTI == 1:
      s = ME + ': Running DoSaveSulciAsNIFTI (in loop) for '+\
             G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      cmd = "./SegMentor/xml/postprocessing/5.4.run.csh " + G.PIDSpaceSCNs 
      print cmd
      os.system(cmd)
      # if DoSaveSulciAsNIFTI

    #.........................................................................
    if DoMakeAtlas == 1 or DoAddSulciToAtlas == 1:
      MakeAtlas.DoIt()

    #.........................................................................
    if DoWarpAtlasToScan == 1:
      cmds.WarpAtlasToScan.DoIt()

    #.........................................................................
    if DoPlotASPdebug == 1:
      PlotASPdebug.DoIt()

    #.........................................................................
    if Do3DcgsPic == 1:
      s = ME + ': Running Do3DcgsPic (in loop) for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      cmd = "./SegMentor/xml/visualization/Sulci.run.csh " + \
              G.PIDSpaceSCNs + " Sulci_cgs3DScreenCap.xml"
      print cmd
      os.system(cmd)
      # if Do3DcgsPic 

    #.........................................................................
    if DoCompare == 1:
      w = 'log'
      w = 'status'
      w = 'otl'
      s = ME + ': Running DoCompare '+w+'(in loop) for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      wDir = '/'+w+'/'
      dcmp = filecmp.dircmp(fullCmpName+"/ADNI30/Data/"+G.PIDSlashSCNs+wDir,
                           "Data/"+G.PIDSlashSCNs+wDir)
      #dcmp.report()
      print "%d file(s) are the same" % (len(dcmp.same_files))
      if len(dcmp.left_only)>0:
        print "Only in %s:" % (dcmp.left)
        print dcmp.left_only
        ans = raw_input("Press 'y' to copy them to "+dcmp.right+" ")
        if ans == 'y':
          for file in dcmp.left_only:
            print 'shutil.copy2('+dcmp.left+file+','+dcmp.right+')'
            shutil.copy2(dcmp.left+file,dcmp.right)
        else:
          print "Not copying."
      else:
        print "None only in left"
      if len(dcmp.right_only)>0:
        print "Only in %s:" % (dcmp.right)
        print dcmp.right_only
      for name in dcmp.diff_files:
        print "diff_file %s found in %s and %s" % (name, dcmp.left,dcmp.right)
        cmd = "diff -c "+dcmp.left+name+' '+dcmp.right+name
        print cmd
        os.system(cmd)
        ans = raw_input("Press 'y' to copy it to "+dcmp.right+" ")
        if ans == 'y':
          print 'shutil.copy2('+dcmp.left+name+','+dcmp.right+')'
          shutil.copy2(dcmp.left+name,dcmp.right)
        else:
          print "Not copying to right."
      # if DoCompare 

    #.........................................................................
    if DoMakeLabelList == 1:
      s = ME + ': Running DoMakeLabelList in loop for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      f = open(LabelListFile,'w')
      f.write('#           PID  SCN\n')
      f.write('set DATA=( '+G.PIDs+' '+G.SCNs+' )\n')
      f.write('set DATALOC=./Data\n')
      f.write('set SEG='+G.SEG+'\n')
      f.close()
      os.system('getalllabel')
      fromName = 'alllabel_'+G.SEG
      if os.access(fromName,os.F_OK) == True:
        toDir    = G.ScanPath + 'status/'
        toName   = toDir+fromName+'.txt'
        if os.access(toDir,os.F_OK) == False:
          print 'Creating directory: ', toDir
          os.mkdir(toDir)
        print "fromName is ", fromName
        print "  toName is ",   toName
        shutil.move(fromName,toName)
      else:
        print fromName, " is missing."
      #sys.exit()
      # if DoMakeLabelList

    #.........................................................................
    if DoShowLabelList == 1:
      s = ME + ': Running DoShowLabelList in loop for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      fromName = 'alllabel_'+G.SEG
      toName   = G.ScanPath + 'status/'+fromName+'.txt'
      os.system('cat '+toName)
      print " "
      # if DoShowLabelList

    #.........................................................................
    if DoPlotVolPerSlice == 1:
      s = ME + ': Running DoPlotVolPerSlice in loop for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      theName   = G.PID_SCNs + '_seg_Volume_Slice.csv'
      os.system('cd Volumes/ ; plotVolPerSlice.py '+theName)
      print " "
      # if DoPlotVolPerSlice

    #.........................................................................
    if DoPlotAllVolPerAgeG == 1:
      s = ME + ': Running DoPlotAllVolPerAgeG in loop for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s
      theName   = G.PID_SCNs + '_seg_Volume_Slice.csv'
      numAG = len(AgeGThresh)
      #print 'theName is:',theName
      #print '  numAG is:',numAG
      for AG in range(numAG-1):
        print AgeGThresh[AG],' < ',age,' <= ',AgeGThresh[AG+1]
        if (int(age) > int(AgeGThresh[AG])) and \
           (int(age) <= int(AgeGThresh[AG+1])):
          cmd = 'cd Volumes/AgeG'+str(AG)+' ; ln -s ../'+theName+' . '
          print 'cmd is:',cmd
          os.system(cmd)
          break
      #print 'final AG is',AG
      #print " "
      # if DoPlotAllVolPerAgeG

    #.........................................................................
    if DoNoteVPSOutliers == 1:
      s = ME + ': Running DoNoteVPSOutliers in loop for '+G.PIDSpaceSCNs+'\n'
      G.TimeLeftFileP.write(s)
      if G.VerboseLevel >= 1:
        print s

      # Find all csv files containing outliers
      csvFileNames = 'Volumes/AgeG?/'+\
                      'VolPerSliceAllStruc_col???_outliers.csv'
      print 'csvFileNames', csvFileNames 
      globList = glob.glob(csvFileNames)
      print 'globList', globList 

      for csvFile in globList:
        cmd = 'noteVolPerSliceOutliers.py -v -n glm_Notations_volPerSlice.xml'+\
               ' '+csvFile
        print 'cmd is', cmd
        os.system(cmd)

      print ''
      print 'Exiting early.'
      sys.exit()
      # if DoNoteVPSOutliers

    #.........................................................................
    if DoRunNVM == 1:
      Cmds.RunNVM.DoIt()

    #.........................................................................
    if DoStatus == 1:
      Cmds.Status.DoIt()

    #.........................................................................
    if DoRunSegScript == 1:
      Cmds.RunSegScript.DoIt()
      if Cmds.RunSegScript.DOONLYONESCAN:
        print 'Ending after 1 scan'
        G.OnlyOneScan = 1

    #.........................................................................
    if DoCheckOut == 1:
      Cmds.CheckOut.DoIt()

    #.........................................................................
    if DoCheckIn == 1:
      Cmds.CheckIn.DoIt()

    #.........................................................................
    if DoTemplate == 1:
      Cmds.Template.DoIt()

    #-------------------------------------------------------------------------
    if G.OnlyOneScan == 1: # then don't do any more
      ListNum = len(G.SCANLIST)
      G.SBJ = 1

    #-------------------------------------------------------------------------
    # Calculate how long it has taken to get through this iteration
    #time.sleep(0.125) # for testing time display 
    thisTime = (time.time() - loopStart)
    SumTime += thisTime
    AvgTime  = SumTime / G.SBJ
    NumToGo  = G.TotalNumScans - G.SBJ
    TimeLeft = AvgTime * NumToGo
    if G.VerboseLevel >= 1:
      print ''
      print 'Time', timedelta(seconds=thisTime), \
            '         Avg.', timedelta(seconds=AvgTime), \
            '        Done in', timedelta(seconds=TimeLeft), '\n'
    elif TimeLeft > TooLongToWait or PrintingTimeLeft:
      t = str(timedelta(seconds=TimeLeft))
      #print >> sys.stderr, 'Done in', t, ''
      s='%4d left to do' % ( NumToGo )
      s=s+', this '+ str(timedelta(seconds=thisTime))
      s=s+', avg '+ str(timedelta(seconds=AvgTime))
      s=s+'\n'
      G.TimeLeftFileP.write('Done in ' + t + s)
      if PrintingTimeLeft == False: # Only executes once
        cmd = 'xterm -r -title "Time Left" -e "sleep 2 ; tail -f ' + \
         G.TimeLeftFile + '" &'
        os.system(cmd)
      else:
        G.TimeLeftFileP.flush()
      PrintingTimeLeft = True

    StopFileName = 'bin/Stop'
    if os.access(StopFileName,os.F_OK):
      print ME + '.py found file, "'+StopFileName+\
            '".  Deleting that and quitting. Bye!'
      os.remove(StopFileName)
      sys.exit()
    # End of while loop

  #===========================================================================
  # 5) After loop  - Finalize(): clean up, etc. after command
  #===========================================================================

  #.........................................................................
  if DoCopyOrigToScan1 == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoCopyOrigToScan1 (after loop)"
    if os.access("./NMM",os.F_OK) == True:
      print "./NMM Exists, deleating it"
      shutil.rmtree("./NMM")
    # if DoCopyOrigToScan1

  #...........................................................................
  if DoInstallRelease == 1:
     if G.VerboseLevel >= 1:
       print ME + ': Running DoInstallRelease (after loop)'
     cmd = 'scp -r '+ResultDirName+' www:www'
     print cmd
     print "NOT REALLY EXECUTING THAT COMMAND!"
     #os.system(cmd)

  #.........................................................................
  if DoMakeAtlas == 1 or DoAddSulciToAtlas == 1:
    MakeAtlas.Finalize()

  #.........................................................................
  if DoWarpAtlasToScan == 1:
    cmds.WarpAtlasToScan.Finalize()

  #.........................................................................
  if DoPlotASPdebug == 1:
    PlotASPdebug.Finalize()

  #.........................................................................
  if DoShowLandmarks == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoShowLandmarks (after loop)"
      Landmarks.Finalize()
    # if DoShowLandmarks

  #.........................................................................
  if DoMakeLabelList == 1:
    s = ME + ': Running DoMakeLabelList (after loop)\n'
    G.TimeLeftFileP.write(s)
    if G.VerboseLevel >= 1:
      print s
    # remove temp file
    if os.access(LabelListFile,os.F_OK) == True:
      if G.VerboseLevel >= 1:
        print "           Removing %s." % (LabelListFile)
      os.remove(LabelListFile)
    # maybe restore temporarily renamed file 
    if SavedLabelListFile != 'none':
      os.rename(SavedLabelListFile,LabelListFile)
      if G.VerboseLevel >= 1:
        print "           Restoring %s to %s." % \
              (SavedLabelListFile,LabelListFile)
    # if DoMakeLabelList

  #.........................................................................
  if DoPlotAllVolPerAgeG == 1:
    s = ME + ': Running DoPlotAllVolPerAgeG (after loop)\n'
    G.TimeLeftFileP.write(s)
    if G.VerboseLevel >= 1:
      print s
    theName   = '_12_seg_Volume_Slice.csv'
    numAG = len(AgeGThresh)
    for AG in range(numAG-1):
      for col in range(1,16):
        cmd = 'cd Volumes/AgeG'+str(AG)+' ; '+\
              'plotVolPerSliceAllStruc.py -c '+str(col)+' '+\
              '-T AgeG'+str(AG)+' '+theName
        print 'cmd is:',cmd
        os.system(cmd)
    print " "
    # if DoPlotAllVolPerAgeG

  #.........................................................................
  if DoRunNVM == 1:
    Cmds.RunNVM.Finalize()

  #.........................................................................
  if DoStatus == 1:
    Cmds.Status.Finalize()

  #.........................................................................
  if DoRunSegScript == 1:
    print "running finalize"
    Cmds.RunSegScript.Finalize()
    #sys.exit()

  #.........................................................................
  if DoCheckOut == 1:
    Cmds.CheckOut.Finalize()

  #.........................................................................
  if DoCheckIn == 1:
    Cmds.CheckIn.Finalize()

  #.........................................................................
  if DoTemplate == 1:
    Cmds.Template.Finalize()

  #---------------------------------------------------------------------------
  print ""
  print "Total subjects ", G.SBJ
  print ""

  s = time.asctime() + '\n'
  G.TimeLeftFileP.write(s)
  tt = 'Total time: %s (average: %s)\n' % \
       (timedelta(seconds=(time.time() - G.StartTime)), \
       timedelta(seconds=AvgTime))
  G.TimeLeftFileP.write(tt)
  G.TimeLeftFileP.close()
  # End of main()

#---------------------------------------------------------------------------
# Call Main Program (above) with exceptions, etc.
#---------------------------------------------------------------------------
# Uncomment the following section if you want readline history support.
#import readline, atexit
#histfile = os.path.join(os.environ['HOME'], '.RunAll_history')
#try:
#    readline.read_history_file(histfile)
#except IOError:
#    pass
#atexit.register(readline.write_history_file, histfile)
if __name__ == '__main__':
  try:
    G.Version+='$Id: RunAll.py,v 1.4 2013/04/11 04:19:15 andy Exp $'
    G.StartTime = time.time()
    parser = optparse.OptionParser(
                formatter=optparse.TitledHelpFormatter(),
                usage=globals()['__doc__'],
                version=G.Version)
                #version='$Id: RunAll.py,v 1.4 2013/04/11 04:19:15 andy Exp $')
    parser.add_option ('-v', '--verbose', action='store_true',
                default=False, help='verbose output')
    parser.add_option ('-V', '--Verbose', action='store_true',
                default=False, help='more verbose output')
    parser.add_option ('-l', '--verboseLevel', action='store', type="int",
                default=0, help='level of verbose output')
    parser.add_option ('-s', '--segPrefix', action='store', type="string",
                default='', help='override seg prefix with this')
    parser.add_option ('-S', '--ScanList', action='store', type="string",
                default='', help='OnlyOne, Random, Flip, DontFlip')
    (options, args) = parser.parse_args()
    #if len(args) < 1:
    #    parser.error ('missing argument')
    G.VerboseLevel = options.verboseLevel
    if options.verbose: 
      if G.VerboseLevel < 1: G.VerboseLevel = 1
    if options.Verbose: 
      if G.VerboseLevel < 2: G.VerboseLevel = 2
    if G.VerboseLevel > 0: 
      print 'Running: ', __file__
      print time.ctime(G.StartTime)
      print "VerboseLevel is ", G.VerboseLevel, '\n'
    exit_code = main() # DoItToIt!
    if exit_code is None:
      exit_code = 0
      tt = 'Total time: %s (average: %s)' % \
               (timedelta(seconds=(time.time() - G.StartTime)), \
               timedelta(seconds=AvgTime))
      if options.verbose >= 1: 
        print time.asctime()
        print tt
    sys.exit(exit_code)
  except KeyboardInterrupt, e: # Ctrl-C
    raise e
  except SystemExit, e: # sys.exit()
    raise e
  except Exception, e:
    print 'ERROR, UNEXPECTED EXCEPTION'
    print str(e)
    traceback.print_exc()
    os._exit(1)

# vi:set autoindent ts=2 sw=2 expandtab : See Vim, :help 'modeline'