doNoteDiffs.py

#!/usr/bin/env python
#*********************************************************************
#                                                          24 Sep 2015
#               Andrew J. Worth
#               andy@neuromorphometrics.com
#
#               Neuromorphometrics
#               22 Westminster Street
#               Somerville, MA  02144-1630  USA
#
#               http://neuromorphometrics.com
#
#*********************************************************************
#*                                                                   *
#*  (c) Copyright 2015 Neuromorphometrics      All rights reserved   *
#*                                                                   *
#*********************************************************************
#-------------------------------------------------------------------------------
# Usage String:
"""
SYNOPSIS
 
    doNoteDiffs.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 ../Settings/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/doNoteDiffs.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 2015 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

import G            # Globals!

# I'm just wondering who I really am
FullPathToMe = os.path.realpath(__file__)
#print "FullPathToMe ", FullPathToMe 
SplitFullPathToMe = os.path.split(FullPathToMe)
PathToMe = SplitFullPathToMe[0]
ME       = SplitFullPathToMe[1]
s = 'Starting '+ME+'\n pwd: '+G.WorkingDirectory+'\n'
if G.VerboseLevel >= 1: # set VerboseLevel in G.py to affect this
  print 'I am "%s"' % ( ME )
  print 'Some call me "%s"' % ( __name__ )
  print 'I am at "%s"' % ( PathToMe )
  print 'I was run from "%s"' % ( G.WorkingDirectory )
  print s
#print ''
#print 'Exiting early!'
#sys.exit()
G.TimeLeftFileP.write(s)

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

  global options, args, AvgTime

  AvgTime = 0

  ThingsToDo = [ ] # a list of messages about things that need to be done
  
  #---------------------------------------------------------------------------
  # Get project-specific settings on what to List
  #  (symbolically linked to ../Settings/Conf.py)
  import Conf

  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()
  #---------------------------------------------------------------------------

  DoLoadLabeles       = 1 # read all default label files (needed to get the
                          #  proper label # to put in notations)

  DoNoteDiffs         = 1 # Create Notations based on Differences

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

  DoNotations         = 1 # Write Notations (after everything else)

  #---------------------------------------------------------------------------
  # 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
  DoGetMetaInfo        = 0 # Sets Meta data global info: ID1&2, age, MF, hand

  #===========================================================================
  # 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 Conf.DoShowGroup == 1:
    HeaderExtra += ",        Group"

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

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

  #...........................................................................
  if Conf.DoShowMF == 1:
    DoGetMetaInfo = 1
    HeaderExtra += ", M/F"

  #...........................................................................
  if Conf.DoShowHandedness == 1:
    DoGetMetaInfo = 1
    HeaderExtra += ", R/L"

  #...........................................................................
  if Conf.DoShowRepeat == 1:
    DoGetMetaInfo = 1
    HeaderExtra += ", Rpt?"

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

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

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

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

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

  #...........................................................................
  if Conf.DoShowIDInfo == 1:
    DoGetMetaInfo = 1
    HeaderExtra += MetaInfo.IDInfoHeaderExtra

  #...........................................................................
  if Conf.DoShowOrigInfoFile == 1:
    DoGetMetaInfo = 1
    HeaderExtra += ", Original Info File "

  #...........................................................................
  if Conf.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 Conf.DoSeeIfLabelIsIn == 1:
    DoGetNIFTIheaderInfo = 1 # Gets slice res, etc. from NIfTI header
    DoGetVoxelCounts = 1 # generate NIfTIPath/voxelCounts.txt
    HeaderExtra += ", label, found"

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

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

  #...........................................................................
  if DoLoadLabeles == 1:
    import Labels

  #...........................................................................
  if DoNoteDiffs == 1:
    import Cmds.NoteDiffs

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

  #...........................................................................
  if  Conf.TestNotations > 0 or \
      Conf.DoShowNotationCount == 1 or \
      DoNotations == 1:
    import Notations

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

  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 DoGetInfoFileInfo == 1:
    import Info

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

  #...........................................................................
  if DoLoadLabeles == 1:
    Labels.Read(G.VerboseLevel)

  #...........................................................................
  if Conf.DoShowNotationCount == 1:
    HeaderExtra += Notations.Initialize()

  #...........................................................................
  if DoNoteDiffs == 1:
    HeaderExtra += Cmds.NoteDiffs.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 (e.g. scans 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 original scan's info file: 
    # (G.OPTH ends in '../Data')
    G.OFile = G.PIDs + '_1.xml'
    G.OPath = G.OPTH + '/'+ G.PIDs + '/1/'
    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 DoGetMetaInfo == 1:
      # set a bunch of Meta variables: ID, age, m/f, handedness, repeat?
      MetaInfo.GetMetaInfo()

    #.........................................................................
    if DoGetNIFTIheaderInfo == 1:
      if 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]))

      else: # G.FullNIfTIPath not available
        print 'WARNING:',G.FullNIfTIPath,'is not available'
        Cols = 0
        Rows = 0
        Slis = 0
        ColRes = 0.0
        RowRes = 0.0
        SliRes = 0.0
        DataType = 0
        VoxOffset = 0

    #.........................................................................
    # 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:
        if os.access(G.FullNIfTIPath,os.F_OK) == False:
          YesDo = False
          print 'ERROR could not find.  Cannot do counts.', G.FullNIfTIPath
      if YesDo:
        cmd = "changeLabels show " + G.FullNIfTIPath + \
         " " + 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, %3d, %s" % (G.PID, G.SCN, G.SEG)

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

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

    #.........................................................................
    if Conf.DoShowAge == 1:
      InfoExtra +=  MetaInfo.AGEFormat % (MetaInfo.AGE)

    #.........................................................................
    if Conf.DoShowMF == 1:
      InfoExtra +=  MetaInfo.MFFormat % (MetaInfo.MF)

    #.........................................................................
    if Conf.DoShowHandedness == 1:
      InfoExtra +=  MetaInfo.HANDFormat % (MetaInfo.HAND)

    #.........................................................................
    if Conf.DoShowRepeat == 1:
      InfoExtra +=  ", %4s" % (MetaInfo.RepeatPID)

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

    #.........................................................................
    if Conf.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()
        InfoExtra +=  ", %4s" % (cmdOutSplit[0])
      else:
        InfoExtra +=  ",     "

    #.........................................................................
    if Conf.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 Conf.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 Conf.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 Conf.DoShowIDInfo == 1:
      InfoExtra +=  MetaInfo.IDInfoHeaderFormat % (MetaInfo.ID1, MetaInfo.ID2)

    #.........................................................................
    if Conf.DoShowOrigInfoFile == 1:
      InfoExtra +=  ",%s" % (G.OFile)

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

    #.........................................................................
    if Conf.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 Conf.DoShowNIfTIInfo == 1:
      InfoExtra +=  ", %d,  %d,  %d,  %f, %f, %f, %d,    %d" % \
               (Cols, Rows, Slis, ColRes, RowRes, SliRes, DataType, VoxOffset)

    #.........................................................................
    if Conf.DoShowNotationCount == 1:
      InfoExtra += Notations.SayIt()

    #.........................................................................
    if DoNoteDiffs == 1:
      InfoExtra += Cmds.NoteDiffs.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 Conf.DoSHowOrigInfoPath:
      print "Original info file path  =", G.FullOPath

    #...........................................................................
    if Conf.DoSeeWhatsIn == 1:
      # Show the whole file
      n = G.NIfTIPath + "voxelCounts.txt"
      if os.access(n,os.F_OK):
        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
      else:
        print 'Cannot see what is in. Cannot find',n

    #.........................................................................
    if DoNoteDiffs == 1:
      Cmds.NoteDiffs.DoIt(options.force)

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

    #.........................................................................
    # This should be done after everything else (that might create Notations)
    if Conf.TestNotations > 0 or \
       DoNotations == 1:
      Notations.DoIt(options.force)

    #-------------------------------------------------------------------------
    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 Conf.DoShowLandmarks == 1:
    if G.VerboseLevel >= 1:
      print ME + ": Running DoShowLandmarks (after loop)"
      Landmarks.Finalize()
    # if Conf.DoShowLandmarks

  #.........................................................................
  if DoNoteDiffs == 1:
    Cmds.NoteDiffs.Finalize()

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

  #.........................................................................
  if DoNotations == 1:
    Notations.Finalize()

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

  if len(G.SCANLIST) == 0:
    ThingsToDo.append('Edit ScanList.py::SL1, SL2, etc. so there are scans'+\
                       ' to run on')

  if len(ThingsToDo) > 0:
    print 'There are things that need to be done:'
    for thing in ThingsToDo:
      print ' '+thing
    print ''

  s = 'Finishing '+ME+' at '+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: doNoteDiffs.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)
    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')
    parser.add_option ('-f', '--force', action='store_true', 
                default=False, help='force recalculation of whatever')
    (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
 
    #---------------------------------------------------------------------------
    # Install links if the files in bin are not present
    fileList = ['MetaInfo.py',\
                'ScanList.py',\
                'Conf.py']
    for theFile in fileList:
      #print theFile
      targFile = '../'+G.Settings+'/'+theFile
      linkFile = 'bin/'+theFile
      if os.access(linkFile,os.F_OK) == False:
        cmd = 'cd bin ; ln -s '+targFile+' '+theFile
        print 'cmd is',cmd
        os.system(cmd)
      else:
        if G.VerboseLevel > 0: 
          print linkFile+' is already there, no need to link'
    #---------------------------------------------------------------------------
    import MetaInfo # Where to find ID, age etc in Meta Info File
 
    if G.VerboseLevel > 0: 
      print 'Running: ', __file__
      print time.ctime(G.StartTime)
      print "VerboseLevel is", G.VerboseLevel
      print "force is",options.force
      print ''
      #print 'Exiting early.'
      #sys.exit()
 
    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'