def _checkDataConstraint(self, *args):
"""
The batch workflow uses the same classifier as the training workflow,
and therefore the batch datasets must be compatible with the training datasets in certain respects.
This function tests those constraints by comparing the batch input against a (arbitrary) training dataset,
and raises a DatasetConstraintError if something is incorrect.
"""
if not self.ConstraintDataset.ready() or not self.RawData.ready():
return
trainingMeta = self.ConstraintDataset.meta
batchMeta = self.RawData.meta
# Must have same number of channels
training_channels = trainingMeta.getTaggedShape()['c']
batch_channels = batchMeta.getTaggedShape()['c']
if training_channels != batch_channels:
raise DatasetConstraintError("Batch Prediction Input",
"Batch input must have the same number of channels as training input."\
"(Batch has {} channels, but training input used {}"\
"".format( batch_channels, training_channels ))
# Other than time, Must have same set of axes (but not necessarily in the same order)
training_axes = set(trainingMeta.getAxisKeys())
batch_axes = set(batchMeta.getAxisKeys())
training_axes.discard('t')
batch_axes.discard('t')
if training_axes != batch_axes:
raise DatasetConstraintError("Batch Prediction Input",
"Batch input file does not have the same spatial input axes as the training input:"\
"has {}, expected {}".format( batch_axes, training_axes ))
def _checkConstraints(self, laneIndex):
"""
Ensure that all input images have the same number of channels.
"""
thisLaneTaggedShape = self.InputImages[laneIndex].meta.getTaggedShape()
# Find a different lane and use it for comparison
validShape = thisLaneTaggedShape
for i, slot in enumerate(self.InputImages):
if slot.ready() and i != laneIndex:
validShape = slot.meta.getTaggedShape()
break
if validShape['c'] != thisLaneTaggedShape['c']:
raise DatasetConstraintError(
"Pixel Classification",
"All input images must have the same number of channels. "\
"Your new image has {} channel(s), but your other images have {} channel(s)."\
.format( thisLaneTaggedShape['c'], validShape['c'] ) )
if len(validShape) != len(thisLaneTaggedShape):
raise DatasetConstraintError(
"Pixel Classification",
"All input images must have the same dimensionality. "\
"Your new image has {} dimensions (including channel), but your other images have {} dimensions."\
.format( len(thisLaneTaggedShape), len(validShape) ) )
def _checkDataConstraint(self, *args):
"""
The batch workflow uses the same classifier as the training workflow,
and therefore the batch datasets must be compatible with the training datasets in certain respects.
This function tests those constraints by comparing the batch input against a (arbitrary) training dataset,
and raises a DatasetConstraintError if something is incorrect.
"""
if not self.ConstraintDataset.ready() or not self.RawData.ready():
return
dataTrain = self.ConstraintDataset.meta
dataBatch = self.RawData.meta
# Must have same dimensionality (but not necessarily the same shape)
if len(dataTrain.shape) != len(dataBatch.shape):
raise DatasetConstraintError(
"Batch Prediction Input",
"Batch input must have the same dimension as training input.")
# Must have same number of channels
if dataTrain.getTaggedShape()['c'] != dataBatch.getTaggedShape()['c']:
raise DatasetConstraintError(
"Batch Prediction Input",
"Batch input must have the same number of channels as training input."
)
# Must have same set of axes (but not necessarily in the same order)
if set(dataTrain.getAxisKeys()) != set(dataBatch.getAxisKeys()):
raise DatasetConstraintError(
"Batch Prediction Input",
"Batch input axis must fit axis of training input.")
def _checkConstraints(self, *args):
if self.RawImage.ready():
rawTaggedShape = self.RawImage.meta.getTaggedShape()
if rawTaggedShape['t'] < 2:
raise DatasetConstraintError(
"Tracking",
"For tracking, the dataset must have a time axis with at least 2 images. " \
"Please load time-series data instead. See user documentation for details.")
if self.LabelImage.ready():
segmentationTaggedShape = self.LabelImage.meta.getTaggedShape()
if segmentationTaggedShape['t'] < 2:
raise DatasetConstraintError(
"Tracking",
"For tracking, the dataset must have a time axis with at least 2 images. " \
"Please load time-series data instead. See user documentation for details.")
if self.RawImage.ready() and self.LabelImage.ready():
rawTaggedShape['c'] = None
segmentationTaggedShape['c'] = None
if dict(rawTaggedShape) != dict(segmentationTaggedShape):
raise DatasetConstraintError("Tracking",
"For tracking, the raw data and the prediction maps must contain the same " \
"number of timesteps and the same shape. " \
"Your raw image has a shape of (t, x, y, z, c) = {}, whereas your prediction image has a " \
"shape of (t, x, y, z, c) = {}" \
.format(self.RawImage.meta.shape, self.BinaryImage.meta.shape))
def _checkConstraints(self, *args):
slot = self.InputData
numChannels = slot.meta.getTaggedShape()['c']
if numChannels != 1:
raise DatasetConstraintError(
"Carving", "Input image must have exactly one channel. " +
"You attempted to add a dataset with {} channels".format(
numChannels))
sh = slot.meta.shape
ax = slot.meta.axistags
if len(slot.meta.shape) != 5:
# Raise a regular exception. This error is for developers, not users.
raise RuntimeError("was expecting a 5D dataset, got shape=%r" %
(sh, ))
if slot.meta.getTaggedShape()['t'] != 1:
raise DatasetConstraintError(
"Carving",
"Input image must not have more than one time slice. " +
"You attempted to add a dataset with {} time slices".format(
slot.meta.getTaggedShape()['t']))
for i in range(1, 4):
if not ax[i].isSpatial():
# This is for developers. Don't need a user-friendly error.
raise RuntimeError("%d-th axis %r is not spatial" % (i, ax[i]))
def _checkConstraints(self, *args):
slot = self.Input
sh = slot.meta.shape
ax = slot.meta.axistags
if (len(slot.meta.shape) != 3) and (len(slot.meta.shape) != 4):
# Raise a regular exception. This error is for developers, not users.
raise RuntimeError(
"was expecting a 3D or 4D dataset, got shape=%r" % (sh, ))
if "t" in slot.meta.getTaggedShape():
raise DatasetConstraintError("PostprocessData",
"Input must not have time.")
if "c" not in slot.meta.getTaggedShape():
raise DatasetConstraintError("PostprocessData",
"Input must have channel.")
if "y" not in slot.meta.getTaggedShape():
raise DatasetConstraintError("PostprocessData",
"Input must have space dim y.")
if "x" not in slot.meta.getTaggedShape():
raise DatasetConstraintError("PostprocessData",
"Input must have space dim x.")
if not ax[0].isChannel():
raise DatasetConstraintError(
"PostprocessData", "Input image must have channel first.")
for i in range(1, len(ax)):
if not ax[i].isSpatial():
# This is for developers. Don't need a user-friendly error.
raise RuntimeError("%d-th axis %r is not spatial" % (i, ax[i]))
def _checkConstraints(self, laneIndex):
"""
Ensure that all input images must be 2D and have the same number of channels
"""
thisLaneTaggedShape = self.InputImages[laneIndex].meta.getTaggedShape()
if thisLaneTaggedShape.has_key('z'):
raise DatasetConstraintError(
"Objects Counting Workflow",
"All input images must be 2D (they cannot contain the z dimension). "\
"Your new image has {} has z dimension"\
.format( thisLaneTaggedShape['z']))
# Find a different lane and use it for comparison
validShape = thisLaneTaggedShape
for i, slot in enumerate(self.InputImages):
if slot.ready() and i != laneIndex:
validShape = slot.meta.getTaggedShape()
break
if len(validShape) != len(thisLaneTaggedShape):
raise DatasetConstraintError(
"Objects Couting Workflow Counting",
"All input images must have the same dimensionality. "\
"Your new image has {} dimensions (including channel), but your other images have {} dimensions."\
.format( len(thisLaneTaggedShape), len(validShape) ) )
if validShape['c'] != thisLaneTaggedShape['c']:
raise DatasetConstraintError(
"Objects Counting Workflow",
"All input images must have the same number of channels. "\
"Your new image has {} channel(s), but your other images have {} channel(s)."\
.format( thisLaneTaggedShape['c'], validShape['c'] ) )
def checkConstraints(self, *args):
"""
Example of how to check input data constraints.
"""
if self.OtherInput.ready() and self.RawInput.ready():
rawTaggedShape = self.RawInput.meta.getTaggedShape()
for other_slot in self.OtherInput:
otherTaggedShape = other_slot.meta.getTaggedShape()
raw_time_size = rawTaggedShape.get("t", 1)
other_time_size = otherTaggedShape.get("t", 1)
if raw_time_size != other_time_size and raw_time_size != 1 and other_time_size != 1:
msg = (
"Your 'raw' and 'other' datasets appear to have differing sizes in the time dimension.\n"
"Your datasets have shapes: {} and {}".format(
self.RawInput.meta.shape, other_slot.meta.shape))
raise DatasetConstraintError("Layer Viewer", msg)
rawTaggedShape["c"] = None
otherTaggedShape["c"] = None
rawTaggedShape["t"] = None
otherTaggedShape["t"] = None
if dict(rawTaggedShape) != dict(otherTaggedShape):
msg = (
"Raw data and other data must have equal spatial dimensions (different channels are okay).\n"
"Your datasets have shapes: {} and {}".format(
self.RawInput.meta.shape, other_slot.meta.shape))
raise DatasetConstraintError("Layer Viewer", msg)
def checkConstraints(self, *args):
tagged_shape = self.InputImage.meta.getTaggedShape()
if 't' in tagged_shape:
raise DatasetConstraintError(
"IIBoost Pixel Classification: Feature Selection",
"This classifier handles only 3D data. Your input data has a time dimension, which is not allowed.")
if not set('xyz').issubset(tagged_shape.keys()):
raise DatasetConstraintError(
"IIBoost Pixel Classification: Feature Selection",
"This classifier handles only 3D data. Your input data does not have all three spatial dimensions (xyz).")
def setupOutputs(self):
# Check for preconditions.
if self.RawImage.ready() and self.BinaryImage.ready():
rawTaggedShape = self.RawImage.meta.getTaggedShape()
binTaggedShape = self.BinaryImage.meta.getTaggedShape()
rawTaggedShape['c'] = None
binTaggedShape['c'] = None
if dict(rawTaggedShape) != dict(binTaggedShape):
msg = "Raw data and other data must have equal dimensions (different channels are okay).\n"\
"Your datasets have shapes: {} and {}".format( self.RawImage.meta.shape, self.BinaryImage.meta.shape )
raise DatasetConstraintError("Layer Viewer", msg)
self.PredictionImage.meta.assignFrom(self.RawImage.meta)
self.PredictionImage.meta.dtype = numpy.uint8 # Ultimately determined by meta.mapping_dtype from OpRelabelSegmentation
prediction_tagged_shape = self.RawImage.meta.getTaggedShape()
prediction_tagged_shape['c'] = 1
self.PredictionImage.meta.shape = tuple(
prediction_tagged_shape.values())
self._block_shape_dict = self.BlockShape3dDict.value
self._halo_padding_dict = self.HaloPadding3dDict.value
block_shape = self._getFullShape(self._block_shape_dict)
region_feature_output_shape = (numpy.array(
self.PredictionImage.meta.shape) + block_shape - 1) / block_shape
self.BlockwiseRegionFeatures.meta.shape = tuple(
region_feature_output_shape)
self.BlockwiseRegionFeatures.meta.dtype = object
self.BlockwiseRegionFeatures.meta.axistags = self.PredictionImage.meta.axistags
def _checkConstraints(self, *args):
if self.RawImage.ready():
rawTaggedShape = self.RawImage.meta.getTaggedShape()
if 't' not in rawTaggedShape or rawTaggedShape['t'] < 2:
msg = "Raw image must have a time dimension with at least 2 images.\n"\
"Your dataset has shape: {}".format(self.RawImage.meta.shape)
if self.BinaryImage.ready():
rawTaggedShape = self.BinaryImage.meta.getTaggedShape()
if 't' not in rawTaggedShape or rawTaggedShape['t'] < 2:
msg = "Binary image must have a time dimension with at least 2 images.\n"\
"Your dataset has shape: {}".format(self.BinaryImage.meta.shape)
if self.RawImage.ready() and self.BinaryImage.ready():
rawTaggedShape = self.RawImage.meta.getTaggedShape()
binTaggedShape = self.BinaryImage.meta.getTaggedShape()
rawTaggedShape['c'] = None
binTaggedShape['c'] = None
if dict(rawTaggedShape) != dict(binTaggedShape):
logger.info("Raw data and other data must have equal dimensions (different channels are okay).\n"\
"Your datasets have shapes: {} and {}".format( self.RawImage.meta.shape, self.BinaryImage.meta.shape ))
msg = "Raw data and other data must have equal dimensions (different channels are okay).\n"\
"Your datasets have shapes: {} and {}".format( self.RawImage.meta.shape, self.BinaryImage.meta.shape )
raise DatasetConstraintError("Object Extraction", msg)
def setupOutputs(self):
# drop non-channel singleton axes
allAxes = 'txyzc'
ts = self.InputImage.meta.getTaggedShape()
oldAxes = "".join(ts.keys())
newAxes = "".join(
[a for a in allAxes if a in ts and ts[a] > 1 or a == 'c'])
self.opReorderIn.AxisOrder.setValue(newAxes)
self.opReorderOut.AxisOrder.setValue(oldAxes)
self.opReorderLayers.AxisOrder.setValue(oldAxes)
if self.FeatureListFilename.ready() and len(
self.FeatureListFilename.value) > 0:
f = open(self.FeatureListFilename.value, 'r')
self._files = []
for line in f:
line = line.strip()
if len(line) > 0:
self._files.append(line)
f.close()
self.OutputImage.disconnect()
self.FeatureLayers.disconnect()
axistags = self.InputImage.meta.axistags
self.FeatureLayers.resize(len(self._files))
for i in range(len(self._files)):
f = h5py.File(self._files[i], 'r')
shape = f["data"].shape
assert len(shape) == 3
dtype = f["data"].dtype.type
f.close()
self.FeatureLayers[i].meta.shape = shape + (1, )
self.FeatureLayers[i].meta.dtype = dtype
self.FeatureLayers[i].meta.axistags = axistags
self.FeatureLayers[i].meta.description = os.path.basename(
self._files[i])
self.OutputImage.meta.shape = (shape) + (len(self._files), )
self.OutputImage.meta.dtype = dtype
self.OutputImage.meta.axistags = axistags
self.CachedOutputImage.meta.shape = (shape) + (len(self._files), )
self.CachedOutputImage.meta.axistags = axistags
else:
# Set the new selection matrix and check if it creates an error.
selections = self.SelectionMatrix.value
self.opPixelFeatures.Matrix.setValue(selections,
check_changed=False)
invalid_scales = self.opPixelFeatures.getInvalidScales()
if invalid_scales:
msg = "Some of your selected feature scales are too large for your dataset.\n"\
"Choose smaller scales (sigma) or use a larger dataset.\n"\
"The invalid scales are: {}".format( invalid_scales )
raise DatasetConstraintError("Feature Selection", msg)
# Connect our external outputs to our internal operators
self.OutputImage.connect(self.opReorderOut.Output)
self.FeatureLayers.connect(self.opReorderLayers.Output)
def setupOutputs(self):
# drop non-channel singleton axes
allAxes = 'txyzc'
ts = self.InputImage.meta.getTaggedShape()
oldAxes = "".join(ts.keys())
newAxes = "".join([a for a in allAxes
if a in ts and ts[a] > 1 or a == 'c'])
self.opReorderIn.AxisOrder.setValue(newAxes)
self.opReorderOut.AxisOrder.setValue(oldAxes)
self.opReorderLayers.AxisOrder.setValue(oldAxes)
# Get features from external file
if self.FeatureListFilename.ready() and len(self.FeatureListFilename.value) > 0:
self.OutputImage.disconnect()
self.FeatureLayers.disconnect()
axistags = self.InputImage.meta.axistags
with h5py.File(self.FeatureListFilename.value,'r') as f:
dset_names = []
f.visit(dset_names.append)
if len(dset_names) != 1:
sys.stderr.write("Input external features HDF5 file should have exactly 1 dataset.\n")
sys.exit(1)
dset = f[dset_names[0]]
chnum = dset.shape[-1]
shape = dset.shape
dtype = dset.dtype.type
# Set the metadata for FeatureLayers. Unlike OutputImage and CachedOutputImage,
# FeatureLayers has one slot per channel and therefore the channel dimension must be 1.
self.FeatureLayers.resize(chnum)
for i in range(chnum):
self.FeatureLayers[i].meta.shape = shape[:-1]+(1,)
self.FeatureLayers[i].meta.dtype = dtype
self.FeatureLayers[i].meta.axistags = axistags
self.FeatureLayers[i].meta.display_mode = 'default'
self.FeatureLayers[i].meta.description = "feature_channel_"+str(i)
self.OutputImage.meta.shape = shape
self.OutputImage.meta.dtype = dtype
self.OutputImage.meta.axistags = axistags
else:
# Set the new selection matrix and check if it creates an error.
selections = self.SelectionMatrix.value
self.opPixelFeatures.Matrix.setValue( selections )
invalid_scales = self.opPixelFeatures.getInvalidScales()
if invalid_scales:
msg = "Some of your selected feature scales are too large for your dataset.\n"\
"Choose smaller scales (sigma) or use a larger dataset.\n"\
"The invalid scales are: {}".format( invalid_scales )
raise DatasetConstraintError( "Feature Selection", msg )
# Connect our external outputs to our internal operators
self.OutputImage.connect( self.opReorderOut.Output )
self.FeatureLayers.connect( self.opReorderLayers.Output )
def _checkConstraints(self, laneIndex):
"""
Ensure that all input images have the same number of channels.
"""
if not self.InputImages[laneIndex].ready():
return
thisLaneTaggedShape = self.InputImages[laneIndex].meta.getTaggedShape()
# Find a different lane and use it for comparison
validShape = thisLaneTaggedShape
for i, slot in enumerate(self.InputImages):
if slot.ready() and i != laneIndex:
validShape = slot.meta.getTaggedShape()
break
if "t" in thisLaneTaggedShape:
del thisLaneTaggedShape["t"]
if "t" in validShape:
del validShape["t"]
if validShape["c"] != thisLaneTaggedShape["c"]:
raise DatasetConstraintError(
"Pixel Classification",
"All input images must have the same number of channels. "
"Your new image has {} channel(s), but your other images have {} channel(s)."
.format(thisLaneTaggedShape["c"], validShape["c"]),
)
if len(validShape) != len(thisLaneTaggedShape):
raise DatasetConstraintError(
"Pixel Classification",
"All input images must have the same dimensionality. "
"Your new image has {} dimensions (including channel), but your other images have {} dimensions."
.format(len(thisLaneTaggedShape), len(validShape)),
)
mask_slot = self.PredictionMasks[laneIndex]
input_shape = self.InputImages[laneIndex].meta.shape
if mask_slot.ready() and mask_slot.meta.shape[:-1] != input_shape[:-1]:
raise DatasetConstraintError(
"Pixel Classification",
"If you supply a prediction mask, it must have the same shape as the input image."
"Your input image has shape {}, but your mask has shape {}.".
format(input_shape, mask_slot.meta.shape),
)
def _checkConstraints(self, *args):
if self.ImageA.ready() and self.ImageB.ready():
shapeA = self.ImageA.meta.getTaggedShape()
shapeB = self.ImageB.meta.getTaggedShape()
if shapeA != shapeB:
raise DatasetConstraintError("Label Image Difference",
"Cannot compute difference of images with different shapes")
def checkConstraints(*_):
if opData.Image.meta.dtype != np.uint8:
msg = "The Autocontext Workflow only supports 8-bit images (UINT8 pixel type).\n"\
"Your image has a pixel type of {}. Please convert your data to UINT8 and try again."\
.format( str(np.dtype(opData.Image.meta.dtype)) )
raise DatasetConstraintError("Autocontext Workflow",
msg,
unfixable=True)
def checkConstraints(self, *args):
if self._opReorder1.Output.ready():
numChannels = self._opReorder1.Output.meta.getTaggedShape()['c']
if self.Channel.value >= numChannels:
raise DatasetConstraintError(
"Two-Level Thresholding",
"Your project is configured to select data from channel"
" #{}, but your input data only has {} channels.".format(
self.Channel.value, numChannels))
def checkConstraints(self, *args):
"""
Example of how to check input data constraints.
"""
if self.RawInput.ready():
numChannels = self.RawInput.meta.getTaggedShape()['c']
if numChannels != 1:
raise DatasetConstraintError(
"Layer Viewer",
"Raw data must have exactly one channel. " +
"You attempted to add a dataset with {} channels".format( numChannels ) )
if self.OtherInput.ready() and self.RawInput.ready():
rawTaggedShape = self.RawInput.meta.getTaggedShape()
otherTaggedShape = self.OtherInput.meta.getTaggedShape()
rawTaggedShape['c'] = None
otherTaggedShape['c'] = None
if dict(rawTaggedShape) != dict(otherTaggedShape):
msg = "Raw data and other data must have equal dimensions (different channels are okay).\n"\
"Your datasets have shapes: {} and {}".format( self.RawInput.meta.shape, self.OtherInput.meta.shape )
raise DatasetConstraintError( "Layer Viewer", msg )
def setupOutputs(self):
taggedOutputShape = self.LabelImage.meta.getTaggedShape()
if 't' not in taggedOutputShape.keys() or taggedOutputShape['t'] < 2:
raise DatasetConstraintError( "Tracking Feature Extraction",
"Label Image must have a time axis with more than 1 image.\n"\
"Label Image shape: {}"\
"".format(self.LabelImage.meta.shape))
# Every value in the region features output is cached separately as it's own "block"
blockshape = (1, ) * len(
self._opDivisionFeatures.BlockwiseDivisionFeatures.meta.shape)
self._opCache.blockShape.setValue(blockshape)
def _checkConstraints(self, *args):
slot = self.Input
sh = slot.meta.shape
ndim = len(sh)
ax = slot.meta.axistags
tsh = slot.meta.getTaggedShape()
if ("c" in tsh):
if (tsh["c"] != 1):
raise DatasetConstraintError(
"ColorizeLabelImage",
"Input image cannot have a non-singleton channel dimension."
)
if (ndim == 1):
raise DatasetConstraintError(
"ColorizeLabelImage",
"There must be more dimensions than just the channel dimension."
)
if not ax[-1].isChannel():
raise DatasetConstraintError(
"ColorizeLabelImage",
"Input image must have channel last.")
def _checkConstraints(self, laneIndex):
"""
Override from OpPixelClassification.
Check all input slots for appropriate size/shape, etc.
"""
if not self.InputImages[laneIndex].ready():
return
tagged_shape = self.InputImages[laneIndex].meta.getTaggedShape()
if 't' in tagged_shape:
raise DatasetConstraintError(
"IIBoost Pixel Classification",
"This classifier handles only 3D data. Your input data has a time dimension, which is not allowed."
)
if not set('xyz').issubset(list(tagged_shape.keys())):
raise DatasetConstraintError(
"IIBoost Pixel Classification",
"This classifier handles only 3D data. Your input data does not have all three spatial dimensions (xyz)."
)
super(OpIIBoostPixelClassification, self)._checkConstraints(laneIndex)
def _checkConstraints(self, *args):
slot = self.Input
sh = slot.meta.shape
ax = slot.meta.axistags
if (len(slot.meta.shape) != 4) and (len(slot.meta.shape) != 5):
# Raise a regular exception. This error is for developers, not users.
raise RuntimeError("was expecting a 4D or 5D dataset, got shape=%r" % (sh,))
if "t" not in slot.meta.getTaggedShape():
raise DatasetConstraintError(
"EstimateF0",
"Input must have time.")
if "y" not in slot.meta.getTaggedShape():
raise DatasetConstraintError(
"EstimateF0",
"Input must have space dim y.")
if "x" not in slot.meta.getTaggedShape():
raise DatasetConstraintError(
"EstimateF0",
"Input must have space dim x.")
if "c" not in slot.meta.getTaggedShape():
raise DatasetConstraintError(
"EstimateF0",
"Input must have channel.")
numChannels = slot.meta.getTaggedShape()["c"]
if numChannels != 1:
raise DatasetConstraintError(
"EstimateF0",
"Input image must have exactly one channel. " +
"You attempted to add a dataset with {} channels".format( numChannels ) )
if not ax[0].isTemporal():
raise DatasetConstraintError(
"EstimateF0",
"Input image must have time first." )
if not ax[-1].isChannel():
raise DatasetConstraintError(
"EstimateF0",
"Input image must have channel last." )
for i in range(1, len(ax) - 1):
if not ax[i].isSpatial():
# This is for developers. Don't need a user-friendly error.
raise RuntimeError("%d-th axis %r is not spatial" % (i, ax[i]))
def setupOutputs(self):
assert self.LabelImage.meta.axistags == self.RawImage.meta.axistags
taggedOutputShape = self.LabelImage.meta.getTaggedShape()
taggedRawShape = self.RawImage.meta.getTaggedShape()
if not np.all(list(taggedOutputShape.get(k, 0) == taggedRawShape.get(k, 0)
for k in "txyz")):
raise DatasetConstraintError( "Object Extraction",
"Raw Image and Label Image shapes do not match.\n"\
"Label Image shape: {}. Raw Image shape: {}"\
"".format(self.LabelImage.meta.shape, self.RawVolume.meta.shape))
# Every value in the regionfeatures output is cached seperately as it's own "block"
blockshape = (1,) * len(self._opRegionFeatures.Output.meta.shape)
self._opCache.blockShape.setValue(blockshape)
def _checkConstraints(self, *args):
if self.RawImage.ready() and self.BinaryImage.ready():
rawTaggedShape = self.RawImage.meta.getTaggedShape()
binTaggedShape = self.BinaryImage.meta.getTaggedShape()
rawTaggedShape["c"] = None
binTaggedShape["c"] = None
if dict(rawTaggedShape) != dict(binTaggedShape):
logger.info(
"Raw data and other data must have equal dimensions (different channels are okay).\n"
"Your datasets have shapes: {} and {}".format(
self.RawImage.meta.shape, self.BinaryImage.meta.shape))
msg = (
"Raw data and other data must have equal dimensions (different channels are okay).\n"
"Your datasets have shapes: {} and {}".format(
self.RawImage.meta.shape, self.BinaryImage.meta.shape))
raise DatasetConstraintError("Object Extraction", msg)
def setupOutputs(self):
# Check for preconditions.
if self.RawImage.ready() and self.BinaryImage.ready():
rawTaggedShape = self.RawImage.meta.getTaggedShape()
binTaggedShape = self.BinaryImage.meta.getTaggedShape()
rawTaggedShape['c'] = None
binTaggedShape['c'] = None
if dict(rawTaggedShape) != dict(binTaggedShape):
msg = "Raw data and other data must have equal dimensions (different channels are okay).\n"\
"Your datasets have shapes: {} and {}".format( self.RawImage.meta.shape, self.BinaryImage.meta.shape )
raise DatasetConstraintError("Blockwise Object Classification",
msg)
self._block_shape_dict = self.BlockShape3dDict.value
self._halo_padding_dict = self.HaloPadding3dDict.value
self.PredictionImage.meta.assignFrom(self.RawImage.meta)
self.PredictionImage.meta.dtype = numpy.uint8 # Ultimately determined by meta.mapping_dtype from OpRelabelSegmentation
prediction_tagged_shape = self.RawImage.meta.getTaggedShape()
prediction_tagged_shape['c'] = 1
self.PredictionImage.meta.shape = tuple(
prediction_tagged_shape.values())
block_shape = self._getFullShape(self._block_shape_dict)
self.PredictionImage.meta.ideal_blockshape = block_shape
raw_ruprp = self.RawImage.meta.ram_usage_per_requested_pixel
binary_ruprp = self.BinaryImage.meta.ram_usage_per_requested_pixel
prediction_ruprp = max(raw_ruprp, binary_ruprp)
self.PredictionImage.meta.ram_usage_per_requested_pixel = prediction_ruprp
self.ProbabilityChannelImage.meta.assignFrom(self.RawImage.meta)
self.ProbabilityChannelImage.meta.dtype = numpy.float32
prediction_channels_tagged_shape = self.RawImage.meta.getTaggedShape()
prediction_channels_tagged_shape['c'] = self.LabelsCount.value
self.ProbabilityChannelImage.meta.shape = tuple(
prediction_channels_tagged_shape.values())
self.ProbabilityChannelImage.meta.ram_usage_per_requested_pixel = prediction_ruprp
region_feature_output_shape = (numpy.array(
self.PredictionImage.meta.shape) + block_shape - 1) // block_shape
self.BlockwiseRegionFeatures.meta.shape = tuple(
region_feature_output_shape)
self.BlockwiseRegionFeatures.meta.dtype = object
self.BlockwiseRegionFeatures.meta.axistags = self.PredictionImage.meta.axistags
def setupOutputs(self):
# drop non-channel singleton axes
oldAxes = self.InputImage.meta.getAxisKeys()
# make sure channel axis is present
if 'c' not in oldAxes:
oldAxes.append('c')
self.opReorderOut.AxisOrder.setValue(oldAxes)
self.opReorderLayers.AxisOrder.setValue(oldAxes)
# Get features from external file
if self.FeatureListFilename.ready() and len(
self.FeatureListFilename.value) > 0:
raise NotImplementedError('Not simplified yet!')
self.OutputImage.disconnect()
self.FeatureLayers.disconnect()
axistags = self.InputImage.meta.axistags
with h5py.File(self.FeatureListFilename.value, 'r') as f:
dset_names = []
f.visit(dset_names.append)
if len(dset_names) != 1:
sys.stderr.write(
"Input external features HDF5 file should have exactly 1 dataset.\n"
)
sys.exit(1)
dset = f[dset_names[0]]
chnum = dset.shape[-1]
shape = dset.shape
dtype = dset.dtype.type
# Set the metadata for FeatureLayers. Unlike OutputImage and CachedOutputImage,
# FeatureLayers has one slot per channel and therefore the channel dimension must be 1.
self.FeatureLayers.resize(chnum)
for i in range(chnum):
self.FeatureLayers[i].meta.shape = shape[:-1] + (1, )
self.FeatureLayers[i].meta.dtype = dtype
self.FeatureLayers[i].meta.axistags = axistags
self.FeatureLayers[i].meta.display_mode = 'default'
self.FeatureLayers[
i].meta.description = "feature_channel_" + str(i)
self.OutputImage.meta.shape = shape
self.OutputImage.meta.dtype = dtype
self.OutputImage.meta.axistags = axistags
else:
invalid_scales, invalid_z_scales = self.opPixelFeatures.getInvalidScales(
)
if invalid_scales or invalid_z_scales:
invalid_z_scales = [
s for s in invalid_z_scales if s not in invalid_scales
] # 'do not complain twice'
msg = 'Some of your selected feature scales are too large for your dataset.\n'
if invalid_scales:
msg += f'Reduce or remove these scales:\n{invalid_scales}\n\n'
if invalid_z_scales:
msg += f'Reduce, remove or switch to 2D computation for these scales:\n{invalid_z_scales}\n\n'
msg += 'Alternatively use another dataset.'
if self.parent.parent.featureSelectionApplet._gui is None:
# headless
fix_dlgs = []
else:
fix_dlgs = [
self.parent.parent.featureSelectionApplet._gui.
currentGui(
fallback_on_lane_0=True).onFeatureButtonClicked
]
raise DatasetConstraintError("Feature Selection",
msg,
fixing_dialogs=fix_dlgs)
# Connect our external outputs to our internal operators
self.OutputImage.connect(self.opReorderOut.Output)
self.FeatureLayers.connect(self.opReorderLayers.Output)
def _generate_traxelstore(self,
time_range,
x_range,
y_range,
z_range,
size_range,
x_scale=1.0,
y_scale=1.0,
z_scale=1.0,
with_div=False,
with_local_centers=False,
median_object_size=None,
max_traxel_id_at=None,
with_opt_correction=False,
with_coordinate_list=False,
with_classifier_prior=False):
if not self.Parameters.ready():
raise Exception("Parameter slot is not ready")
parameters = self.Parameters.value
parameters['scales'] = [x_scale, y_scale, z_scale]
parameters['time_range'] = [min(time_range), max(time_range)]
parameters['x_range'] = x_range
parameters['y_range'] = y_range
parameters['z_range'] = z_range
parameters['size_range'] = size_range
logger.info("generating traxels")
logger.info("fetching region features and division probabilities")
feats = self.ObjectFeatures(time_range).wait()
if with_div:
if not self.DivisionProbabilities.ready() or len(
self.DivisionProbabilities([0]).wait()[0]) == 0:
msgStr = "\nDivision classifier has not been trained! " + \
"Uncheck divisible objects if your objects don't divide or " + \
"go back to the Division Detection applet and train it."
raise DatasetConstraintError("Tracking", msgStr)
divProbs = self.DivisionProbabilities(time_range).wait()
if with_local_centers:
localCenters = self.RegionLocalCenters(time_range).wait()
if with_classifier_prior:
if not self.DetectionProbabilities.ready() or len(
self.DetectionProbabilities([0]).wait()[0]) == 0:
msgStr = "\nObject count classifier has not been trained! " + \
"Go back to the Object Count Classification applet and train it."
raise DatasetConstraintError("Tracking", msgStr)
detProbs = self.DetectionProbabilities(time_range).wait()
logger.info("filling traxelstore")
ts = pgmlink.TraxelStore()
fs = pgmlink.FeatureStore()
max_traxel_id_at = pgmlink.VectorOfInt()
filtered_labels = {}
obj_sizes = []
total_count = 0
empty_frame = False
for t in feats.keys():
rc = feats[t][default_features_key]['RegionCenter']
lower = feats[t][default_features_key]['Coord<Minimum>']
upper = feats[t][default_features_key]['Coord<Maximum>']
if rc.size:
rc = rc[1:, ...]
lower = lower[1:, ...]
upper = upper[1:, ...]
if with_opt_correction:
try:
rc_corr = feats[t][
config.features_vigra_name]['RegionCenter_corr']
except:
raise Exception, 'Can not consider optical correction since it has not been computed before'
if rc_corr.size:
rc_corr = rc_corr[1:, ...]
ct = feats[t][default_features_key]['Count']
if ct.size:
ct = ct[1:, ...]
logger.debug("at timestep {}, {} traxels found".format(
t, rc.shape[0]))
count = 0
filtered_labels_at = []
for idx in range(rc.shape[0]):
# for 2d data, set z-coordinate to 0:
if len(rc[idx]) == 2:
x, y = rc[idx]
z = 0
elif len(rc[idx]) == 3:
x, y, z = rc[idx]
else:
raise DatasetConstraintError(
"Tracking",
"The RegionCenter feature must have dimensionality 2 or 3."
)
size = ct[idx]
if (x < x_range[0] or x >= x_range[1] or y < y_range[0]
or y >= y_range[1] or z < z_range[0] or z >= z_range[1]
or size < size_range[0] or size >= size_range[1]):
filtered_labels_at.append(int(idx + 1))
continue
else:
count += 1
tr = pgmlink.Traxel()
tr.set_feature_store(fs)
tr.set_x_scale(x_scale)
tr.set_y_scale(y_scale)
tr.set_z_scale(z_scale)
tr.Id = int(idx + 1)
tr.Timestep = int(t)
# pgmlink expects always 3 coordinates, z=0 for 2d data
tr.add_feature_array("com", 3)
for i, v in enumerate([x, y, z]):
tr.set_feature_value('com', i, float(v))
tr.add_feature_array("CoordMinimum", 3)
for i, v in enumerate(lower[idx]):
tr.set_feature_value("CoordMinimum", i, float(v))
tr.add_feature_array("CoordMaximum", 3)
for i, v in enumerate(upper[idx]):
tr.set_feature_value("CoordMaximum", i, float(v))
if with_opt_correction:
tr.add_feature_array("com_corrected", 3)
for i, v in enumerate(rc_corr[idx]):
tr.set_feature_value("com_corrected", i, float(v))
if len(rc_corr[idx]) == 2:
tr.set_feature_value("com_corrected", 2, 0.)
if with_div:
tr.add_feature_array("divProb", 1)
# idx+1 because rc and ct start from 1, divProbs starts from 0
tr.set_feature_value("divProb", 0,
float(divProbs[t][idx + 1][1]))
if with_classifier_prior:
tr.add_feature_array("detProb", len(detProbs[t][idx + 1]))
for i, v in enumerate(detProbs[t][idx + 1]):
val = float(v)
if val < 0.0000001:
val = 0.0000001
if val > 0.99999999:
val = 0.99999999
tr.set_feature_value("detProb", i, float(val))
# FIXME: check whether it is 2d or 3d data!
if with_local_centers:
tr.add_feature_array("localCentersX",
len(localCenters[t][idx + 1]))
tr.add_feature_array("localCentersY",
len(localCenters[t][idx + 1]))
tr.add_feature_array("localCentersZ",
len(localCenters[t][idx + 1]))
for i, v in enumerate(localCenters[t][idx + 1]):
tr.set_feature_value("localCentersX", i, float(v[0]))
tr.set_feature_value("localCentersY", i, float(v[1]))
tr.set_feature_value("localCentersZ", i, float(v[2]))
tr.add_feature_array("count", 1)
tr.set_feature_value("count", 0, float(size))
if median_object_size is not None:
obj_sizes.append(float(size))
ts.add(fs, tr)
if len(filtered_labels_at) > 0:
filtered_labels[str(int(t) -
time_range[0])] = filtered_labels_at
logger.debug("at timestep {}, {} traxels passed filter".format(
t, count))
max_traxel_id_at.append(int(rc.shape[0]))
if count == 0:
empty_frame = True
total_count += count
if median_object_size is not None:
median_object_size[0] = np.median(np.array(obj_sizes),
overwrite_input=True)
logger.info('median object size = ' + str(median_object_size[0]))
self.FilteredLabels.setValue(filtered_labels, check_changed=True)
return fs, ts, empty_frame, max_traxel_id_at
def _generate_traxelstore(self,
time_range,
x_range,
y_range,
z_range,
size_range,
x_scale=1.0,
y_scale=1.0,
z_scale=1.0,
with_div=False,
with_local_centers=False,
with_classifier_prior=False):
logger.info("generating traxels")
self.progressVisitor.showState("Object features")
self.progressVisitor.showProgress(0)
traxelstore = ProbabilityGenerator()
logger.info("fetching region features and division probabilities")
feats = self.ObjectFeatures(time_range).wait()
if with_div:
if not self.DivisionProbabilities.ready() or len(
self.DivisionProbabilities([0]).wait()[0]) == 0:
msgStr = "\nDivision classifier has not been trained! " + \
"Uncheck divisible objects if your objects don't divide or " + \
"go back to the Division Detection applet and train it."
raise DatasetConstraintError("Tracking", msgStr)
self.progressVisitor.showState("Division probabilities")
self.progressVisitor.showProgress(0)
divProbs = self.DivisionProbabilities(time_range).wait()
if with_local_centers:
localCenters = self.RegionLocalCenters(time_range).wait()
if with_classifier_prior:
if not self.DetectionProbabilities.ready() or len(
self.DetectionProbabilities([0]).wait()[0]) == 0:
msgStr = "\nObject count classifier has not been trained! " + \
"Go back to the Object Count Classification applet and train it."
raise DatasetConstraintError("Tracking", msgStr)
self.progressVisitor.showState("Detection probabilities")
self.progressVisitor.showProgress(0)
detProbs = self.DetectionProbabilities(time_range).wait()
logger.info("filling traxelstore")
filtered_labels = {}
total_count = 0
empty_frame = False
numTimeStep = len(list(feats.keys()))
countT = 0
stepStr = "Creating traxel store"
self.progressVisitor.showState(stepStr +
" ")
for t in list(feats.keys()):
countT += 1
self.progressVisitor.showProgress(
old_div(countT, float(numTimeStep)))
rc = feats[t][default_features_key]['RegionCenter']
lower = feats[t][default_features_key]['Coord<Minimum>']
upper = feats[t][default_features_key]['Coord<Maximum>']
if rc.size:
rc = rc[1:, ...]
lower = lower[1:, ...]
upper = upper[1:, ...]
ct = feats[t][default_features_key]['Count']
if ct.size:
ct = ct[1:, ...]
logger.debug("at timestep {}, {} traxels found".format(
t, rc.shape[0]))
count = 0
filtered_labels_at = []
for idx in range(rc.shape[0]):
traxel = Traxel()
# for 2d data, set z-coordinate to 0:
if len(rc[idx]) == 2:
x, y = rc[idx]
z = 0
x_lower, y_lower = lower[idx]
x_upper, y_upper = upper[idx]
z_lower = 0
z_upper = 0
elif len(rc[idx]) == 3:
x, y, z = rc[idx]
x_lower, y_lower, z_lower = lower[idx]
x_upper, y_upper, z_upper = upper[idx]
else:
raise DatasetConstraintError(
"Tracking",
"The RegionCenter feature must have dimensionality 2 or 3."
)
size = ct[idx]
if (x_upper < x_range[0] or x_lower >= x_range[1]
or y_upper < y_range[0] or y_lower >= y_range[1]
or z_upper < z_range[0] or z_lower >= z_range[1]
or size < size_range[0] or size >= size_range[1]):
filtered_labels_at.append(int(idx + 1))
continue
else:
count += 1
traxel.Id = int(idx + 1)
traxel.Timestep = int(t)
traxel.set_x_scale(x_scale)
traxel.set_y_scale(y_scale)
traxel.set_z_scale(z_scale)
# Expects always 3 coordinates, z=0 for 2d data
traxel.add_feature_array("com", 3)
for i, v in enumerate([x, y, z]):
traxel.set_feature_value('com', i, float(v))
traxel.add_feature_array("CoordMinimum", 3)
for i, v in enumerate(lower[idx]):
traxel.set_feature_value("CoordMinimum", i, float(v))
traxel.add_feature_array("CoordMaximum", 3)
for i, v in enumerate(upper[idx]):
traxel.set_feature_value("CoordMaximum", i, float(v))
if with_div:
traxel.add_feature_array("divProb", 2)
# idx+1 because rc and ct start from 1, divProbs starts from 0
prob = float(divProbs[t][idx + 1][1])
prob = float(prob)
if prob < 0.0000001:
prob = 0.0000001
if prob > 0.99999999:
prob = 0.99999999
traxel.set_feature_value("divProb", 0, 1.0 - prob)
traxel.set_feature_value("divProb", 1, prob)
if with_classifier_prior:
traxel.add_feature_array("detProb",
len(detProbs[t][idx + 1]))
for i, v in enumerate(detProbs[t][idx + 1]):
val = float(v)
if val < 0.0000001:
val = 0.0000001
if val > 0.99999999:
val = 0.99999999
traxel.set_feature_value("detProb", i, float(val))
# FIXME: check whether it is 2d or 3d data!
if with_local_centers:
traxel.add_feature_array("localCentersX",
len(localCenters[t][idx + 1]))
traxel.add_feature_array("localCentersY",
len(localCenters[t][idx + 1]))
traxel.add_feature_array("localCentersZ",
len(localCenters[t][idx + 1]))
for i, v in enumerate(localCenters[t][idx + 1]):
traxel.set_feature_value("localCentersX", i,
float(v[0]))
traxel.set_feature_value("localCentersY", i,
float(v[1]))
traxel.set_feature_value("localCentersZ", i,
float(v[2]))
traxel.add_feature_array("count", 1)
traxel.set_feature_value("count", 0, float(size))
if (x_upper < x_range[0] or x_lower >= x_range[1]
or y_upper < y_range[0] or y_lower >= y_range[1]
or z_upper < z_range[0] or z_lower >= z_range[1]
or size < size_range[0] or size >= size_range[1]):
logger.info("Omitting traxel with ID: {} {}".format(
traxel.Id, t))
print("Omitting traxel with ID: {} {}".format(
traxel.Id, t))
else:
logger.debug("Adding traxel with ID: {} {}".format(
traxel.Id, t))
traxelstore.TraxelsPerFrame.setdefault(
int(t), {})[int(idx + 1)] = traxel
if len(filtered_labels_at) > 0:
filtered_labels[str(int(t) -
time_range[0])] = filtered_labels_at
logger.debug("at timestep {}, {} traxels passed filter".format(
t, count))
if count == 0:
empty_frame = True
logger.info('Found empty frames for time {}'.format(t))
total_count += count
self.parent.parent.trackingApplet.progressSignal(100)
self.FilteredLabels.setValue(filtered_labels, check_changed=True)
return traxelstore
def raiseDatasetConstraintError(self, progressWindow, titleStr, str):
if progressWindow is not None:
progressWindow.onTrackDone()
raise DatasetConstraintError(titleStr, str)
def track(self,
time_range,
x_range,
y_range,
z_range,
size_range=(0, 100000),
x_scale=1.0,
y_scale=1.0,
z_scale=1.0,
maxDist=30,
maxObj=2,
divThreshold=0.5,
avgSize=[0],
withTracklets=False,
sizeDependent=True,
divWeight=10.0,
detWeight=10.0,
transWeight=10.0,
withDivisions=True,
withOpticalCorrection=True,
withClassifierPrior=False,
ndim=3,
cplex_timeout=None,
withMergerResolution=True,
borderAwareWidth=0.0,
withArmaCoordinates=True,
appearance_cost=500,
disappearance_cost=500,
motionModelWeight=10.0,
force_build_hypotheses_graph=False,
max_nearest_neighbors=1,
withBatchProcessing=False,
solverName="ILP",
numFramesPerSplit=0):
if not self.Parameters.ready():
raise Exception("Parameter slot is not ready")
if numFramesPerSplit != 0:
raise Exception(
"PGMLINK tracking does not support sliding window tracking")
# it is assumed that the self.Parameters object is changed only at this
# place (ugly assumption). Therefore we can track any changes in the
# parameters as done in the following lines: If the same value for the
# key is already written in the parameters dictionary, the
# paramters_changed dictionary will get a "False" entry for this key,
# otherwise it is set to "True"
parameters = self.Parameters.value
parameters['maxDist'] = maxDist
parameters['maxObj'] = maxObj
parameters['divThreshold'] = divThreshold
parameters['avgSize'] = avgSize
parameters['withTracklets'] = withTracklets
parameters['sizeDependent'] = sizeDependent
parameters['detWeight'] = detWeight
parameters['divWeight'] = divWeight
parameters['transWeight'] = transWeight
parameters['withDivisions'] = withDivisions
parameters['withOpticalCorrection'] = withOpticalCorrection
parameters['withClassifierPrior'] = withClassifierPrior
parameters['withMergerResolution'] = withMergerResolution
parameters['borderAwareWidth'] = borderAwareWidth
parameters['withArmaCoordinates'] = withArmaCoordinates
parameters['appearanceCost'] = appearance_cost
parameters['disappearanceCost'] = disappearance_cost
parameters['max_nearest_neighbors'] = max_nearest_neighbors
parameters['numFramesPerSplit'] = numFramesPerSplit
do_build_hypotheses_graph = True
if cplex_timeout:
parameters['cplex_timeout'] = cplex_timeout
else:
parameters['cplex_timeout'] = ''
cplex_timeout = float(1e75)
if withClassifierPrior:
if not self.DetectionProbabilities.ready() or len(
self.DetectionProbabilities([0]).wait()[0]) == 0:
raise DatasetConstraintError(
'Tracking',
'Classifier not ready yet. Did you forget to train the Object Count Classifier?'
)
if not self.NumLabels.ready() or self.NumLabels.value < (maxObj +
1):
raise DatasetConstraintError('Tracking', 'The max. number of objects must be consistent with the number of labels given in Object Count Classification.\n' +\
'Check whether you have (i) the correct number of label names specified in Object Count Classification, and (ii) provided at least ' +\
'one training example for each class.')
if len(self.DetectionProbabilities(
[0]).wait()[0][0]) < (maxObj + 1):
raise DatasetConstraintError('Tracking', 'The max. number of objects must be consistent with the number of labels given in Object Count Classification.\n' +\
'Check whether you have (i) the correct number of label names specified in Object Count Classification, and (ii) provided at least ' +\
'one training example for each class.')
median_obj_size = [0]
fs, ts, empty_frame, max_traxel_id_at = self._generate_traxelstore(
time_range,
x_range,
y_range,
z_range,
size_range,
x_scale,
y_scale,
z_scale,
median_object_size=median_obj_size,
with_div=withDivisions,
with_opt_correction=withOpticalCorrection,
with_classifier_prior=withClassifierPrior)
if empty_frame:
raise DatasetConstraintError(
'Tracking', 'Can not track frames with 0 objects, abort.')
if avgSize[0] > 0:
median_obj_size = avgSize
logger.info('median_obj_size = {}'.format(median_obj_size))
ep_gap = 0.05
transition_parameter = 5
fov = pgmlink.FieldOfView(
time_range[0] * 1.0,
x_range[0] * x_scale,
y_range[0] * y_scale,
z_range[0] * z_scale,
time_range[-1] * 1.0,
(x_range[1] - 1) * x_scale,
(y_range[1] - 1) * y_scale,
(z_range[1] - 1) * z_scale,
)
logger.info('fov = {},{},{},{},{},{},{},{}'.format(
time_range[0] * 1.0,
x_range[0] * x_scale,
y_range[0] * y_scale,
z_range[0] * z_scale,
time_range[-1] * 1.0,
(x_range[1] - 1) * x_scale,
(y_range[1] - 1) * y_scale,
(z_range[1] - 1) * z_scale,
))
if ndim == 2:
assert z_range[0] * z_scale == 0 and (
z_range[1] -
1) * z_scale == 0, "fov of z must be (0,0) if ndim==2"
if self.tracker is None:
do_build_hypotheses_graph = True
solverType = self.getPgmlinkSolverType(solverName)
if do_build_hypotheses_graph:
print '\033[94m' + "make new graph" + '\033[0m'
self.tracker = pgmlink.ConsTracking(
int(maxObj),
bool(sizeDependent), # size_dependent_detection_prob
float(median_obj_size[0]), # median_object_size
float(maxDist),
bool(withDivisions),
float(divThreshold),
"none", # detection_rf_filename
fov,
"none", # dump traxelstore,
solverType,
ndim)
g = self.tracker.buildGraph(ts, max_nearest_neighbors)
# create dummy uncertainty parameter object with just one iteration, so no perturbations at all (iter=0 -> MAP)
sigmas = pgmlink.VectorOfDouble()
for i in range(5):
sigmas.append(0.0)
uncertaintyParams = pgmlink.UncertaintyParameter(
1, pgmlink.DistrId.PerturbAndMAP, sigmas)
params = self.tracker.get_conservation_tracking_parameters(
0, # forbidden_cost
float(ep_gap), # ep_gap
bool(withTracklets), # with tracklets
float(detWeight), # detection weight
float(divWeight), # division weight
float(transWeight), # transition weight
float(disappearance_cost), # disappearance cost
float(appearance_cost), # appearance cost
bool(withMergerResolution), # with merger resolution
int(ndim), # ndim
float(transition_parameter), # transition param
float(borderAwareWidth), # border width
True, #with_constraints
uncertaintyParams, # uncertainty parameters
float(cplex_timeout), # cplex timeout
None, # transition classifier
solverType,
False, # training to hard constraints
1 # num threads
)
# if motionModelWeight > 0:
# logger.info("Registering motion model with weight {}".format(motionModelWeight))
# params.register_motion_model4_func(swirl_motion_func_creator(motionModelWeight), motionModelWeight * 25.0)
try:
eventsVector = self.tracker.track(params, False)
eventsVector = eventsVector[
0] # we have a vector such that we could get a vector per perturbation
# extract the coordinates with the given event vector
if withMergerResolution:
coordinate_map = pgmlink.TimestepIdCoordinateMap()
self._get_merger_coordinates(coordinate_map, time_range,
eventsVector)
self.CoordinateMap.setValue(coordinate_map)
eventsVector = self.tracker.resolve_mergers(
eventsVector,
params,
coordinate_map.get(),
float(ep_gap),
float(transWeight),
bool(withTracklets),
ndim,
transition_parameter,
max_traxel_id_at,
True, # with_constraints
None) # TransitionClassifier
except Exception as e:
raise Exception, 'Tracking terminated unsuccessfully: ' + str(e)
if len(eventsVector) == 0:
raise Exception, 'Tracking terminated unsuccessfully: Events vector has zero length.'
events = get_events(eventsVector)
self.Parameters.setValue(parameters, check_changed=False)
self.EventsVector.setValue(events, check_changed=False)
self.RelabeledImage.setDirty()
if not withBatchProcessing:
merger_layer_idx = self.parent.parent.trackingApplet._gui.currentGui(
).layerstack.findMatchingIndex(lambda x: x.name == "Merger")
tracking_layer_idx = self.parent.parent.trackingApplet._gui.currentGui(
).layerstack.findMatchingIndex(lambda x: x.name == "Tracking")
if 'withMergerResolution' in parameters.keys(
) and not parameters['withMergerResolution']:
self.parent.parent.trackingApplet._gui.currentGui().layerstack[merger_layer_idx].colorTable = \
self.parent.parent.trackingApplet._gui.currentGui().merger_colortable
else:
self.parent.parent.trackingApplet._gui.currentGui().layerstack[merger_layer_idx].colorTable = \
self.parent.parent.trackingApplet._gui.currentGui().tracking_colortable
