def setupLayers( self ):        
        layers = []
        
        self.translationsrc = self.mainOperator.TranslationVectorsDisplay   
        translationLayer = self.createStandardLayerFromSlot( self.translationsrc )           
        translationLayer.name = "Translation Vector"
        translationLayer.opacity = 0.8
        translationLayer.visible = False
        layers.append(translationLayer)

        ct = colortables.create_default_8bit()
        ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
        ct[1] = QColor(0,255,0,255).rgba() # foreground is green
        self.warpedSrc = LazyflowSource( self.mainOperator.WarpedImage )
        warpedLayer = ColortableLayer( self.warpedSrc, ct )
        warpedLayer.name = "Translation Corrected Binary Image"
        warpedLayer.visible = False
        warpedLayer.opacity = 0.4
        layers.append(warpedLayer)


        ct = colortables.create_default_8bit()
        ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
        ct[1] = QColor(255,0,0,255).rgba() # foreground is read
        self.binarySrc = LazyflowSource( self.mainOperator.BinaryImage )
        binaryLayer = ColortableLayer( self.binarySrc, ct )
        binaryLayer.name = "Binary Image"
        binaryLayer.visible = True
        binaryLayer.opacity = 0.8
        layers.append(binaryLayer)
                
        ## raw data layer        
        self.rawsrc = LazyflowSource( self.mainOperator.RawImage )
        rawLayer = GrayscaleLayer( self.rawsrc )
        rawLayer.name = "Raw Image"        
        layers.insert( len(layers), rawLayer )   
        
        
        if self.topLevelOperatorView.TranslationVectors.meta.shape:
            self.editor.dataShape = self.topLevelOperatorView.TranslationVectors.meta.shape    
        
        self.topLevelOperatorView.RawImage.notifyReady( self._onReady )
        self.topLevelOperatorView.RawImage.notifyMetaChanged( self._onMetaChanged ) 
        
        self._onParametersChanged()        
        self._drawer.methodBox.currentIndexChanged.connect(self._onMethodChanged)
        self._drawer.templateSizeBox.valueChanged.connect(self._onMethodChanged)
        self._drawer.maxTranslationBox.valueChanged.connect(self._onMethodChanged)
        self._drawer.maxDiffValsBox.valueChanged.connect(self._onMethodChanged)
                
        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
Example #3
0
    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