def deep_segment(
image: FileAtom,
deep_segment_pipeline: FileAtom,
anatomical_suffix: str,
count_suffix: str,
outline_suffix: str = None,
cell_min_area: int = None,
cell_mean_area: float = None,
cell_max_area: int = None,
temp_dir: str = None,
):
anatomical = image.newname_with_suffix("_" + anatomical_suffix)
count = image.newname_with_suffix("_" + count_suffix)
outline = image.newname_with_suffix(
"_" + outline_suffix) if outline_suffix else None
stage = CmdStage(inputs=(image, deep_segment_pipeline),
outputs=(anatomical, count),
cmd=['deep_segment.py',
'--segment-intensity 1',
'--temp-dir %s' % temp_dir if temp_dir else "",
'--learner %s' % deep_segment_pipeline.path,
'--image %s' % image.path,
'--image-output %s' % anatomical.path,
'--centroids-output %s' % count.path,
'--outlines-output %s' % outline.path if outline_suffix else ""
'--cell-min-area %s' % cell_min_area if cell_min_area else "",
'--process-clusters --cell-mean-area %s --cell-max-area %s' % (cell_mean_area, cell_max_area)\
if (cell_mean_area and cell_max_area) else ""
])
return Result(stages=Stages([stage]), output=(anatomical, count, outline))
def surface_mask2(input: MincAtom,
surface: FileAtom,
args: List[str] = []) -> Result[MincAtom]:
mask_vol = surface.newname_with_suffix("_mask", ext=".mnc")
stage = CmdStage(inputs=(input, surface),
outputs=(mask_vol, ),
cmd=["surface_mask2", "-clobber"] + args +
[input.path, surface.path, mask_vol.path])
return Result(stages=Stages([stage]), output=mask_vol)
def transform_objects(
input_obj: FileAtom,
xfm: XfmAtom) -> Result[FileAtom]: # XfmAtom -> XfmHandler??
output_obj = input_obj.newname_with_suffix("_resampled_via_%s" %
xfm.filename_wo_ext)
stage = CmdStage(
inputs=(input_obj, xfm),
outputs=(output_obj, ),
cmd=["transform_objects", input_obj.path, xfm.path, output_obj.path])
return Result(stages=Stages([stage]), output=output_obj)
def make_laplace_grid(input_labels: FileAtom,
label_mapping: FileAtom,
binary_closing: bool = None,
side: Optional[Side] = None):
out_grid = input_labels.newname_with_suffix("_laplace_grid" +
("_%s" %
side.name if side else ""))
s = CmdStage(inputs=(input_labels, label_mapping),
outputs=(out_grid, ),
cmd=["make_laplace_grid", "--clobber"] +
optional(binary_closing, "--binary_closing") +
optional(side, "--%s" % side.name) +
[input_labels.path, label_mapping.path, out_grid.path])
return Result(stages=Stages([s]), output=out_grid)
def diffuse(
obj_file: FileAtom,
input_signal: FileAtom,
#output_signal : FileAtom,
kernel: Optional[float] = None,
iterations: Optional[int] = None,
parametric: Optional[int] = None):
output_signal = input_signal.newname_with_suffix("_thickness")
stage = CmdStage(
inputs=(obj_file, input_signal),
outputs=(output_signal, ),
cmd=[
"diffuse"
] # TODO make an abstraction for this; see Nix stdlib's `optional`
+ ["-kernel", str(kernel)] if kernel is not None else [] +
["-iterations", iterations] if iterations is not None else [] +
["-parametric", parametric] if parametric is not None else [] +
[obj_file, input_signal, output_signal])
return Result(stages=Stages([stage]), output=output_signal)
def decimate(in_obj: FileAtom,
reduction: float,
smoothing_method: Optional[Smoothing] = None,
smoothing_iterations: Optional[int] = None):
decimated = in_obj.newname_with_suffix("_decimated_%s" % reduction + (
"_smooth" if smoothing_method not in (Smoothing.none, None) else ""))
stage = CmdStage(inputs=(in_obj, ),
outputs=(decimated, ),
cmd=["decimate.py"] +
(["--smoothing-method", smoothing_method.name]
if smoothing_method not in ("none", None) else []) +
(["--smoothing-iterations",
str(smoothing_iterations)]
if smoothing_iterations is not None else []) +
[str(reduction), in_obj.path, decimated.path])
return Result(stages=Stages([stage]), output=decimated)
