#! /bin/csh -f
##########################################################################
# mksurface.csh: cortical surface reconstruction script (orig: 1995)
##########################################################################
# 96/08/06 -- v01: (0.2K)
# 97/07/30 -- v10: (0.7K)
# 97/11/11 -- v20: (1.0K)
# 02/08/05 -- v29: (1.4K) last UCSD version
# ...
# 12/03/15 -- v30: (1.4K) resurrect for bucky2
# 12/03/17 -- v31: fix args for recompiled fill, surf, wmfilter
#-----------------
#OK: mksurface -wmfilter -initfill -dofill -tessellate
#TODO: fix to use new tkstrip, add a few parms
#TODO: fix inflate/flatten parms
#TODO: make sure spacingXYZ-updated wmfilter/fill/surf work
#TODO: fix to use new white/pial making script
##########################################################################
# replaces:
#    NOTES, substname, substword
#    mriconv.csh, imaconv.dat
#    talairach.csh normalize.csh
#    brain.csh, brain.dat
#    mkwm.csh, wmfilter.dat
#    mksurf.csh, mksurf-.csh
#    mkfilldat.csh, fill.dat
#    inflate.csh, plump.csh
#    flatten.csh, flattenmore.csh
#    inner_skull.csh, inner_skull.dat
#    outer_skin.csh, outer_skin.dat
#    outer_skull.csh, outer_skull.dat
#    tridec.csh
##########################################################################
# uses binaries: (these vars mostly not used yet)
set convertprog = orig2cor
set regprog = tkregister
set cor2mniprog = mri_convert
set talairprog = mritotal     # perl using 6 binaries
set editprog = tkmedit
set avgprog = regcor
set normprog = mri_normalize
set skullprog = tktrishrink
set segprog = wmfilter
set initprog = mkfilldat
set fillprog = fill
set tessprog = surf
set surfprog = tksurfer
if (`uname -r` == "6.5") set surfprog = tksurfer-n32
##########################################################################
# defaults (overridden by mksurface.dat if present)
##########################################################################
# (awk needs next line and line w/"nobody")
# mksurface.dat: parmfile for mksurface
#########################################
set name = nobody

#### CONVERT to COR format (-convert: orig2cor*, => mri/orig/COR-)
set scantype = Siemens       # GE,Siemens,noheader,ignoreheader,bshort,afnibrik
set filepatterns = (1/392-4-%03d.ima 2/392-5-%03d.ima) # printf or literal(BRIK)
set firstnumbers = (1 161)   # filepattern(s) ^above^ relative to ~/mri/orig
set registeravg = 0          # registeravg=1: scans in diff orig dirs; 1st=targ
set numslices = 160          # per sequence
set prescale = 1             # short/prescale=>byte (higher if many max's>255)
set flipCORview = NOFLIP     # (MGHsag2cor:"-z y x") (HillcrestUCSD:"x -z -y")
#set thickness = 1.0         # slice thick, mm     (noheader,ignoreheader)
#set fov = 240               # FOV:mm (256*pixsiz) (noheader,ignoreheader)
#set swapbytes = 1           # swapbytes           (noheader,ignoreheader)
#set o2cflags = ""
#### [stop interp: scantype=ignoreheader, thk=1.0, FOV=256; undo after TESSELL]

### TALAIRACH (-talairach: mri_convert,mritotal,mri_add_xform_to_header):xform
set mniproto = icbm    # local/etc/mni_autoreg: icbm,default,marty

### NORMALIZE (-normalize: mri_normalize*): reads talairach transform: orig=>T1
set autonormalize = 1  # if on (1) mri_normalize (needs talairach), else below
# normalize one dir by piecewise linear scale factor (test w/tkmedit first)
set normdir = 1        # 0=PostAnt, 1=InfSup, 2=LeftRight
set lim3 = 170         # coord of image (tkmedit left-click)
set ffrac3 = 1.0       # brightness scale at coord=lim3 (flat to coord=255)
set lim2 = 145
set ffrac2 = 1.0       # bright scale at coord=lim2 (lin interp to coord=lim3)
set lim1 = 95
set ffrac1 = 1.0
set lim0 = 75
set ffrac0 = 1.0

### STRIPSKULL (-stripskull: tktrishrink*, brain.dat)
set fzero = 40     # (40) brain: higher=>more eroded
set fmax = 130     # (130) outer: lower=>more eroded (ifMRI>:fc0=0;out-fc1=neg)
set dfrac = 0.7    # starting dia of icos => fraction image bounding box
set istilt = 1.0   # inside stilt mm

### TRUNCATE/WHITE MATTER FILTER (-wmfilter: wmfilter*, wmfilter.dat)
# whitelims=>0, then planefilter (graylim: high=>more floss) interactive:trunc
set white_hilim = 140  # (140) pretrunc: above=>black (set just above wm)
set white_lolim = 80   # (80) pretrunc: below=>black (set just below wm)
set gray_hilim = 100   # (100) wmfilter: below=>black (set between above two)

### FILL WHITE MATTER (-initfill,-dofill: mkfilldat*, fill.dat, fill*)
# auto: -initfill -dofill
# manual: tkmedit left-click for nums; edit mksurface.dat; -initfill -dofill
set manualfilldat = 0    # if 0, next parms overwritten by output of autoinit
# seeds 
set nseed = 2
set seed1 = "112 157 128 80"  # RH: imnr:pos->ant  i:sup->inf  j:R->L  fillval
set seed2 = "112 157 132 255" # LH: imnr:pos->ant  i:sup->inf  j:R->L  fillval
# callosal/midsagittal cutting box
set callosal_imnr =  "82 160"    # post-ant extent of callosum
set callosal_i =      "0 160"    # zero to superior extent of callosum
set callosal_j =    "128 130"    # 2 pix wide right/left at callosal midline
# midbrain cutting box
set midbrain_imnr =  "95 121"    # post-ant extent of midbrain
set midbrain_i =    "110 112"    # 2 pix inf/sup at bottom (inferior) midbrain
set midbrain_j =    "113 147"    # right/left extent of midbrain
# fill limits (not normally reset)
set max_fill_iter = 10           # (10,20) max number of horiz S-wiggles filled
set min_filled_per_cyc = 100     # (100,0) thresh before reversing fill direct.
set max_same_neigh = 10          # (10,8) wormhole filter (higher more eroded)

### TESSELLATE (reset these only to fix resolution-saving nointerp -convert)
set rhlhscale = 1.0
set antpostscale = 1.0
set supinfscale = 1.0

### INFLATE (-inflate: tksurfer*, inflate.tcl) (not normally reset)
set inflate_cthk = 1.0
set inflate_mmid = 45.0
set inflate_whitemid = 45.0
set inflate_graymid = 30.0

### PLUMP (-plump: tksurfer*, plump.tcl)
set plump_cthk = 4.0
set plump_mmid = 80.0
set plump_whitemid = 80.0
set plump_graymid = 80.0

### FLATTEN (-flatten: tksurfer*, flatten.tcl)
set shrinkcycles = 100         # origflatten=50; flattenmore=50
# default view: patch (makes position.tcl read by funct painting scripts)
set rh_patch_zrot = 90
set rh_patch_scale = 1.4
set rh_patch_xtrans = 0.0
set rh_patch_ytrans = 0.0
set lh_patch_zrot = 90
set lh_patch_scale = 1.4
set lh_patch_xtrans = 0.0
set lh_patch_ytrans = 0.0
# default view: unfoldfull
set rh_full_zrot = 90
set rh_full_scale = 0.7
set rh_full_xtrans = 0.0
set rh_full_ytrans = 0.0
set lh_full_zrot = 90
set lh_full_scale = 0.7
set lh_full_xtrans = 0.0
set lh_full_ytrans = 0.0

###### next only for bem (OK to omit)
### INNER SKULL (-innerskull: trishrink*, inner_skull.dat)
set isku_fzero = 20
set isku_fmax = 100
set isku_dfrac = 1.1
set isku_istilt = 4.0

### OUTER SKULL (-outerskull: trishrink*, outer_skull.dat)
set osku_fzero = 40
set osku_fmax = 255
set osku_dfrac = 1.5
set osku_istilt = 5.0

