jeah...segmentation layer is working

Author: DerThorsten

layerviewer/helpers.py

@@ -8,4 +8,16 @@ def setPolicy(widget,p=QtGui.QSizePolicy.Maximum):
     sizePolicy = QtGui.QSizePolicy(p,p)
     sizePolicy.setHorizontalStretch(0)
     sizePolicy.setVerticalStretch(0)
-    widget.setSizePolicy(sizePolicy)
+    widget.setSizePolicy(sizePolicy)
+
+
+
+
+def permuteLabels(data):
+
+    flat = np.array(data).reshape([-1])
+    unique , relabeling = np.unique(flat,return_inverse=True)
+    permUnique = np.random.permutation(unique)
+    flatNew = permUnique[relabeling]
+    newLabels = flatNew.reshape([data.shape[0],data.shape[1]])
+    return newLabels

layerviewer/layers.py

@@ -4,12 +4,14 @@
 from collections import OrderedDict
 import pyqtgraph.parametertree.parameterTypes as pTypes
 from pyqtgraph.parametertree import Parameter, ParameterTree, ParameterItem, registerParameterType
-from helpers import setPolicy
-from abc import ABCMeta,abstractmethod
 
+from abc import ABCMeta,abstractmethod
+    
+from helpers    import setPolicy,permuteLabels
 from inputCheck import InputCheck
+from normalize  import norm01
 #from lazycall   import lazyCall
-from normalize import norm01
+
 
 
 class LayerBase(object):
@@ -123,11 +125,11 @@ def lala(self):
 class LayerImageItem(pg.ImageItem):
     def __init__(self,*args,**kwargs):
         super(LayerImageItem,self).__init__(*args,**kwargs)
-
+    """
     def mouseClickEvent(self, ev):
         print type(self)
         print ev.pos()
-
+    """
 
 class ImageRgbLayer(LayerImageItem,LayerBase):
 
@@ -140,12 +142,8 @@ def checkData(self,data):
         InputCheck.colorImage(data)
 
     def setData(self,data=None):
-        if data is None:
-            self.removeItems()
-            return 
-        else:
-            self.data=data
-            self.setImage(self.data,opacity=self.getParamValue('Opacity'))
+        self.data=data
+        self.setImage(self.data,opacity=self.getParamValue('Opacity'))
 
     def controlTemplate(self):
         return [{'name': 'Opacity', 'type': 'float', 'value': 0.75, 'step': 0.1,'limits':[0,1]} ] 
@@ -160,7 +158,6 @@ def onOpacityChanged(param,changes):
         self.connectParam('Opacity',onOpacityChanged)
 
 
-
 class ImageGrayLayer(LayerImageItem,LayerBase):
 
 
@@ -180,14 +177,10 @@ def checkData(self,data):
         InputCheck.grayImage(data)
 
     def setData(self,data=None):
