owattributestatistics.py

orange源码 数据挖掘技术

"""
<name>Attribute Statistics</name>
<description>Basic attribute statistics.</description>
<contact>Jure Zabkar ([e-mail])</contact>
<icon>icons/AttributeStatistics.png</icon>
<priority>200</priority>
"""
#
# OWAttributeStatistics.py
#

#import orange
from qtcanvas import *
from OWWidget import *
from OWGUI import *
from OWDlgs import OWChooseImageSizeDlg

class OWAttributeStatistics(OWWidget):
    contextHandlers = {"": DomainContextHandler("", ["HighlightedAttribute"], findImperfect = True)}

    def __init__(self,parent=None, signalManager = None):
        OWWidget.__init__(self, parent, signalManager, "AttributeStatistics", TRUE)

        self.callbackDeposit = []

        #set default settings
        self.cwbias = 300 # canvas_width = widget_width - 300 pixels
        self.chbias = 30

        self.cw = self.width()-self.cwbias
        self.ch = self.height()-self.chbias

        #load settings
        self.loadSettings()

        self.dataset = None
        self.canvas = None
        self.HighlightedAttribute = None
        #list inputs and outputs
        self.inputs = [("Examples", ExampleTable, self.data, Default)]

        #GUI

        AttsBox = QVGroupBox('Attributes',self.controlArea)
        self.attributes = QListBox(AttsBox)
        self.attributes.setSelectionMode(QListBox.Single)
        self.attributes.setMinimumSize(150, 200)
        #connect controls to appropriate functions
        self.connect(self.attributes, SIGNAL("highlighted(int)"), self.attributeHighlighted)

        QWidget(self.controlArea).setFixedSize(0, 16)

        #give mainArea a layout
        self.layout=QVBoxLayout (self.mainArea)
        self.canvas = DisplayStatistics (self.cw, self.ch)
        self.canvasview = QCanvasView (self.canvas, self.mainArea)
        self.layout.addWidget ( self.canvasview )
        self.canvasview.show()

        self.icons = self.createAttributeIconDict()
        self.connect(self.graphButton, SIGNAL("clicked()"), self.saveToFileCanvas)
        

    def resizeEvent(self, event):
        if self.canvas and self.HighlightedAttribute>=0:
            # canvas height should be a bit less than the height of the widget frame
            self.ch = self.height()-20
            self.canvas = DisplayStatistics (self.cw, self.ch)
            # the height of the bar should be 150 pixels smaller than the height of the canvas
            self.canvas.bar_height_pixels = self.height()-150
            #self.canvas.bar_height_pixels = 50
            self.canvas.displayStat(self.dataset, self.HighlightedAttribute, self.dist)
            self.canvasview.setCanvas(self.canvas)
            self.canvas.update()

    def attributeHighlighted(self, ind):
        self.HighlightedAttribute = ind
        self.ch = self.height()-self.chbias
        self.canvas = DisplayStatistics (self.cw, self.ch)
        self.canvas.bar_height_pixels = self.height()-160
        self.canvas.displayStat(self.dataset, ind, self.dist)
        self.canvasview.setCanvas(self.canvas)
        self.canvas.update()

       
    def data(self, data):
        print self.HighlightedAttribute
        self.closeContext()
        
        self.attributes.clear()
        if data==None:
            self.dataset = None
            self.canvasview.hide()
        else:
            self.canvasview.show()

            self.dataset = data
            self.dist = orange.DomainDistributions(self.dataset)

            for a in self.dataset.domain:
                self.attributes.insertItem(self.icons[a.varType], a.name)
                
        self.HighlightedAttribute = 0
        self.openContext("", data)
        print self.HighlightedAttribute
        self.attributes.setCurrentItem(self.HighlightedAttribute)


    def saveToFileCanvas(self):
        sizeDlg = OWChooseImageSizeDlg(self.canvas)
        sizeDlg.exec_loop()

