def iterate(self):
for i in range(self.generations):
nlinOutput = abspath(self.nlinDir) + "/" + "nlin-%g.mnc" % (i+1)
nlinFH = RegistrationPipeFH(nlinOutput, mask=self.target.getMask(), basedir=self.nlinDir)
self.addBlurStage(self.target, i)
filesToAvg = []
for inputFH in self.inputs:
self.addBlurStage(inputFH, i)
self.regAndResample(inputFH, i, filesToAvg, nlinFH)
"""Because we don't reset lastBasevol on each inputFH, call mincAverage with files only.
We create fileHandler first though, so we have log directory.
This solution seems a bit hackish--may want to modify?
Additionally, we are currently using the full RegistrationPipeFH class, but ultimately
we'll want to create a third class that is somewhere between a full and base class.
"""
logBase = removeBaseAndExtension(nlinOutput)
avgLog = createLogFile(nlinFH.logDir, logBase)
avg = mincAverage(filesToAvg, nlinOutput, logFile=avgLog)
self.p.addStage(avg)
"""Reset target for next iteration and add to array"""
self.target = nlinFH
self.nlinAverages.append(nlinFH)
"""Create a final nlin group to add to the inputFH.
lastBasevol = by default, will grab the lastBasevol used in these calculations (e.g. lsq12)
setLastXfm between final nlin average and inputFH will be set for stats calculations.
"""
if i == (self.generations -1):
for inputFH in self.inputs:
"""NOTE: The last xfm being set below is NOT the result of a registration between
inputFH and nlinFH, but rather is the output transform from the previous generation's
average."""
finalXfm = inputFH.getLastXfm(self.nlinAverages[self.generations-2])
inputFH.newGroup(groupName="final")
inputFH.setLastXfm(nlinFH, finalXfm)
def setupTarget(self):
if self.targetAvg:
if isinstance(self.targetAvg, str):
self.initialTarget = RegistrationPipeFH(self.targetAvg,
mask=self.targetMask,
basedir=self.targetOutputDir)
self.outputAvg = self.targetAvg
elif isinstance(self.targetAvg, RegistrationPipeFH):
self.initialTarget = self.targetAvg
self.outputAvg = self.targetAvg.getLastBasevol()
if not self.initialTarget.getMask():
if self.targetMask:
self.initialTarget.setMask(self.targetMask)
else:
print "You have passed a target average that is neither a string nor a file handler: " + str(self.targetAvg)
print "Exiting..."
else:
self.targetAvg = abspath(self.targetOutputDir) + "/" + "initial-target.mnc"
self.initialTarget = RegistrationPipeFH(self.targetAvg,
mask=self.targetMask,
basedir=self.targetOutputDir)
self.outputAvg = self.targetAvg
if self.createAvg:
avg = mincAverage(self.inputFiles,
self.initialTarget,
output=self.outputAvg,
defaultDir=self.targetOutputDir)
self.p.addStage(avg)
def setupTarget(self):
if self.targetAvg:
if isinstance(self.targetAvg, str):
self.initialTarget = RegistrationPipeFH(
self.targetAvg,
mask=self.targetMask,
basedir=self.targetOutputDir)
self.outputAvg = self.targetAvg
elif isinstance(self.targetAvg, RegistrationPipeFH):
self.initialTarget = self.targetAvg
self.outputAvg = self.targetAvg.getLastBasevol()
if not self.initialTarget.getMask():
if self.targetMask:
self.initialTarget.setMask(self.targetMask)
else:
print "You have passed a target average that is neither a string nor a file handler: " + str(
self.targetAvg)
print "Exiting..."
else:
self.targetAvg = abspath(
self.targetOutputDir) + "/" + "initial-target.mnc"
self.initialTarget = RegistrationPipeFH(
self.targetAvg,
mask=self.targetMask,
basedir=self.targetOutputDir)
self.outputAvg = self.targetAvg
if self.createAvg:
avg = mincAverage(self.inputFiles,
self.initialTarget,
output=self.outputAvg,
defaultDir=self.targetOutputDir)
self.p.addStage(avg)
def iterate(self):
if not self.maxPairs:
xfmsToAvg = {}
lsq12ResampledFiles = {}
for inputFH in self.inputs:
"""Create an array of xfms, to compute an average lsq12 xfm for each input"""
xfmsToAvg[inputFH] = []
for targetFH in self.inputs:
if inputFH != targetFH:
lsq12 = LSQ12(inputFH,
targetFH,
self.blurs,
self.stepSize,
self.useGradient,
self.simplex)
self.p.addPipeline(lsq12.p)
xfmsToAvg[inputFH].append(inputFH.getLastXfm(targetFH))
"""Create average xfm for inputFH using xfmsToAvg array"""
cmd = ["xfmavg"]
for i in range(len(xfmsToAvg[inputFH])):
cmd.append(InputFile(xfmsToAvg[inputFH][i]))
avgXfmOutput = createBaseName(inputFH.transformsDir, inputFH.basename + "-avg-lsq12.xfm")
cmd.append(OutputFile(avgXfmOutput))
xfmavg = CmdStage(cmd)
xfmavg.setLogFile(LogFile(logFromFile(inputFH.logDir, avgXfmOutput)))
self.p.addStage(xfmavg)
self.lsq12AvgXfms[inputFH] = avgXfmOutput
""" resample brain and add to array for mincAveraging"""
if not self.likeFile:
likeFile=inputFH
else:
likeFile=self.likeFile
rslOutput = createBaseName(inputFH.resampledDir, inputFH.basename + "-resampled-lsq12.mnc")
res = ma.mincresample(inputFH,
inputFH,
transform=avgXfmOutput,
likeFile=likeFile,
output=rslOutput,
argArray=["-sinc"])
self.p.addStage(res)
lsq12ResampledFiles[inputFH] = rslOutput
""" After all registrations complete, setLastBasevol for each subject to be
resampled file in lsq12 space. We can then call mincAverage on fileHandlers,
as it will use the lastBasevol for each by default."""
for inputFH in self.inputs:
inputFH.setLastBasevol(lsq12ResampledFiles[inputFH])
""" mincAverage all resampled brains and put in lsq12Directory"""
self.lsq12Avg = abspath(self.lsq12Dir) + "/" + basename(self.lsq12Dir) + "-pairs.mnc"
self.lsq12AvgFH = RegistrationPipeFH(self.lsq12Avg, basedir=self.lsq12Dir)
avg = ma.mincAverage(self.inputs,
self.lsq12AvgFH,
output=self.lsq12Avg,
defaultDir=self.lsq12Dir)
self.p.addStage(avg)
else:
print "Registration using a specified number of max pairs not yet working. Check back soon!"
sys.exit()
def run(self):
options = self.options
args = self.args
# Setup output directories for non-linear registration.
dirs = rf.setupDirectories(self.outputDir, options.pipeline_name, module="NLIN")
"""Initialize input files (from args) and initial target"""
inputFiles = rf.initializeInputFiles(args, dirs.processedDir, maskDir=options.mask_dir)
if options.target_avg:
initialTarget = RegistrationPipeFH(options.target_avg,
mask=options.target_mask,
basedir=dirs.nlinDir)
else:
# if no target is specified, create an average from the inputs
targetName = abspath(self.outputDir) + "/" + "initial-target.mnc"
initialTarget = RegistrationPipeFH(targetName, basedir=self.outputDir)
avg = mincAverage(inputFiles,
initialTarget,
output=targetName,
defaultDir=self.outputDir)
self.pipeline.addStage(avg)
"""Based on options.reg_method, register with minctracc or mincANTS"""
nlinModule = initNLINModule(inputFiles,
initialTarget,
dirs.nlinDir,
options.nlin_protocol,
options.reg_method)
nlinModule.iterate()
self.pipeline.addPipeline(nlinModule.p)
self.nlinAverages = nlinModule.nlinAverages
"""Calculate statistics between final nlin average and individual mice"""
if options.calc_stats:
"""Get blurs from command line option and put into array"""
blurs = []
for i in options.stats_kernels.split(","):
blurs.append(float(i))
"""Choose final average from array of nlin averages"""
numGens = len(self.nlinAverages)
finalNlin = self.nlinAverages[numGens-1]
"""For each input file, calculate statistics from finalNlin to input"""
for inputFH in inputFiles:
stats = CalcStats(inputFH, finalNlin, blurs, inputFiles)
stats.fullStatsCalc()
self.pipeline.addPipeline(stats.p)
def iterate(self):
for i in range(self.generations):
outputName = "nlin-%g.mnc" % (i + 1)
if self.avgPrefix:
outputName = str(self.avgPrefix) + "-" + outputName
nlinOutput = abspath(self.nlinDir) + "/" + outputName
nlinFH = RegistrationPipeFH(nlinOutput,
mask=self.target.getMask(),
basedir=self.nlinDir)
self.addBlurStage(self.target, i)
filesToAvg = []
for inputFH in self.inputs:
self.addBlurStage(inputFH, i)
self.regAndResample(inputFH, i, filesToAvg, nlinFH)
"""Because we don't reset lastBasevol on each inputFH, call mincAverage with files only.
We create fileHandler first though, so we have log directory.
This solution seems a bit hackish--may want to modify?
Additionally, we are currently using the full RegistrationPipeFH class, but ultimately
we'll want to create a third class that is somewhere between a full and base class.
"""
logBase = removeBaseAndExtension(nlinOutput)
avgLog = createLogFile(nlinFH.logDir, logBase)
avg = mincAverage(filesToAvg, nlinOutput, logFile=avgLog)
self.p.addStage(avg)
"""Reset target for next iteration and add to array"""
self.target = nlinFH
self.nlinAverages.append(nlinFH)
"""Create a final nlin group to add to the inputFH.
lastBasevol = by default, will grab the lastBasevol used in these calculations (e.g. lsq12)
setLastXfm between final nlin average and inputFH will be set for stats calculations.
"""
if i == (self.generations - 1):
for inputFH in self.inputs:
"""NOTE: The last xfm being set below is NOT the result of a registration between
inputFH and nlinFH, but rather is the output transform from the previous generation's
average."""
finalXfm = inputFH.getLastXfm(
self.nlinAverages[self.generations - 2])
inputFH.newGroup(groupName="final")
inputFH.setLastXfm(nlinFH, finalXfm)
def iterate(self):
if not self.maxPairs:
xfmsToAvg = {}
lsq12ResampledFiles = {}
for inputFH in self.inputs:
"""Create an array of xfms, to compute an average lsq12 xfm for each input"""
xfmsToAvg[inputFH] = []
for targetFH in self.inputs:
if inputFH != targetFH:
lsq12 = LSQ12(inputFH,
targetFH,
blurs=self.blurs,
step=self.stepSize,
gradient=self.useGradient,
simplex=self.simplex,
w_translations=self.w_translations)
self.p.addPipeline(lsq12.p)
xfmsToAvg[inputFH].append(inputFH.getLastXfm(targetFH))
"""Create average xfm for inputFH using xfmsToAvg array"""
cmd = ["xfmavg"]
for i in range(len(xfmsToAvg[inputFH])):
cmd.append(InputFile(xfmsToAvg[inputFH][i]))
avgXfmOutput = createBaseName(
inputFH.transformsDir, inputFH.basename + "-avg-lsq12.xfm")
cmd.append(OutputFile(avgXfmOutput))
xfmavg = CmdStage(cmd)
xfmavg.setLogFile(
LogFile(logFromFile(inputFH.logDir, avgXfmOutput)))
self.p.addStage(xfmavg)
self.lsq12AvgXfms[inputFH] = avgXfmOutput
""" resample brain and add to array for mincAveraging"""
if not self.likeFile:
likeFile = inputFH
else:
likeFile = self.likeFile
rslOutput = createBaseName(
inputFH.resampledDir,
inputFH.basename + "-resampled-lsq12.mnc")
res = ma.mincresample(inputFH,
inputFH,
transform=avgXfmOutput,
likeFile=likeFile,
output=rslOutput,
argArray=["-sinc"])
self.p.addStage(res)
lsq12ResampledFiles[inputFH] = rslOutput
""" After all registrations complete, setLastBasevol for each subject to be
resampled file in lsq12 space. We can then call mincAverage on fileHandlers,
as it will use the lastBasevol for each by default."""
for inputFH in self.inputs:
inputFH.setLastBasevol(lsq12ResampledFiles[inputFH])
""" mincAverage all resampled brains and put in lsq12Directory"""
self.lsq12Avg = abspath(self.lsq12Dir) + "/" + basename(
self.lsq12Dir) + "-pairs.mnc"
self.lsq12AvgFH = RegistrationPipeFH(self.lsq12Avg,
basedir=self.lsq12Dir)
avg = ma.mincAverage(self.inputs,
self.lsq12AvgFH,
output=self.lsq12Avg,
defaultDir=self.lsq12Dir)
self.p.addStage(avg)
else:
print "Registration using a specified number of max pairs not yet working. Check back soon!"
sys.exit()
def run(self):
options = self.options
args = self.args
# Setup output directories for two-level model building (_processed and _nlin for now).
dirs = rf.setupDirectories(self.outputDir, options.pipeline_name, module="NLIN")
# read in files from CSV
fileList = open(self.args[0], 'rb')
subjectList = csv.reader(fileList, delimiter=',', skipinitialspace=True)
subjects = {}
index = 0
for subj in subjectList:
subjects[index] = rf.initializeInputFiles(subj, dirs.processedDir, maskDir=options.mask_dir)
index += 1
# testing only part of the code: run one lsq12 followed by an NLIN
# this actually makes little sense, but what the hell
# blurs = [10,5,5]
# step = [4,4,4]
# simplex = [20,20,20]
# filesToAvg = []
# LSQ12 = mm.LSQ12(inputFiles[0], inputFiles[1], blurs, step, simplex)
# rs = ma.mincresample(inputFiles[0], inputFiles[1], likeFile=inputFiles[1])
# filesToAvg.append(rs.outputFiles[0])
# self.pipeline.addStage(rs)
# self.pipeline.addPipeline(LSQ12.p)
# LSQ12 = mm.LSQ12(inputFiles[1], inputFiles[0], blurs, step, simplex)
# rs = ma.mincresample(inputFiles[1], inputFiles[0], likeFile=inputFiles[0])
# filesToAvg.append(rs.outputFiles[0])
# self.pipeline.addPipeline(LSQ12.p)
# self.pipeline.addStage(rs)
# lsq12AvgFile = abspath(processedDirectory) + "/" + "lsq12avg.mnc"
# avg = ma.mincAverage(filesToAvg, lsq12AvgFile)
# self.pipeline.addStage(avg)
# TODO: LSQ6 registration if requested
# TODO: LSQ12 registration if requested
# for the moment assume that all input files are in LSQ12 space
index = 0
firstlevelNlins = [] # stores the per subject NLINs avgs
### first level of registrations: register within subject
for i in range(len(subjects)):
### filename munging ###
# takes the filename of the first file in the list and prepends FIRSTLEVEL- to it
baseVol = subjects[i][0].getLastBasevol()
subjBase = "FIRSTLEVEL-" + splitext(split(baseVol)[1])[0]
# create an NLIN directory inside the main NLIN directory per subject
firstNlinDirectory = fh.createSubDir(dirs.nlinDir, subjBase)
# put the lsq12 averages in the processed directory for now
lsq12AvgFile = abspath(dirs.processedDir) + "/" + subjBase + "-lsq12avg.mnc"
lsq12FH = rfh.RegistrationPipeFH(lsq12AvgFile, basedir=dirs.nlinDir)
### step 1: create an average of all the input files per subject ###
# TODO: optionally allow LSQ12 or LSQ6 + LSQ12 here rather than assume they come prealigned
avg = ma.mincAverage(subjects[i], lsq12FH)
lsq12FH.setLastBasevol(avg.outputFiles[0])
self.pipeline.addStage(avg)
### step 2: run iterative ANTS model building for each subject
NL = nl.NLINANTS(subjects[i], lsq12FH, firstNlinDirectory, options.nlin_protocol)
NL.iterate()
self.pipeline.addPipeline(NL.p)
# add the last NLIN average to the volumes that will proceed to step 2
firstlevelNlins.append(NL.nlinAvg[-1])
### second level of registrations: register across subjects
## start by averaging all the NLINs from the first level; should be replaced by an LSQ12
lsq12AvgFile = abspath(dirs.processedDir) + "/firstlevelNlins-lsq12avg.mnc"
lsq12FH = rfh.RegistrationPipeFH(lsq12AvgFile, basedir=dirs.nlinDir)
avg = ma.mincAverage(firstlevelNlins, lsq12FH)
lsq12FH.setLastBasevol(avg.outputFiles[0])
self.pipeline.addStage(avg)
## run iterative ANTS model building across the per subject averages
# TODO: allow for a different protocol here.
NL = nl.NLINANTS(firstlevelNlins, lsq12FH, dirs.nlinDir, options.nlin_protocol)
NL.iterate()
self.pipeline.addPipeline(NL.p)
def iterate(self):
xfmsToAvg = {}
lsq12ResampledFiles = {}
for inputFH in self.inputs:
"""Create an array of xfms, to compute an average lsq12 xfm for each input"""
xfmsToAvg[inputFH] = []
if self.maxPairs is not None:
if self.maxPairs >= len(self.inputs) - 1:
# -1 prevents unnecessary sampling in the case self.maxPairs = len(self.inputs) - 1
inputs = self.inputs
else:
random.seed(
tuple(map(lambda fh: fh.inputFileName, self.inputs)))
# if inputFH is included in the sample, we will register against one fewer target
inputs = random.sample(
filter(lambda fh: fh != inputFH, self.inputs),
self.maxPairs)
else:
inputs = self.inputs
for targetFH in inputs:
if inputFH != targetFH:
lsq12 = LSQ12(inputFH,
targetFH,
blurs=self.blurs,
step=self.stepSize,
gradient=self.useGradient,
simplex=self.simplex,
w_translations=self.w_translations)
self.p.addPipeline(lsq12.p)
xfmsToAvg[inputFH].append(inputFH.getLastXfm(targetFH))
"""Create average xfm for inputFH using xfmsToAvg array"""
avgXfmOutput = createBaseName(inputFH.transformsDir,
inputFH.basename + "-avg-lsq12.xfm")
cmd = ["xfmavg", "-verbose", "-clobber"] \
+ map(InputFile, xfmsToAvg[inputFH]) + [OutputFile(avgXfmOutput)]
#for i in range(len(xfmsToAvg[inputFH])):
# cmd.append(InputFile(xfmsToAvg[inputFH][i]))
# '-clobber' works around #157, but is probably better in general
#cmd.append(OutputFile(avgXfmOutput))
xfmavg = CmdStage(cmd)
xfmavg.setLogFile(
LogFile(logFromFile(inputFH.logDir, avgXfmOutput)))
self.p.addStage(xfmavg)
self.lsq12AvgXfms[inputFH] = avgXfmOutput
""" resample brain and add to array for mincAveraging"""
if not self.likeFile:
likeFile = inputFH
else:
likeFile = self.likeFile
rslOutput = createBaseName(
inputFH.resampledDir,
inputFH.basename + "-resampled-lsq12.mnc")
res = ma.mincresample(inputFH,
inputFH,
transform=avgXfmOutput,
likeFile=likeFile,
output=rslOutput,
argArray=["-sinc"])
self.p.addStage(res)
lsq12ResampledFiles[inputFH] = rslOutput
""" After all registrations complete, setLastBasevol for each subject to be
resampled file in lsq12 space. We can then call mincAverage on fileHandlers,
as it will use the lastBasevol for each by default."""
for inputFH in self.inputs:
inputFH.setLastBasevol(lsq12ResampledFiles[inputFH])
""" mincAverage all resampled brains and put in lsq12Directory"""
self.lsq12Avg = abspath(self.lsq12Dir) + "/" + basename(
self.lsq12Dir) + "-pairs.mnc"
self.lsq12AvgFH = RegistrationPipeFH(self.lsq12Avg,
basedir=self.lsq12Dir)
avg = ma.mincAverage(inputs,
self.lsq12AvgFH,
output=self.lsq12Avg,
defaultDir=self.lsq12Dir)
self.p.addStage(avg)