-        if data is None:
-            self.removeItems()
-            return 
-        else:
-            self.data=data
-            self.preProcessedData   = norm01(np.squeeze(self.data))
-            self.cmappedData        = self.getParamValue('ColorMap').map(self.preProcessedData)
-            self.setImage(self.cmappedData,opacity=self.getParamValue('Opacity'))
+        self.data=data
+        self.preProcessedData   = norm01(np.squeeze(self.data))
+        self.cmappedData        = self.getParamValue('ColorMap').map(self.preProcessedData)
+        self.setImage(self.cmappedData,opacity=self.getParamValue('Opacity'))
 
     def controlTemplate(self):
         return [
@@ -212,7 +205,6 @@ def onColorMapChanged(param,changes):
         self.connectParam('ColorMap',onColorMapChanged)
 
 
-
 class ImageMultiGrayLayer(LayerImageItem,LayerBase):
 
 
@@ -223,22 +215,18 @@ def __init__(self,name,layerViewer):
         self.addItem(self)
         self.preProcessedData   = None
         self.selectedChannelImg = None
-        self.cmappedData         = None
+        self.cmappedData        = None
 
     def checkData(self,data):
         InputCheck.multiGrayImage(data)
 
     def setData(self,data=None):
-        if data is None:
-            self.removeItems()
-            return 
-        else:
-            self.layerParameter.param('Channel').setOpts(name = 'Channel',value =0 ,limits=[0,data.shape[2]-1])
-            self.data               = data
-            self.preProcessedData   = norm01(self.data,channelWise=True)
-            self.selectedChannelImg = self.preProcessedData[:,:,self.getParamValue('Channel')]
-            self.cmappedData        = self.getParamValue('ColorMap').map(self.selectedChannelImg)
-            self.setImage(self.cmappedData,opacity=self.getParamValue('Opacity'))
+        self.layerParameter.param('Channel').setOpts(name = 'Channel',value =0 ,limits=[0,data.shape[2]-1])
+        self.data               = data
+        self.preProcessedData   = norm01(self.data,channelWise=True)
+        self.selectedChannelImg = self.preProcessedData[:,:,self.getParamValue('Channel')]
+        self.cmappedData        = self.getParamValue('ColorMap').map(self.selectedChannelImg)
+        self.setImage(self.cmappedData,opacity=self.getParamValue('Opacity'))
 
 
     def controlTemplate(self):
@@ -274,6 +262,69 @@ def onOpacityChanged(param,changes):
         self.connectParam('ColorMap',onColorMapChanged)
 
 
+class SegmentationLayer(LayerImageItem,LayerBase):
+
+
+    def __init__(self,name,layerViewer):
+        LayerBase.__init__(self,name,layerViewer)
+        LayerImageItem.__init__(self,parent=self.layerView)
+
+        self.addItem(self)
+        self.preProcessedData = None
+        self.cmappedData      = None
+
+
+    def checkData(self,data):
+        InputCheck.grayImage(data)
+
+    def setData(self,data=None):
+        self.data=data
+        self.preProcessedData   = norm01(np.require( permuteLabels(self.data),dtype=np.float32 ) )
+        self.cmappedData        = self.getParamValue('ColorMap').map(self.preProcessedData)
+        self.setImage(self.cmappedData,opacity=self.getParamValue('Opacity'))
+
+    def controlTemplate(self):
+        return [
+            {'name': 'ColorMap', 'type': 'colormap'},
+            {'name': 'Opacity', 'type': 'float', 'value': 0.75, 'step': 0.1,'limits':[0,1]} 
+        ] 
+
+    def connectControls(self):
+
+        def onOpacityChanged(param,changes):
+            assert len(changes)==1
+            param,change,opacity = changes[0]
+            self.setImage(self.cmappedData,opacity=opacity)
+
+        def onColorMapChanged(param,changes):
+            assert len(changes)==1
+            param,change,cmap = changes[0]
+            self.cmappedData  = cmap.map(self.preProcessedData)
+            self.setImage(self.cmappedData,opacity=self.getParamValue('Opacity'))
+
+        self.connectParam('Opacity',onOpacityChanged)
+        self.connectParam('ColorMap',onColorMapChanged)
+
+
+    def mouseClickEvent(self, ev):
+        pos = ev.pos()
+        label = self.data[pos[0],pos[1]]
+        self.segClicked(label,ev)
+
+
+    def segClicked(self,label,ev):
+        print "label %d clicked"%label
+
+
+
+class PixelLabelLayer(LayerImageItem,LayerBase):
+    pass
+
+
+
+
+
 layerTypes['RgbLayer']=ImageRgbLayer
 layerTypes['GrayLayer']=ImageGrayLayer
-layerTypes['MultiGrayLayer']=ImageMultiGrayLayer
+layerTypes['MultiGrayLayer']=ImageMultiGrayLayer
+layerTypes['SegmentationLayer']=SegmentationLayer

layerviewer/lazycall.py

@@ -0,0 +1,6 @@
+
+def lazyCall(value,f,*args,**kwargs):
+	if value is None:
+		return f(*args,**kwargs)
+	else:
+		return value

layerviewer/normalize.py

@@ -0,0 +1,12 @@
+def norm01(dataIn,channelWise=False):
+	out=dataIn.copy()
+	if channelWise==False:
+		out-=out.min()
+		out/=out.max()
+	else :
+		for c in range(dataIn.shape[2]):
+			out[:,:,c]-=out[:,:,c].min()
+			out[:,:,c]/=out[:,:,c].max()
+	return out
+
+

myviewer.py

@@ -20,21 +20,30 @@
 viewer =  lv.LayerViewer()
 viewer.show()
 
-rgbImg = vigra.readImage('/home/tbeier/Desktop/lena.bmp')#[:,:,:]
-viewer.addLayer(name='rgb',layerType='RgbLayer')
-viewer.setLayerData(name='rgb',data=rgbImg)
+rgbImg   = vigra.readImage('/home/tbeier/Desktop/lena.bmp')
+gradMag  = vigra.filters.gaussianGradientMagnitude(rgbImg,3.5)
+seg,nSeg = vigra.analysis.watersheds(gradMag) 
 
 
+print seg,nSeg
 
-gray = vigra.filters.gaussianGradientMagnitude(rgbImg,1.5)
-viewer.addLayer(name='gray',layerType='GrayLayer')
-viewer.setLayerData(name='gray',data=gray)
 
+# rgb layer
+viewer.addLayer(name='Rgb',layerType='RgbLayer')
+viewer.setLayerData(name='Rgb',data=rgbImg)
 
+# gray layer
+viewer.addLayer(name='GradMag',layerType='GrayLayer')
+viewer.setLayerData(name='GradMag',data=gradMag)
 
 
-viewer.addLayer(name='mgray',layerType='MultiGrayLayer')
-viewer.setLayerData(name='mgray',data=rgbImg)
+# seg layer
+viewer.addLayer(name='SuperPixels',layerType='SegmentationLayer')
+viewer.setLayerData(name='SuperPixels',data=seg)
+
+
+#viewer.addLayer(name='mgray',layerType='MultiGrayLayer')
+#viewer.setLayerData(name='mgray',data=rgbImg)
 
 
 viewer.autoRange()