owdistancemap.py

orange源码 数据挖掘技术

                self.annotationText[i*2 + 1].setX(self.offsetX)
                self.annotationText[i*2 + 1].setY(self.offsetY + maxHeight + 10 + i*self.CellHeight)
                
            self.offsetX += maxWidth + 10
            self.offsetY += maxHeight + 10
                   
        self.distanceImage = ImageItem(bitmap, self.canvas, width, height, palette, x=self.offsetX, y=self.offsetY, z=0)
        self.distanceImage.height = height
        self.distanceImage.width = width

        self.imageWidth = width
        self.imageHeight = height

        color = self.colorPalette.getCurrentColorSchema().getAdditionalColors()["Cell outline"]
        self.selector.setPen(QPen(self.qrgbToQColor(color),v_sel_width))
        self.selector.setSize(self.CellWidth, self.getCellHeight())
        
        self.updateSelectionRect()
        self.canvas.update()

    def addSelectionLine(self, x, y, direction):
        selLine = QCanvasLine(self.canvas)
        if direction==0:
            #horizontal line
            selLine.setPoints(self.offsetX + x*self.CellWidth, self.offsetY + y*self.getCellHeight(),
                              self.offsetX + (x+1)*self.CellWidth, self.offsetY + y*self.getCellHeight())
        else:
            #vertical line
            selLine.setPoints(self.offsetX + x*self.CellWidth, self.offsetY + y*self.getCellHeight(),
                              self.offsetX + x*self.CellWidth, self.offsetY + (y+1)*self.getCellHeight())
        color = self.colorPalette.getCurrentColorSchema().getAdditionalColors()["Selected cells"]            
        selLine.setPen(QPen(self.qrgbToQColor(color),v_sel_width))        
        selLine.setZ(20)            
        selLine.show();
        self.selectionLines += [selLine]
            
    def updateSelectionRect(self):
        entireSelection = []
        newSel = False
        for selLine in self.selectionLines:
            selLine.setCanvas(None)
            
        self.selectionLines = []
        if len(self.selection.getSelection())>0:
            for sel in self.selection.getSelection():
                for i in range(sel[0].x(), sel[1].x()):
                    for j in range(sel[0].y(), sel[1].y()):
                        selTuple = (i, j)
                        if not (selTuple in entireSelection):
                            entireSelection += [selTuple]
            for selTuple in entireSelection:
                #check left
                if (not (selTuple[0] - 1, selTuple[1]) in entireSelection):
                    self.addSelectionLine(selTuple[0], selTuple[1], 1)
                    
                #check up
                if (not (selTuple[0], selTuple[1] - 1) in entireSelection):
                    self.addSelectionLine(selTuple[0], selTuple[1], 0)

                #check down
                if (not (selTuple[0], selTuple[1] + 1) in entireSelection):
                    self.addSelectionLine(selTuple[0], selTuple[1] + 1, 0)                    

                #check right
                if (not (selTuple[0] + 1, selTuple[1]) in entireSelection):
                    self.addSelectionLine(selTuple[0] + 1, selTuple[1], 1)                    
        self.canvas.update()    

            
    def mouseMove(self, x, y):
        row = self.rowFromMousePos(x,y)
        col = self.colFromMousePos(x,y)

        if (self.clicked==True):
            self.selection.UpdateSel(col, row)

        if (row==-1 or col==-1):
            self.selector.hide()
            self.bubble.hide()
        else:
            self.selector.setX(self.offsetX + col * self.CellWidth)
            self.selector.setY(self.offsetY + row * self.getCellHeight())
            self.selector.show()

            if self.ShowBalloon == 1:
                self.bubble.move(x + 20, y + 20)

                i = self.getItemFromPos(col)
                j = self.getItemFromPos(row)
                self.bubble.head.setText(str(self.matrix[i, j]))
              
                if (self.ShowItemsInBalloon == 1):
                    namei, namej = self.matrix.items[i], self.matrix.items[j]
                    if type(namei) not in [str, unicode]:
                        namei = namei.name
                    if type(namej) not in [str, unicode]:
                        namej = namej.name
                    if namei or namej:
                        self.bubble.body.setText(namei + "\n" + namej)
                    else:
                        self.bubble.body.setText("")
                else:
                    self.bubble.body.setText("")

                self.bubble.show()
            else:
                self.bubble.hide()

            self.updateSelectionRect()

        self.canvas.update()

    def keyPressEvent(self, e):
        self.shiftPressed = (e.key() == 4128)

    def keyReleaseEvent(self, e):        
        self.shiftPressed = False
        
    def mousePress(self, x,y):
        self.clicked = True
        row = self.rowFromMousePos(x,y)
        col = self.colFromMousePos(x,y)
        if not (self.shiftPressed == True):
            self.selection.clear()
        self.selection.SelStart(col, row)
        
    def mouseRelease(self, x,y):
        if self.clicked==True:
            self.clicked = False
            row = self.rowFromMousePos(x,y)
            col = self.colFromMousePos(x,y)

            if (row<>-1 and col<>-1):
                self.selection.SelEnd()
            else:
                self.selection.CancelSel()

            self.updateSelectionRect()
            if self.SendOnRelease==1:
                self.sendOutput()

    def actionUndo(self):
        self.selection.undo()
        self.updateSelectionRect()
    
    def actionRemoveAllSelections(self):
        self.selection.clear()
        self.updateSelectionRect()
                        

    ##########################################################################
    # input signal management

    def sortNone(self):
        self.order = None

    def sortAdjDist(self):
        self.order = None

    def sortRandom(self):
        import random
        self.order = range(len(self.matrix.items))
        random.shuffle(self.order)

    def sortItems(self):
        if not self.matrix:
            return
        self.sorting[self.Sort][1]()
        self.createDistanceMap()

    ##########################################################################
    # input signal management

    def setMatrix(self, matrix):
        if not matrix:
            # should remove the data where necessary
            return
        # check if the same length
        self.matrix = matrix
        self.constructDistanceMap()        


##################################################################################################
# new canvas items

class ImageItem(QCanvasRectangle):
    def __init__(self, bitmap, canvas, width, height, palette, depth=8, numColors=256, x=0, y=0, z=0):
        QCanvasRectangle.__init__(self, canvas)
        self.image = QImage(bitmap, width, height, depth, palette, numColors, QImage.LittleEndian)
        self.image.bitmap = bitmap # this is tricky: bitmap should not be freed, else we get mess. hence, we store it in the object
        self.canvas = canvas
        self.setSize(width, height)
        self.setX(x); self.setY(y); self.setZ(z)
        self.show()
        
    def drawShape(self, painter):
        painter.drawImage(self.x(), self.y(), self.image, 0, 0, -1, -1)

class QCustomCanvasText(QCanvasRectangle):
    def __init__(self, text, canvas = None, rotateAngle = 0.0):
        QCanvasRectangle.__init__(self, canvas)
        self.text = text
        self.rotateAngle = rotateAngle
        self.hiddenText = QCanvasText(text, canvas)
        xsize = self.hiddenText.boundingRect().height()
        ysize = self.hiddenText.boundingRect().width()        
        self.setSize(xsize, ysize)

    def setText(self, text):
        self.text = text
        self.hiddenText = QCanvasText(text, canvas)
        xsize = self.hiddenText.boundingRect().height()
        ysize = self.hiddenText.boundingRect().width()        
        self.setSize(xsize, ysize)

    def setAngle(self, angle):
        self.rotateAngle = rotateAngle
        
    def draw(self, painter):
        pixmap = QPixmap()
        xsize = self.hiddenText.boundingRect().height()
        ysize = self.hiddenText.boundingRect().width()
        pixmap.resize(xsize, ysize)

        helpPainter = QPainter()
        helpPainter.begin(pixmap)

        helpPainter.setPen( Qt.black );
        helpPainter.setBrush( Qt.white );
        helpPainter.drawRect( -1, -1, xsize + 2, ysize + 2);
        helpPainter.rotate(self.rotateAngle)
        helpPainter.drawText(-ysize - 1, xsize, self.text)
        helpPainter.end()
            
        painter.drawPixmap(self.x(), self.y(), pixmap)
##################################################################################################
# selection manager class

class SelectionManager:
    def __init__(self):
        self.selection = []
        self.selecting = False
        self.currSelEnd = None
        self.currSel = None

    def SelStart(self, x, y):
        if x < 0: x=0
        if y < 0: y=0
        self.currSel = QPoint(x,y)
        self.currSelEnd = QPoint(x,y)
        self.selecting = True
        
    def UpdateSel(self, x, y):
        self.currSelEnd = QPoint(x,y)

    def CancelSel(self):
        self.selecting = False
        
    def SelEnd(self):
        minx = min(self.currSel.x(), self.currSelEnd.x())
        maxx = max(self.currSel.x(), self.currSelEnd.x())

        miny = min(self.currSel.y(), self.currSelEnd.y())
        maxy = max(self.currSel.y(), self.currSelEnd.y())
            
        if (minx==maxx) and (miny==maxy):
            maxx+=1
            maxy+=1
        
        self.selection += [(QPoint(minx, miny),QPoint(maxx,maxy))]
        self.selecting = False

    def clear(self):
        self.selection = []

    def undo(self):
        if len(self.selection)>0:
            del self.selection[len(self.selection)-1]
                        
    def getSelection(self):
        res = self.selection + []
        if self.selecting==True:
            minx = min(self.currSel.x(), self.currSelEnd.x())
            maxx = max(self.currSel.x(), self.currSelEnd.x())

            miny = min(self.currSel.y(), self.currSelEnd.y())
            maxy = max(self.currSel.y(), self.currSelEnd.y())

            res += [(QPoint(minx, miny),QPoint(maxx,maxy))]
        return res


        
##################################################################################################
# bubble info class

bubbleBorder = 4

class BubbleInfo(QCanvasRectangle):
    def __init__(self, *args):
        apply(QCanvasRectangle.__init__, (self,) + args)
        self.canvas = args[0]
        self.setBrush(QBrush(Qt.white))
        #self.setPen(QPen(Qt.black, v_sel_width))
        self.bubbleShadow = QCanvasRectangle(self.canvas)
        self.bubbleShadow.setBrush(QBrush(Qt.black))
        self.bubbleShadow.setPen(QPen(Qt.black))
        self.head = QCanvasText(self.canvas)
        self.line = QCanvasLine(self.canvas)
        self.body = QCanvasText(self.canvas)
        self.items = [self.head, self.line, self.body]
        self.setZ(110)
        self.bubbleShadow.setZ(109)
        for i in self.items:
            i.setZ(111)

    def move(self, x, y):
        QCanvasRectangle.move(self, x, y)
        self.setX(x); self.setY(y)
        self.bubbleShadow.move(x+5, y+5)
        for item in self.items:
            item.setX(x + bubbleBorder)
        w = max(100, self.head.boundingRect().width() + 2 * bubbleBorder, self.body.boundingRect().width() + 2 * bubbleBorder)
        y += 2
        self.head.setY(y)
        y += self.head.boundingRect().height()
        self.line.setPoints(0,0,w,0)
        self.line.setX(x); self.line.setY(y)
        y += 2
        self.body.setY(y)
        h = 2 * (2 + (self.body.text()<>None)) + self.head.boundingRect().height() + (self.body.text()<>None) * self.body.boundingRect().height()
        self.setSize(w,h)
        self.bubbleShadow.setSize(w,h)
        
    def show(self):
        QCanvasRectangle.show(self)
        self.bubbleShadow.show()
        self.head.show()
        if self.body.text():
            self.line.show()
            self.body.show()

    def hide(self):
        QCanvasRectangle.hide(self)
        self.bubbleShadow.hide()
        for item in self.items:
            item.hide()

##################################################################################################
# test script

if __name__=="__main__":

    def computeMatrix(data):
        dist = orange.ExamplesDistanceConstructor_Euclidean(data)
        matrix = orange.SymMatrix(len(data))
        matrix.setattr('items', data)
        for i in range(len(data)):
            for j in range(i+1):
                matrix[i, j] = dist(data[i], data[j])
        return matrix
    
    import orange
    a = QApplication(sys.argv)
    ow = OWDistanceMap()
    a.setMainWidget(ow)

    ow.show()

    data = orange.ExampleTable(r'../../doc/datasets/wt')
    
    matrix = computeMatrix(data)
    ow.setMatrix(matrix)

    a.exec_loop()

    ow.saveSettings()