owsomvisualizer.py

orange源码 数据挖掘技术

"""
<name>SOMVisualizer</name>
<description>SOM visualizer</description>
<icon>SOMVisualizer.png</icon>
<contact>Ales Erjavec (ales.erjavec(@at@)fri.uni-lj.si)</contact> 
<priority>5020</priority>
"""
import orange, orngSOM, orangeom
import math, Numeric, sets
import OWGUI, OWGraphTools
from OWWidget import *
from qt import *
from qtcanvas import *
from OWTreeViewer2D import CanvasBubbleInfo
from OWDlgs import OWChooseImageSizeDlg

DefColor=QColor(200, 200, 0)
BaseColor=QColor(0, 0, 200)
class CanvasSOMItem(QCanvasPolygon):
    startAngle=0
    segment=6
    def __init__(self, *args):
        apply(QCanvasPolygon.__init__,(self,)+args)
        self.node=None
        self.hasNode=False
        self.isSelected=False
        self.labelText=""
        self.textColor=Qt.black
        self.outlinePoints=None
        self.histObj=[]
        self.setSize(10)
        self.setZ(0)

    def boundingRect(self):
        return self.outlinePoints.boundingRect()

    def move(self, x, y):
        QCanvasPolygon.move(self, x, y)
        for e in self.histObj:
            e.move(x, y)

    def areaPoints(self):
        return self.outlinePoints
    
    def setSize(self, size):
        self.outlinePoints=QPointArray(self.segments)
        for i in range(self.segments):
            x=int(math.cos(2*math.pi/self.segments*i+self.startAngle)*size)
            y=int(math.sin(2*math.pi/self.segments*i+self.startAngle)*size)
            self.outlinePoints.setPoint(i,x,y)
        self.setPoints(self.outlinePoints)

    def setPie(self, attrIndex, size):
        for e in self.histObj:
            e.setCanvas(None)
        self.histObj=[]
        if len(self.node.examples)<0:
            return
        dist=orange.Distribution(attrIndex, self.node.examples)
        colors=OWGraphTools.ColorPaletteHSV(len(dist))
        distSum=max(sum(dist),1)
        startAngle=0
        for i in range(len(dist)):
            angle=360/distSum*dist[i]*16
            c=QCanvasEllipse(size, size, startAngle, angle, self.canvas())
            c.setBrush(QBrush(colors[i]))
            c.setZ(10)
            c.move(self.x(), self.y())
            c.show()
            startAngle+=angle
            self.histObj.append(c)

    def setHist(self, size):
        for e in self.histObj:
            e.setCanvas(None)
        self.histObj=[]
        c=QCanvasEllipse(size, size, self.canvas())
        c.setZ(10)
        c.move(self.x(), self.y())
        c.setBrush(QBrush(DefColor))
        c.setPen(QPen(Qt.white))
        c.show()
        self.histObj.append(c)

    def setLabel(self, label):
        self.labelText=label

    def setColor(self, color):
        self.color=color
        if color.hsv()[2]<100:
            self.textColor=Qt.white
        self.setBrush(QBrush(color))

    def setNode(self, node):
        self.node=node
        self.hasNode=True

    def setSelected(self, bool=True):
        if self.isSelected!=bool:
            self.isSelected=bool
            self.setChanged()
            self.setZ(bool and (self.z()+1) or (self.z()-1))

    def advancement(self):
        pass

    def setChanged(self):
        self.canvas().setChanged(self.boundingRect())
       
    def drawShape(self, painter):
        QCanvasPolygon.drawShape(self, painter)
        if self.canvas().showGrid or self.isSelected:
            color=self.isSelected and Qt.blue or Qt.black
            p=QPen(color)
            if self.isSelected:
                p.setWidth(3)
            painter.setPen(p)
            painter.drawPolyline(self.outlinePoints)
            painter.drawLine(self.outlinePoints.point(0)[0],self.outlinePoints.point(0)[1],
                             self.outlinePoints.point(self.segments-1)[0],self.outlinePoints.point(self.segments-1)[1])
        """if self.node:
            painter.setPen(QPen(self.isSelected and Qt.red or self.textColor))
            if self.labelText:
                painter.drawText(self.boundingRect(), Qt.AlignVCenter | Qt.AlignLeft, " "+self.labelText)
            else:
                #return 
                painter.setBrush(QBrush(self.isSelected and Qt.red or self.textColor))
                painter.drawPie(self.x()-2,self.y()-2,4,4,0,5760)
        #self.setChanged()"""

    def setCanvas(self, canvas):
        QCanvasPolygon.setCanvas(self, canvas)
        for e in self.histObj:
            e.setCanvas(canvas)
        