### OUTER SKIN (-outerskin: trishrink*, outer_skin.dat)
set oski_fzero = 40
set oski_fmax = 255
set oski_dfrac = 1.2
set oski_istilt = 3.0

### end mksurface.dat
# (mksubjdirs awk looks for previous line)
##########################################################################
# don't clutter default parmfile
#set invert = 1           # invert contrast      (not usually used--for 3DFSE)
set skipstrip = 0         # if on (=1) just copy T1 to brain
set skiparea = 0          # skip area correct for quick topology test
set planefilterflag = 1   # (1) set=0 to turn off plane filter (bucky)
set wmfilter_minim = 0    # (0)   (reset to filter a few images)
set wmfilter_maxim = 255  # (255) (reset to filter a few images)
##########################################################################
onintr rmtmp

# read in non-default parms if there
set parmfile = mksurface.dat
echo ""
if (-e $parmfile) then
  csh $parmfile >& /tmp/TestDatFile
  if ($status) then
    echo "mksurface: ### found syntax error reading local mksurface.dat"
    cat /tmp/TestDatFile
    rm /tmp/TestDatFile
    exit
  endif
  echo "mksurface: source local parmfile:   ./$parmfile"
  source $parmfile
  set default = 0
  set d = $cwd;             set r = `basename $d`       # def:"scripts"
  set dp = `dirname $d`;    set rp = `basename $dp`     # def:$name
  if ($rp != $name) then
    echo "mksurface: ### operating on subject <$name> but in <$rp> scriptsdir"
  endif
else
  echo "mksurface: ### local $parmfile not found"
  set d = $cwd;             set r = `basename $d`       # def:"scripts"
  set dp = `dirname $d`;    set rp = `basename $dp`     # def:$name
  set dpp = `dirname $dp`;  set rpp = `basename $dpp`   # def:"subjects"
  if ($r == "scripts") then
    set name = $rp
    if ($rpp == `basename $SUBJECTS_DIR`) then
      echo "mksurface: in scripts dir in SUBJECTS_DIR"
    else
      echo "mksurface: ### in scripts dir in non-cshrc subjects dir"
    endif
    echo "mksurface: change name in mksurface.dat to $name"
  endif
  set default = 1
endif
if (`basename $cwd` != "scripts") then
  echo 'mksurface: ### N.B.: not in a "scripts" dir'
endif

### force correct paths (resurrect: tcl done
#setenv TCL_LIBRARY $LOCAL_DIR/lib/tcl7.4
#setenv TK_LIBRARY $LOCAL_DIR/lib/tk4.0
#set bindir = $CSURF_DIR/bin/`uname -s`
set onearch = `$CSURF_DIR/bin/noarch/getonearch`
set bindir = $CSURF_DIR/bin/$onearch
#set locbin = $LOCAL_DIR/bin/`uname -s`  # TODO: talairach moved (Linux only)
#set loclib = $LOCAL_DIR/lib             # TODO: talairach moved (Linux only)
set scriptsdir = $CSURF_DIR/lib/tcl

