def remove_wrongly_sized_connected_components(a,
min_size,
max_size=None,
in_place=False,
bin_out=False):
original_dtype = a.dtype
if not in_place:
a = a.copy()
if min_size == 0 and (max_size is None or max_size > numpy.prod(a.shape)
): # shortcut for efficiency
if bin_out:
numpy.place(a, a, 1)
return a
component_sizes = vigra_bincount(a)
bad_sizes = component_sizes < min_size
if max_size is not None:
numpy.logical_or(bad_sizes, component_sizes > max_size, out=bad_sizes)
del component_sizes
bad_locations = bad_sizes[a]
a[bad_locations] = 0
del bad_locations
if bin_out:
# Replace non-zero values with 1
numpy.place(a, a, 1)
return numpy.asarray(a, dtype=original_dtype)
def filter_labels(a, min_size, max_size=None):
"""
Remove (set to 0) labeled connected components that are too small or too large.
Note: Operates in-place.
"""
if min_size == 0 and (max_size is None or max_size > numpy.prod(a.shape)): # shortcut for efficiency
return a
component_sizes = vigra_bincount(a)
bad_sizes = component_sizes < min_size
if max_size is not None:
numpy.logical_or( bad_sizes, component_sizes > max_size, out=bad_sizes )
bad_locations = bad_sizes[a]
a[bad_locations] = 0
return a
def filter_labels(a, min_size, max_size=None):
"""
Remove (set to 0) labeled connected components that are too small or too large.
Note: Operates in-place.
"""
if min_size == 0 and (max_size is None or max_size > numpy.prod(a.shape)
): # shortcut for efficiency
return a
component_sizes = vigra_bincount(a)
bad_sizes = component_sizes < min_size
if max_size is not None:
numpy.logical_or(bad_sizes, component_sizes > max_size, out=bad_sizes)
bad_locations = bad_sizes[a]
a[bad_locations] = 0
return a
def remove_wrongly_sized_connected_components(a, min_size, max_size=None, in_place=False, bin_out=False):
original_dtype = a.dtype
if not in_place:
a = a.copy()
if min_size == 0 and (max_size is None or max_size > numpy.prod(a.shape)): # shortcut for efficiency
if (bin_out):
numpy.place(a,a,1)
return a
component_sizes = vigra_bincount(a)
bad_sizes = component_sizes < min_size
if max_size is not None:
numpy.logical_or( bad_sizes, component_sizes > max_size, out=bad_sizes )
del component_sizes
bad_locations = bad_sizes[a]
a[bad_locations] = 0
del bad_locations
if (bin_out):
# Replace non-zero values with 1
numpy.place(a,a,1)
return numpy.asarray(a, dtype=original_dtype)
def import_labeling_layer(labelLayer, labelingSlots, parent_widget=None):
"""
Prompt the user for layer import settings, and perform the layer import.
:param labelLayer: The top label layer source
:param labelingSlots: An instance of LabelingGui.LabelingSlots
:param parent_widget: The Qt GUI parent object
"""
writeSeeds = labelingSlots.labelInput
assert isinstance(writeSeeds, lazyflow.graph.Slot), "slot is of type %r" % (type(writeSeeds))
opLabels = writeSeeds.getRealOperator()
assert isinstance(opLabels, lazyflow.graph.Operator), "slot's operator is of type %r" % (type(opLabels))
recentlyImported = PreferencesManager().get('labeling', 'recently imported')
mostRecentProjectPath = PreferencesManager().get('shell', 'recently opened')
mostRecentImageFile = PreferencesManager().get( 'DataSelection', 'recent image' )
if recentlyImported:
defaultDirectory = os.path.split(recentlyImported)[0]
elif mostRecentProjectPath:
defaultDirectory = os.path.split(mostRecentProjectPath)[0]
elif mostRecentImageFile:
defaultDirectory = os.path.split(mostRecentImageFile)[0]
else:
defaultDirectory = os.path.expanduser('~')
fileNames = DataSelectionGui.getImageFileNamesToOpen(parent_widget, defaultDirectory)
fileNames = map(str, fileNames)
if not fileNames:
return
PreferencesManager().set('labeling', 'recently imported', fileNames[0])
try:
# Initialize operators
opImport = OpInputDataReader( parent=opLabels.parent )
opCache = OpArrayCache( parent=opLabels.parent )
opMetadataInjector = OpMetadataInjector( parent=opLabels.parent )
opReorderAxes = OpReorderAxes( parent=opLabels.parent )
# Set up the pipeline as follows:
#
# opImport --> opCache --> opMetadataInjector --------> opReorderAxes --(inject via setInSlot)--> labelInput
# / /
# User-specified axisorder labelInput.meta.axistags
opImport.WorkingDirectory.setValue(defaultDirectory)
opImport.FilePath.setValue(fileNames[0] if len(fileNames) == 1 else
os.path.pathsep.join(fileNames))
assert opImport.Output.ready()
opCache.blockShape.setValue( opImport.Output.meta.shape )
opCache.Input.connect( opImport.Output )
assert opCache.Output.ready()
opMetadataInjector.Input.connect( opCache.Output )
metadata = opCache.Output.meta.copy()
opMetadataInjector.Metadata.setValue( metadata )
opReorderAxes.Input.connect( opMetadataInjector.Output )
# Transpose the axes for assignment to the labeling operator.
opReorderAxes.AxisOrder.setValue( writeSeeds.meta.getAxisKeys() )
# We'll show a little window with a busy indicator while the data is loading
busy_dlg = QProgressDialog(parent=parent_widget)
busy_dlg.setLabelText("Importing Label Data...")
busy_dlg.setCancelButton(None)
busy_dlg.setMinimum(100)
busy_dlg.setMaximum(100)
def close_busy_dlg(*args):
QApplication.postEvent(busy_dlg, QCloseEvent())
# Load the data from file into our cache
# When it's done loading, close the progress dialog.
req = opCache.Output[:]
req.notify_finished( close_busy_dlg )
req.notify_failed( close_busy_dlg )
req.submit()
busy_dlg.exec_()
readData = req.result
maxLabels = len(labelingSlots.labelNames.value)
# Can't use return_counts feature because that requires numpy >= 1.9
#unique_read_labels, readLabelCounts = numpy.unique(readData, return_counts=True)
# This does the same as the above, albeit slower, and probably with more ram.
unique_read_labels = numpy.unique(readData)
readLabelCounts = vigra_bincount(readData)[unique_read_labels]
labelInfo = (maxLabels, (unique_read_labels, readLabelCounts))
del readData
# Ask the user how to interpret the data.
settingsDlg = LabelImportOptionsDlg( parent_widget,
fileNames, opMetadataInjector.Output,
labelingSlots.labelInput, labelInfo )
def handle_updated_axes():
# The user is specifying a new interpretation of the file's axes
updated_axisorder = str(settingsDlg.axesEdit.text())
metadata = opMetadataInjector.Metadata.value.copy()
metadata.axistags = vigra.defaultAxistags(updated_axisorder)
opMetadataInjector.Metadata.setValue( metadata )
if opReorderAxes._invalid_axes:
settingsDlg.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
# Red background
settingsDlg.axesEdit.setStyleSheet("QLineEdit { background: rgb(255, 128, 128);"
"selection-background-color: rgb(128, 128, 255); }")
settingsDlg.axesEdit.editingFinished.connect( handle_updated_axes )
# Initialize
handle_updated_axes()
dlg_result = settingsDlg.exec_()
if dlg_result != LabelImportOptionsDlg.Accepted:
return
# Get user's chosen label mapping from dlg
labelMapping = settingsDlg.labelMapping
# Get user's chosen offsets.
# Offsets in dlg only include the file axes, not the 5D axes expected by the label input,
# so expand them to full 5D
axes_5d = opReorderAxes.Output.meta.getAxisKeys()
tagged_offsets = collections.OrderedDict( zip( axes_5d, [0]*len(axes_5d) ) )
tagged_offsets.update( dict( zip( opMetadataInjector.Output.meta.getAxisKeys(), settingsDlg.imageOffsets ) ) )
imageOffsets = tagged_offsets.values()
# Optimization if mapping is identity
if labelMapping.keys() == labelMapping.values():
labelMapping = None
# This will be fast (it's already cached)
label_data = opReorderAxes.Output[:].wait()
# Map input labels to output labels
if labelMapping:
# There are other ways to do a relabeling (e.g skimage.segmentation.relabel_sequential)
# But this supports potentially huge values of unique_read_labels (in the billions),
# without needing GB of RAM.
mapping_indexes = numpy.searchsorted(unique_read_labels, label_data)
new_labels = numpy.array([labelMapping[x] for x in unique_read_labels])
label_data[:] = new_labels[mapping_indexes]
label_roi = numpy.array( roiFromShape(opReorderAxes.Output.meta.shape) )
label_roi += imageOffsets
label_slice = roiToSlice(*label_roi)
writeSeeds[label_slice] = label_data
finally:
opReorderAxes.cleanUp()
opMetadataInjector.cleanUp()
opCache.cleanUp()
opImport.cleanUp()
def import_labeling_layer(labelLayer, labelingSlots, parent_widget=None):
"""
Prompt the user for layer import settings, and perform the layer import.
:param labelLayer: The top label layer source
:param labelingSlots: An instance of LabelingGui.LabelingSlots
:param parent_widget: The Qt GUI parent object
"""
writeSeeds = labelingSlots.labelInput
assert isinstance(
writeSeeds,
lazyflow.graph.Slot), "slot is of type %r" % (type(writeSeeds))
opLabels = writeSeeds.getRealOperator()
assert isinstance(opLabels, lazyflow.graph.Operator
), "slot's operator is of type %r" % (type(opLabels))
recentlyImported = PreferencesManager().get('labeling',
'recently imported')
mostRecentProjectPath = PreferencesManager().get('shell',
'recently opened')
mostRecentImageFile = PreferencesManager().get('DataSelection',
'recent image')
if recentlyImported:
defaultDirectory = os.path.split(recentlyImported)[0]
elif mostRecentProjectPath:
defaultDirectory = os.path.split(mostRecentProjectPath)[0]
elif mostRecentImageFile:
defaultDirectory = os.path.split(mostRecentImageFile)[0]
else:
defaultDirectory = os.path.expanduser('~')
fileNames = DataSelectionGui.getImageFileNamesToOpen(
parent_widget, defaultDirectory)
fileNames = map(str, fileNames)
if not fileNames:
return
PreferencesManager().set('labeling', 'recently imported', fileNames[0])
try:
# Initialize operators
opImport = OpInputDataReader(parent=opLabels.parent)
opCache = OpBlockedArrayCache(parent=opLabels.parent)
opMetadataInjector = OpMetadataInjector(parent=opLabels.parent)
opReorderAxes = OpReorderAxes(parent=opLabels.parent)
# Set up the pipeline as follows:
#
# opImport --> opCache --> opMetadataInjector --------> opReorderAxes --(inject via setInSlot)--> labelInput
# / /
# User-specified axisorder labelInput.meta.axistags
opImport.WorkingDirectory.setValue(defaultDirectory)
opImport.FilePath.setValue(fileNames[0] if len(fileNames) ==
1 else os.path.pathsep.join(fileNames))
assert opImport.Output.ready()
opCache.Input.connect(opImport.Output)
opCache.CompressionEnabled.setValue(True)
assert opCache.Output.ready()
opMetadataInjector.Input.connect(opCache.Output)
metadata = opCache.Output.meta.copy()
opMetadataInjector.Metadata.setValue(metadata)
opReorderAxes.Input.connect(opMetadataInjector.Output)
# Transpose the axes for assignment to the labeling operator.
opReorderAxes.AxisOrder.setValue(writeSeeds.meta.getAxisKeys())
# We'll show a little window with a busy indicator while the data is loading
busy_dlg = QProgressDialog(parent=parent_widget)
busy_dlg.setLabelText("Importing Label Data...")
busy_dlg.setCancelButton(None)
busy_dlg.setMinimum(100)
busy_dlg.setMaximum(100)
def close_busy_dlg(*args):
QApplication.postEvent(busy_dlg, QCloseEvent())
# Load the data from file into our cache
# When it's done loading, close the progress dialog.
req = opCache.Output[:]
req.notify_finished(close_busy_dlg)
req.notify_failed(close_busy_dlg)
req.submit()
busy_dlg.exec_()
readData = req.result
maxLabels = len(labelingSlots.labelNames.value)
# Can't use return_counts feature because that requires numpy >= 1.9
#unique_read_labels, readLabelCounts = numpy.unique(readData, return_counts=True)
# This does the same as the above, albeit slower, and probably with more ram.
unique_read_labels = numpy.sort(vigra.analysis.unique(readData))
readLabelCounts = vigra_bincount(readData)[unique_read_labels]
labelInfo = (maxLabels, (unique_read_labels, readLabelCounts))
del readData
# Ask the user how to interpret the data.
settingsDlg = LabelImportOptionsDlg(parent_widget, fileNames,
opMetadataInjector.Output,
labelingSlots.labelInput,
labelInfo)
def handle_updated_axes():
# The user is specifying a new interpretation of the file's axes
updated_axisorder = str(settingsDlg.axesEdit.text())
metadata = opMetadataInjector.Metadata.value.copy()
metadata.axistags = vigra.defaultAxistags(updated_axisorder)
opMetadataInjector.Metadata.setValue(metadata)
if opReorderAxes._invalid_axes:
settingsDlg.buttonBox.button(
QDialogButtonBox.Ok).setEnabled(False)
# Red background
settingsDlg.axesEdit.setStyleSheet(
"QLineEdit { background: rgb(255, 128, 128);"
"selection-background-color: rgb(128, 128, 255); }")
settingsDlg.axesEdit.editingFinished.connect(handle_updated_axes)
# Initialize
handle_updated_axes()
dlg_result = settingsDlg.exec_()
if dlg_result != LabelImportOptionsDlg.Accepted:
return
# Get user's chosen label mapping from dlg
labelMapping = settingsDlg.labelMapping
# Get user's chosen offsets, ordered by the 'write seeds' slot
axes_5d = opReorderAxes.Output.meta.getAxisKeys()
tagged_offsets = collections.OrderedDict(
zip(axes_5d, [0] * len(axes_5d)))
tagged_offsets.update(
dict(
zip(opReorderAxes.Output.meta.getAxisKeys(),
settingsDlg.imageOffsets)))
imageOffsets = tagged_offsets.values()
# Optimization if mapping is identity
if labelMapping.keys() == labelMapping.values():
labelMapping = None
# This will be fast (it's already cached)
label_data = opReorderAxes.Output[:].wait()
# Map input labels to output labels
if labelMapping:
# There are other ways to do a relabeling (e.g skimage.segmentation.relabel_sequential)
# But this supports potentially huge values of unique_read_labels (in the billions),
# without needing GB of RAM.
mapping_indexes = numpy.searchsorted(unique_read_labels,
label_data)
new_labels = numpy.array(
[labelMapping[x] for x in unique_read_labels])
label_data[:] = new_labels[mapping_indexes]
label_roi = numpy.array(roiFromShape(opReorderAxes.Output.meta.shape))
label_roi += imageOffsets
label_slice = roiToSlice(*label_roi)
writeSeeds[label_slice] = label_data
finally:
opReorderAxes.cleanUp()
opMetadataInjector.cleanUp()
opCache.cleanUp()
opImport.cleanUp()
def execute(self, slot, subindex, roi, result):
assert slot == self.Output
# This operator is typically used with very big rois, so be extremely memory-conscious:
# - Don't request the small and big inputs in parallel.
# - Clean finished requests immediately (don't wait for this function to exit)
# - Delete intermediate results as soon as possible.
if logger.isEnabledFor(logging.DEBUG):
dtypeBytes = self.SmallLabels.meta.getDtypeBytes()
roiShape = roi.stop - roi.start
logger.debug("Roi shape is {} = {} MB".format(roiShape, numpy.prod(roiShape) * dtypeBytes / 1e6 ))
starting_memory_usage_mb = getMemoryUsageMb()
logger.debug("Starting with memory usage: {} MB".format(starting_memory_usage_mb))
def logMemoryIncrease(msg):
"""Log a debug message about the RAM usage compared to when this function started execution."""
if logger.isEnabledFor(logging.DEBUG):
memory_increase_mb = getMemoryUsageMb() - starting_memory_usage_mb
logger.debug("{}, memory increase is: {} MB".format(msg, memory_increase_mb))
smallLabelsReq = self.SmallLabels(roi.start, roi.stop)
smallLabels = smallLabelsReq.wait()
smallLabelsReq.clean()
logMemoryIncrease("After obtaining small labels")
smallNonZero = numpy.ndarray(shape=smallLabels.shape, dtype=bool)
smallNonZero[...] = (smallLabels != 0)
del smallLabels
logMemoryIncrease("Before obtaining big labels")
bigLabels = self.BigLabels(roi.start, roi.stop).wait()
logMemoryIncrease("After obtaining big labels")
prod = smallNonZero * bigLabels
del smallNonZero
# get labels that passed the masking
#passed = numpy.unique(prod)
passed = vigra_bincount(prod).nonzero()[0] # Much faster than unique(), which copies and sorts
# 0 is not a valid label
if passed[0] == 0:
passed = passed[1:]
logMemoryIncrease("After taking product")
del prod
all_label_values = numpy.zeros((bigLabels.max()+1,),
dtype=numpy.uint32)
for i, l in enumerate(passed):
all_label_values[l] = i+1
all_label_values[0] = 0
# tricky: map the old labels to the new ones, labels that didnt pass
# are mapped to zero
result[:] = all_label_values[bigLabels]
logMemoryIncrease("Just before return")
return result