def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# check if output image exists
if not args.force:
if os.path.exists(args.output):
logger.warning(
'The output image {} already exists. Exiting.'.format(
args.output))
exit(-1)
# constants
# the minimal edge length of a subvolume-cube ! has to be of type int!
minimal_edge_length = 200
overlap = 20
# load input images
region_image_data, reference_header = load(args.region)
markers_image_data, _ = load(args.markers)
gradient_image_data, _ = load(args.gradient)
# split marker image into fg and bg images
fgmarkers_image_data, bgmarkers_image_data = split_marker(
markers_image_data)
# execute distributed graph cut
output_volume = graphcut_split(graphcut_stawiaski, region_image_data,
gradient_image_data, fgmarkers_image_data,
bgmarkers_image_data, minimal_edge_length,
overlap)
# save resulting mask
save(output_volume, args.output, reference_header, args.force)
logger.info('Successfully terminated.')
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# check if output image exists
if not args.force:
if os.path.exists(args.output):
logger.warning('The output image {} already exists. Exiting.'.format(args.output))
exit(-1)
# constants
# the minimal edge length of a subvolume-cube ! has to be of type int!
minimal_edge_length = 200
overlap = 20
# load input images
region_image_data, reference_header = load(args.region)
markers_image_data, _ = load(args.markers)
gradient_image_data, _ = load(args.gradient)
# split marker image into fg and bg images
fgmarkers_image_data, bgmarkers_image_data = split_marker(markers_image_data)
# execute distributed graph cut
output_volume = graphcut_split(graphcut_stawiaski,
region_image_data,
gradient_image_data,
fgmarkers_image_data,
bgmarkers_image_data,
minimal_edge_length,
overlap)
# save resulting mask
save(output_volume, args.output, reference_header, args.force)
logger.info('Successfully terminated.')
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# check if output image exists
if not args.force:
if os.path.exists(args.output):
logger.warning('The output image {} already exists. Exiting.'.format(args.output))
exit(-1)
# select boundary term
['diff_linear', 'diff_exp', 'diff_div', 'diff_pow', 'max_linear', 'max_exp', 'max_div', 'max_pow']
if 'diff_linear' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_difference_linear
logger.info('Selected boundary term: linear difference of intensities')
elif 'diff_exp' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_difference_exponential
logger.info('Selected boundary term: exponential difference of intensities')
elif 'diff_div' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_difference_division
logger.info('Selected boundary term: divided difference of intensities')
elif 'diff_pow' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_difference_power
logger.info('Selected boundary term: power based / raised difference of intensities')
elif 'max_linear' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_maximum_linear
logger.info('Selected boundary term: linear maximum of intensities')
elif 'max_exp' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_maximum_exponential
logger.info('Selected boundary term: exponential maximum of intensities')
elif 'max_div' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_maximum_division
logger.info('Selected boundary term: divided maximum of intensities')
elif 'max_pow' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_maximum_power
logger.info('Selected boundary term: power based / raised maximum of intensities')
# load input images
badditional_image_data, reference_header = load(args.badditional)
markers_image_data, _ = load(args.markers)
# split marker image into fg and bg images
fgmarkers_image_data, bgmarkers_image_data = split_marker(markers_image_data)
# check if all images dimensions are the same
if not (badditional_image_data.shape == fgmarkers_image_data.shape == bgmarkers_image_data.shape):
logger.critical('Not all of the supplied images are of the same shape.')
raise ArgumentError('Not all of the supplied images are of the same shape.')
# extract spacing if required
if args.spacing:
spacing = header.get_pixel_spacing(reference_header)
logger.info('Taking spacing of {} into account.'.format(spacing))
else:
spacing = False
# generate graph
logger.info('Preparing BK_MFMC C++ graph...')
gcgraph = graphcut.graph_from_voxels(fgmarkers_image_data,
bgmarkers_image_data,
boundary_term = boundary_term,
boundary_term_args = (badditional_image_data, args.sigma, spacing))
# execute min-cut
logger.info('Executing min-cut...')
maxflow = gcgraph.maxflow()
logger.debug('Maxflow is {}'.format(maxflow))
# reshape results to form a valid mask
logger.info('Applying results...')
result_image_data = scipy.zeros(bgmarkers_image_data.size, dtype=scipy.bool_)
for idx in range(len(result_image_data)):
result_image_data[idx] = 0 if gcgraph.termtype.SINK == gcgraph.what_segment(idx) else 1
result_image_data = result_image_data.reshape(bgmarkers_image_data.shape)
# save resulting mask
save(result_image_data.astype(scipy.bool_), args.output, reference_header, args.force)
logger.info('Successfully terminated.')
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# check if output image exists
if not args.force:
if os.path.exists(args.output):
logger.warning('The output image {} already exists. Exiting.'.format(args.output))
exit(-1)
# select boundary term
if args.boundary == 'stawiaski':
boundary_term = graphcut.energy_label.boundary_stawiaski
logger.info('Selected boundary term: stawiaski')
else:
boundary_term = graphcut.energy_label.boundary_difference_of_means
logger.info('Selected boundary term: difference of means')
# load input images
region_image_data, reference_header = load(args.region)
badditional_image_data, _ = load(args.badditional)
markers_image_data, _ = load(args.markers)
# split marker image into fg and bg images
fgmarkers_image_data, bgmarkers_image_data = split_marker(markers_image_data)
# check if all images dimensions are the same
if not (badditional_image_data.shape == region_image_data.shape == fgmarkers_image_data.shape == bgmarkers_image_data.shape):
logger.critical('Not all of the supplied images are of the same shape.')
raise ArgumentError('Not all of the supplied images are of the same shape.')
# recompute the label ids to start from id = 1
logger.info('Relabel input image...')
region_image_data = filter.relabel(region_image_data)
# generate graph
logger.info('Preparing graph...')
gcgraph = graphcut.graph_from_labels(region_image_data,
fgmarkers_image_data,
bgmarkers_image_data,
boundary_term = boundary_term,
boundary_term_args = (badditional_image_data)) # second is directedness of graph , 0)
logger.info('Removing images that are not longer required from memory...')
del fgmarkers_image_data
del bgmarkers_image_data
del badditional_image_data
# execute min-cut
logger.info('Executing min-cut...')
maxflow = gcgraph.maxflow()
logger.debug('Maxflow is {}'.format(maxflow))
# apply results to the region image
logger.info('Applying results...')
mapping = [0] # no regions with id 1 exists in mapping, entry used as padding
mapping.extend(map(lambda x: 0 if gcgraph.termtype.SINK == gcgraph.what_segment(int(x) - 1) else 1,
scipy.unique(region_image_data)))
region_image_data = filter.relabel_map(region_image_data, mapping)
# save resulting mask
save(region_image_data.astype(scipy.bool_), args.output, reference_header, args.force)
logger.info('Successfully terminated.')
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# check if output image exists
if not args.force:
if os.path.exists(args.output):
logger.warning('The output image {} already exists. Exiting.'.format(args.output))
exit(-1)
# select boundary term
['diff_linear', 'diff_exp', 'diff_div', 'diff_pow', 'max_linear', 'max_exp', 'max_div', 'max_pow']
if 'diff_linear' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_difference_linear
logger.info('Selected boundary term: linear difference of intensities')
elif 'diff_exp' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_difference_exponential
logger.info('Selected boundary term: exponential difference of intensities')
elif 'diff_div' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_difference_division
logger.info('Selected boundary term: divided difference of intensities')
elif 'diff_pow' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_difference_power
logger.info('Selected boundary term: power based / raised difference of intensities')
elif 'max_linear' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_maximum_linear
logger.info('Selected boundary term: linear maximum of intensities')
elif 'max_exp' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_maximum_exponential
logger.info('Selected boundary term: exponential maximum of intensities')
elif 'max_div' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_maximum_division
logger.info('Selected boundary term: divided maximum of intensities')
elif 'max_pow' == args.boundary:
boundary_term = graphcut.energy_voxel.boundary_maximum_power
logger.info('Selected boundary term: power based / raised maximum of intensities')
# load input images
badditional_image_data, reference_header = load(args.badditional)
markers_image_data, _ = load(args.markers)
# split marker image into fg and bg images
fgmarkers_image_data, bgmarkers_image_data = split_marker(markers_image_data)
# check if all images dimensions are the same
if not (badditional_image_data.shape == fgmarkers_image_data.shape == bgmarkers_image_data.shape):
logger.critical('Not all of the supplied images are of the same shape.')
raise ArgumentError('Not all of the supplied images are of the same shape.')
# extract spacing if required
if args.spacing:
spacing = header.get_pixel_spacing(reference_header)
logger.info('Taking spacing of {} into account.'.format(spacing))
else:
spacing = False
# generate graph
logger.info('Preparing BK_MFMC C++ graph...')
gcgraph = graphcut.graph_from_voxels(fgmarkers_image_data,
bgmarkers_image_data,
boundary_term = boundary_term,
boundary_term_args = (badditional_image_data, args.sigma, spacing))
# execute min-cut
logger.info('Executing min-cut...')
maxflow = gcgraph.maxflow()
logger.debug('Maxflow is {}'.format(maxflow))
# reshape results to form a valid mask
logger.info('Applying results...')
result_image_data = scipy.zeros(bgmarkers_image_data.size, dtype=scipy.bool_)
for idx in range(len(result_image_data)):
result_image_data[idx] = 0 if gcgraph.termtype.SINK == gcgraph.what_segment(idx) else 1
result_image_data = result_image_data.reshape(bgmarkers_image_data.shape)
# save resulting mask
save(result_image_data.astype(scipy.bool_), args.output, reference_header, args.force)
logger.info('Successfully terminated.')
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# check if output image exists
if not args.force:
if os.path.exists(args.output):
logger.warning(
'The output image {} already exists. Exiting.'.format(
args.output))
exit(-1)
# load input images
region_image_data, reference_header = load(args.region)
markers_image_data, _ = load(args.markers)
gradient_image_data, _ = load(args.gradient)
# split marker image into fg and bg images
logger.info('Extracting foreground and background markers...')
fgmarkers_image_data, bgmarkers_image_data = split_marker(
markers_image_data)
# check if all images dimensions are the same shape
if not (gradient_image_data.shape == region_image_data.shape ==
fgmarkers_image_data.shape == bgmarkers_image_data.shape):
logger.critical(
'Not all of the supplied images are of the same shape.')
raise ArgumentError(
'Not all of the supplied images are of the same shape.')
# collect cut objects
cut_xy = __get_bg_bounding_pipe(bgmarkers_image_data)
# cut volumes
old_size = region_image_data.shape
gradient_image_data = gradient_image_data[cut_xy]
region_image_data = region_image_data[cut_xy]
fgmarkers_image_data = fgmarkers_image_data[cut_xy]
bgmarkers_image_data = bgmarkers_image_data[cut_xy]
# recompute the label ids to start from id = 1
logger.info('Relabel input image...')
region_image_data = filter.relabel(region_image_data)
# generate graph
logger.info('Preparing graph...')
gcgraph = graphcut.graph_from_labels(
region_image_data,
fgmarkers_image_data,
bgmarkers_image_data,
boundary_term=graphcut.energy_label.boundary_stawiaski,
boundary_term_args=(
gradient_image_data)) # second is directedness of graph , 0)
logger.info('Removing images that are not longer required from memory...')
del fgmarkers_image_data
del bgmarkers_image_data
del gradient_image_data
# execute min-cut
logger.info('Executing min-cut...')
maxflow = gcgraph.maxflow()
logger.debug('Maxflow is {}'.format(maxflow))
# apply results to the region image
logger.info('Applying results...')
mapping = [
0
] # no regions with id 1 exists in mapping, entry used as padding
mapping.extend(
map(
lambda x: 0 if gcgraph.termtype.SINK == gcgraph.what_segment(
int(x) - 1) else 1, scipy.unique(region_image_data)))
region_image_data = filter.relabel_map(region_image_data, mapping)
# generating final image by increasing the size again
output_image_data = scipy.zeros(old_size, dtype=scipy.bool_)
output_image_data[cut_xy] = region_image_data
# save resulting mask
save(output_image_data, args.output, reference_header, args.force)
logger.info('Successfully terminated.')
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# check if output image exists
if not args.force:
if os.path.exists(args.output):
logger.warning('The output image {} already exists. Exiting.'.format(args.output))
exit(-1)
# select boundary term
if args.boundary == 'stawiaski':
boundary_term = graphcut.energy_label.boundary_stawiaski
logger.info('Selected boundary term: stawiaski')
else:
boundary_term = graphcut.energy_label.boundary_difference_of_means
logger.info('Selected boundary term: difference of means')
# select regional term
if args.regional == 'atlas':
regional_term = graphcut.energy_label.regional_atlas
else:
regional_term = None
# load input images
region_image_data, reference_header = load(args.region)
markers_image_data, _ = load(args.markers)
# loading and splitting the marker image
fgmarkers_image_data, bgmarkers_image_data = split_marker(markers_image_data)
badditional_image_data, _ = load(args.badditional)
if 'radditional' in args:
radditional_image_data, _ = load(args.radditional)
else:
radditional_image_data = False
# check if all images dimensions are the same
if not (badditional_image_data.shape == region_image_data.shape == fgmarkers_image_data.shape == bgmarkers_image_data.shape):
logger.critical('Not all of the supplied images are of the same shape.')
raise ArgumentError('Not all of the supplied images are of the same shape.')
if not bool == type(radditional_image_data):
if not (badditional_image_data.shape == radditional_image_data.shape):
logger.critical('Not all of the supplied images are of the same shape.')
raise ArgumentError('Not all of the supplied images are of the same shape.')
# recompute the label ids to start from id = 1
logger.info('Relabel input image...')
region_image_data = filter.relabel(region_image_data)
# generate graph
logger.info('Preparing graph...')
gcgraph = graphcut.graph_from_labels(region_image_data,
fgmarkers_image_data,
bgmarkers_image_data,
regional_term = regional_term,
boundary_term = boundary_term,
regional_term_args = (radditional_image_data, args.alpha),
boundary_term_args = (badditional_image_data)) # second (optional) parameter is directedness of graph , 0)
logger.info('Removing images that are not longer required from memory...')
del fgmarkers_image_data
del bgmarkers_image_data
del radditional_image_data
del badditional_image_data
# execute min-cut
logger.info('Executing min-cut...')
maxflow = gcgraph.maxflow()
logger.debug('Maxflow is {}'.format(maxflow))
# apply results to the region image
logger.info('Applying results...')
mapping = [0] # no regions with id 1 exists in mapping, entry used as padding
mapping.extend(map(lambda x: 0 if gcgraph.termtype.SINK == gcgraph.what_segment(int(x) - 1) else 1,
scipy.unique(region_image_data)))
region_image_data = filter.relabel_map(region_image_data, mapping)
# save resulting mask
save(region_image_data.astype(scipy.bool_), args.output, reference_header, args.force)
logger.info('Successfully terminated.')
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# check if output image exists
if not args.force:
if os.path.exists(args.output):
logger.warning('The output image {} already exists. Exiting.'.format(args.output))
exit(-1)
# load input images
region_image_data, reference_header = load(args.region)
markers_image_data, _ = load(args.markers)
gradient_image_data, _ = load(args.gradient)
# split marker image into fg and bg images
logger.info('Extracting foreground and background markers...')
fgmarkers_image_data, bgmarkers_image_data = split_marker(markers_image_data)
# check if all images dimensions are the same shape
if not (gradient_image_data.shape == region_image_data.shape == fgmarkers_image_data.shape == bgmarkers_image_data.shape):
logger.critical('Not all of the supplied images are of the same shape.')
raise ArgumentError('Not all of the supplied images are of the same shape.')
# collect cut objects
cut_xy = __get_bg_bounding_pipe(bgmarkers_image_data)
# cut volumes
old_size = region_image_data.shape
gradient_image_data = gradient_image_data[cut_xy]
region_image_data = region_image_data[cut_xy]
fgmarkers_image_data = fgmarkers_image_data[cut_xy]
bgmarkers_image_data = bgmarkers_image_data[cut_xy]
# recompute the label ids to start from id = 1
logger.info('Relabel input image...')
region_image_data = filter.relabel(region_image_data)
# generate graph
logger.info('Preparing graph...')
gcgraph = graphcut.graph_from_labels(region_image_data,
fgmarkers_image_data,
bgmarkers_image_data,
boundary_term = graphcut.energy_label.boundary_stawiaski,
boundary_term_args = (gradient_image_data)) # second is directedness of graph , 0)
logger.info('Removing images that are not longer required from memory...')
del fgmarkers_image_data
del bgmarkers_image_data
del gradient_image_data
# execute min-cut
logger.info('Executing min-cut...')
maxflow = gcgraph.maxflow()
logger.debug('Maxflow is {}'.format(maxflow))
# apply results to the region image
logger.info('Applying results...')
mapping = [0] # no regions with id 1 exists in mapping, entry used as padding
mapping.extend(map(lambda x: 0 if gcgraph.termtype.SINK == gcgraph.what_segment(int(x) - 1) else 1,
scipy.unique(region_image_data)))
region_image_data = filter.relabel_map(region_image_data, mapping)
# generating final image by increasing the size again
output_image_data = scipy.zeros(old_size, dtype=scipy.bool_)
output_image_data[cut_xy] = region_image_data
# save resulting mask
save(output_image_data, args.output, reference_header, args.force)
logger.info('Successfully terminated.')