### single comment-outs for resurrection, double comment-outs are old
if ($#argv < 1) then
  echo ""
  echo "usage: mksurface [-lh or -rh] [-action] ...         [name: $name]"
  echo ""
  echo "           ACTIONS (multiple actions done in order below)"
  echo "   -mkparmfile : make default mksurface.dat parmfile in cwd"
#  echo "      -convert : convert/avg from raw MRIformat(orig/[subdir] => orig)"
#  echo "    -talairach : generate orig => average Talairach transform"
#  echo "    -normalize : normalize image brightness (orig=>T1)"
#  echo "   -stripskull : strip skull w/hull (brain.dat; brain/COR-; brain.tri)"
  echo "     -wmfilter : run gray/white matter filter (wmfilter.dat; brain => wm)"
#  echo "         -edit : use tkmedit to edit wm for re-fill; wm)"
  echo "     -initfill : init seeds,cutplanes,2hemi--auto or manual (fill.dat)"
## echo "     -readfill : cp fill.dat seeds,cutplanes,2hemi into mksurface.dat"
  echo "       -dofill : fill both hemis (script can override; wm => filled)"
  echo "   -tessellate : tessellate both hemispheres (filled => rh,lh.orig)"
  echo "      -inflate : smth,infl surfs (?h.curv/sulc/area/smoothwm/inflated)"
#  echo "       -remake : shortcut: initfill,dofill,tessellate,inflate"
#  echo "   -viewfolded : view folded (?h.smoothwm)"
#  echo " -viewinflated : view inflated (?h.inflated)"
## echo "        -plump : plump surfaces (?h.plump)"
## echo "  -viewplumped : view plump (?h.plump)"
#  echo "  -cutinflated : interact cutinfl (?h.occip.patch.3d;?h.full.patch.3d)"
  echo " -flattenpatch : flatten cut-off patches (?h.occip.patch.flat); redo OK"
  echo "  -flattenfull : flatten full nomid hemi (?h.full.patch.flat); redo OK"
#  echo "     -viewcuts : view cuts on unfolded (?h.occip/full.patch.3d)"
#  echo "-viewflattened : view flatten (?h.occip/full.patch.flat)"
#  echo "     -savergbs : save unfolded and flattened rgbs"
## echo "      -cleanup : remove stray tmp dat files"
  echo "       -lh,-rh : modifiers: just do one hemi if possible (default:both)"
## echo "   -innerskull : bem only (inner_skull.dat; inner_skull.tri)"
## echo "   -outerskull : bem only (outer_skull.dat; outer_skull.tri)"
## echo "    -outerskin : bem only (outer_skin.dat; outer_skin.tri)"
## echo "       -tridec : bem only (decimated version of in/outskull,inskin)"
##  if (! -e $SUBJECTS_DIR/$name) then
##    echo ""
##    echo "  first run:  mknewsubj <subj_name> <subjectsdir>"
##  endif
  echo ""
  echo " [bins: $bindir, v31]"
  echo ""
  exit
endif

if ($name == "nobody" && ! $default) then
  echo ""
  echo "mksurface: ### change name (currently: 'nobody') in $parmfile"
  echo ""
endif

set convert = 0
set talairach = 0
set normalize = 0
set stripskull = 0
set wmfilter = 0
set edit = 0
set initfill = 0
set dofill = 0
set tessellate = 0
set cutinflated = 0
set inflate = 0
set remake = 0
set plump = 0
set flattenpatch = 0
set flattenfull = 0
set viewfolded = 0
set viewplumped = 0
set viewinflated = 0
set viewcuts = 0
set viewflattened = 0
set savergbs = 0
set innerskull = 0
set outerskull = 0
set outerskin = 0
set tridec = 0
set cleanup = 0
set mkparmfile = 0
set readfill = 0

set right = 1
set left = 1
set mkpositiontcl = 0

set i = 1
while ($i <= $#argv)
    switch ("$argv[$i]")
      case '-convert':
        set convert = 1
      breaksw
      case '-talairach':
        set talairach = 1
      breaksw
      case '-normalize':
        set normalize = 1
      breaksw
      case '-stripskull':
        set stripskull = 1
      breaksw
      case '-wmfilter':
        set wmfilter = 1
      breaksw
      case '-edit':
        set edit = 1
      breaksw
      case '-initfill':
        set initfill = 1
      breaksw
      case '-dofill':
        set dofill = 1
      breaksw
      case '-tessellate':
        set tessellate = 1
      breaksw
      case '-inflate':
        set inflate = 1
      breaksw
      case '-remake':
        set initfill = 1
        set dofill = 1
        set tessellate = 1
        set inflate = 1
      breaksw
      case '-plump':
        set plump = 1
      breaksw
      case '-cutinflated':
        set cutinflated = 1
      breaksw
      case '-flattenpatch':
        set flattenpatch = 1
        set mkpositiontcl = 1
      breaksw
      case '-flattenfull':
        set flattenfull = 1
        set mkpositiontcl = 1
      breaksw
      case '-viewfolded':
        set viewfolded = 1
      breaksw
      case '-viewplumped':
        set viewplumped = 1
      breaksw
      case '-viewinflated':
        set viewinflated = 1
      breaksw
      case '-viewcuts':
        set viewcuts = 1
      breaksw
      case '-viewflattened':
        set viewflattened = 1
        set mkpositiontcl = 1
      breaksw
      case '-savergbs':
        set savergbs = 1
        set mkpositiontcl = 1
      breaksw
      case '-innerskull':
        set innerskull = 1
      breaksw
      case '-outerskull':
        set outerskull = 1
      breaksw
      case '-outerskin':
        set outerskin = 1
      breaksw
      case '-tridec':
        set tridec = 1
      breaksw
      case '-cleanup':
        set cleanup = 1
      breaksw
      case '-mkparmfile':
        set mkparmfile = 1
      breaksw
      case '-readfill':
        set readfill = 1
      breaksw
      case '-rh':
        set left = 0
      breaksw
      case '-lh':
        set right = 0
      breaksw
      default:
        echo " => $argv[$i] <=   bad arg"
        exit
      breaksw
    endsw
    @ i++
end

if ($default && ! $mkparmfile) then
  echo "mksurface: ### to make default: mksurface -mkparmfile"
  exit
endif

set actions = 0
@ actions = ($convert + $talairach + $normalize + $stripskull + $wmfilter \
       + $edit + $initfill + $dofill + $tessellate + $cutinflated + $inflate \
       + $plump + $flattenpatch + $flattenfull + $viewcuts + $viewflattened \
       + $savergbs + $innerskull + $outerskull + $outerskin + $tridec \
       + $cleanup + $mkparmfile + $readfill + $viewfolded + $viewinflated \
       + $viewplumped)
if ($actions == 0) echo "mksurface: ### no actions selected"

set hemilist = ""
if ($right) set hemilist = ($hemilist rh)
if ($left)  set hemilist = ($hemilist lh)

if ($name == "nobody" && ! $mkparmfile) exit

# tmp
set tmptcl = /tmp/TmpTclProg.$$    # pid
set tmpawk = /tmp/TmpAwkProg.$$

#echo "mksurface: sourcing local parmfile: ./$parmfile"
echo "mksurface: current SUBJECTS_DIR:     $SUBJECTS_DIR"
echo "mksurface: working on subject:       $name"
##########################################################################
# convert raw images to COR format, possibly registering before average
if ($convert) then
  if ($?sag2corflip) then  # backward compat
    if ($sag2corflip) then
      set flipCORview = "-z y x"
      echo "mksurface: ### default MGH sag2cor flip: set flipCORview = -z y x"
    endif
  endif
  if ($?fileprefix) then  # backward compat
    set filepatterns = ( $fileprefix )
  endif
  if ($#filepatterns != $#firstnumbers) then
    echo "mksurface: ### list length of filepatterns, firstnumbers don't match"
    exit
  endif
  set options = (-p $prescale)
  if ($?thickness) then
    if ($thickness != 0) set options = ($options -t $thickness)
  endif
  if ($?fov) then
    if ($thickness != 0) set options = ($options -f $fov)
  endif
  if ($?invert) then
    if ($invert)  set options = ($options -i)
  endif
  if ($?swapbytes) then
     if ($swapbytes)  set options = ($options -s)
  endif
  if ($?o2cflags) then
    if ("$o2cflags" != "") set options = ($options $o2cflags)
  endif
  # default orig2cor is now noflip
  ### register before average
  if ($registeravg) then
    echo "#####################################################################"
    echo "mksurface: (1) covert separately, (2) register each to first, (3) avg"
    echo "#####################################################################"
    set regdirlist = ()
    foreach patt ($filepatterns)
      # check if in subdirs, make dirlist
      set regdir = `dirname $patt`
      if ($regdir == ".") then
        echo \
         "mksurface: ### scans must be in separate orig subdirs for registeravg"
        exit
      endif
      set regdirlist = ($regdirlist $regdir)
    end
    # convert each one to COR
    set i = 1
    while ($i <= $#filepatterns)
      # left trim regdir (regdir may be composite path) since we go in there
      set tmppatt = $filepatterns[$i]
      set filepattern = `basename $filepatterns[$i]`
      while (`dirname $tmppatt` != "$regdirlist[$i]")
        set tmppatt = `dirname $tmppatt`
        set filepattern = `basename $tmppatt`/$filepattern
      end
      set intercalated = ($filepattern $firstnumbers[$i])
      set currorig = $SUBJECTS_DIR/$name/mri/orig/$regdirlist[$i]
      pushd $currorig
        if (-e COR-255) then
          echo "mksurface: ### converted scan already there in $regdirlist[$i]"
          echo "mksurface: ### skipped convert (flip)"
          echo "mksurface: ### re-convert: ctrl-C"
          echo "mksurface:                 rm $currorig/COR-*"
          echo "mksurface:                 mksurface -convert"
        else
          echo \
        "mksurface: orig2cor $options $scantype local $intercalated $numslices"
          $bindir/orig2cor $options $scantype local $intercalated $numslices
          if ($status) then
            echo "mksurface: ### conversion (orig2cor) failed"
            exit
          endif
          # abusable flip (flip each each to-be-reg so tkregister buttons right)
          if ("$flipCORview" != "NOFLIP") then    # var needs quotes
            echo "mkfunct: ### flipping struct--N.B.: may mirror dataset"
            echo "mkfunct: tkmedit: flip_corview_xyz $flipCORview"
            echo "flip_corview_xyz $flipCORview" > $tmptcl
            echo "write_images"                 >> $tmptcl
            echo "exit"                         >> $tmptcl
            $bindir/tkmedit local -tcl $tmptcl
            rm -f $tmptcl
          endif
        endif
      popd
      @ i++
    end
    # first is target, register rest of list to targ
    set regtarg = $regdirlist[1]
    pushd $SUBJECTS_DIR/$name/mri/orig/$regtarg
      echo "mksurface: make default register.dat (identity) for target"
      $bindir/tkregister -readinfo
    popd
    set i = 2
    while ($i <= $#regdirlist)
      echo "================================================================="
      echo "mksurface: interactive reg: orig/$regdirlist[$i] => orig/$regtarg"
      echo "mksurface:   SAVEREG and QUIT to start next"
      echo "================================================================="
      echo "tkregister $name orig/$regdirlist[$i] orig/$regtarg"
      $bindir/tkregister $name orig/$regdirlist[$i] orig/$regtarg
      @ i++
    end
    # average
    set prefregdirlist = ()   # regcor needs orig/ prefixes
    set i = 1
    while ($i <= $#regdirlist)
      set prefregdirlist = ($prefregdirlist orig/$regdirlist[$i])
      @ i++
    end
    echo "regcor $name $prefregdirlist orig"  # output alongside subdirs
    $bindir/regcor $name $prefregdirlist orig   # copies COR-.info from target
    if ($status) then
      echo "mksurface: ### regcor failed"
      exit
    endif
    foreach regdir ($regdirlist)
      echo "mksurface: rm tmp single-scan COR in: orig/$regdir"
      rm -f $SUBJECTS_DIR/$name/mri/orig/$regdir/COR-???  # leave register.dat
    end
  ### or simple average
  else
    set intercalated = ()
    set i = 1
    while ($i <= $#filepatterns)
      set intercalated = ($intercalated $filepatterns[$i] $firstnumbers[$i])
      @ i++
    end
    echo "mksurface: orig2cor $options $scantype $name $intercalated $numslices"
    $bindir/orig2cor $options $scantype $name $intercalated $numslices
    if ($status) then
      echo "mksurface: ### conversion (orig2cor) failed"
      exit
    endif
    # abusable flip (after no reg average)
    if ("$flipCORview" != "NOFLIP") then    # var needs quotes
      echo "mkfunct: ### flipping struct--N.B.: may mirror dataset"
      echo "mkfunct: tkmedit: flip_corview_xyz $flipCORview"
      echo "flip_corview_xyz $flipCORview" > $tmptcl
      echo "write_images"                 >> $tmptcl
      echo "exit"                         >> $tmptcl
      $bindir/tkmedit $name orig -tcl $tmptcl
      rm -f $tmptcl
    endif
  endif
  pushd $SUBJECTS_DIR/$name/mri/orig
  cp COR-.info ../T1/COR-.info
  cp COR-.info ../brain/COR-.info
  cp COR-.info ../wm/COR-.info
  cp COR-.info ../filled/COR-.info
  echo "mksurface: copied COR-.info from orig => T1,brain,wm,filled"
  popd
  #echo "mksurface: orig images => COR format (to view:  tkmedit $name orig)"
  echo "mksurface: view orig images: tkmedit $name orig"
  $bindir/tkmedit $name orig
endif

##########################################################################
# MNI make talairach transform matrix
if ($talairach) then
  # mri_convert (fischl), mritotal (perl script calling many binaries)

  set moveable = notfound
  foreach subdir (orig T1)
    if (-e $SUBJECTS_DIR/$name/mri/$subdir/COR-.info) then
      set moveable = $subdir
      echo "mksurface: aligning COR (from $subdir) to MNI 305-brain avg"
      break
    endif
  end
  if ($moveable == "notfound") then
    echo "mksurface: ### data to align not found (tried orig, T1)  ...quitting"
    exit
  endif

  set cordir = $SUBJECTS_DIR/$name/mri/$moveable
  set mincfile = $cordir/$moveable.mnc
  set logfile = $cordir/$moveable.log
  set xformfile = $SUBJECTS_DIR/$name/mri/transforms/talairach.xfm

  if (-e $xformfile) mv $xformfile $xformfile~
  if (! -e $SUBJECTS_DIR/$name/mri/transforms) then
    mkdir $SUBJECTS_DIR/$name/mri/transforms
  endif

  ### use MNI stuff in ~/local
  set path = ($locbin $path)                       # so mritotal can find stuff
  setenv PERL5LIB        $loclib/mni_autoreg/perl  # MNI-specific perl
  setenv MNI_CONFIG_PATH $loclib/mni_autoreg/cfg   # needs mritotal hack
  set mnimodeldir =      $loclib/mni_autoreg/model # 305 brain average,blurs
  echo "mksurface: mri_convert $cordir $mincfile"
  $bindir/mri_convert $cordir $mincfile
  echo "mksurface: mritotal -clobber -protocol $mniproto $mincfile $xformfile"
  mritotal -clobber \
           -modeldir $mnimodeldir \
           -protocol $mniproto \
           $mincfile $xformfile |& tee $logfile

  if (-e $mincfile) rm $mincfile
  if (! -e $xformfile) then
    echo "mksurface: ### auto-talairach (mritotal) failed  ...quitting"
    if (-e $xformfile~) mv $xformfile~ $xformfile
    exit
  endif
  echo "mksurface: Talairach transformation file written to:"
  echo "   $xformfile"

  # insert transform filename into each COR-.info file
  cat << END0 > $tmpawk
  {
    if (\$1 == "ti") {
      print \$0; print "xform `basename $xformfile`"
    } else {
      if (\$1 != "xform") {
        print
      }
    }
  }
END0
  foreach subdir (orig T1 brain wm filled)
    set headerfile = $SUBJECTS_DIR/$name/mri/$subdir/COR-.info 
    if (! -e $headerfile) then
      echo "mksurface: ### $headerfile missing  ...not updated"
    else
      mv $headerfile $headerfile~
      awk -f $tmpawk $headerfile~ > $headerfile
      echo "mksurface: updated COR-.info in $subdir"
    endif
  end
  rm $tmpawk

endif

##########################################################################
# normalize brightness, COR images (mri_normalize needs talairach transform)
if ($normalize) then
  if (-e $SUBJECTS_DIR/$name/mri/T1/COR-001) then
    echo "mksurface: ### T1 images exist--overwriting (ctrl-C to quit)"
  endif
  if ($autonormalize) then
    set xformfile = $SUBJECTS_DIR/$name/mri/transforms/talairach.xfm
    if (! -e $xformfile) then
      echo "mksurface: ### $xformfile not found"
      echo "mksurface:   ==> first run -talairach"
    else
      echo "mksurface: mri_normalize $SUBJECTS_DIR/$name/mri/orig"
      echo "                         $SUBJECTS_DIR/$name/mri/T1"
      $bindir/mri_normalize \
         $SUBJECTS_DIR/$name/mri/orig $SUBJECTS_DIR/$name/mri/T1
    endif
  else
    if ($?ilim0 || $?ilim1 || $?ilim2 || $?ilim3) then   # backwards compat
      set lim0 = $ilim0; set lim1 = $ilim1;
      set lim2 = $ilim2; set lim3 = $ilim3;
    endif
    echo "mkfunct: tkmedit: norm_allslices $normdir"
    echo "setfile abs_imstem ~/mri/T1/COR-"    > $tmptcl
    echo "set lim0 $lim0; set ffrac0 $ffrac0" >> $tmptcl
    echo "set lim1 $lim1; set ffrac1 $ffrac1" >> $tmptcl
    echo "set lim2 $lim2; set ffrac2 $ffrac2" >> $tmptcl
    echo "set lim3 $lim3; set ffrac3 $ffrac3" >> $tmptcl
    echo "norm_allslices $normdir"            >> $tmptcl
    echo "write_images"                       >> $tmptcl
    echo "exit"                               >> $tmptcl
    $bindir/tkmedit $name orig -tcl $tmptcl
    rm -f $tmptcl
  endif
  echo "mksurface: normalized images => COR format (to view:  tkmedit $name T1)"
endif

##########################################################################
# remove skull (brain.csh)
if ($stripskull) then
  if (-e $SUBJECTS_DIR/$name/mri/brain/COR-001) then
    echo "mksurface: ### brain images exist--overwriting (ctrl-C to quit)"
  endif
  # tcl script version w/intercalated smooth steps
  if ($skipstrip) then
    echo "mksurface: copying T1 -> brain"
    cp $SUBJECTS_DIR/$name/mri/T1/COR-??? $SUBJECTS_DIR/$name/mri/brain
    # -convert might not have run
    pushd $SUBJECTS_DIR/$name/mri/orig
    cp COR-.info ../T1/COR-.info
    cp COR-.info ../brain/COR-.info
    cp COR-.info ../wm/COR-.info
    cp COR-.info ../filled/COR-.info
    echo "mksurface: copied COR-.info from orig => T1,brain,wm,filled"
    popd
  else
    # setenv (but not set) vars here and in current env passed to tcl scripts
    setenv fzero $fzero
    setenv fmax $fmax
    setenv dfrac $dfrac
    setenv istilt $istilt
    echo "mksurface: tktrishrink $name 0 -tcl stripskull.tcl"
    $bindir/tktrishrink $name 0 -tcl $scriptsdir/stripskull.tcl
    echo \
      "mksurface: skull stripped (to view surf:  tktrishrink -$name brain.tri)"
    echo \
      "                          (to rerun interactively: tktrishrink $name 0)"
  endif
  echo "                          (to view stripped mri: tkmedit $name brain)"
endif

##########################################################################
# truncate and filter (mkwm.csh)
if ($wmfilter) then
  if (-e $SUBJECTS_DIR/$name/mri/wm/COR-001) then
    echo "mksurface: ### wm images exist--overwriting (ctrl-C to quit)"
  endif
  set filter_cycles = 1
  if ($white_hilim < $white_lolim) then
    echo "mksurface: ### white_hilim < white_lolim: would make all black images"
    exit
  endif
  echo "white_hilim $white_hilim"  > wmfilter.dat
  echo "white_lolim $white_lolim" >> wmfilter.dat
  echo "gray_hilim $gray_hilim"   >> wmfilter.dat
  echo "minim $wmfilter_minim"    >> wmfilter.dat
  echo "maxim $wmfilter_maxim"    >> wmfilter.dat
  echo "planefilterflag $planefilterflag"  >> wmfilter.dat

  ### old args 
  #echo "mksurface: wmfilter $name $filter_cycles"
  #$bindir/wmfilter $name $filter_cycles

  ### recompiled
  set invol = $SUBJECTS_DIR/$name/mri/brain
  set outvol = $SUBJECTS_DIR/$name/mri/wm
  echo "mksurface: fill $invol $outvol"
  $bindir/wmfilter $invol $outvol

  echo "mksurface: made white matter images--edit these if needed"
  echo "             to edit:  mksurface -edit (or: tkmedit $name wm)"
  if ($wmfilter_minim != 0 || $wmfilter_maxim != 255) then
    echo "mksurface: ### N.B.: partially filtered wm is unsuitable for fill"
  endif
  rm -f wmfilter.dat
endif

##########################################################################
# edit wm images to remove wormholes
if ($edit) then
  if (`uname -s` == "IRIX" || `uname -s` == "IRIX64") then
    echo "mksurface: disable all hosts w/xhost so send works"
    set machinelist = ""
    foreach word (`xhost`)
      if ($word =~ INET*) then
        set machinelist = ($machinelist `echo $word | awk -F: '{print $2}'`)
      endif
    end
    xhost -
    foreach machine ($machinelist)
      xhost -$machine
    end
  endif
  echo "mksurface: editing white matter images"
  setenv white_hilim $white_hilim
  setenv white_lolim $white_lolim
  setenv gray_hilim $gray_hilim
  set hemisurf = ""
  if ($left)  set hemisurf = lh.orig
  if ($right) set hemisurf = rh.orig
  echo "mksurface: tkmedit $name wm $hemisurf"
  $bindir/tkmedit $name wm $hemisurf
  if (`uname -s` == "IRIX" || `uname -s` == "IRIX64") then
    echo "mksurface: put hosts back as before w/xhost"
    foreach machine ($machinelist)
      xhost +$machine
    end
  endif
endif 

##########################################################################
# auto calc cutting planes, seeds, limits (mkfilldat.csh)
if ($initfill) then
  if ($manualfilldat) then    # use hand-edited
    echo "nseed $nseed"          > fill.dat
    echo "seed1 $seed1"         >> fill.dat
    echo "seed2 $seed2"         >> fill.dat
    echo "imnr  $callosal_imnr" >> fill.dat
    echo "i     $callosal_i"    >> fill.dat
    echo "j     $callosal_j"    >> fill.dat
    echo "imnr  $midbrain_imnr" >> fill.dat
    echo "i     $midbrain_i"    >> fill.dat
    echo "j     $midbrain_j"    >> fill.dat
    echo "max_fill_iter       $max_fill_iter"      >> fill.dat
    echo "min_filled_per_cyc  $min_filled_per_cyc" >> fill.dat
    echo "max_same_neigh      $max_same_neigh"     >> fill.dat
    echo "mksurface: using parmfile fill.dat (overrides output of mkfilldat)"
  else   # autoinit
    echo "mksurface: mkfilldat $name fill.dat"
    $bindir/mkfilldat $name fill.dat
    if ($status) then
      echo "mksurface: ### automatic cutting planes (mkfilldat) failed"
      exit
    endif
    echo "max_fill_iter       $max_fill_iter"      >> fill.dat
    echo "min_filled_per_cyc  $min_filled_per_cyc" >> fill.dat
    echo "max_same_neigh      $max_same_neigh"     >> fill.dat
    # fix hard coded seed val
    set seed1array = ( $seed1 )    # quoted list length = 1
    set seed2array = ( $seed2 )
    cat << END1 > $tmpawk
    BEGIN { printflag = 0; }
    {
      if (\$1=="seed1") { print \$1, \$2, \$3, \$4, $seed1array[4]; continue }
      if (\$1=="seed2") { print \$1, \$2, \$3, \$4, $seed2array[4]; continue }
      print
    }
END1
    awk -f $tmpawk fill.dat > fill.datFIXED
    mv -f fill.datFIXED fill.dat
    rm -f $tmpawk
    echo "mksurface: read autoinit into parmfile for later edit"
    mksurface -readfill
  endif
  echo "mksurface: made fill.dat (to view:  vi fill.dat)"
endif

##########################################################################
# fill white matter (mksurf.csh)
if ($dofill) then
  if (-e $SUBJECTS_DIR/$name/mri/filled/COR-001) then
    echo "mksurface: ### filled images exist--overwriting (ctrl-C to quit)"
  endif
  if ($wmfilter_minim != 0 || $wmfilter_maxim != 255) then
    echo "mksurface: ### partially filtered wm     ...terminated -dofill"
    echo "mksurface:  re-run -wmfilter w/wmfilter_minim=0,wmfilter_maxim=255"
    exit
  endif
  if (! -e fill.dat) then
    echo "mksurface: ### first run:  mksurface -initfill"
  else
    if ($manualfilldat) then   # check for stale fill.dat
      echo "nseed $nseed"          > fill.datTEST
      echo "seed1 $seed1"         >> fill.datTEST
      echo "seed2 $seed2"         >> fill.datTEST
      echo "imnr  $callosal_imnr" >> fill.datTEST
      echo "i     $callosal_i"    >> fill.datTEST
      echo "j     $callosal_j"    >> fill.datTEST
      echo "imnr  $midbrain_imnr" >> fill.datTEST
      echo "i     $midbrain_i"    >> fill.datTEST
      echo "j     $midbrain_j"    >> fill.datTEST
      echo "max_fill_iter       $max_fill_iter"      >> fill.datTEST
      echo "min_filled_per_cyc  $min_filled_per_cyc" >> fill.datTEST
      echo "max_same_neigh      $max_same_neigh"     >> fill.datTEST
      diff fill.dat fill.datTEST > /dev/null
      if ($status) then
        echo "mksurface: ### stale fill.dat, making new one from mksurface.dat"
        mv -f fill.dat fill.dat~
        mv -f fill.datTEST fill.dat
      else
        rm -f fill.datTEST
      endif
    endif
    echo "mksurface: filling right, then left hemisphere (radiological view)"

    ### old args
    #echo "mksurface: fill $name 0"
    #$bindir/fill $name 0

    ### recompiled
    set invol = $SUBJECTS_DIR/$name/mri/wm
    set outvol = $SUBJECTS_DIR/$name/mri/filled
    echo "mksurface: fill $invol $outvol"
    $bindir/fill $invol $outvol

    if ($status) then
      echo "mksurface: ### white matter region-growing (fill) failed"
      exit
    endif
    echo "mksurface: filled both hemispheres (to view:  tkmedit $name filled)"
    rm -f fill.dat
  endif
endif

##########################################################################
# tessellate fill (mksurf.csh)
if ($tessellate) then
  foreach hemi ($hemilist)
    if (-e $SUBJECTS_DIR/$name/surf/$hemi.orig) then
      echo "mksurface: ### $hemi.orig exists--overwriting (ctrl-C to quit)"
    endif
    if ($hemi == "rh") set seedarray = ( $seed1 )  # quoted list length = 1
    if ($hemi == "lh") set seedarray = ( $seed2 )  # ditto
    echo "mksurface: ==== tessellating $hemi ===="
    ### old args
    #echo "mksurface: surf $name $seedarray[4] $hemi"
    #$bindir/surf $name $seedarray[4] $hemi

    ### recompiled
    set invol = $SUBJECTS_DIR/$name/mri/filled
    set outsurf = $SUBJECTS_DIR/$name/surf/$hemi.orig
    echo "mksurface: surf $invol $seedarray[4] $outsurf"
    $bindir/surf $invol $seedarray[4] $outsurf

    if ($status) then
      echo "mksurface: ### tessellation (surf) failed"
      exit
    endif
    if ($rhlhscale != 1.0 || $antpostscale != 1.0 || $supinfscale != 1.0) then
      # possibly correct sub1x1x1 pix not resampled at -convert (to save res)
      # misaligns surf w/MRI (TODO: for plump: redo interp convert)
      echo "mksurface: ### rescaling $hemi.orig to compensate nointerp convert"
      echo "mksurface: ### misaligns surf w/orig,T1 (redo -convert w/interp)"
      echo "really_scale_brain $rhlhscale $antpostscale $supinfscale" \
                                                > $tmptcl
      echo "setfile outsurf ~/surf/$hemi.orig" >> $tmptcl
      echo "write_binary_surface"              >> $tmptcl
      echo "exit"                              >> $tmptcl
      echo "mksurface: tksurfer -$name $hemi orig -tcl $tmptcl"
      $bindir/tksurfer -$name $hemi orig -tcl $tmptcl
      rm -f $tmptcl
    endif
  end
  foreach hemi ($hemilist)
    echo "              (to view $hemi surface:  tksurfer -$name $hemi orig)"
  end
  echo "              (to edit rh+lh:  tkmedit $name wm; SAVEIMG; re-fill)"
endif

##########################################################################
# area-corrected inflate, calc curv and sulc (mksurf.csh)
if ($inflate) then
  # setenv (but not set) vars here and in current env passed to tcl scripts
  if ($skiparea) setenv skiparea TRUE
  setenv cthk $inflate_cthk
  setenv mmid $inflate_mmid
  setenv whitemid $inflate_whitemid
  setenv graymid $inflate_graymid
  foreach hemi ($hemilist)
    if (-e $SUBJECTS_DIR/$name/surf/$hemi.smoothwm) then
      echo "mksurface: ### $hemi.smoothwm exists--overwriting (ctrl-C to quit)"
    endif
    if (-e $SUBJECTS_DIR/$name/surf/$hemi.inflated && ! $skiparea) then
      echo "mksurface: ### $hemi.inflated exists--overwriting (ctrl-C to quit)"
    endif
    echo "mksurface: ==== inflating $hemi ===="
    rm -f $SUBJECTS_DIR/$name/surf/$hemi.area
    #echo "mksurface: tksurfer -$name $hemi orig -tcl inflate.tcl"
    #$bindir/tksurfer -$name $hemi orig -tcl $scriptsdir/inflate.tcl
    #echo "mksurface: $surfprog -$name $hemi orig -tcl inflate.tcl"
    #$bindir/$surfprog -$name $hemi orig -tcl $scriptsdir/inflate.tcl
    ## change default dividequadsflag=1, which tries to write tri file
    echo \
      "mksurface: tksurfer $name $hemi orig -tcl inflate.tcl -dividequadsflag 0"
    $bindir/tksurfer \
      $name $hemi orig -tcl $scriptsdir/inflate.tcl -dividequadsflag 0
  end
  echo "mksurface: refined and inflated hemisphere(s)"
  foreach hemi ($hemilist)
    echo   "    (to view $hemi white matter:  tksurfer -$name $hemi smoothwm)"
    if ($skiparea) then
      echo "mksurface: ### N.B. test inflate: redo for final with skiparea=0"
      echo "    (to view $hemi quick inflate: tksurfer -$name $hemi 1000)"
    else
      echo "    (to view $hemi inflated surf: tksurfer -$name $hemi inflated)"
    endif
  end
endif

##########################################################################
# plump (plump.csh)
if ($plump) then
  if ($rhlhscale != 1.0 || $antpostscale != 1.0 || $supinfscale != 1.0) then
    echo "mksurface: ### rescaled surf: be sure interp -convert has been rerun"
  endif
  # setenv (but not set) vars here and in current env passed to tcl scripts
  setenv cthk $plump_cthk
  setenv mmid $plump_mmid
  setenv whitemid $plump_whitemid
  setenv graymid $plump_graymid
  foreach hemi ($hemilist)
    if (-e $SUBJECTS_DIR/$name/surf/$hemi.plump) then
      echo "mksurface: ### $hemi.plump exists--overwriting (ctrl-C to quit)"
    endif
    echo "mksurface: ==== plumping $hemi ===="
    echo "mksurface: tksurfer $name $hemi smoothwm -tcl plump.tcl"
    # no "-" => reads mri/T1/COR-
    $bindir/tksurfer $name $hemi smoothwm -tcl $scriptsdir/plump.tcl
  end
  echo "mksurface: plumped hemispheres(s)"
  foreach hemi ($hemilist)
    echo "            (to view $hemi plumped:  tksurfer -$name $hemi plump)"
  end
endif

##########################################################################
# interactive cutting (batch script resumes afterward)
if ($cutinflated) then
  #set defaultinpatch = patch-nomid.0
  #set defaultinpatch = patch-nomid.3d
  set defaultinpatch = full.patch.3d
  foreach hemi ($hemilist)
    if (-e $SUBJECTS_DIR/$name/surf/$hemi.$defaultinpatch) then
      echo \
       "mksurface: ### $hemi.$defaultinpatch exists--overwriting (quit:ctrl-C)"
    endif
    echo "mksurface: ==== interactively cut $hemi ===="
    echo "setfile patch ~/surf/$hemi.$defaultinpatch"    > $tmptcl
    echo "open_window; make_lateral_view"               >> $tmptcl
    echo "rotate_brain_y 180; read_binary_curv; redraw" >> $tmptcl
    echo "#################################################################"
    echo "#################################################################"
    echo " 1) left-click vertices, then REGION to make closed-line cut"
    echo " 2) single left-click in region, then FILL to floodfill/save it"
    echo " 3) left-click vertices, then LINE to make open-line relaxation cuts"
    echo " 4) three left-clicks define plane, one in part to keep, then PLANE"
    echo " 5) WRITE to save patch:"
    echo "    occip (init,final):  ?h.occip.patch.3d, ?h.occip.patch.flat"
    echo "     full (init,final):  ?h.full.patch.3d, ?h.full.patch.flat"
    echo " 6) INIT to start over, UNDO to clear last cut"
    echo "#################################################################"
    echo "#################################################################"
    echo "mksurface: tksurfer -$name $hemi inflated -tcl $tmptcl"
    $bindir/tksurfer -$name $hemi inflated -tcl $tmptcl
    rm -f $tmptcl
  end
endif

##########################################################################
# make position.tcl file if not there
if ($mkpositiontcl) then
  if (-e $SUBJECTS_DIR/$name/scripts/position.tcl) then
    mv position.tcl position.tclOLD
  endif
  # write position.tcl
  echo "mksurface: create position.tcl (standard view for rendering scripts)"
  echo "#! /usr/local/bin/tclsh7.4"                       > position.tcl
  echo "###############################################" >> position.tcl
  echo "# used by rendering scripts (funct scripts dir)" >> position.tcl
  echo "###############################################" >> position.tcl
  echo "set rh.patch.flatzrot $rh_patch_zrot"     >> position.tcl
  echo "set rh.patch.flatscale $rh_patch_scale"   >> position.tcl
  echo "set rh.patch.flatxtrans $rh_patch_xtrans" >> position.tcl
  echo "set rh.patch.flatytrans $rh_patch_ytrans" >> position.tcl
  echo "set lh.patch.flatzrot $lh_patch_zrot"     >> position.tcl
  echo "set lh.patch.flatscale $lh_patch_scale"   >> position.tcl
  echo "set lh.patch.flatxtrans $lh_patch_xtrans" >> position.tcl
  echo "set lh.patch.flatytrans $lh_patch_ytrans" >> position.tcl
  echo ""                                         >> position.tcl
  echo "set rh.patch-nomid.1000.flatzrot $rh_full_zrot"     >> position.tcl
  echo "set rh.patch-nomid.1000.flatscale $rh_full_scale"   >> position.tcl
  echo "set rh.patch-nomid.1000.flatxtrans $rh_full_xtrans" >> position.tcl
  echo "set rh.patch-nomid.1000.flatytrans $rh_full_ytrans" >> position.tcl
  echo "set lh.patch-nomid.1000.flatzrot $lh_full_zrot"     >> position.tcl
  echo "set lh.patch-nomid.1000.flatscale $lh_full_scale"   >> position.tcl
  echo "set lh.patch-nomid.1000.flatxtrans $lh_full_xtrans" >> position.tcl
  echo "set lh.patch-nomid.1000.flatytrans $lh_full_ytrans" >> position.tcl
  if (-e $SUBJECTS_DIR/$name/scripts/position.tclOLD) then
    diff position.tcl position.tclOLD > /dev/null
    if ($status) then
      echo "mksurface: ### position.tcl doesn't match mksurface.dat  ...saved"
      mv -f position.tclOLD position.tcl~
    else
      rm -f position.tclOLD
    endif
  endif
endif

##########################################################################
# flatten (flatten.csh, flattenmore.csh)--does flatten or flattenmore
if ($flattenpatch) then
  foreach hemi ($hemilist)
    echo "mksurface: ==== flattening $hemi patch ===="
    # setenv (but not set) vars here (and in curr env) passed to tcl scripts
    if (-e $SUBJECTS_DIR/$name/surf/$hemi.occip.patch.3d) then
      setenv inpatch $hemi.occip.patch.3d
    else if (-e $SUBJECTS_DIR/$name/surf/$hemi.occip.3d) then
      setenv inpatch $hemi.occip.3d
    else if (-e $SUBJECTS_DIR/$name/surf/$hemi.patch.3d) then
      setenv inpatch $hemi.patch.3d
    else if (-e $SUBJECTS_DIR/$name/surf/$hemi.patch) then
      setenv inpatch $hemi.patch
    else
      echo "mksurface: ### input patch for flattenpatch not found"
      echo "mksurface: ### looked in order for: $hemi.occip.patch.3d"
      echo "                                    $hemi.occip.3d"
      echo "                                    $hemi.patch.3d"
      echo "                                    $hemi.patch"
      exit
    endif
    setenv outpatch $hemi.occip.patch.flat
    setenv shrinkcycles $shrinkcycles
    #echo "mksurface: tksurfer -$name $hemi inflated -tcl flatten.tcl"
    #$bindir/tksurfer -$name $hemi inflated -tcl $scriptsdir/flatten.tcl
    echo "mksurface: $surfprog -$name $hemi inflated -tcl flatten.tcl"
    $bindir/$surfprog -$name $hemi inflated -tcl $scriptsdir/flatten.tcl
  end
endif

##########################################################################
# full flatten (flatten.csh)--this does flatten or flattenmore
if ($flattenfull) then
  # setenv (but not set) vars here (and in curr env) passed to tcl scripts
  foreach hemi ($hemilist)
    echo "mksurface: ==== full flatten of $hemi ===="
    #if (-e $SUBJECTS_DIR/$name/surf/$hemi.patch-nomid.1000) then
    #  echo "mksurface: flatten already flattened ($hemi.patch-nomid.1000) more"
    #  echo "mksurface: (to reflatten: ctrl-C, mv $hemi.patch-nomid.1000 aside)"
    #  setenv inpatch $hemi.patch-nomid.1000
    #else  # not unfurled yet (maybe flattened)
    if (-e $SUBJECTS_DIR/$name/surf/$hemi.full.patch.3d) then
      setenv inpatch $hemi.full.patch.3d
    else if (-e $SUBJECTS_DIR/$name/surf/$hemi.full.3d) then
      setenv inpatch $hemi.full.3d
    else if (-e $SUBJECTS_DIR/$name/surf/$hemi.patch-nomid.3d) then
      setenv inpatch $hemi.patch-nomid.3d
    else if (-e $SUBJECTS_DIR/$name/surf/$hemi.patch-nomid.0) then
      setenv inpatch $hemi.patch-nomid.0
    else
      echo "mksurface: ### input patch for fullflatten not found"
      echo "mksurface: ### looked in order for: $hemi.full.patch.3d"
      echo "                                    $hemi.full.3d"
      echo "                                    $hemi.patch-nomid.3d"
      echo "                                    $hemi.patch-nomid.0"
      exit
    endif
    #endif
    setenv outpatch $hemi.full.patch.flat
    setenv shrinkcycles $shrinkcycles
    #echo "mksurface: tksurfer -$name $hemi inflated -tcl flatten.tcl"
    #$bindir/tksurfer -$name $hemi inflated -tcl $scriptsdir/flatten.tcl
    echo "mksurface: $surfprog -$name $hemi inflated -tcl flatten.tcl"
    $bindir/$surfprog -$name $hemi inflated -tcl $scriptsdir/flatten.tcl
    echo "        (to view flattened ${hemi}: mksurface -$hemi -viewflattened)"
    echo "        (to view flattened ${hemi}: mksurface -$hemi -viewflattened)"
  end
endif

##########################################################################
# view folded
if ($viewfolded) then
  foreach hemi ($hemilist)
    echo "open_window; read_binary_curv"               > $tmptcl
    echo "make_lateral_view; scale_brain 1.5; redraw" >> $tmptcl
    echo "mksurface: tksurfer -$name $hemi smoothwm -tcl $tmptcl"
    $bindir/tksurfer -$name $hemi smoothwm -tcl $tmptcl
    rm -f $tmptcl
  end
endif

##########################################################################
# view plump 
if ($viewplumped) then
  foreach hemi ($hemilist)
    echo "open_window; read_binary_curv"  > $tmptcl
    echo "make_lateral_view; redraw"     >> $tmptcl
    echo "mksurface: tksurfer -$name $hemi plump -tcl $tmptcl"
    $bindir/tksurfer -$name $hemi plump -tcl $tmptcl
    rm -f $tmptcl
  end
endif

##########################################################################
# view inflated
if ($viewinflated) then
  foreach hemi ($hemilist)
    echo "open_window; read_binary_curv"  > $tmptcl
    echo "make_lateral_view; redraw"     >> $tmptcl
    echo "mksurface: tksurfer -$name $hemi inflated -tcl $tmptcl"
    $bindir/tksurfer -$name $hemi inflated -tcl $tmptcl
    rm -f $tmptcl
  end
endif

##########################################################################
# interactive cutting (batch script resumes afterward)
if ($viewcuts) then
  foreach hemi ($hemilist)
    foreach patchname (full.patch.3d occip.patch.3d patch.3d patch-nomid.3d)
      if (! -e $SUBJECTS_DIR/$name/surf/$hemi.$patchname) continue
      echo "setfile patch ~/surf/$hemi.$patchname"         > $tmptcl
      echo "open_window; make_lateral_view"               >> $tmptcl
      echo "read_binary_patch; set flag2d 0; restore"     >> $tmptcl
      echo "rotate_brain_y 180; read_binary_curv; redraw" >> $tmptcl
      echo "mksurface: tksurfer -$name $hemi inflated -tcl $tmptcl"
      $bindir/tksurfer -$name $hemi inflated -tcl $tmptcl
      rm -f $tmptcl
    end
  end
endif

##########################################################################
# view flatten
if ($viewflattened) then
  set patchlist = ( full.patch.flat occip.patch.flat patch patch-nomid.1000 )
  foreach hemi ($hemilist)
    foreach patch ($patchlist)
      if (! -e $SUBJECTS_DIR/$name/surf/$hemi.$patch) continue
      setenv patchname $patch   # here so setdefpatch resets def patchname
      echo "source $CSURF_DIR/lib/tcl/setdefpatchview.tcl" > $tmptcl
      echo "setfile patch ~/surf/$hemi.$patch"           >> $tmptcl
      echo "read_binary_curv; read_binary_patch"         >> $tmptcl
      echo "open_window"                                 >> $tmptcl
      echo "restore_zero_position; rotate_brain_x -90"   >> $tmptcl
      # use tcl vars set using position.tcl (single quote saves $)
      echo 'rotate_brain_z $flatzrot'                    >> $tmptcl
      echo 'translate_brain_x $flatxtrans'               >> $tmptcl
      echo 'translate_brain_y $flatytrans'               >> $tmptcl
      echo 'scale_brain $flatscale'                      >> $tmptcl
      echo "redraw"                                      >> $tmptcl
      echo "mksurface: tksurfer -$name $hemi inflated -tcl $tmptcl"
      $bindir/tksurfer -$name $hemi inflated -tcl $tmptcl
      rm -f $tmptcl
    end
  end
endif

##########################################################################
# save curvature rgbs
if ($savergbs) then
  set patchlist = ( full.patch.flat occip.patch.flat patch patch-nomid.1000 )
  set surflist = ( inflated )   # or add: smoothwm
  set viewlist = ( lat med ven pos )
  foreach view ($viewlist)
    setenv $view
  end
  foreach hemi ($hemilist)
    foreach surf ($surflist)    # folded/unfolded
      if (! -e $SUBJECTS_DIR/$name/surf/$hemi.$surf) continue
      tksurfer -$name $hemi $surf -tcl $scriptsdir/curv-views.tcl
    end
    foreach patch ($patchlist)  # flattened
      if (! -e $SUBJECTS_DIR/$name/surf/$hemi.$patch) continue
      setenv patchname $patch
      $bindir/tksurfer -$name $hemi inflated -tcl $scriptsdir/curv-flat.tcl
    end
  end
endif

##########################################################################
# for bem: make innerskull surface (inner_skull.csh)
if ($innerskull) then
  echo "fzero $isku_fzero"    > inner_skull.dat
  echo "fmax $isku_fmax"     >> inner_skull.dat
  echo "dfrac $isku_dfrac"   >> inner_skull.dat
  echo "istilt $isku_istilt" >> inner_skull.dat
  echo "mksurface: trishrink $name 2"
  $bindir/trishrink $name 2 
  echo "mksurface: innerskull surf (view:  tktrishrink -$name inner_skull.tri)"
  rm -f inner_skull.dat
endif

##########################################################################
# for bem: make outerskull surface (outer_skull.csh)
if ($outerskull) then
  echo "fzero $osku_fzero"    > outer_skull.dat
  echo "fmax $osku_fmax"     >> outer_skull.dat
  echo "dfrac $osku_dfrac"   >> outer_skull.dat
  echo "istilt $osku_istilt" >> outer_skull.dat
  echo "mksurface" trishrink $name 3"
  $bindir/trishrink $name 3
  echo "mksurface: outerskull surf (view:  tktrishrink -$name outer_skull.tri)"
  rm -f outer_skull.dat
endif

##########################################################################
# for bem: make outerskin surface (outer_skin.csh)
if ($outerskin) then
  echo "fzero $oski_fzero"    > outer_skin.dat
  echo "fmax $oski_fmax"     >> outer_skin.dat
  echo "dfrac $oski_dfrac"   >> outer_skin.dat
  echo "istilt $oski_istilt" >> outer_skin.dat
  #echo "mksurface: trishrink $name 4"
  #$bindir/trishrink $name 4
  echo "mksurface: tktrishrink $name 4"
  $bindir/tktrishrink $name 4 
  echo "mksurface: outerskin surf (view:  tktrishrink -$name outer_skin.tri)"
  rm -f outer_skin.dat
endif

##########################################################################
if ($tridec) then
  tridec $name inner_skull.tri ic3.tri inner_skull642.tri
  tridec $name outer_skull.tri ic3.tri outer_skull642.tri
  tridec $name outer_skin.tri ic3.tri outer_skin642.tri
  echo "mksurface: made decimated inner_skull, outer_skull, outer_skin"
  echo "         (to view inner skull: tktrishrink -$name inner_skull642.tri)"
  echo "         (to view outer skull: tktrishrink -$name outer_skull642.tri)"
  echo "         (to view outer skin:  tktrishrink -$name outer_skin642.tri)"
endif

##########################################################################
# make parmfile in cwd from header to this script
if ($mkparmfile) then
  cat << END2 > $tmpawk
  BEGIN { printflag = 0; }
  {
    if (\$2=="mksurface.dat:" && \$3=="parmfile") { printflag = 1 }
    if (\$2=="end" && \$3=="mksurface.dat")       { printflag = 0 }
    if (\$1=="set" && \$2=="name" && \$4=="nobody") {
      print "set name = $name"
      printflag = 2
    }
    if (printflag==1) { print }
    if (printflag==2) { printflag = 1 }
  }
END2
  set src = $CSURF_DIR/bin/noarch/mksurface
  if (-e $parmfile) then
    echo "mksurface: ### $parmfile already exists--move aside to make new"
  else
    awk -f $tmpawk $src > $parmfile
    echo "mksurface: made default parmfile in cwd: $parmfile"
  endif
  rm -f $tmpawk
endif

##########################################################################
# read ./fill.dat into mksurface.dat (for template; origvals=>comments)
if ($readfill) then
  if (! -e fill.dat) then
    echo "mksurface: ### fill.dat (to incorporate) not found"
  else
    set nseed         = `cat fill.dat | awk '{if(NR==1) print $2}'`
    set seed1         = `cat fill.dat | awk '{if(NR==2) print $2, $3, $4, $5}'`
    set seed2         = `cat fill.dat | awk '{if(NR==3) print $2, $3, $4, $5}'`
    set callosal_imnr = `cat fill.dat | awk '{if(NR==4) print $2, $3}'`
    set callosal_i    = `cat fill.dat | awk '{if(NR==5) print $2, $3}'`
    set callosal_j    = `cat fill.dat | awk '{if(NR==6) print $2, $3}'`
    set midbrain_imnr = `cat fill.dat | awk '{if(NR==7) print $2, $3}'`
    set midbrain_i    = `cat fill.dat | awk '{if(NR==8) print $2, $3}'`
    set midbrain_j    = `cat fill.dat | awk '{if(NR==9) print $2, $3}'`
    if (`cat fill.dat | wc -l` > 9) then
      set max_fill_iter      = `cat fill.dat | awk '{if(NR==10) print $2}'`
      set min_filled_per_cyc = `cat fill.dat | awk '{if(NR==11) print $2}'`
      set max_same_neigh     = `cat fill.dat | awk '{if(NR==12) print $2}'`
    endif

    cat << END3 > $tmpawk
    {
      printflag = 1;
      ORS = " ";
      if (\$1=="set" && \$2=="nseed") {
        print "set nseed = $nseed"; printflag = 0;
      }
      if (\$1=="set" && \$2=="seed1") {
        print "set seed1 = \"$seed1\""; printflag = 0;
      }
      if (\$1=="set" && \$2=="seed2") {
        print "set seed2 = \"$seed2\""; printflag = 0;
      }
      if (\$1=="set" && \$2=="callosal_imnr") {
        print "set callosal_imnr = \"$callosal_imnr\""; printflag = 0;
      }
      if (\$1=="set" && \$2=="callosal_i") {
        print "set callosal_i = \"$callosal_i\""; printflag = 0;
      }
      if (\$1=="set" && \$2=="callosal_j") {
        print "set callosal_j = \"$callosal_j\""; printflag = 0;
      }
      if (\$1=="set" && \$2=="midbrain_imnr") {
        print "set midbrain_imnr = \"$midbrain_imnr\""; printflag = 0;
      }
      if (\$1=="set" && \$2=="midbrain_i") {
        print "set midbrain_i = \"$midbrain_i\""; printflag = 0;
      }
      if (\$1=="set" && \$2=="midbrain_j") {
        print "set midbrain_j = \"$midbrain_j\""; printflag = 0;
      }
      if (\$1=="set" && \$2=="max_fill_iter") {
        print "set max_fill_iter = $max_fill_iter"; printflag = 0;
      }
      if (\$1=="set" && \$2=="min_filled_per_cyc") {
        print "set min_filled_per_cyc = $min_filled_per_cyc"; printflag = 0;
      }
      if (\$1=="set" && \$2=="max_same_neigh") {
        print "set max_same_neigh = $max_same_neigh"; printflag = 0;
      }
      if (printflag==1) {
        ORS = "\n"; print;
      } else {   # save comments
        j = 99;
        for (i = 1; i <= NF; i++) if (\$i=="#") { j = i; break; }
        if (j < 99) print "   "; for (i = j; i <= NF; i++) print \$i;
        ORS = "\n"; print ""
      }
    }
END3
    set src = mksurface.dat
    cp $src $src~
    awk -f $tmpawk $src~ > mksurface.dat
    rm -f $tmpawk
    echo "mksurface: read fill.dat parms into mksurface.dat (old saved as ~)"
  endif
endif

##########################################################################
# cleanup
if ($cleanup) then
  echo "mksurface: rm -f brain.dat wmfilter.dat fill.dat"
  echo "mksurface: rm -f inner_skull.dat outer_skull.dat outer_skin.dat"
  rm -f brain.dat wmfilter.dat fill.dat
  rm -f inner_skull.dat outer_skull.dat outer_skin.dat
endif

##########################################################################
# onintr
rmtmp:
rm -f $tmptcl $tmpawk
rm -f position.tclOLD fill.datTEST

