owsomvisualizer.py

orange源码 数据挖掘技术

                    self.clearSelection()
                    self.addSelection(obj[-1])
            else:
                if self.master.ctrlPressed:
                    self.addSelection(obj[-1])
                else:
                    self.clearSelection()
                    self.addSelection(obj[-1])
            obj[-1].setChanged()
        else:
            self.clearSelection()
        self.master.updateSelection([a.node for a in self.selectionList])
        self.canvas().update()
        """

    def contentsMouseReleaseEvent(self, event):
        #obj=self.canvas().collisions(event.pos())
        #if obj and obj[-1]
        self.updateSelection()
        self.selectionRect.setCanvas(None)
        self.selectionRect=None
        self.master.updateSelection([a.node for a in self.selectionList])
        self.canvas().update()
        pass
    
    def updateSelection(self):
        obj=self.canvas().collisions(self.selectionRect.rect())
        obj=filter(lambda a:isinstance(a, CanvasSOMItem) and a.hasNode, obj)
        if self.master.ctrlPressed:
            set1=sets.Set(obj)
            set2=sets.Set(self.oldSelection)
            intersection=set1.intersection(set2)
            union=set1.union(set2)
            for e in list(intersection):
                self.removeSelection(e)
            for e in list(set1.difference(set2)):
                self.addSelection(e)
        else:
            self.clearSelection()
            for e in obj:
                self.addSelection(e)          

    def addSelection(self, obj):
        obj.setSelected(True)
        self.selectionList.append(obj)
           
    def removeSelection(self, obj):
        obj.setSelected(False)
        self.selectionList=filter(lambda a:a.isSelected ,self.selectionList)
    
    def clearSelection(self):
        for o in self.selectionList:
            o.setSelected(False)
        self.selectionList=[]
        
    def invertSelection(self):
        for n in self.canvas().canvasObj:
            if n.hasNode:
                if not n.isSelected:
                    self.addSelection(n)
                else:
                    self.removeSelection(n)
        self.master.updateSelection([a.node for a in self.selectionList])
        self.canvas().update()

baseColor=QColor(20,20,20)  

class SOMCanvas(QCanvas):
    def __init__(self, *args):
        apply(QCanvas.__init__, (self,)+args)
        self.drawMode=1
        self.showGrid=True
        self.component=0
        self.objSize=25
        self.canvasObj=[]
        self.somMap=None

    def drawHistogram(self):
        if self.parent().inputSet:
            maxVal=max([len(n.mappedExamples) for n in self.somMap.nodes]+[1])
        else:
            maxVal=max([len(n.examples) for n in self.somMap.nodes]+[1])
        if self.drawMode==1:
            maxSize=4*int(self.somMap.xDim*self.objSize/(2*self.somMap.xDim-1)*0.7)
        else:
            maxSize=4*int(self.objSize*0.7)
        for n in self.canvasObj:
            if n.hasNode:
                if self.parent().inputSet:
                    size=float(len(n.node.mappedExamples))/maxVal*maxSize
                else:
                    size=float(len(n.node.examples))/maxVal*maxSize
                if self.parent().drawPies():
                    n.setPie(self.parent().attribute, size)
                else:
                    n.setHist(size)
                    
        self.updateHistogramColors()            

    def updateHistogramColors(self):
        if self.parent().drawPies():
            return
        attr=self.somMap.examples.domain.variables[self.parent().attribute]
        for n in self.canvasObj:
            if n.hasNode:
                if attr.varType==orange.VarTypes.Discrete:
                    if self.parent().inputSet:
                        dist=orange.Distribution(attr, n.node.mappedExamples)
                    else:
                        dist=orange.Distribution(attr, n.node.examples)
                    colors=OWGraphTools.ColorPaletteHSV(len(dist))
                    maxProb=max(dist)
                    majValInd=filter(lambda i:dist[i]==maxProb, range(len(dist)))[0]
                    if self.parent().discHistMode==1:
                        n.histObj[0].setBrush(QBrush(colors[majValInd]))
                    elif self.parent().discHistMode==2:
                        light=180-80*float(dist[majValInd])/max(sum(dist),1)
                        n.histObj[0].setBrush(QBrush(colors[majValInd].light(light)))
                else:
                    if self.parent().inputSet:
                        dist=orange.Distribution(attr, n.node.mappedExamples)
                        fullDist=orange.Distribution(attr, self.parent().examples)
                    else:
                        dist=orange.Distribution(attr, n.node.examples)
                        fullDist=orange.Distribution(attr, self.somMap.examples)
                    if len(dist)==0:
                        continue
                    
                    if self.parent().contHistMode==0:
                        n.histObj[0].setBrush(QBrush(DefColor))
                    if self.parent().contHistMode==1:
                        std=(dist.average()-fullDist.average())/max(fullDist.dev(),1)
                        std=min(max(std,-1),1)
                        #print std
                        n.histObj[0].setBrush(QBrush(QColor(70*(std+1)+50, 70*(std+1)+50, 0)))                           
                    if self.parent().contHistMode==2:
                        light = 300-200*dist.var()/fullDist.var()
                        n.histObj[0].setBrush(QBrush(QColor(0,0,20).light(light)))                   
    
    def setSom(self, somMap=None):
        self.oldSom=self.somMap
        self.somMap=somMap
        self.clear()
        if not self.somMap:
            return
        
        self.somNodeMap={}
        for n in somMap.nodes:
            self.somNodeMap[(n.x,n.y)]=n

        if self.drawMode==1:
            self.uMat=orngSOM.getUMat(somMap)
            if somMap.topology==orangeom.SOMLearner.HexagonalTopology:
                self.drawUMatHex()
            else:
                self.drawUMatRect()
        else:
            if somMap.topology==orangeom.SOMLearner.HexagonalTopology:
                self.drawHex()
            else:
                self.drawRect()
            if self.drawMode!=0:
                minVal=min([n.vector[self.component] for n in self.somMap.nodes])
                maxVal=max([n.vector[self.component] for n in self.somMap.nodes])
                for o in self.canvasObj:
                    val=255-max(min(255*(o.node.vector[self.component]-minVal)/(maxVal-minVal),245),10)
                    o.setColor(QColor(val,val,val))
        if (self.parent().inputSet==0 or self.parent().examples) and self.parent().histogram:
            self.drawHistogram()
        self.updateLabels()
        
    def redrawSom(self):    #for redrawing without clearing the selection 
        if not self.somMap:
            return
        oldSelection=self.parent().canvasView.selectionList
        self.setSom(self.somMap)
        nodeList=[n.node for n in oldSelection]
        newSelection=[]
        for o in self.canvasObj:
            if o.node in nodeList:
                o.setSelected(True)
                newSelection.append(o)
        self.parent().canvasView.selectionList=newSelection
        self.update()
    
    def drawHex(self):
        #size=self.objSize*2-1
        #size=int((self.objSize-9)/10.0*20)*2-1
        size=2*self.objSize-1
        x,y=size, size*2
        for n in self.somMap.nodes:
            offset=1-abs(n.x%2-2)
            h=CanvasHexagon(self)
            h.setSize(size)
            h.setNode(n)
            (xa,ya)=h.advancement()
            h.move(x+n.x*xa, y+n.y*ya+offset*ya/2)
            h.show()
            self.canvasObj.append(h)
        self.resize(x+self.somMap.xDim*xa, y+self.somMap.yDim*ya)
        self.update()
    
    def drawRect(self):
        size=self.objSize*2-1
        x,y=size, size
        self.resize(1,1)    # crashes at update without this line !!!
        for n in self.somMap.nodes:
            r=CanvasRectangle(self)
            r.setSize(size)
            r.setNode(n)
            (xa,ya)=r.advancement()
            r.move(x+n.x*xa, y+n.y*ya)
            r.show()
            self.canvasObj.append(r)
        self.resize(x+self.somMap.xDim*xa, y+self.somMap.yDim*ya)
        self.update()
    
    def drawUMatHex(self):
        #size=2*(int(self.objSize*1.15)/2)-1
        size=2*int(self.somMap.xDim*self.objSize/(2*self.somMap.xDim-1))-1
        x,y=size, size
        maxDist=max(reduce(Numeric.maximum, [a for a in self.uMat]))
        minDist=max(reduce(Numeric.minimum, [a for a in self.uMat]))
        for i in range(len(self.uMat)):
            offset=2-abs(i%4-2)
            for j in range(len(self.uMat[i])):
                h=CanvasHexagon(self)
                h.setSize(size)
                (xa,ya)=h.advancement()
                h.move(x+i*xa, y+j*ya+offset*ya/2)
                if i%2==0 and j%2==0:
                    h.setNode(self.somNodeMap[(i/2,j/2)])
                h.show()
                val=255-min(max(255*(self.uMat[i][j]-minDist)/(maxDist-minDist),10),245)
                h.setColor(QColor(val, val, val))
                self.canvasObj.append(h)
        self.resize(x+self.somMap.xDim*xa*2, y+self.somMap.yDim*ya*2)
        self.update()
        
    def drawUMatRect(self):
        #size=self.objSize-1
        size=2*int(self.somMap.xDim*self.objSize/(2*self.somMap.xDim-1))-1
        x,y=size, size
        
        maxDist=max(reduce(Numeric.maximum, [a for a in self.uMat]))
        minDist=max(reduce(Numeric.minimum, [a for a in self.uMat]))
        for i in range(len(self.uMat)):
            for j in range(len(self.uMat[i])):
                r=CanvasRectangle(self)
                r.setSize(size)
                if i%2==0 and j%2==0:
                    r.setNode(self.somNodeMap[(i/2,j/2)])
                (xa,ya)=r.advancement()
                r.move(x+i*xa, y+j*ya)
                r.show()