class CanvasHexagon(CanvasSOMItem):
    startAngle=0
    segments=6
    def __init__(self, *args):
        apply(CanvasSOMItem.__init__,(self,)+args)
    def advancement(self):
        width=self.outlinePoints.point(0)[0]-self.outlinePoints.point(3)[0]
        line=self.outlinePoints.point(1)[0]-self.outlinePoints.point(2)[0]
        x=width-(width-line)/2
        y=self.outlinePoints.point(2)[1]-self.outlinePoints.point(5)[1]
        return (x,y)

class CanvasRectangle(CanvasSOMItem):
    startAngle=math.pi/4
    segments=4
    def advancement(self):
        x=self.outlinePoints.point(0)[0]-self.outlinePoints.point(1)[0]
        y=self.outlinePoints.point(0)[1]-self.outlinePoints.point(3)[1]
        return (x,y)

class SOMCanvasView(QCanvasView):
    def __init__(self, master, canvas, *args):
        apply(QCanvasView.__init__, (self,canvas)+args)
        self.master=master
        self.selectionList=[]
        self.bubble=None
        self.bubbleNode=None
        self.showBubbleInfo=True
        self.includeCodebook=True
        self.selectionRect=None
        self.viewport().setMouseTracking(True)
        
    def buildBubble(self, node):
        b=CanvasBubbleInfo(node,None,self.canvas())
        b.setZ(20)
        s="Items: "+str(len(node.examples))
        b.addTextLine(s)
        
        if self.includeCodebook:
            b.addTextLine()
            b.addTextLine("Codebook vector:")
            for a in node.referenceExample:
                if a.variable!=node.referenceExample.domain.classVar:
                    b.addTextLine(a.variable.name+": "+str(a))
            #b.addTextLine()    
            
        if node.examples.domain.classVar and len(node.examples):
            b.addTextLine()
            dist=orange.Distribution(node.examples.domain.classVar, node.examples)
            if node.examples.domain.classVar.__class__==orange.FloatVariable:
                s="Avg "+node.examples.domain.classVar.name+":"+("%.3f" % dist.average())
                b.addTextLine(s)
            else:
                colors=OWGraphTools.ColorPaletteHSV(len(node.examples.domain.classVar.values))
                for i in range(len(node.examples.domain.classVar.values)):
                    s=str(node.examples.domain.classVar.values[i])+": "+str(dist[i])
                    b.addTextLine(s, colors[i])
        b.fitSquare()
        b.show()
        return b
    
    def fitBubble(self):
        bRect=self.bubble.boundingRect()
        #cRect=self.canvas().rect()
        flipX=flipY=False
        if self.canvas().width()<bRect.right():
            flipX=True
        if self.canvas().height()<bRect.bottom():
            flipY=True
        self.bubble.move(self.bubble.x()-(flipX and self.bubble.width()+20 or 0),
                         self.bubble.y()-(flipY and self.bubble.height()+20 or 0))
        
    def contentsMouseMoveEvent(self, event):
        pos=event.pos()
        if self.selectionRect:
            rect=self.selectionRect.rect()
            self.selectionRect.setSize(pos.x()-rect.x(),pos.y()-rect.y())
            #self.updateSelection()
        obj=self.canvas().collisions(pos)
        if obj and (obj[-1].__class__==CanvasHexagon or obj[-1].__class__==CanvasRectangle) and obj[-1].hasNode:
            if not self.showBubbleInfo:
                if self.bubble:
                    self.bubble.hide()
                self.canvas().update()
                return
            node=obj[-1].node
            if self.bubbleNode:
                if node==self.bubbleNode:
                    self.bubble.move(pos.x()+10,pos.y()+10)
                else:
                    self.bubble.setCanvas(None)
                    self.bubble=self.buildBubble(node)
                    self.bubble.move(pos.x()+10,pos.y()+10)
                    self.bubbleNode=node
            else:
                self.bubble=self.buildBubble(node)
                self.bubble.move(pos.x()+10,pos.y()+10)
                self.bubbleNode=node
            self.fitBubble()
        elif self.bubble:
            self.bubble.setCanvas(None)
            self.bubble=None
            self.bubbleNode=None
        self.canvas().update()
        
    def contentsMousePressEvent(self, event):
        pos=event.pos()
        self.selectionRect=r=QCanvasRectangle(pos.x(), pos.y(), 1, 1, self.canvas())
        r.show()
        r.setZ(19)
        self.oldSelection=self.selectionList
        if not self.master.ctrlPressed:
            self.clearSelection()            
        """
        obj=self.canvas().collisions(event.pos())
        if obj and obj[-1].hasNode:
            if obj[-1] in self.selectionList:
                if self.master.ctrlPressed:
                    self.removeSelection(obj[-1])
                else: