From 51123396f398f08598f0cc5d14147db71efa047b Mon Sep 17 00:00:00 2001
From: Paul McCarthy <pauldmccarthy@gmail.com>
Date: Sat, 3 Mar 2018 17:34:14 +0000
Subject: [PATCH] Fixed up fslmaths module
---
fsl/wrappers/fslmaths.py | 110 ++++++++++++++++++++-------------------
1 file changed, 56 insertions(+), 54 deletions(-)
diff --git a/fsl/wrappers/fslmaths.py b/fsl/wrappers/fslmaths.py
index a15a26e52..3ad54b784 100644
--- a/fsl/wrappers/fslmaths.py
+++ b/fsl/wrappers/fslmaths.py
@@ -9,7 +9,8 @@ for the ``fslmaths`` command-line tool.
"""
-import fsl.utils.run as run
+import fsl.utils.run as run
+from . import wrapperutils as wutils
class fslmaths(object):
@@ -17,142 +18,143 @@ class fslmaths(object):
def __init__(self, input):
"""Constructor."""
- self.inputImage = input
- self.outputImage = None
- self.operations = []
+ self.__input = input
+ self.__args = []
def abs(self):
"""Absolute value."""
- self.operations.append("-abs")
+ self.__args.append("-abs")
return self
def bin(self):
"""Use (current image>0) to binarise."""
- self.operations.append("-bin")
+ self.__args.append("-bin")
return self
def binv(self):
"""Binarise and invert (binarisation and logical inversion)."""
- self.operations.append("-binv")
+ self.__args.append("-binv")
return self
def recip(self):
"""Reciprocal (1/current image)."""
- self.operations.append("-recip")
+ self.__args.append("-recip")
return self
def Tmean(self):
"""Mean across time."""
- self.operations.append("-Tmean")
+ self.__args.append("-Tmean")
return self
def Tstd(self):
"""Standard deviation across time."""
- self.operations.append("-Tstd")
+ self.__args.append("-Tstd")
return self
def Tmin(self):
"""Min across time."""
- self.operations.append("-Tmin")
+ self.__args.append("-Tmin")
return self
def Tmax(self):
"""Max across time."""
- self.operations.append("-Tmax")
+ self.__args.append("-Tmax")
return self
def fillh(self):
"""fill holes in a binary mask (holes are internal - i.e. do not touch
the edge of the FOV)."""
- self.operations.append("-fillh")
+ self.__args.append("-fillh")
return self
def ero(self, repeat=1):
"""Erode by zeroing non-zero voxels when zero voxels in kernel."""
for i in range(repeat):
- self.operations.append("-ero")
+ self.__args.append("-ero")
return self
def dilM(self, repeat=1):
"""Mean Dilation of non-zero voxels."""
for i in range(repeat):
- self.operations.append("-dilM")
+ self.__args.append("-dilM")
return self
def dilF(self, repeat=1):
"""Maximum filtering of all voxels."""
for i in range(repeat):
- self.operations.append("-dilF")
+ self.__args.append("-dilF")
return self
- def add(self, input):
+ def add(self, image):
"""Add input to current image."""
- self.operations.append("-add {0}".format(input))
+ self.__args.extend(("-add", image))
return self
- def sub(self, input):
- """Subtract input from current image."""
- self.operations.append("-sub {0}".format(input))
+ def sub(self, image):
+ """Subtract image from current image."""
+ self.__args.extend(("-sub", image))
return self
- def mul(self, input):
- """Multiply current image by input."""
- self.operations.append("-mul {0}".format(input))
+ def mul(self, image):
+ """Multiply current image by image."""
+ self.__args.extend(("-mul", image))
return self
- def div(self, input):
- """Divide current image by input."""
- self.operations.append("-div {0}".format(input))
+ def div(self, image):
+ """Divide current image by image."""
+ self.__args.extend(("-div", image))
return self
def mas(self, image):
"""Use image (>0) to mask current image."""
- self.operations.append("-mas {0}".format(image))
+ self.__args.extend(("-mas", image))
return self
- def rem(self, input):
- """Divide current image by following input and take remainder."""
- self.operations.append("-rem {0}".format(input))
+ def rem(self, image):
+ """Divide current image by following image and take remainder."""
+ self.__args.extend(("-rem", image))
return self
- def thr(self, input):
- """use input number to threshold current image (zero < input)."""
- self.operations.append("-thr {0}".format(input))
+ def thr(self, image):
+ """use image number to threshold current image (zero < image)."""
+ self.__args.extend(("-thr", image))
return self
- def uthr(self, input):
- """use input number to upper-threshold current image (zero
+ def uthr(self, image):
+ """use image number to upper-threshold current image (zero
anything above the number)."""
- self.operations.append("-uthr {0}".format(input))
+ self.__args.extend(("-uthr", image))
return self
- def inm(self, input):
+ def inm(self, image):
"""Intensity normalisation (per 3D volume mean)"""
- self.operations.append("-inm {0}".format(input))
+ self.__args.extend(("-inm", image))
return self
def bptf(self, hp_sigma, lp_sigma):
"""Bandpass temporal filtering; nonlinear highpass and Gaussian linear
lowpass (with sigmas in volumes, not seconds); set either sigma<0 to
skip that filter."""
- self.operations.append("-bptf {0} {1}".format(hp_sigma, lp_sigma))
+ self.__args.extend(("-bptf", hp_sigma, lp_sigma))
return self
- def toString(self):
- """Generate fslmaths command string."""
- cmd = "fslmaths {0} ".format(self.inputImage)
- for oper in self.operations:
- cmd = cmd + oper + " "
- cmd = cmd + self.outputImage
- return cmd
-
def run(self, output=None):
"""Save output of operations to image."""
- if output:
- self.outputImage = output
- else:
- self.outputImage = self.inputImage
- run.runfsl(self.toString())
+ cmd = ['fslmaths', self.__input] + self.__args
+
+ if output is None: cmd += [wutils.LOAD]
+ else: cmd += [output]
+
+ result = self.__run(*cmd)
+
+ # if output is LOADed, there
+ # will only be one entry in
+ # the result dict.
+ if output is None: return list(result.values())[0]
+ else: return output
- return self.outputImage
+ @wutils.fileOrImage()
+ def __run(self, *cmd):
+ """Run the given ``fslmaths`` command. """
+ return run.runfsl([str(c) for c in cmd])
--
GitLab