def __init__(self, topLevelOperatorView):
self.topLevelOperatorView = topLevelOperatorView
super(ManualTrackingGui, self).__init__(topLevelOperatorView)
self.mainOperator = topLevelOperatorView
if self.mainOperator.LabelImage.meta.shape:
self.editor.dataShape = self.mainOperator.LabelImage.meta.shape
self.mainOperator.LabelImage.notifyMetaChanged( self._onMetaChanged)
self.ct = colortables.create_random_16bit()
self.divLock = False
self.divs = []
self.labelsWithDivisions = {}
self.misdetLock = False
self.misdetIdx = -1
if self.mainOperator.LabelImage.meta.shape:
# FIXME: assumes t,x,y,z,c
if self.mainOperator.LabelImage.meta.shape[3] == 1: # 2D images
self._drawer.windowZBox.setValue(1)
self._drawer.windowZBox.setEnabled(False)
self.connect( self, QtCore.SIGNAL('postCriticalMessage(QString)'), self.postCriticalMessage)
self._initShortcuts()
class TrackingBaseResultsViewer(DataExportLayerViewerGui):
ct = colortables.create_random_16bit()
ct[0] = QColor(0, 0, 0, 255)
def setupLayers(self):
layers = []
fromDiskSlot = self.topLevelOperatorView.ImageOnDisk
if fromDiskSlot.ready():
exportLayer = ColortableLayer(LazyflowSource(fromDiskSlot),
colorTable=self.ct)
exportLayer.name = "Selected Output - Exported"
exportLayer.visible = True
layers.append(exportLayer)
previewSlot = self.topLevelOperatorView.ImageToExport
if previewSlot.ready():
previewLayer = ColortableLayer(LazyflowSource(previewSlot),
colorTable=self.ct)
previewLayer.name = "Selected Output - Preview"
previewLayer.visible = False
layers.append(previewLayer)
rawSlot = self.topLevelOperatorView.RawData
if rawSlot.ready():
rawLayer = self.createStandardLayerFromSlot(rawSlot)
rawLayer.name = "Raw Data"
rawLayer.opacity = 1.0
layers.append(rawLayer)
return layers
def __init__(self, topLevelOperatorView):
"""
"""
self.topLevelOperatorView = topLevelOperatorView
super(ManualTrackingGui, self).__init__(topLevelOperatorView)
self.mainOperator = topLevelOperatorView
if self.mainOperator.LabelImage.meta.shape:
self.editor.dataShape = self.mainOperator.LabelImage.meta.shape
self.mainOperator.LabelImage.notifyMetaChanged( self._onMetaChanged)
self.ct = colortables.create_random_16bit()
self.divLock = False
self.divs = []
self.labelsWithDivisions = {}
self.misdetLock = False
self.misdetIdx = -1
def setupLayers( self ):
layers = []
self.ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
self.ct[255] = QColor(0,0,0,255).rgba() # make -1 black
self.ct[-1] = QColor(0,0,0,255).rgba()
self.trackingsrc = LazyflowSource( self.topLevelOperatorView.TrackImage )
trackingLayer = ColortableLayer( self.trackingsrc, self.ct )
trackingLayer.name = "Manual Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 0.8
def toggleTrackingVisibility():
trackingLayer.visible = not trackingLayer.visible
trackingLayer.shortcutRegistration = (
"Layer Visibilities",
"Toggle Manual Tracking Layer Visibility",
QtGui.QShortcut( QtGui.QKeySequence("e"), self.viewerControlWidget(), toggleTrackingVisibility),
trackingLayer )
layers.append(trackingLayer)
ct = colortables.create_random_16bit()
ct[1] = QColor(230,0,0,150).rgba()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
self.untrackedsrc = LazyflowSource( self.topLevelOperatorView.UntrackedImage )
untrackedLayer = ColortableLayer( self.untrackedsrc, ct )
untrackedLayer.name = "Untracked Objects"
untrackedLayer.visible = False
untrackedLayer.opacity = 0.8
layers.append(untrackedLayer)
self.objectssrc = LazyflowSource( self.topLevelOperatorView.BinaryImage )
ct = colortables.create_random_16bit()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
ct[1] = QColor(255,255,0,100).rgba()
objLayer = ColortableLayer( self.objectssrc, ct )
objLayer.name = "Objects"
objLayer.opacity = 0.8
objLayer.visible = True
def toggleObjectVisibility():
objLayer.visible = not objLayer.visible
objLayer.shortcutRegistration = (
"Layer Visibilities",
"Toggle Objects Layer Visibility",
QtGui.QShortcut( QtGui.QKeySequence("r"), self.viewerControlWidget(), toggleObjectVisibility),
objLayer )
layers.append(objLayer)
## raw data layer
self.rawsrc = None
self.rawsrc = LazyflowSource( self.mainOperator.RawImage )
rawLayer = GrayscaleLayer( self.rawsrc )
rawLayer.name = "Raw"
layers.insert( len(layers), rawLayer )
if self.topLevelOperatorView.LabelImage.meta.shape:
self.editor.dataShape = self.topLevelOperatorView.LabelImage.meta.shape
self.topLevelOperatorView.RawImage.notifyReady( self._onReady )
self.topLevelOperatorView.RawImage.notifyMetaChanged( self._onMetaChanged )
self._setDivisionsList()
self._setActiveTrackList()
return layers
def setupLayers(self):
layers = []
if "MergerOutput" in self.topLevelOperatorView.outputs and self.topLevelOperatorView.MergerOutput.ready(
):
ct = colortables.create_default_8bit()
for i in range(7):
ct[i] = self.mergerColors[i].rgba()
self.mergersrc = LazyflowSource(
self.topLevelOperatorView.MergerOutput)
mergerLayer = ColortableLayer(self.mergersrc, ct)
mergerLayer.name = "Merger"
mergerLayer.visible = True
layers.append(mergerLayer)
ct = colortables.create_random_16bit()
ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent
ct[1] = QColor(128, 128, 128, 255).rgba(
) # misdetections have id 1 and will be indicated by grey
if self.topLevelOperatorView.CachedOutput.ready():
self.trackingsrc = LazyflowSource(
self.topLevelOperatorView.CachedOutput)
trackingLayer = ColortableLayer(self.trackingsrc, ct)
trackingLayer.name = "Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 1.0
layers.append(trackingLayer)
elif self.topLevelOperatorView.zeroProvider.Output.ready():
# provide zeros while waiting for the tracking result
self.trackingsrc = LazyflowSource(
self.topLevelOperatorView.zeroProvider.Output)
trackingLayer = ColortableLayer(self.trackingsrc, ct)
trackingLayer.name = "Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 1.0
layers.append(trackingLayer)
if self.topLevelOperatorView.LabelImage.ready():
self.objectssrc = LazyflowSource(
self.topLevelOperatorView.LabelImage)
ct = colortables.create_random_16bit()
ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent
objLayer = ColortableLayer(self.objectssrc, ct)
objLayer.name = "Objects"
objLayer.opacity = 1.0
objLayer.visible = True
layers.append(objLayer)
if self.mainOperator.RawImage.ready():
self.rawsrc = None
self.rawsrc = LazyflowSource(self.mainOperator.RawImage)
rawLayer = GrayscaleLayer(self.rawsrc)
rawLayer.name = "Raw"
layers.insert(len(layers), rawLayer)
if self.topLevelOperatorView.LabelImage.meta.shape:
self.editor.dataShape = self.topLevelOperatorView.LabelImage.meta.shape
maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1
maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1
maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1
maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1
if not self.mainOperator.Parameters.ready():
raise Exception("Parameter slot is not ready")
parameters = self.mainOperator.Parameters.value
self._setRanges()
if 'size_range' in parameters:
self._drawer.to_size.setValue(parameters['size_range'][1] - 1)
self._drawer.from_size.setValue(parameters['size_range'][0])
else:
self._drawer.from_size.setValue(0)
self._drawer.to_size.setValue(10000)
if 'x_range' in parameters:
self._drawer.to_x.setValue(parameters['x_range'][1] - 1)
self._drawer.from_x.setValue(parameters['x_range'][0])
else:
self._drawer.from_x.setValue(0)
self._drawer.to_x.setValue(maxx)
if 'y_range' in parameters:
self._drawer.to_y.setValue(parameters['y_range'][1] - 1)
self._drawer.from_y.setValue(parameters['y_range'][0])
else:
self._drawer.from_y.setValue(0)
self._drawer.to_y.setValue(maxy)
if 'z_range' in parameters:
self._drawer.to_z.setValue(parameters['z_range'][1] - 1)
self._drawer.from_z.setValue(parameters['z_range'][0])
else:
self._drawer.from_z.setValue(0)
self._drawer.to_z.setValue(maxz)
if 'time_range' in parameters:
self._drawer.to_time.setValue(parameters['time_range'][1])
self._drawer.from_time.setValue(parameters['time_range'][0])
else:
self._drawer.from_time.setValue(0)
self._drawer.to_time.setValue(maxt)
if 'scales' in parameters:
self._drawer.x_scale.setValue(parameters['scales'][0])
self._drawer.y_scale.setValue(parameters['scales'][1])
self._drawer.z_scale.setValue(parameters['scales'][2])
else:
self._drawer.x_scale.setValue(1)
self._drawer.y_scale.setValue(1)
self._drawer.z_scale.setValue(1)
self.topLevelOperatorView.RawImage.notifyReady(self._onReady)
self.topLevelOperatorView.RawImage.notifyMetaChanged(
self._onMetaChanged)
return layers
def setupLayers( self ):
layers = []
# use same colortable for the following two generated layers: the merger
# and the tracking layer
self.tracking_colortable = colortables.create_random_16bit()
self.tracking_colortable[0] = QColor(0,0,0,0).rgba() # make 0 transparent
self.tracking_colortable[1] = QColor(128,128,128,255).rgba() # misdetections have id 1 and will be indicated by grey
self.merger_colortable = colortables.create_default_16bit()
for i in range(7):
self.merger_colortable[i] = self.mergerColors[i].rgba()
if "MergerOutput" in self.topLevelOperatorView.outputs:
parameters = self.mainOperator.Parameters.value
if 'withMergerResolution' in parameters.keys() and not parameters['withMergerResolution']:
merger_ct = self.merger_colortable
else:
merger_ct = self.tracking_colortable
# Using same color table for tracking with and without mergers (Is there any reason for using different color tables?)
merger_ct = self.tracking_colortable
if self.topLevelOperatorView.MergerCachedOutput.ready():
self.mergersrc = LazyflowSource( self.topLevelOperatorView.MergerCachedOutput )
else:
self.mergersrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output )
mergerLayer = ColortableLayer( self.mergersrc, merger_ct )
mergerLayer.name = "Merger"
if 'withMergerResolution' in parameters.keys() and not parameters['withMergerResolution']:
mergerLayer.visible = True
else:
mergerLayer.visible = False
layers.append(mergerLayer)
if self.topLevelOperatorView.CachedOutput.ready():
self.trackingsrc = LazyflowSource( self.topLevelOperatorView.CachedOutput )
trackingLayer = ColortableLayer( self.trackingsrc, self.tracking_colortable )
trackingLayer.name = "Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 1.0
layers.append(trackingLayer)
elif self.topLevelOperatorView.zeroProvider.Output.ready():
# provide zeros while waiting for the tracking result
self.trackingsrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output )
trackingLayer = ColortableLayer( self.trackingsrc, self.tracking_colortable )
trackingLayer.name = "Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 1.0
layers.append(trackingLayer)
if "RelabeledImage" in self.topLevelOperatorView.outputs:
if self.topLevelOperatorView.RelabeledCachedOutput.ready():
self.objectssrc = LazyflowSource( self.topLevelOperatorView.RelabeledCachedOutput )
else:
self.objectssrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output )
else:
if self.topLevelOperatorView.LabelImage.ready():
self.objectssrc = LazyflowSource( self.topLevelOperatorView.LabelImage )
ct = colortables.create_random_16bit()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
objLayer = ColortableLayer( self.objectssrc, ct )
objLayer.name = "Objects"
objLayer.opacity = 1.0
objLayer.visible = False
layers.append(objLayer)
if self.mainOperator.RawImage.ready():
rawLayer = self.createStandardLayerFromSlot(self.mainOperator.RawImage)
rawLayer.name = "Raw"
layers.insert( len(layers), rawLayer )
if self.topLevelOperatorView.LabelImage.meta.shape:
maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1
maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1
maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1
maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1
if not self.mainOperator.Parameters.ready():
raise Exception("Parameter slot is not ready")
parameters = self.mainOperator.Parameters.value
self._setRanges()
if 'size_range' in parameters:
self._drawer.to_size.setValue(parameters['size_range'][1]-1)
self._drawer.from_size.setValue(parameters['size_range'][0])
else:
self._drawer.from_size.setValue(0)
self._drawer.to_size.setValue(10000)
if 'x_range' in parameters:
self._drawer.to_x.setValue(parameters['x_range'][1]-1)
self._drawer.from_x.setValue(parameters['x_range'][0])
else:
self._drawer.from_x.setValue(0)
self._drawer.to_x.setValue(maxx)
if 'y_range' in parameters:
self._drawer.to_y.setValue(parameters['y_range'][1]-1)
self._drawer.from_y.setValue(parameters['y_range'][0])
else:
self._drawer.from_y.setValue(0)
self._drawer.to_y.setValue(maxy)
if 'z_range' in parameters:
self._drawer.to_z.setValue(parameters['z_range'][1]-1)
self._drawer.from_z.setValue(parameters['z_range'][0])
else:
self._drawer.from_z.setValue(0)
self._drawer.to_z.setValue(maxz)
if 'time_range' in parameters:
self._drawer.to_time.setValue(parameters['time_range'][1])
self._drawer.from_time.setValue(parameters['time_range'][0])
else:
self._drawer.from_time.setValue(0)
self._drawer.to_time.setValue(maxt)
if 'scales' in parameters:
self._drawer.x_scale.setValue(parameters['scales'][0])
self._drawer.y_scale.setValue(parameters['scales'][1])
self._drawer.z_scale.setValue(parameters['scales'][2])
else:
self._drawer.x_scale.setValue(1)
self._drawer.y_scale.setValue(1)
self._drawer.z_scale.setValue(1)
return layers
def setupLayers( self ):
layers = []
if "MergerOutput" in self.topLevelOperatorView.outputs:
ct = colortables.create_default_8bit()
for i in range(7):
ct[i] = self.mergerColors[i].rgba()
if self.topLevelOperatorView.MergerCachedOutput.ready():
self.mergersrc = LazyflowSource( self.topLevelOperatorView.MergerCachedOutput )
else:
self.mergersrc = LazyflowSource( self.topLevelOperatorView.ZeroOutput )
mergerLayer = ColortableLayer( self.mergersrc, ct )
mergerLayer.name = "Merger"
mergerLayer.visible = True
layers.append(mergerLayer)
ct = colortables.create_random_16bit()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
ct[1] = QColor(128,128,128,255).rgba() # misdetections have id 1 and will be indicated by grey
if self.topLevelOperatorView.CachedOutput.ready():
self.trackingsrc = LazyflowSource( self.topLevelOperatorView.CachedOutput )
trackingLayer = ColortableLayer( self.trackingsrc, ct )
trackingLayer.name = "Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 1.0
layers.append(trackingLayer)
elif self.topLevelOperatorView.zeroProvider.Output.ready():
# provide zeros while waiting for the tracking result
self.trackingsrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output )
trackingLayer = ColortableLayer( self.trackingsrc, ct )
trackingLayer.name = "Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 1.0
layers.append(trackingLayer)
if self.topLevelOperatorView.LabelImage.ready():
self.objectssrc = LazyflowSource( self.topLevelOperatorView.LabelImage )
ct = colortables.create_random_16bit()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
objLayer = ColortableLayer( self.objectssrc, ct )
objLayer.name = "Objects"
objLayer.opacity = 1.0
objLayer.visible = True
layers.append(objLayer)
if self.mainOperator.RawImage.ready():
rawLayer = self.createStandardLayerFromSlot(self.mainOperator.RawImage)
rawLayer.name = "Raw"
layers.insert( len(layers), rawLayer )
if self.topLevelOperatorView.LabelImage.meta.shape:
self.editor.dataShape = self.topLevelOperatorView.LabelImage.meta.shape
maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1
maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1
maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1
maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1
if not self.mainOperator.Parameters.ready():
raise Exception("Parameter slot is not ready")
parameters = self.mainOperator.Parameters.value
self._setRanges()
if 'size_range' in parameters:
self._drawer.to_size.setValue(parameters['size_range'][1]-1)
self._drawer.from_size.setValue(parameters['size_range'][0])
else:
self._drawer.from_size.setValue(0)
self._drawer.to_size.setValue(10000)
if 'x_range' in parameters:
self._drawer.to_x.setValue(parameters['x_range'][1]-1)
self._drawer.from_x.setValue(parameters['x_range'][0])
else:
self._drawer.from_x.setValue(0)
self._drawer.to_x.setValue(maxx)
if 'y_range' in parameters:
self._drawer.to_y.setValue(parameters['y_range'][1]-1)
self._drawer.from_y.setValue(parameters['y_range'][0])
else:
self._drawer.from_y.setValue(0)
self._drawer.to_y.setValue(maxy)
if 'z_range' in parameters:
self._drawer.to_z.setValue(parameters['z_range'][1]-1)
self._drawer.from_z.setValue(parameters['z_range'][0])
else:
self._drawer.from_z.setValue(0)
self._drawer.to_z.setValue(maxz)
if 'time_range' in parameters:
self._drawer.to_time.setValue(parameters['time_range'][1])
self._drawer.from_time.setValue(parameters['time_range'][0])
else:
self._drawer.from_time.setValue(0)
self._drawer.to_time.setValue(maxt)
if 'scales' in parameters:
self._drawer.x_scale.setValue(parameters['scales'][0])
self._drawer.y_scale.setValue(parameters['scales'][1])
self._drawer.z_scale.setValue(parameters['scales'][2])
else:
self._drawer.x_scale.setValue(1)
self._drawer.y_scale.setValue(1)
self._drawer.z_scale.setValue(1)
return layers
def setupLayers(self):
layers = []
# use same colortable for the following two generated layers: the merger
# and the tracking layer
self.tracking_colortable = colortables.create_random_16bit()
self.tracking_colortable[0] = QColor(0, 0, 0,
0).rgba() # make 0 transparent
self.tracking_colortable[1] = QColor(128, 128, 128, 255).rgba(
) # misdetections have id 1 and will be indicated by grey
self.merger_colortable = colortables.create_default_16bit()
for i in range(7):
self.merger_colortable[i] = self.mergerColors[i].rgba()
if "MergerOutput" in self.topLevelOperatorView.outputs:
parameters = self.mainOperator.Parameters.value
if 'withMergerResolution' in list(parameters.keys(
)) and not parameters['withMergerResolution']:
merger_ct = self.merger_colortable
else:
merger_ct = self.tracking_colortable
# Using same color table for tracking with and without mergers (Is there any reason for using different color tables?)
merger_ct = self.tracking_colortable
if self.topLevelOperatorView.MergerCachedOutput.ready():
self.mergersrc = LazyflowSource(
self.topLevelOperatorView.MergerCachedOutput)
else:
self.mergersrc = LazyflowSource(
self.topLevelOperatorView.zeroProvider.Output)
mergerLayer = ColortableLayer(self.mergersrc, merger_ct)
mergerLayer.name = "Merger"
if 'withMergerResolution' in list(parameters.keys(
)) and not parameters['withMergerResolution']:
mergerLayer.visible = True
else:
mergerLayer.visible = False
layers.append(mergerLayer)
if self.topLevelOperatorView.CachedOutput.ready():
self.trackingsrc = LazyflowSource(
self.topLevelOperatorView.CachedOutput)
trackingLayer = ColortableLayer(self.trackingsrc,
self.tracking_colortable)
trackingLayer.name = "Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 1.0
layers.append(trackingLayer)
elif self.topLevelOperatorView.zeroProvider.Output.ready():
# provide zeros while waiting for the tracking result
self.trackingsrc = LazyflowSource(
self.topLevelOperatorView.zeroProvider.Output)
trackingLayer = ColortableLayer(self.trackingsrc,
self.tracking_colortable)
trackingLayer.name = "Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 1.0
layers.append(trackingLayer)
if "RelabeledImage" in self.topLevelOperatorView.outputs:
if self.topLevelOperatorView.RelabeledCachedOutput.ready():
self.objectssrc = LazyflowSource(
self.topLevelOperatorView.RelabeledCachedOutput)
else:
self.objectssrc = LazyflowSource(
self.topLevelOperatorView.zeroProvider.Output)
else:
if self.topLevelOperatorView.LabelImage.ready():
self.objectssrc = LazyflowSource(
self.topLevelOperatorView.LabelImage)
ct = colortables.create_random_16bit()
ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent
objLayer = ColortableLayer(self.objectssrc, ct)
objLayer.name = "Objects"
objLayer.opacity = 1.0
objLayer.visible = False
layers.append(objLayer)
if self.mainOperator.RawImage.ready():
rawLayer = self.createStandardLayerFromSlot(
self.mainOperator.RawImage)
rawLayer.name = "Raw"
layers.insert(len(layers), rawLayer)
if self.topLevelOperatorView.LabelImage.meta.shape:
maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1
maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1
maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1
maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1
if not self.mainOperator.Parameters.ready():
raise Exception("Parameter slot is not ready")
parameters = self.mainOperator.Parameters.value
self._setRanges()
if 'size_range' in parameters:
self._drawer.to_size.setValue(parameters['size_range'][1] - 1)
self._drawer.from_size.setValue(parameters['size_range'][0])
else:
self._drawer.from_size.setValue(0)
self._drawer.to_size.setValue(10000)
if 'x_range' in parameters:
self._drawer.to_x.setValue(parameters['x_range'][1] - 1)
self._drawer.from_x.setValue(parameters['x_range'][0])
else:
self._drawer.from_x.setValue(0)
self._drawer.to_x.setValue(maxx)
if 'y_range' in parameters:
self._drawer.to_y.setValue(parameters['y_range'][1] - 1)
self._drawer.from_y.setValue(parameters['y_range'][0])
else:
self._drawer.from_y.setValue(0)
self._drawer.to_y.setValue(maxy)
if 'z_range' in parameters:
self._drawer.to_z.setValue(parameters['z_range'][1] - 1)
self._drawer.from_z.setValue(parameters['z_range'][0])
else:
self._drawer.from_z.setValue(0)
self._drawer.to_z.setValue(maxz)
if 'time_range' in parameters:
self._drawer.to_time.setValue(parameters['time_range'][1])
self._drawer.from_time.setValue(parameters['time_range'][0])
else:
self._drawer.from_time.setValue(0)
self._drawer.to_time.setValue(maxt)
if 'scales' in parameters:
self._drawer.x_scale.setValue(parameters['scales'][0])
self._drawer.y_scale.setValue(parameters['scales'][1])
self._drawer.z_scale.setValue(parameters['scales'][2])
else:
self._drawer.x_scale.setValue(1)
self._drawer.y_scale.setValue(1)
self._drawer.z_scale.setValue(1)
return layers
def showStuff(raw_name, pred_viewer1, pred_viewer2, cutout_name, one_extra = None):
# display the raw and annotations for cremi challenge data
raw = vigra.impex.readHDF5(indir+datasets[raw_name], "data", order = 'C')
# raw_old = vigra.readHDF5(indir+datasets["raw_bad"], "data", order = 'C')
defect_prediction_128 = vigra.impex.readHDF5(indir+datasets[pred_viewer2], "data", order = 'C')
defect_prediction_150 = vigra.impex.readHDF5(indir+datasets[pred_viewer1], "data", order = 'C')
cutout_from_150_pred = vigra.impex.readHDF5(indir+datasets[cutout_name], "data", order = 'C')
####################################################################################################################
# only used for fast testing stuff
#change_one = vigra.readHDF5(indir+datasets["segmentation_on_equalized_image"], "data", order = 'C')
#pdb.set_trace()
#defect_prediction_150[1,:,:] = change_one[0,:,:,0]
####################################################################################################################
# defect_prediction_150 = gt[..., 0]
cutout = numpy.asarray(cutout_from_150_pred)
rawdata = numpy.asarray(raw)
# rawdata_old = numpy.asarray(raw_old)
# op5ify
# shape5d = rawdata.shape
shape5d = (1,)+rawdata.shape+(1,)
print shape5d, rawdata.shape, rawdata.dtype
app = QApplication([])
v = Viewer()
direct = False
# layer for raw data
rawdata = numpy.reshape(rawdata, shape5d)
rawsource = ArraySource(rawdata)
v.dataShape = shape5d
lraw = GrayscaleLayer(rawsource, direct=direct)
lraw.visible = True
lraw.name = "raw"
v.layerstack.append(lraw)
# layer for cutout regions from raw data
cutout = numpy.reshape(cutout, shape5d)
cutoutsource = ArraySource(cutout)
lcutout = GrayscaleLayer(cutoutsource, direct = direct)
lcutout.visible = False
lcutout.name = "cut_out"
v.layerstack.append(lcutout)
# layer for first prediction result
defect_prediction_128 = numpy.reshape(defect_prediction_128, shape5d)
synsource = ArraySource(defect_prediction_128)
ct = create_random_16bit()
ct[0] = 0
lsyn = ColortableLayer(synsource, ct)
lsyn.name = pred_viewer2
lsyn.visible = False
v.layerstack.append(lsyn)
# layer for second prediction result
segm = numpy.reshape(defect_prediction_150, shape5d)
segsource = ArraySource(segm)
ct = create_random_16bit()
ct[0] = 0
lseg = ColortableLayer(segsource, ct)
lseg.name = pred_viewer1
lseg.visible = False
v.layerstack.append(lseg)
if one_extra is None:
v.showMaximized()
app.exec_()
if one_extra is not None:
# layer for third prediction result
extra_prediction = vigra.readHDF5(indir+datasets[one_extra], "data", order = 'C')
extra_pred_reshaped = numpy.reshape(extra_prediction, shape5d)
segsource = ArraySource(extra_pred_reshaped)
ct = create_random_16bit()
ct[0] = 0
# ct = create_default_16bit()
lseg = ColortableLayer(segsource, ct)
lseg.name = one_extra
lseg.visible = False
v.layerstack.append(lseg)
v.showMaximized()
app.exec_()
def setupLayers( self ):
layers = []
self.ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
self.ct[255] = QColor(0,0,0,255).rgba() # make -1 black
self.ct[-1] = QColor(0,0,0,255).rgba()
self.trackingsrc = LazyflowSource( self.topLevelOperatorView.TrackImage )
trackingLayer = ColortableLayer( self.trackingsrc, self.ct )
trackingLayer.name = "Manual Tracking"
trackingLayer.visible = True
trackingLayer.opacity = 0.8
layers.append(trackingLayer)
ct = colortables.create_random_16bit()
ct[1] = QColor(230,0,0,150).rgba()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
self.untrackedsrc = LazyflowSource( self.topLevelOperatorView.UntrackedImage )
untrackedLayer = ColortableLayer( self.untrackedsrc, ct )
untrackedLayer.name = "Untracked Objects"
untrackedLayer.visible = False
untrackedLayer.opacity = 0.8
layers.append(untrackedLayer)
self.objectssrc = LazyflowSource( self.topLevelOperatorView.BinaryImage )
# ct = colortables.create_default_8bit()
ct = colortables.create_random_16bit()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
ct[1] = QColor(255,255,0,100).rgba() # make 0 transparent
objLayer = ColortableLayer( self.objectssrc, ct )
objLayer.name = "Objects"
objLayer.opacity = 0.8
objLayer.visible = True
layers.append(objLayer)
## raw data layer
self.rawsrc = None
self.rawsrc = LazyflowSource( self.mainOperator.RawImage )
rawLayer = GrayscaleLayer( self.rawsrc )
rawLayer.name = "Raw"
layers.insert( len(layers), rawLayer )
if self.topLevelOperatorView.LabelImage.meta.shape:
self.editor.dataShape = self.topLevelOperatorView.LabelImage.meta.shape
# maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1
# maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1
# maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1
# maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1
#
# self._setRanges()
# self._drawer.from_time.setValue(0)
# self._drawer.to_time.setValue(maxt)
# self._drawer.from_x.setValue(0)
# self._drawer.to_x.setValue(maxx)
# self._drawer.from_y.setValue(0)
# self._drawer.to_y.setValue(maxy)
# self._drawer.from_z.setValue(0)
# self._drawer.to_z.setValue(maxz)
self.topLevelOperatorView.RawImage.notifyReady( self._onReady )
self.topLevelOperatorView.RawImage.notifyMetaChanged( self._onMetaChanged )
self._setDivisionsList()
self._setActiveTrackList()
return layers
def showStuff(raw_name,
pred_viewer1,
pred_viewer2,
cutout_name,
one_extra=None):
# display the raw and annotations for cremi challenge data
raw = vigra.impex.readHDF5(indir + datasets[raw_name], "data", order='C')
# raw_old = vigra.readHDF5(indir+datasets["raw_bad"], "data", order = 'C')
defect_prediction_128 = vigra.impex.readHDF5(indir +
datasets[pred_viewer2],
"data",
order='C')
defect_prediction_150 = vigra.impex.readHDF5(indir +
datasets[pred_viewer1],
"data",
order='C')
cutout_from_150_pred = vigra.impex.readHDF5(indir + datasets[cutout_name],
"data",
order='C')
####################################################################################################################
# only used for fast testing stuff
#change_one = vigra.readHDF5(indir+datasets["segmentation_on_equalized_image"], "data", order = 'C')
#pdb.set_trace()
#defect_prediction_150[1,:,:] = change_one[0,:,:,0]
####################################################################################################################
# defect_prediction_150 = gt[..., 0]
cutout = numpy.asarray(cutout_from_150_pred)
rawdata = numpy.asarray(raw)
# rawdata_old = numpy.asarray(raw_old)
# op5ify
# shape5d = rawdata.shape
shape5d = (1, ) + rawdata.shape + (1, )
print shape5d, rawdata.shape, rawdata.dtype
app = QApplication([])
v = Viewer()
direct = False
# layer for raw data
rawdata = numpy.reshape(rawdata, shape5d)
rawsource = ArraySource(rawdata)
v.dataShape = shape5d
lraw = GrayscaleLayer(rawsource, direct=direct)
lraw.visible = True
lraw.name = "raw"
v.layerstack.append(lraw)
# layer for cutout regions from raw data
cutout = numpy.reshape(cutout, shape5d)
cutoutsource = ArraySource(cutout)
lcutout = GrayscaleLayer(cutoutsource, direct=direct)
lcutout.visible = False
lcutout.name = "cut_out"
v.layerstack.append(lcutout)
# layer for first prediction result
defect_prediction_128 = numpy.reshape(defect_prediction_128, shape5d)
synsource = ArraySource(defect_prediction_128)
ct = create_random_16bit()
ct[0] = 0
lsyn = ColortableLayer(synsource, ct)
lsyn.name = pred_viewer2
lsyn.visible = False
v.layerstack.append(lsyn)
# layer for second prediction result
segm = numpy.reshape(defect_prediction_150, shape5d)
segsource = ArraySource(segm)
ct = create_random_16bit()
ct[0] = 0
lseg = ColortableLayer(segsource, ct)
lseg.name = pred_viewer1
lseg.visible = False
v.layerstack.append(lseg)
if one_extra is None:
v.showMaximized()
app.exec_()
if one_extra is not None:
# layer for third prediction result
extra_prediction = vigra.readHDF5(indir + datasets[one_extra],
"data",
order='C')
extra_pred_reshaped = numpy.reshape(extra_prediction, shape5d)
segsource = ArraySource(extra_pred_reshaped)
ct = create_random_16bit()
ct[0] = 0
# ct = create_default_16bit()
lseg = ColortableLayer(segsource, ct)
lseg.name = one_extra
lseg.visible = False
v.layerstack.append(lseg)
v.showMaximized()
app.exec_()