"""
class DisplayStatistics
constructs a canvas to display some statistics
"""
class DisplayStatistics (QCanvas):
	def __init__(self,*args):
		apply(QCanvas.__init__, (self,)+args)
		self.bar_height_pixels=None
		self.bar_width_pixels=None
		self.canvasW, self.canvasH = args[0], args[1]
		self.vbias, self.hbias = 60, 200

	def displayStat(self, data, ind, dist):
		attr = data.domain[ind]
		attr_name = QCanvasText (attr.name, self)
		attr_name.move(10, 10)
		attr_name.show()
		title_str = "Category"
		if attr.varType == orange.VarTypes.Continuous:
			title_str = "Values"
		category = QCanvasText (title_str, self)
		category.move(self.hbias-20, 30)
		category.setTextFlags(Qt.AlignRight)
		category.show()
		if attr.varType == orange.VarTypes.Discrete:
			totalvalues = QCanvasText ("Total Values", self)
			totalvalues.move(self.hbias+30, 30)
			totalvalues.show()
			rect_len = 100
			rect_width = 20
			f = rect_len/max(dist[ind])
			for v in range(len(attr.values)):
				t = QCanvasText (attr.values[v],self)
				t.move(self.hbias-10,self.vbias)
				t.setTextFlags(Qt.AlignRight)
				t.show()
				bar_len = dist[ind][v]*f
				if int(bar_len)==0 and bar_len!=0:
					bar_len=1
				r = QCanvasRectangle(self.hbias, self.vbias, bar_len, rect_width-2, self)
				r.setPen (QPen(Qt.NoPen))
				r.setBrush (QBrush(QColor(0,0,254)))
				r.show()
				t1 = QCanvasText (str(dist[ind][v]), self)
				t1.move(self.hbias+dist[ind][v]*rect_len/max(dist[ind])+10, self.vbias)
				t1.show()
				self.vbias+=rect_width
			if self.vbias > self.canvasH:
				self.canvasH = self.vbias+50
		if attr.varType == orange.VarTypes.Continuous:
			quartiles_list = reduce(lambda x, y: x+y, [[x[0]]*int(x[1]) for x in dist[ind].items()])
			qlen = len(quartiles_list)
			if qlen%2 == 0:
				self.median = (quartiles_list[qlen/2] + quartiles_list[qlen/2 -1])/2.0
			else:
				self.median = quartiles_list[qlen/2]
			if qlen%4 == 0:
				self.q1 = (quartiles_list[qlen/4] + quartiles_list[qlen/4 -1])/2.0
				self.q3 = (quartiles_list[3*qlen/4] + quartiles_list[3*qlen/4 -1])/2.0
			else:
				self.q1 = quartiles_list[qlen/4]
				self.q3 = quartiles_list[3*qlen/4]
			if self.bar_height_pixels==None: self.bar_height_pixels = 300
			if self.bar_width_pixels==None: self.bar_width_pixels = 20
			self.mini = quartiles_list[0]
			self.maxi = quartiles_list[-1]
			self.total_values = len(quartiles_list)
			self.distinct_values = len(dist[ind])
			self.mean = dist[ind].average()
			self.stddev = dist[ind].dev()
			self.drawCStat()
		self.resize(self.canvasW+10, self.canvasH)

	def drawCStat(self):
		# draw the main rectangle 
		bar_height = self.maxi-self.mini
		#all = QCanvasRectangle (self.hbias, self.vbias, self.bar_width_pixels, self.bar_height_pixels, self)
		#all.show()
		textoffset = 15
		# draw a max line and text
		maxi_txt = QCanvasText ("max", self)
		# assume equal fonts for all the text
		self.textHeight = maxi_txt.boundingRect().height()
		maxvTextPos = self.vbias - self.textHeight*0.5
		maxi_txt.move (self.hbias+self.bar_width_pixels+15, maxvTextPos)
		maxi_txt.show()
		maxi_txtL = QCanvasText ("%5.2f" % self.maxi, self)
		maxi_txtL.move (self.hbias-textoffset, maxvTextPos)
		maxi_txtL.setTextFlags(Qt.AlignRight)
		maxi_txtL.show()
		max_line = QCanvasLine(self)
		max_line.setPoints (self.hbias-5, self.vbias, self.hbias+self.bar_width_pixels+5, self.vbias)
		max_line.show()
		max_line.setZ(1.0)

		# draw a min line and text
		mini_txt = QCanvasText ("min", self)
		minvTextPos = self.bar_height_pixels+self.vbias - self.textHeight*0.5
		mini_txt.move (self.hbias+self.bar_width_pixels+textoffset, minvTextPos)
		mini_txt.show()
		mini_txtL = QCanvasText ("%5.2f" % self.mini, self)
		mini_txtL.move (self.hbias-textoffset, minvTextPos)
		mini_txtL.setTextFlags(Qt.AlignRight)
		mini_txtL.show()
		min_line = QCanvasLine(self)
		min_line.setPoints (self.hbias-5, self.vbias+self.bar_height_pixels, self.hbias+self.bar_width_pixels+5, self.vbias+self.bar_height_pixels)
		min_line.show()
		min_line.setZ(1.0)

		# draw a rectangle from the 3rd quartile to max; add line and text
		quartile3 =  int(self.bar_height_pixels*(self.maxi-self.q3)/bar_height)
		crq3 = QCanvasRectangle (self.hbias, self.vbias, self.bar_width_pixels, quartile3, self)
		crq3.setPen (QPen(Qt.NoPen))
		crq3.setBrush (QBrush(QColor(0,175,0)))
		crq3.show()
		q3line = self.vbias + quartile3
		line2 = QCanvasLine(self)
		line2.setPoints (self.hbias-5, q3line, self.hbias+self.bar_width_pixels+5, q3line)
		line2.show()
		line2.setZ(1.0)
		crq3tR = QCanvasText ("75%", self)
		q3vTextPos = q3line - self.textHeight*0.5
		crq3tR.move(self.hbias+self.bar_width_pixels+textoffset, q3vTextPos)
		crq3tR.show()
		crq3tL = QCanvasText ("%5.2f" % self.q3, self)
		crq3tL.move(self.hbias-textoffset, q3vTextPos)
		crq3tL.setTextFlags(Qt.AlignRight)
		crq3tL.show()

		# draw a rectangle from the median to the 3rd quartile; add line and text
		med = int(self.bar_height_pixels*(self.maxi-self.median)/bar_height)
		crm = QCanvasRectangle (self.hbias, self.vbias+quartile3, self.bar_width_pixels, med-quartile3, self)
		crm.setPen (QPen(Qt.NoPen))
		crm.setBrush (QBrush(QColor(0,134,0)))
		crm.show()
		mline = self.vbias + med
		line3 = QCanvasLine(self)
		line3.setPoints (self.hbias-5, mline, self.hbias+self.bar_width_pixels+5, mline)
		line3.show()
		line3.setZ(1.0)
		crmtR = QCanvasText ("median", self)
		medvTextPos = mline - self.textHeight*0.5
		crmtR.move(self.hbias+self.bar_width_pixels+textoffset, medvTextPos)
		crmtR.show()
		crmtL = QCanvasText ("%5.2f" % self.median, self)
		crmtL.move(self.hbias-textoffset, medvTextPos)
		crmtL.setTextFlags(Qt.AlignRight)
		crmtL.show()

		# draw a rectangle from the 1st quartile to the median; add line and text
		quartile1 = int(self.bar_height_pixels*(self.maxi-self.q1)/bar_height)
		crq1 = QCanvasRectangle (self.hbias, self.vbias+med, self.bar_width_pixels, quartile1-med, self)
		crq1.setPen (QPen(Qt.NoPen))
		crq1.setBrush (QBrush(QColor(0,92,0)))
		crq1.show()