def __init__(self,
inputArray,
targetFH,
nlinOutputDir,
avgPrefix,
nlin_protocol,
resolution=None):
self.p = Pipeline()
"""Initial inputs should be an array of fileHandlers with lastBasevol in lsq12 space"""
self.inputs = inputArray
"""Initial target should be the file handler for the lsq12 average"""
self.target = targetFH
"""Output directory should be _nlin """
self.nlinDir = nlinOutputDir
"""Prefix to pre-pend to averages at each generation"""
self.avgPrefix = avgPrefix
"""Empty array that we will fill with averages as we create them"""
self.nlinAverages = []
"""Create the blurring resolution from the file resolution"""
self.fileRes = resolution
if (nlin_protocol == None and resolution == None):
print "\nError: NLIN module was initialized without a protocol, and without a resolution for the registrations to be run at. Please specify one of the two. Exiting\n"
sys.exit()
if (nlin_protocol and resolution):
# we should have the nlin_protocol be able to overwrite the given resolution:
self.fileRes = None
# Create new nlin group for each input prior to registration
for i in range(len(self.inputs)):
self.inputs[i].newGroup(groupName="nlin")
def __init__(self,
inputFH,
targetFH,
blurs=[0.3, 0.2, 0.15],
step=[1, 0.5, 0.333333333333333],
gradient=[False, True, False],
simplex=[3, 1.5, 1],
w_translations=[0.4, 0.4, 0.4],
defaultDir="tmp"):
# TO DO: Might want to take this out and pass in # of generations, since
# checking happens there.
if len(blurs) == len(step) == len(simplex):
# do nothing - all lengths are the same and we're therefore happy
pass
else:
logger.error(
"The same number of entries are required for blurs, step, and simplex in LSQ12"
)
sys.exit()
self.p = Pipeline()
self.inputFH = inputFH
self.targetFH = targetFH
self.blurs = blurs
self.step = step
self.blurs = blurs
self.gradient = gradient
self.simplex = simplex
self.w_translations = w_translations
self.defaultDir = defaultDir
self.blurFiles()
self.buildPipeline()
def __init__(self,
inputFH,
targetFH,
lsq12_protocol=None,
nlin_protocol=None,
includeLinear=True,
subject_matter=None,
defaultDir="tmp"):
self.p = Pipeline()
self.inputFH = inputFH
self.targetFH = targetFH
self.lsq12_protocol = lsq12_protocol
self.nlin_protocol = nlin_protocol
self.includeLinear = includeLinear
self.subject_matter = subject_matter
self.defaultDir = defaultDir
if ((self.lsq12_protocol == None and self.subject_matter == None)
or self.nlin_protocol == None):
# the resolution of the registration should be based on the target
self.fileRes = rf.returnFinestResolution(self.targetFH)
else:
self.fileRes = None
self.buildPipeline()
def MAGeTRegister(inputFH,
templateFH,
regMethod,
name="initial",
createMask=False,
lsq12_protocol=None,
nlin_protocol=None):
p = Pipeline()
if createMask:
defaultDir = "tmp"
else:
defaultDir = "transforms"
if regMethod == "minctracc":
sp = HierarchicalMinctracc(inputFH,
templateFH,
lsq12_protocol=lsq12_protocol,
nlin_protocol=nlin_protocol,
defaultDir=defaultDir)
p.addPipeline(sp.p)
elif regMethod == "mincANTS":
register = LSQ12ANTSNlin(inputFH,
templateFH,
lsq12_protocol=lsq12_protocol,
nlin_protocol=nlin_protocol,
defaultDir=defaultDir)
p.addPipeline(register.p)
rp = LabelAndFileResampling(inputFH,
templateFH,
name=name,
createMask=createMask)
p.addPipeline(rp.p)
return (p)
def __init__(self,
inputPipeFH,
templatePipeFH,
name="initial",
createMask=False):
self.p = Pipeline()
self.name = name
if createMask:
resampleDefault = "tmp"
labelsDefault = "tmp"
else:
resampleDefault = "resampled"
labelsDefault = "labels"
# Resample all inputLabels
inputLabelArray = templatePipeFH.returnLabels(True)
if len(inputLabelArray) > 0:
""" for the initial registration, resulting labels should be added
to inputLabels array for subsequent pairwise registration
otherwise labels should be added to labels array for voting """
if self.name == "initial":
addOutputToInputLabels = True
else:
addOutputToInputLabels = False
for i in range(len(inputLabelArray)):
"""Note: templatePipeFH and inputPipeFH have the reverse order
from how they are passed into this function. This is intentional
because the mincresample classes use the first argument as the
one from which to get the file to be resampled. Here, either the
mask or labels to be resampled come from the template."""
if createMask:
resampleStage = ma.mincresampleMask(
templatePipeFH,
inputPipeFH,
defaultDir=labelsDefault,
likeFile=inputPipeFH,
argArray=["-invert"],
outputLocation=inputPipeFH,
labelIndex=i,
setInputLabels=addOutputToInputLabels)
else:
resampleStage = ma.mincresampleLabels(
templatePipeFH,
inputPipeFH,
defaultDir=labelsDefault,
likeFile=inputPipeFH,
argArray=["-invert"],
outputLocation=inputPipeFH,
labelIndex=i,
setInputLabels=addOutputToInputLabels)
self.p.addStage(resampleStage)
# resample files
resampleStage = ma.mincresample(templatePipeFH,
inputPipeFH,
defaultDir=resampleDefault,
likeFile=inputPipeFH,
argArray=["-invert"],
outputLocation=inputPipeFH)
self.p.addStage(resampleStage)
def __init__(
self,
targetOutputDir, #Output directory for files related to initial target (often _lsq12)
inputFiles,
nlinDir,
avgPrefix, #Prefix for nlin-1.mnc, ... nlin-k.mnc
createAvg=True, #True=call mincAvg, False=targetAvg already exists
targetAvg=None, #Optional path to initial target - passing name does not guarantee existence
targetMask=None, #Optional path to mask for initial target
nlin_protocol=None,
reg_method=None):
self.p = Pipeline()
self.targetOutputDir = targetOutputDir
self.inputFiles = inputFiles
self.nlinDir = nlinDir
self.avgPrefix = avgPrefix
self.createAvg = createAvg
self.targetAvg = targetAvg
self.targetMask = targetMask
self.nlin_protocol = nlin_protocol
self.reg_method = reg_method
# setup initialTarget (if needed) and initialize non-linear module
self.setupTarget()
self.initNlinModule()
#iterate through non-linear registration and setup averages
self.nlinModule.iterate()
self.p.addPipeline(self.nlinModule.p)
self.nlinAverages = self.nlinModule.nlinAverages
self.nlinParams = self.nlinModule.nlinParams
def resampleToCommon(xfm, FH, statsGroup, statsKernels, nlinFH):
blurs = []
if isinstance(statsKernels, list):
blurs = statsKernels
elif isinstance(statsKernels, str):
for i in statsKernels.split(","):
blurs.append(float(i))
else:
print "Improper type of blurring kernels specified for stats calculation: " + str(statsKernels)
sys.exit()
pipeline = Pipeline()
outputDirectory = FH.statsDir
filesToResample = []
for b in blurs:
filesToResample.append(statsGroup.relativeJacobians[b])
if statsGroup.absoluteJacobians:
filesToResample.append(statsGroup.absoluteJacobians[b])
for f in filesToResample:
outputBase = fh.removeBaseAndExtension(f).split(".mnc")[0]
outputFile = fh.createBaseName(outputDirectory, outputBase + "_common" + ".mnc")
logFile = fh.logFromFile(FH.logDir, outputFile)
targetAndLike=nlinFH.getLastBasevol()
res = ma.mincresample(f,
targetAndLike,
likeFile=targetAndLike,
transform=xfm,
output=outputFile,
logFile=logFile,
argArray=["-sinc"])
pipeline.addStage(res)
return pipeline
def maskFiles(FH, isAtlas, numAtlases=1):
""" Assume that if there is more than one atlas, multiple
masks were generated and we need to perform a voxel_vote.
Otherwise, assume we are using inputLabels from crossing with
only one atlas.
"""
#MF TODO: Make this more general to handle pairwise option.
p = Pipeline()
if not isAtlas:
if numAtlases > 1:
voxel = voxelVote(FH, False, True)
p.addStage(voxel)
mincMathInput = voxel.outputFiles[0]
else:
mincMathInput = FH.returnLabels(True)[0]
FH.setMask(mincMathInput)
else:
mincMathInput = FH.getMask()
mincMathOutput = fh.createBaseName(FH.resampledDir, FH.basename)
mincMathOutput += "_masked.mnc"
logFile = fh.logFromFile(FH.logDir, mincMathOutput)
cmd = ["mincmath"] + ["-clobber"] + ["-mult"]
cmd += [InputFile(mincMathInput)] + [InputFile(FH.getLastBasevol())]
cmd += [OutputFile(mincMathOutput)]
mincMath = CmdStage(cmd)
mincMath.setLogFile(LogFile(logFile))
p.addStage(mincMath)
FH.setLastBasevol(mincMathOutput)
return (p)
def MAGeTMask(atlases,
inputs,
numAtlases,
regMethod,
lsq12_protocol=None,
nlin_protocol=None):
""" Masking algorithm is as follows:
1. Run HierarchicalMinctracc or mincANTS with mask=True,
using masks instead of labels.
2. Do voxel voting to find the best mask. (Or, if single atlas,
use that transform)
3. mincMath to multiply original input by mask to get _masked.mnc file
(This is done for both atlases and inputs, though for atlases, voxel
voting is not required.)
4. Replace lastBasevol with masked version, since once we have created
mask, we no longer care about unmasked version.
5. Clear out labels arrays, which were used to keep track of masks,
as we want to re-set them for actual labels.
Note: All data will be placed in a newly created masking directory
to keep it separate from data generated during actual MAGeT.
"""
p = Pipeline()
for atlasFH in atlases:
maskDirectoryStructure(atlasFH, masking=True)
for inputFH in inputs:
maskDirectoryStructure(inputFH, masking=True)
for atlasFH in atlases:
sp = MAGeTRegister(inputFH,
atlasFH,
regMethod,
name="initial",
createMask=True,
lsq12_protocol=lsq12_protocol,
nlin_protocol=nlin_protocol)
p.addPipeline(sp)
""" Prior to final masking, set log and tmp directories as they were."""
for atlasFH in atlases:
"""Retrieve labels for use in new group. Assume only one"""
labels = atlasFH.returnLabels(True)
maskDirectoryStructure(atlasFH, masking=False)
mp = maskFiles(atlasFH, True)
p.addPipeline(mp)
atlasFH.newGroup()
atlasFH.addLabels(labels[0], inputLabel=True)
for inputFH in inputs:
maskDirectoryStructure(inputFH, masking=False)
mp = maskFiles(inputFH, False, numAtlases)
p.addPipeline(mp)
# this will remove the "inputLabels"; labels that
# come directly from the atlas library
inputFH.clearLabels(True)
# this will remove the "labels"; second generation
# labels. I.e. labels from labels from the atlas library
inputFH.clearLabels(False)
inputFH.newGroup()
return (p)
def __init__(self, inputs, dirs, options, avgPrefix=None, initModel=None):
self.inputs = inputs
self.dirs = dirs
self.options = options
self.avgPrefix = avgPrefix
self.initModel = initModel
self.nlinFH = None
self.p = Pipeline()
self.buildPipeline()
def __init__(self, subjects, timePoint, nlinFH, statsKernels, commonName):
self.subjects = subjects
self.timePoint = timePoint
self.nlinFH = nlinFH
self.blurs = []
self.setupBlurs(statsKernels)
self.commonName = commonName
self.p = Pipeline()
self.buildPipeline()
def __init__(self,
inputArray,
outputDir,
likeFile=None,
maxPairs=None,
lsq12_protocol=None,
subject_matter=None,
resolution=None):
self.p = Pipeline()
"""Initial inputs should be an array of fileHandlers with lastBasevol in lsq12 space"""
self.inputs = inputArray
"""Output directory should be _nlin """
self.lsq12Dir = outputDir
"""likeFile for resampling"""
self.likeFile = likeFile
"""Maximum number of pairs to calculate"""
self.maxPairs = maxPairs
"""Final lsq12 average"""
self.lsq12Avg = None
"""Final lsq12 average file handler (e.g. the file handler associated with lsq12Avg)"""
self.lsq12AvgFH = None
""" Dictionary of lsq12 average transforms, which will include one per input.
Key is input file handler and value is string pointing to final average lsq12
transform for that particular subject.
These xfms may be used subsequently for statistics calculations. """
self.lsq12AvgXfms = {}
self.fileRes = None
"""Create the blurring resolution from the file resolution"""
if (subject_matter == None and resolution == None):
print "\nError: the FullLSQ12 module was called without specifying the resolution that it should be run at, and without specifying a subject matter. Please indicate one of the two. Exiting...\n"
sys.exit()
elif (subject_matter and resolution):
# subject matter has precedence over resolution
self.fileRes = None
elif resolution:
self.fileRes = resolution
""""Set up parameter array"""
self.lsq12Params = mp.setLSQ12MinctraccParams(
self.fileRes,
subject_matter=subject_matter,
reg_protocol=lsq12_protocol)
self.blurs = self.lsq12Params.blurs
self.stepSize = self.lsq12Params.stepSize
self.useGradient = self.lsq12Params.useGradient
self.simplex = self.lsq12Params.simplex
self.w_translations = self.lsq12Params.w_translations
self.generations = self.lsq12Params.generations
# Create new lsq12 group for each input prior to registration
for input in self.inputs:
input.newGroup(groupName="lsq12")
def __init__(self, inputFH, targetFH, statsKernels, additionalXfm=None):
self.p = Pipeline()
self.inputFH = inputFH
self.targetFH = targetFH
self.blurs = []
self.setupBlurs(statsKernels)
self.statsGroup = StatsGroup()
self.setupXfms()
""" additionalXfm is an optional transform that may be specified. If it is,
it is concatenated with the lastXfm from input to target. This additional
transform must also be in the same direction as the lastXfm (e.g. input to target)
Example usage: if the lastXfm from input to target goes from lsq12 to nlin space
and you would like to calculate the absolute jacobians to lsq6 space, the additional
transform specified may be the lsq6 to lsq12 transform from input to target.
"""
self.additionalXfm = additionalXfm
self.fullStatsCalc()
def __init__(self, inFile, targetFile, nameForStage=None, **kwargs):
self.p = Pipeline()
self.outputFiles = [
] # this will contain the outputFiles from the mincresample of the main MINC file
self.outputFilesMask = [
] # this will contain the outputFiles from the mincresample of the mask belonging to the main MINC file
# the first step is to simply run the mincresample command:
fileRS = mincresample(inFile, targetFile, **kwargs)
if (nameForStage):
fileRS.name = nameForStage
self.p.addStage(fileRS)
self.outputFiles = fileRS.outputFiles
# initialize the array of outputs for the mask in case there is none to be resampled
self.outputFilesMask = [None] * len(self.outputFiles)
# next up, is this a file handler, and if so is there a mask that needs to be resampled?
if (isFileHandler(inFile)):
if (inFile.getMask()):
# there is a mask associated with this file, should be updated
# we have to watch out in terms of interpolation arguments, if
# the original resample command asked for "-sinc" or "-tricubic"
# for instance, we should remove that argument for the mask resampling
# these options would reside in the argArray...
maskArgs = copy.deepcopy(kwargs)
if maskArgs.has_key("argArray"):
argList = maskArgs["argArray"]
for i in range(len(argList)):
if (re.match("-sinc", argList[i])
or re.match("-trilinear", argList[i])
or re.match("-tricubic", argList[i])):
del argList[i]
maskArgs["argArray"] = argList
# if the output file for the mincresample command was already
# specified, add "_mask.mnc" to it
if maskArgs.has_key("output"):
maskArgs["output"] = re.sub(".mnc", "_mask.mnc",
maskArgs["output"])
maskRS = mincresampleMask(inFile, targetFile, **maskArgs)
if (nameForStage):
maskRS.name = nameForStage + "--mask--"
self.p.addStage(maskRS)
self.outputFilesMask = maskRS.outputFiles
def __init__(self,
inputArray,
outputDir,
likeFile=None,
maxPairs=None,
lsq12_protocol=None,
subject_matter=None):
self.p = Pipeline()
"""Initial inputs should be an array of fileHandlers with lastBasevol in lsq12 space"""
self.inputs = inputArray
"""Output directory should be _nlin """
self.lsq12Dir = outputDir
"""likeFile for resampling"""
self.likeFile = likeFile
"""Maximum number of pairs to calculate"""
self.maxPairs = maxPairs
"""Final lsq12 average"""
self.lsq12Avg = None
"""Final lsq12 average file handler (e.g. the file handler associated with lsq12Avg)"""
self.lsq12AvgFH = None
""" Dictionary of lsq12 average transforms, which will include one per input.
Key is input file handler and value is string pointing to final average lsq12
transform for that particular subject.
These xfms may be used subsequently for statistics calculations. """
self.lsq12AvgXfms = {}
"""Create the blurring resolution from the file resolution"""
if (subject_matter == None and lsq12_protocol == None):
self.fileRes = rf.returnFinestResolution(self.inputs[0])
else:
self.fileRes = None
""""Set up parameter array"""
self.lsq12Params = mp.setLSQ12MinctraccParams(
self.fileRes,
subject_matter=subject_matter,
reg_protocol=lsq12_protocol)
self.blurs = self.lsq12Params.blurs
self.stepSize = self.lsq12Params.stepSize
self.useGradient = self.lsq12Params.useGradient
self.simplex = self.lsq12Params.simplex
self.w_translations = self.lsq12Params.w_translations
self.generations = self.lsq12Params.generations
# Create new lsq12 group for each input prior to registration
for i in range(len(self.inputs)):
self.inputs[i].newGroup(groupName="lsq12")
def __init__(self, filesToResample, resolution):
"""During initialization make sure all files are resampled
at resolution we'd like to use for each pipeline stage
"""
self.p = Pipeline()
for FH in filesToResample:
dirForOutput = self.getOutputDirectory(FH)
currentRes = volumeFromFile(FH.getLastBasevol()).separations
if not abs(abs(currentRes[0]) - abs(resolution)) < 0.01:
crop = ma.autocrop(resolution, FH, defaultDir=dirForOutput)
self.p.addStage(crop)
mask = FH.getMask()
if mask:
#Need to resample the mask as well.
cropMask = ma.mincresampleMask(FH,
FH,
outputLocation=FH,
likeFile=FH)
self.p.addStage(cropMask)
def __init__(self, inputArray, targetFH, nlinOutputDir, avgPrefix,
nlin_protocol):
self.p = Pipeline()
"""Initial inputs should be an array of fileHandlers with lastBasevol in lsq12 space"""
self.inputs = inputArray
"""Initial target should be the file handler for the lsq12 average"""
self.target = targetFH
"""Output directory should be _nlin """
self.nlinDir = nlinOutputDir
"""Prefix to pre-pend to averages at each generation"""
self.avgPrefix = avgPrefix
"""Empty array that we will fill with averages as we create them"""
self.nlinAverages = []
"""Create the blurring resolution from the file resolution"""
if nlin_protocol == None:
self.fileRes = rf.returnFinestResolution(self.inputs[0])
else:
self.fileRes = None
# Create new nlin group for each input prior to registration
for i in range(len(self.inputs)):
self.inputs[i].newGroup(groupName="nlin")
def __init__(self,
inputFH,
targetFH,
lsq12_protocol=None,
nlin_protocol=None,
subject_matter=None,
defaultDir="tmp"):
self.p = Pipeline()
self.inputFH = inputFH
self.targetFH = targetFH
self.lsq12_protocol = lsq12_protocol
self.nlin_protocol = nlin_protocol
self.subject_matter = subject_matter
self.defaultDir = defaultDir
if ((self.lsq12_protocol == None and self.subject_matter==None) or self.nlin_protocol == None):
self.fileRes = rf.returnFinestResolution(self.inputFH)
else:
self.fileRes = None
self.buildPipeline()
def maskFiles(FH, isAtlas, numAtlases=1):
""" Assume that if there is more than one atlas, multiple
masks were generated and we need to perform a voxel_vote.
Otherwise, assume we are using inputLabels from crossing with
only one atlas.
"""
#MF TODO: Make this more general to handle pairwise option.
p = Pipeline()
if not isAtlas:
if numAtlases > 1:
voxel = voxelVote(FH, False, True)
p.addStage(voxel)
mincMathInput = voxel.outputFiles[0]
else:
mincMathInput = FH.returnLabels(True)[0]
FH.setMask(mincMathInput)
else:
mincMathInput = FH.getMask()
mincMathOutput = fh.createBaseName(FH.resampledDir, FH.basename)
mincMathOutput += "_masked.mnc"
logFile = fh.logFromFile(FH.logDir, mincMathOutput)
cmd = ["mincmath"] + ["-clobber"] + ["-mult"]
# In response to issue #135
# the order of the input files to mincmath matters. By default the
# first input files is used as a "like file" for the output file.
# We should make sure that the mask is not used for that, because
# it has an image range from 0 to 1; not something we want to be
# set for the masked output file
# average mask
cmd += [InputFile(FH.getLastBasevol())] + [InputFile(mincMathInput)]
cmd += [OutputFile(mincMathOutput)]
mincMath = CmdStage(cmd)
mincMath.setLogFile(LogFile(logFile))
p.addStage(mincMath)
FH.setLastBasevol(mincMathOutput)
return (p)
def _setup_pipeline(self):
self.pipeline = Pipeline()
def _setup_pipeline(self, options):
self.pipeline = Pipeline()
self.pipeline.main_options_hash = options