Ignore:
Timestamp:
02/22/13 18:54:02 (14 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Some PEP8 code style fixes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeWidgets/Unsupervised/OWHierarchicalClustering.py

    r11217 r11353  
    11""" 
    22<name>Hierarchical Clustering</name> 
    3 <description>Hierarchical clustering based on distance matrix, and a dendrogram viewer.</description> 
     3<description>Hierarchical clustering based on distance matrix, and 
     4a dendrogram viewer.</description> 
    45<icon>icons/HierarchicalClustering.svg</icon> 
    5 <contact>Ales Erjavec (ales.erjavec(@at@)fri.uni-lj.si)</contact>  
     6<contact>Ales Erjavec (ales.erjavec(@at@)fri.uni-lj.si)</contact> 
    67<priority>2100</priority> 
    78""" 
    89from __future__ import with_statement 
     10 
     11import os 
     12import math 
     13from operator import add 
     14 
     15import numpy 
    916 
    1017from OWWidget import * 
     
    1320import OWGUI 
    1421import OWColorPalette 
    15 import math 
    16 import numpy 
    17 import os 
    1822 
    1923import orange 
    20 from Orange.clustering import hierarchical  
     24from Orange.clustering import hierarchical 
    2125 
    2226from OWDlgs import OWChooseImageSizeDlg 
     27from OWGraphics import GraphicsSimpleTextList 
    2328 
    2429from PyQt4.QtCore import * 
    2530from PyQt4.QtGui import * 
    2631 
     32 
    2733class OWHierarchicalClustering(OWWidget): 
    2834    settingsList = ["Linkage", "Annotation", "PrintDepthCheck", 
    29                     "PrintDepth", "HDSize", "VDSize", "ManualHorSize","AutoResize", 
    30                     "TextSize", "LineSpacing", "SelectionMode", 
    31                     "AppendClusters", "CommitOnChange", "ClassifyName", "addIdAs"] 
    32      
    33     contextHandlers={"":DomainContextHandler("", [ContextField("Annotation", DomainContextHandler.Required)])} 
    34      
     35                    "PrintDepth", "HDSize", "VDSize", "ManualHorSize", 
     36                    "AutoResize", "TextSize", "LineSpacing", "SelectionMode", 
     37                    "AppendClusters", "CommitOnChange", "ClassifyName", 
     38                    "addIdAs"] 
     39 
     40    contextHandlers = { 
     41        "": DomainContextHandler( 
     42            "", [ContextField("Annotation", DomainContextHandler.Required)] 
     43        ) 
     44    } 
     45 
    3546    def __init__(self, parent=None, signalManager=None): 
    36         OWWidget.__init__(self, parent, signalManager, 'Hierarchical Clustering', wantGraph=True) 
    37          
     47        OWWidget.__init__(self, parent, signalManager, 
     48                          'Hierarchical Clustering', wantGraph=True) 
     49 
    3850        self.inputs = [("Distances", orange.SymMatrix, self.set_matrix)] 
    39         self.outputs = [("Selected Data", ExampleTable), ("Other Data", ExampleTable), ("Centroids", ExampleTable)] 
    40         self.linkage = [("Single linkage", orange.HierarchicalClustering.Single), 
    41                         ("Average linkage", orange.HierarchicalClustering.Average), 
    42                         ("Ward's linkage", orange.HierarchicalClustering.Ward), 
    43                         ("Complete linkage", orange.HierarchicalClustering.Complete), 
    44                        ] 
     51        self.outputs = [("Selected Data", ExampleTable), 
     52                        ("Other Data", ExampleTable), 
     53                        ("Centroids", ExampleTable)] 
     54 
     55        self.linkage = [ 
     56            ("Single linkage", orange.HierarchicalClustering.Single), 
     57            ("Average linkage", orange.HierarchicalClustering.Average), 
     58            ("Ward's linkage", orange.HierarchicalClustering.Ward), 
     59            ("Complete linkage", orange.HierarchicalClustering.Complete), 
     60        ] 
     61 
    4562        self.Linkage = 3 
    4663        self.Annotation = 0 
    4764        self.PrintDepthCheck = 0 
    4865        self.PrintDepth = 10 
    49         self.HDSize = 500         #initial horizontal and vertical dendrogram size 
     66        # initial horizontal and vertical dendrogram size 
     67        self.HDSize = 500 
    5068        self.VDSize = 800 
    5169        self.ManualHorSize = 0 
     
    5876        self.ClassifyName = "HC_class" 
    5977        self.addIdAs = 0 
    60          
     78 
    6179        self.loadSettings() 
    62          
     80 
    6381        self.inputMatrix = None 
    6482        self.matrixSource = "Unknown" 
    6583        self.root_cluster = None 
    6684        self.selectedExamples = None 
    67          
     85 
    6886        self.selectionChanged = False 
    6987 
     
    7391        ##GUI 
    7492        ################################# 
    75          
     93 
    7694        #HC Settings 
    7795        OWGUI.comboBox(self.controlArea, self, "Linkage", box="Linkage", 
    7896                items=self.linkageMethods, tooltip="Choose linkage method", 
    79                 callback=self.run_clustering, addSpace = True) 
     97                callback=self.run_clustering, addSpace=True) 
    8098        #Label 
    81         box = OWGUI.widgetBox(self.controlArea, "Annotation", addSpace = True) 
    82         self.labelCombo = OWGUI.comboBox(box, self, "Annotation", 
    83                 items=["None"],tooltip="Choose label attribute", 
    84                 callback=self.update_labels) 
     99        box = OWGUI.widgetBox(self.controlArea, "Annotation", addSpace=True) 
     100        self.labelCombo = OWGUI.comboBox( 
     101            box, self, "Annotation", 
     102            items=["None"], 
     103            tooltip="Choose label attribute", 
     104            callback=self.update_labels 
     105        ) 
    85106 
    86107        OWGUI.spin(box, self, "TextSize", label="Text size", 
    87                         min=5, max=15, step=1,  
     108                        min=5, max=15, step=1, 
    88109                        callback=self.update_font, 
    89110                        controlWidth=40, 
    90111                        keyboardTracking=False) 
    91 #        OWGUI.spin(box,self, "LineSpacing", label="Line spacing", 
    92 #                        min=2,max=8,step=1,  
    93 #                        callback=self.update_spacing,  
    94 #                        controlWidth=40, 
    95 #                        keyboardTracking=False) 
    96112 
    97113        # Dendrogram graphics settings 
    98         dendrogramBox = OWGUI.widgetBox(self.controlArea, "Limits",  
     114        dendrogramBox = OWGUI.widgetBox(self.controlArea, "Limits", 
    99115                                        addSpace=True) 
    100          
     116 
    101117        form = QFormLayout() 
    102118        form.setLabelAlignment(Qt.AlignLeft) 
    103          
    104         # Depth settings  
     119 
     120        # Depth settings 
    105121        sw = OWGUI.widgetBox(dendrogramBox, orientation="horizontal", 
    106122                             addToLayout=False) 
    107         cw = OWGUI.widgetBox(dendrogramBox, orientation="horizontal",  
     123        cw = OWGUI.widgetBox(dendrogramBox, orientation="horizontal", 
    108124                             addToLayout=False) 
    109          
    110         sllp = OWGUI.hSlider(sw, self, "PrintDepth", minValue=1, maxValue=50,  
    111                              callback=self.on_depth_change) 
    112         cblp = OWGUI.checkBox(cw, self, "PrintDepthCheck", "Show to depth",  
    113                               callback = self.on_depth_change,  
     125 
     126        OWGUI.hSlider(sw, self, "PrintDepth", minValue=1, maxValue=50, 
     127                      callback=self.on_depth_change) 
     128 
     129        cblp = OWGUI.checkBox(cw, self, "PrintDepthCheck", "Show to depth", 
     130                              callback=self.on_depth_change, 
    114131                              disables=[sw]) 
    115132        form.addRow(cw, sw) 
    116          
     133 
    117134        checkWidth = OWGUI.checkButtonOffsetHint(cblp) 
    118          
     135 
    119136        # Width settings 
    120         sw = OWGUI.widgetBox(dendrogramBox, orientation="horizontal",  
     137        sw = OWGUI.widgetBox(dendrogramBox, orientation="horizontal", 
    121138                             addToLayout=False) 
    122         cw = OWGUI.widgetBox(dendrogramBox, orientation="horizontal",  
     139        cw = OWGUI.widgetBox(dendrogramBox, orientation="horizontal", 
    123140                             addToLayout=False) 
    124          
    125         hsb = OWGUI.spin(sw, self, "HDSize", min=200, max=10000, step=10,  
    126                          callback=self.on_width_changed,  
    127                          callbackOnReturn = False, 
     141 
     142        hsb = OWGUI.spin(sw, self, "HDSize", min=200, max=10000, step=10, 
     143                         callback=self.on_width_changed, 
     144                         callbackOnReturn=False, 
    128145                         keyboardTracking=False) 
    129         cbhs = OWGUI.checkBox(cw, self, "ManualHorSize", "Horizontal size",  
    130                               callback=self.on_width_changed,  
    131                               disables=[sw]) 
    132          
     146 
     147        OWGUI.checkBox(cw, self, "ManualHorSize", "Horizontal size", 
     148                       callback=self.on_width_changed, 
     149                       disables=[sw]) 
     150 
    133151        self.hSizeBox = hsb 
    134152        form.addRow(cw, sw) 
    135153        dendrogramBox.layout().addLayout(form) 
    136154 
    137         # Selection settings  
     155        # Selection settings 
    138156        box = OWGUI.widgetBox(self.controlArea, "Selection") 
    139157        OWGUI.checkBox(box, self, "SelectionMode", "Show cutoff line", 
    140158                       callback=self.update_cutoff_line) 
     159 
    141160        cb = OWGUI.checkBox(box, self, "AppendClusters", "Append cluster IDs", 
    142161                            callback=self.commit_data_if) 
    143          
     162 
    144163        self.classificationBox = ib = OWGUI.widgetBox(box, margin=0) 
    145          
     164 
    146165        form = QWidget() 
    147166        le = OWGUI.lineEdit(form, self, "ClassifyName", None, callback=None, 
     
    155174                                   "Meta attribute"], 
    156175                            callback=self.commit_data_if) 
    157          
     176 
    158177        layout = QFormLayout() 
    159178        layout.setSpacing(8) 
     
    163182        layout.addRow("Name  ", le) 
    164183        layout.addRow("Place  ", aa) 
    165          
     184 
    166185        form.setLayout(layout) 
    167          
     186 
    168187        ib.layout().addWidget(form) 
    169188        ib.layout().setContentsMargins(checkWidth, 5, 5, 5) 
    170          
     189 
    171190        cb.disables.append(ib) 
    172191        cb.makeConsistent() 
    173          
     192 
    174193        OWGUI.separator(box) 
    175         cbAuto = OWGUI.checkBox(box, self, "CommitOnChange", "Commit on change") 
    176         btCommit = OWGUI.button(box, self, "&Commit", self.commit_data, default=True) 
    177         OWGUI.setStopper(self, btCommit, cbAuto, "selectionChanged", self.commit_data) 
    178          
    179          
     194        cbAuto = OWGUI.checkBox(box, self, "CommitOnChange", 
     195                                "Commit on change") 
     196        btCommit = OWGUI.button(box, self, "&Commit", self.commit_data, 
     197                                default=True) 
     198        OWGUI.setStopper(self, btCommit, cbAuto, "selectionChanged", 
     199                         self.commit_data) 
     200 
    180201        OWGUI.rubber(self.controlArea) 
    181202        self.connect(self.graphButton, SIGNAL("clicked()"), self.saveGraph) 
     
    184205        self.headerView = ScaleView(scale, self) 
    185206        self.footerView = ScaleView(scale, self) 
    186          
     207 
    187208        self.dendrogram = DendrogramScene(self) 
    188209        self.dendrogramView = DendrogramView(self.dendrogram, self.mainArea) 
    189          
    190         self.connect(self.dendrogram, SIGNAL("clusterSelectionChanged()"), self.on_selection_change) 
    191         self.connect(self.dendrogram, SIGNAL("sceneRectChanged(QRectF)"), scale.scene_rect_update) 
    192         self.connect(self.dendrogram, SIGNAL("dendrogramGeometryChanged(QRectF)"), self.on_dendrogram_geometry_change) 
    193         self.connect(self.dendrogram, SIGNAL("cutoffValueChanged(float)"), self.on_cuttof_value_changed) 
    194          
    195         self.connect(self.dendrogramView, SIGNAL("viewportResized(QSize)"), self.on_width_changed) 
    196         self.connect(self.dendrogramView, SIGNAL("transformChanged(QTransform)"), self.headerView.setTransform) 
    197         self.connect(self.dendrogramView, SIGNAL("transformChanged(QTransform)"), self.footerView.setTransform) 
    198          
     210 
     211        self.connect(self.dendrogram, 
     212                     SIGNAL("clusterSelectionChanged()"), 
     213                     self.on_selection_change) 
     214 
     215        self.connect(self.dendrogram, 
     216                     SIGNAL("sceneRectChanged(QRectF)"), 
     217                     scale.scene_rect_update) 
     218 
     219        self.connect(self.dendrogram, 
     220                    SIGNAL("dendrogramGeometryChanged(QRectF)"), 
     221                    self.on_dendrogram_geometry_change) 
     222 
     223        self.connect(self.dendrogram, 
     224                     SIGNAL("cutoffValueChanged(float)"), 
     225                     self.on_cuttof_value_changed) 
     226 
     227        self.connect(self.dendrogramView, 
     228                     SIGNAL("viewportResized(QSize)"), 
     229                     self.on_width_changed) 
     230 
     231        self.connect(self.dendrogramView, 
     232                     SIGNAL("transformChanged(QTransform)"), 
     233                     self.headerView.setTransform) 
     234        self.connect(self.dendrogramView, 
     235                     SIGNAL("transformChanged(QTransform)"), 
     236                     self.footerView.setTransform) 
     237 
    199238        self.mainArea.layout().addWidget(self.headerView) 
    200239        self.mainArea.layout().addWidget(self.dendrogramView) 
    201240        self.mainArea.layout().addWidget(self.footerView) 
    202          
     241 
    203242        self.dendrogram.header = self.headerView 
    204243        self.dendrogram.footer = self.footerView 
    205244 
    206         self.connect(self.dendrogramView.horizontalScrollBar(),SIGNAL("valueChanged(int)"), 
    207                 self.footerView.horizontalScrollBar().setValue) 
    208         self.connect(self.dendrogramView.horizontalScrollBar(),SIGNAL("valueChanged(int)"), 
    209                 self.headerView.horizontalScrollBar().setValue) 
    210         self.dendrogram.setSceneRect(0, 0, self.HDSize,self.VDSize) 
     245        self.connect(self.dendrogramView.horizontalScrollBar(), 
     246                     SIGNAL("valueChanged(int)"), 
     247                     self.footerView.horizontalScrollBar().setValue) 
     248 
     249        self.connect(self.dendrogramView.horizontalScrollBar(), 
     250                     SIGNAL("valueChanged(int)"), 
     251                     self.headerView.horizontalScrollBar().setValue) 
     252 
     253        self.dendrogram.setSceneRect(0, 0, self.HDSize, self.VDSize) 
    211254        self.dendrogram.update() 
    212255        self.resize(800, 500) 
    213          
    214         self.natural_dendrogram_width = 800  
     256 
     257        self.natural_dendrogram_width = 800 
    215258        self.dendrogramView.set_fit_to_width(not self.ManualHorSize) 
    216          
     259 
    217260        self.matrix = None 
    218261        self.selectionList = [] 
    219         self.selected_clusters = []  
     262        self.selected_clusters = [] 
    220263 
    221264    def sendReport(self): 
    222         self.reportSettings("Settings", 
    223                             [("Linkage", self.linkageMethods[self.Linkage]), 
    224                              ("Annotation", self.labelCombo.currentText()), 
    225                              self.PrintDepthCheck and ("Shown depth limited to", self.PrintDepth), 
    226                              self.SelectionMode and hasattr(self, "cutoff_height") and ("Cutoff line at", self.cutoff_height)]) 
    227          
     265        self.reportSettings( 
     266            "Settings", 
     267            [("Linkage", self.linkageMethods[self.Linkage]), 
     268             ("Annotation", self.labelCombo.currentText()), 
     269             self.PrintDepthCheck and ("Shown depth limited to", 
     270                                       self.PrintDepth), 
     271             self.SelectionMode and hasattr(self, "cutoff_height") and \ 
     272             ("Cutoff line at", self.cutoff_height)] 
     273        ) 
     274 
    228275        self.reportSection("Dendrogram") 
    229         canvases = header, graph, footer = self.headerView.scene(), self.dendrogramView.scene(), self.footerView.scene() 
    230         buffer = QPixmap(max(c.width() for c in canvases), sum(c.height() for c in canvases)) 
     276        header = self.headerView.scene() 
     277        graph = self.dendrogramView.scene() 
     278        footer = self.footerView.scene() 
     279        canvases = header, graph, footer 
     280 
     281        buffer = QPixmap(max(c.width() for c in canvases), 
     282                         sum(c.height() for c in canvases)) 
     283 
    231284        painter = QPainter(buffer) 
    232285        painter.fillRect(buffer.rect(), QBrush(QColor(255, 255, 255))) 
    233         header.render(painter, QRectF(0, 0, header.width(), header.height()), QRectF(0, 0, header.width(), header.height())) 
    234         graph.render(painter, QRectF(0, header.height(), graph.width(), graph.height()), QRectF(0, 0, graph.width(), graph.height())) 
    235         footer.render(painter, QRectF(0, header.height()+graph.height(), footer.width(), footer.height()), QRectF(0, 0, footer.width(), footer.height())) 
     286        header.render(painter, 
     287                      QRectF(0, 0, header.width(), header.height()), 
     288                      QRectF(0, 0, header.width(), header.height())) 
     289 
     290        graph.render(painter, 
     291                     QRectF(0, header.height(), graph.width(), graph.height()), 
     292                     QRectF(0, 0, graph.width(), graph.height())) 
     293 
     294        footer.render(painter, 
     295                      QRectF(0, header.height() + graph.height(), 
     296                             footer.width(), footer.height()), 
     297                      QRectF(0, 0, footer.width(), footer.height())) 
     298 
    236299        painter.end() 
    237         self.reportImage(lambda filename: buffer.save(filename, os.path.splitext(filename)[1][1:])) 
    238          
     300 
     301        def save_to(filename): 
     302            _, ext = os.path.splitext(filename) 
     303            buffer.save(filename, ext[1:]) 
     304 
     305        self.reportImage(save_to) 
     306 
    239307    def clear(self): 
    240308        self.matrix = None 
     
    243311        self.dendrogram.clear() 
    244312        self.labelCombo.clear() 
    245          
     313 
    246314    def set_matrix(self, data): 
    247315        self.clear() 
     
    260328        self.matrixSource = "Unknown" 
    261329        items = getattr(self.matrix, "items") 
    262         if isinstance(items, orange.ExampleTable): #Example Table from Example Distance 
    263  
    264             self.labels = ["None", "Default"]+ \ 
    265                           [a.name for a in items.domain.attributes] 
    266             if items.domain.classVar: 
    267                 self.labels.append(items.domain.classVar.name) 
     330        if isinstance(items, orange.ExampleTable): 
     331            # Example Table from Example Distance 
     332            domain = items.domain 
     333            self.labels = ["None", "Default"] + \ 
     334                          [a.name for a in domain.attributes] 
     335            if domain.classVar: 
     336                self.labels.append(domain.classVar.name) 
    268337 
    269338            self.labelInd = range(len(self.labels) - 2) 
    270             self.labels.extend([m.name for m in items.domain.getmetas().values()]) 
    271             self.labelInd.extend(items.domain.getmetas().keys()) 
    272             self.numMeta = len(items.domain.getmetas()) 
    273             self.metaLabels = items.domain.getmetas().values() 
     339            self.labels.extend([m.name for m in domain.getmetas().values()]) 
     340 
     341            self.labelInd.extend(domain.getmetas().keys()) 
     342            self.numMeta = len(domain.getmetas()) 
     343            self.metaLabels = domain.getmetas().values() 
    274344            self.matrixSource = "Example Distance" 
    275         elif isinstance(items, list):   # a list of item (most probably strings) 
     345 
     346        elif isinstance(items, list): 
     347            # a list of items (most probably strings) 
    276348            self.labels = ["None", "Default", "Name", "Strain"] 
    277349            self.Annotation = 0 
    278350            self.matrixSource = "Data Distance" 
    279         else:   #From Attribute Distance 
     351        else: 
     352            # From Attribute Distance 
    280353            self.labels = ["None", "Attribute Name"] 
    281354            self.Annotation = 1 
    282             self.matrixSource="Attribute Distance" 
    283              
     355            self.matrixSource = "Attribute Distance" 
     356 
    284357        self.labelCombo.clear() 
    285358        self.labelCombo.addItems(self.labels) 
     359 
    286360        if len(self.labels) < self.Annotation - 1: 
    287                 self.Annotation = 0 
     361            self.Annotation = 0 
     362 
    288363        self.labelCombo.setCurrentIndex(self.Annotation) 
    289364        if self.matrixSource == "Example Distance": 
     
    294369            self.openContext("", items) 
    295370        self.error(0) 
     371 
    296372        try: 
    297373            self.run_clustering() 
     
    299375            self.error(0, "Could not cluster data! %s" % ex.message) 
    300376            self.setMatrix(None) 
    301          
     377 
    302378    def update_labels(self): 
    303         """ Change the labels in the scene. 
     379        """ 
     380        Change the labels in the scene. 
    304381        """ 
    305382        if self.matrix is None: 
    306383            return 
    307          
     384 
    308385        items = getattr(self.matrix, "items", range(self.matrix.dim)) 
    309          
     386 
    310387        if self.Annotation == 0: 
    311388            labels = [""] * len(items) 
     
    313390            try: 
    314391                labels = [item.name for item in items] 
    315                 if not any(labels): raise AttributeError("No labels.") 
     392                if not any(labels): 
     393                    raise AttributeError("No labels.") 
    316394            except AttributeError: 
    317395                labels = [str(item) for item in items] 
     396 
    318397        elif self.Annotation > 1 and isinstance(items, ExampleTable): 
    319398            attr = self.labelInd[min(self.Annotation - 2, len(self.labelInd) - 1)] 
     
    321400        else: 
    322401            labels = [str(item) for item in items] 
    323              
     402 
    324403        self.dendrogram.set_labels(labels) 
    325404        self.dendrogram.set_tool_tips(labels) 
     
    327406    def run_clustering(self): 
    328407        if self.matrix: 
     408            def callback(value, *args): 
     409                self.progressBarSet(value * 100) 
     410 
    329411            self.progressBarInit() 
    330             self.root_cluster = orange.HierarchicalClustering(self.matrix, 
     412            self.root_cluster = orange.HierarchicalClustering( 
     413                self.matrix, 
    331414                linkage=self.linkage[self.Linkage][1], 
    332                 progressCallback=lambda value, a: self.progressBarSet(value*100)) 
     415                progressCallback=callback 
     416            ) 
     417 
    333418            self.progressBarFinished() 
    334419            self.display_tree() 
     
    339424            root = hierarchical.pruned(root, level=self.PrintDepth) 
    340425        self.display_tree1(root) 
    341          
     426 
    342427    def display_tree1(self, tree): 
    343428        self.dendrogram.clear() 
     
    347432        self.update_labels() 
    348433        self.update_cutoff_line() 
    349          
     434 
    350435    def update_font(self): 
    351436        font = self.font() 
     
    354439        if self.dendrogram.widget: 
    355440            self.update_labels() 
    356              
     441 
    357442    def update_spacing(self): 
    358443        if self.dendrogram.labels_widget: 
    359444            layout = self.dendrogram.labels_widget.layout() 
    360445            layout.setSpacing(self.LineSpacing) 
    361          
     446 
    362447    def on_width_changed(self, size=None): 
    363448        if size is not None: 
     
    365450        else: 
    366451            auto_width = self.natural_dendrogram_width 
    367              
     452 
    368453        self.dendrogramView.set_fit_to_width(not self.ManualHorSize) 
    369454        if self.ManualHorSize: 
     
    373458            self.dendrogram.set_scene_width_hint(auto_width) 
    374459            self.update_labels() 
    375              
     460 
    376461    def on_dendrogram_geometry_change(self, geometry): 
    377462        if self.root_cluster and self.dendrogram.widget: 
     
    379464            left, top, right, bottom = widget.layout().getContentsMargins() 
    380465            geometry = geometry.adjusted(left, top, -right, -bottom) 
    381             self.scale_scene.set_scale_bounds(geometry.left(), geometry.right()) 
     466            self.scale_scene.set_scale_bounds(geometry.left(), 
     467                                              geometry.right()) 
    382468            self.scale_scene.set_scale(self.root_cluster.height, 0.0) 
    383469            pos = widget.pos_at_height(self.cutoff_height) 
    384470            self.scale_scene.set_marker(pos) 
    385              
     471 
    386472    def on_depth_change(self): 
    387473        if self.root_cluster and self.dendrogram.widget: 
     
    392478                root = hierarchical.pruned(root, level=self.PrintDepth) 
    393479            self.display_tree1(root) 
    394              
    395             selected = [c for c in hierarchical.preorder(root) if (c.first, c.last) in selected] 
    396             self.dendrogram.widget.set_selected_clusters(selected)  
     480 
     481            selected = [c for c in hierarchical.preorder(root) 
     482                        if (c.first, c.last) in selected] 
     483            self.dendrogram.widget.set_selected_clusters(selected) 
    397484 
    398485    def set_cuttof_position_from_scale(self, pos): 
    399         """ Cuttof position changed due to a mouse event in the scale scene. 
     486        """ 
     487        Cuttof position changed due to a mouse event in the scale scene. 
    400488        """ 
    401489        if self.root_cluster and self.dendrogram.cutoff_line: 
     
    403491            self.cutoff_height = height 
    404492            line = self.dendrogram.cutoff_line.set_cutoff_at_height(height) 
    405              
     493 
    406494    def on_cuttof_value_changed(self, height): 
    407         """ Cuttof value changed due to line drag in the dendrogram. 
     495        """ 
     496        Cuttof value changed due to line drag in the dendrogram. 
    408497        """ 
    409498        if self.root_cluster and self.dendrogram.widget: 
     
    412501            pos = widget.pos_at_height(height) 
    413502            self.scale_scene.set_marker(pos) 
    414              
     503 
    415504    def update_cutoff_line(self): 
    416505        if self.matrix: 
     
    421510                self.dendrogram.cutoff_line.hide() 
    422511                self.scale_scene.marker.hide() 
    423              
     512 
    424513    def on_selection_change(self): 
    425514        if self.matrix: 
     
    428517                self.selected_clusters = [item.cluster for item in items] 
    429518                self.commit_data_if() 
    430             except RuntimeError: # underlying C/C++ object has been deleted 
     519            except RuntimeError: 
     520                # underlying C/C++ object has been deleted 
    431521                pass 
    432          
     522 
    433523    def commit_data_if(self): 
    434524        if self.CommitOnChange: 
     
    440530        items = getattr(self.matrix, "items", None) 
    441531        if not items: 
    442             return # nothing to commit 
    443          
     532            # nothing to commit 
     533            return 
     534 
    444535        self.selectionChanged = False 
    445536        self.selectedExamples = None 
    446537        selection = self.selected_clusters 
    447538        selection = sorted(selection, key=lambda c: c.first) 
    448         maps = [list(self.root_cluster.mapping[c.first: c.last]) for c in selection] 
    449          
    450         from operator import add 
     539        maps = [list(self.root_cluster.mapping[c.first: c.last]) 
     540                for c in selection] 
     541 
    451542        selected_indices = reduce(add, maps, []) 
    452         unselected_indices = sorted(set(self.root_cluster.mapping) - set(selected_indices)) 
    453          
     543        unselected_indices = sorted(set(self.root_cluster.mapping) - \ 
     544                                    set(selected_indices)) 
     545 
    454546        self.selection = selected = [items[k] for k in selected_indices] 
    455547        unselected = [items[k] for k in unselected_indices] 
    456          
     548 
    457549        if not selected: 
    458550            self.send("Selected Data", None) 
     
    460552            self.send("Centroids", None) 
    461553            return 
    462          
    463         if isinstance(items, ExampleTable):  
     554 
     555        if isinstance(items, ExampleTable): 
    464556            c = [i for i in range(len(maps)) for j in maps[i]] 
    465557            aid = clustVar = None 
    466558            if self.AppendClusters: 
    467                 clustVar = orange.EnumVariable(str(self.ClassifyName) , 
    468                             values=["Cluster " + str(i) for i in range(len(maps))] + ["Other"]) 
     559                clustVar = orange.EnumVariable( 
     560                    str(self.ClassifyName), 
     561                    values=["Cluster " + str(i) for i in range(len(maps))] + \ 
     562                           ["Other"] 
     563                ) 
     564 
    469565                origDomain = items.domain 
    470566                if self.addIdAs == 0: 
     
    474570                    aid = -1 
    475571                elif self.addIdAs == 1: 
    476                     domain = orange.Domain(origDomain.attributes + [clustVar], origDomain.classVar) 
     572                    domain = orange.Domain(origDomain.attributes + [clustVar], 
     573                                           origDomain.classVar) 
     574 
    477575                    aid = len(origDomain.attributes) 
    478576                else: 
    479                     domain = orange.Domain(origDomain.attributes, origDomain.classVar) 
     577                    domain = orange.Domain(origDomain.attributes, 
     578                                           origDomain.classVar) 
     579 
    480580                    aid = orange.newmetaid() 
    481581                    domain.addmeta(aid, clustVar) 
     
    487587                    for i in range(len(selected)): 
    488588                        table1[i][clustVar] = clustVar("Cluster " + str(c[i])) 
    489                  
     589 
    490590                if unselected: 
    491591                    table2 = orange.ExampleTable(domain, unselected) 
     
    496596                self.unselectedExamples = table2 
    497597            else: 
    498                 self.selectedExamples = orange.ExampleTable(selected) if selected else None 
    499                 self.unselectedExamples = orange.ExampleTable(unselected) if unselected else None 
    500                  
     598                self.selectedExamples = \ 
     599                    orange.ExampleTable(selected) if selected else None 
     600 
     601                self.unselectedExamples = \ 
     602                    orange.ExampleTable(unselected) if unselected else None 
     603 
    501604            self.send("Selected Data", self.selectedExamples) 
    502605            self.send("Other Data", self.unselectedExamples) 
     
    506609                self.centroids = orange.ExampleTable(self.selectedExamples.domain) 
    507610                for i in range(len(maps)): 
    508                     clusterEx = [ex for cluster, ex in zip(c, self.selectedExamples) if cluster == i] 
     611                    clusterEx = [ex for cluster, ex in zip(c, self.selectedExamples) 
     612                                 if cluster == i] 
    509613                    clusterEx = orange.ExampleTable(clusterEx) 
    510614                    contstat = orange.DomainBasicAttrStat(clusterEx) 
    511615                    discstat = orange.DomainDistributions(clusterEx, 0, 0, 1) 
    512                     ex = [cs.avg if cs else (ds.modus() if ds else "?") for cs, ds in zip(contstat, discstat)] 
     616                    ex = [cs.avg if cs else (ds.modus() if ds else "?") 
     617                          for cs, ds in zip(contstat, discstat)] 
    513618                    example = orange.Example(self.centroids.domain, ex) 
    514619                    if clustVar is not None: 
     
    516621                    self.centroids.append(ex) 
    517622            self.send("Centroids", self.centroids) 
    518              
    519         elif self.matrixSource=="Data Distance": 
    520             names=list(set([d.strain for d in self.selection])) 
    521             data=[(name, [d for d in filter(lambda a:a.strain==name, self.selection)]) for name in names] 
    522             self.send("Structured Data Files",data) 
    523              
     623 
     624        elif self.matrixSource == "Data Distance": 
     625            names = list(set([d.strain for d in self.selection])) 
     626            data = [(name, 
     627                     [filter(lambda a:a.strain == name, self.selection)]) 
     628                    for name in names] 
     629            self.send("Structured Data Files", data) 
     630 
    524631    def saveGraph(self): 
    525        sizeDlg = OWChooseImageSizeDlg(self.dendrogram, parent=self) 
    526        sizeDlg.exec_() 
    527         
     632        sizeDlg = OWChooseImageSizeDlg(self.dendrogram, parent=self) 
     633        sizeDlg.exec_() 
     634 
    528635 
    529636class DendrogramView(QGraphicsView): 
     
    534641        self.setAlignment(Qt.AlignLeft | Qt.AlignCenter) 
    535642        self.setFocusPolicy(Qt.WheelFocus) 
    536 #        self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing) 
     643 
    537644        self.setRenderHints(QPainter.TextAntialiasing) 
    538645        self.fit_contents = True 
    539         self.connect(self, SIGNAL("viewportResized(QSize)"), self.updateTransform) 
    540         self.connect(self.scene(), SIGNAL("sceneRectChanged(QRectF)"), lambda: self.updateTransform(self.viewport().size())) 
     646        self.connect(self, 
     647                     SIGNAL("viewportResized(QSize)"), 
     648                     self.updateTransform) 
     649        self.connect(self.scene(), 
     650                     SIGNAL("sceneRectChanged(QRectF)"), 
     651                     lambda: self.updateTransform(self.viewport().size())) 
    541652 
    542653    def resizeEvent(self, e): 
    543654        QGraphicsView.resizeEvent(self, e) 
    544655        self.emit(SIGNAL("viewportResized(QSize)"), e.size()) 
    545          
     656 
    546657    def updateTransform(self, size): 
    547658        return 
     
    555666#            self.setTransform(QTransform()) 
    556667#        self.emit(SIGNAL("transformChanged(QTransform)"), self.transform()) 
    557          
     668 
    558669    def set_fit_to_width(self, state): 
    559670        self.fit_contents = state 
    560671        self.updateTransform(self.viewport().size()) 
    561672 
    562 from OWGraphics import GraphicsSimpleTextList 
    563673 
    564674class DendrogramScene(QGraphicsScene): 
     
    568678        self.header = None 
    569679        self.footer = None 
    570          
     680 
    571681        self.grid_widget = None 
    572682        self.widget = None 
     
    576686 
    577687    def set_cluster(self, root): 
    578         """ Set the cluster to display  
     688        """ 
     689        Set the cluster to display 
    579690        """ 
    580691        self.clear() 
    581692        self.root_cluster = root 
    582693        self.cutoff_line = None 
    583          
     694 
    584695        if not self.root_cluster: 
    585696            return 
    586          
     697 
    587698        # the main widget containing the dendrogram and labels 
    588699        self.grid_widget = QGraphicsWidget() 
     
    590701        layout = QGraphicsGridLayout() 
    591702        self.grid_widget.setLayout(layout) 
    592          
     703 
    593704        # dendrogram widget 
    594         self.widget = widget = OWClustering.DendrogramWidget(root=root, orientation=Qt.Vertical, parent=self.grid_widget) 
    595         self.connect(widget, SIGNAL("dendrogramGeometryChanged(QRectF)"),  
    596                      lambda rect: self.emit(SIGNAL("dendrogramGeometryChanged(QRectF)"), 
    597                                             rect)) 
    598         self.connect(widget, SIGNAL("selectionChanged()"), 
    599                      lambda: self.emit(SIGNAL("clusterSelectionChanged()")) 
    600                      ) 
    601          
     705        self.widget = widget = OWClustering.DendrogramWidget( 
     706            root=root, orientation=Qt.Vertical, parent=self.grid_widget 
     707        ) 
     708 
     709        self.connect(widget, 
     710                     SIGNAL("dendrogramGeometryChanged(QRectF)"), 
     711                     lambda rect: self.emit( 
     712                         SIGNAL("dendrogramGeometryChanged(QRectF)"), 
     713                         rect 
     714                     )) 
     715 
     716        self.connect(widget, 
     717                     SIGNAL("selectionChanged()"), 
     718                     lambda: self.emit(SIGNAL("clusterSelectionChanged()"))) 
     719 
    602720        widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) 
    603          
     721 
    604722        layout.addItem(self.widget, 0, 0) 
    605723        self.grid_widget.setMinimumWidth(self.scene_width_hint) 
    606724        self.grid_widget.setMaximumWidth(self.scene_width_hint) 
    607          
     725 
    608726        spacing = QFontMetrics(self.font()).lineSpacing() 
    609727        left, top, right, bottom = widget.layout().getContentsMargins() 
    610         widget.layout().setContentsMargins(0.0, spacing / 2.0, 0.0, spacing / 2.0) 
    611          
    612         labels = [self.cluster_text(leaf.cluster) for leaf in widget.leaf_items()] 
    613          
     728        widget.layout().setContentsMargins(0.0, spacing / 2.0, 
     729                                           0.0, spacing / 2.0) 
     730 
     731        labels = [self.cluster_text(leaf.cluster) for 
     732                  leaf in widget.leaf_items()] 
     733 
    614734        # Labels widget 
    615         labels = GraphicsSimpleTextList(labels, orientation=Qt.Vertical, parent=self.grid_widget) 
     735        labels = GraphicsSimpleTextList(labels, orientation=Qt.Vertical, 
     736                                        parent=self.grid_widget) 
    616737        labels.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) 
    617738        labels.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding) 
    618739        labels.setFont(self.font()) 
    619740        layout.addItem(labels, 0, 1) 
    620          
    621         # Cutoff line     
     741 
     742        # Cutoff line 
    622743        self.cutoff_line = OWClustering.CutoffLine(widget) 
    623         self.connect(self.cutoff_line.emiter, SIGNAL("cutoffValueChanged(float)"), 
    624                      lambda val: self.emit(SIGNAL("cutoffValueChanged(float)"), val)) 
     744        self.connect(self.cutoff_line.emiter, 
     745                     SIGNAL("cutoffValueChanged(float)"), 
     746                     lambda val: self.emit(SIGNAL("cutoffValueChanged(float)"), 
     747                                           val)) 
     748 
    625749        self.cutoff_line.set_cutoff_at_height(self.root_cluster.height * 0.95) 
    626              
     750 
    627751        self.labels_widget = labels 
    628          
    629         layout.activate()  
     752 
     753        layout.activate() 
    630754        self._update_scene_rect() 
    631          
     755 
    632756    def cluster_text(self, cluster): 
    633         """ Return the text to display next to the cluster. 
     757        """ 
     758        Return the text to display next to the cluster. 
    634759        """ 
    635760        if cluster in self.leaf_labels: 
     
    644769 
    645770    def set_labels(self, labels): 
    646         """ Set the item labels. 
     771        """ 
     772        Set the item labels. 
    647773        """ 
    648774        assert(len(labels) == len(self.root_cluster.mapping)) 
     
    658784                    text = text[0] 
    659785                label_items.append(text) 
    660                  
     786 
    661787            self.labels_widget.set_labels(label_items) 
    662788        self._update_scene_rect() 
    663789 
    664790    def set_tool_tips(self, tool_tips): 
    665         """ Set the item tool tips. 
     791        """ 
     792        Set the item tool tips. 
    666793        """ 
    667794        assert(len(tool_tips) == len(self.root_cluster.mapping)) 
    668795        if self.labels_widget: 
    669             for leaf, label in zip(self.widget.leaf_items(), self.labels_widget): 
     796            for leaf, label in zip(self.widget.leaf_items(), 
     797                                   self.labels_widget): 
    670798                cluster = leaf.cluster 
    671799                indices = cluster.mapping[cluster.first: cluster.last] 
     
    673801                text = "<br>".join(text) 
    674802                label.setToolTip(text) 
    675                  
     803 
    676804    def set_scene_width_hint(self, width): 
    677805        self.scene_width_hint = width 
     
    679807            self.grid_widget.setMinimumWidth(self.scene_width_hint) 
    680808            self.grid_widget.setMaximumWidth(self.scene_width_hint) 
    681              
     809 
    682810    def clear(self): 
    683811        self.widget = None 
     
    687815        self.cutoff_line = None 
    688816        QGraphicsScene.clear(self) 
    689          
     817 
    690818    def setFont(self, font): 
    691819        QGraphicsScene.setFont(self, font) 
     
    696824            spacing = QFontMetrics(self.font()).lineSpacing() 
    697825            left, top, right, bottom = self.widget.layout().getContentsMargins() 
    698             self.widget.layout().setContentsMargins(left, spacing / 2.0, right, spacing / 2.0) 
     826            self.widget.layout().setContentsMargins(left, spacing / 2.0, right, 
     827                                                    spacing / 2.0) 
    699828            self.grid_widget.resize(self.grid_widget.sizeHint(Qt.PreferredSize)) 
    700              
     829 
    701830    def _update_scene_rect(self): 
    702         self.setSceneRect(reduce(QRectF.united, [item.sceneBoundingRect() for item in self.items()], QRectF()).adjusted(-10, -10, 10, 10)) 
    703          
    704      
     831        items_rect = reduce(QRectF.united, 
     832                            [item.sceneBoundingRect() 
     833                             for item in self.items()], 
     834                            QRectF()) 
     835 
     836        self.setSceneRect(items_rect.adjusted(-10, -10, 10, 10)) 
     837 
     838 
    705839class AxisScale(QGraphicsWidget): 
    706     """ A graphics widget for an axis scale 
     840    """ 
     841    A graphics widget for an axis scale 
    707842    """ 
    708843    # Defaults 
    709844    orientation = Qt.Horizontal 
    710     tick_count=5 
     845    tick_count = 5 
    711846    tick_align = Qt.AlignTop 
    712847    text_align = Qt.AlignHCenter | Qt.AlignBottom 
    713848    axis_scale = (0.0, 1.0) 
    714      
     849 
    715850    def __init__(self, parent=None, orientation=Qt.Horizontal, tick_count=5, 
    716                  tick_align = Qt.AlignBottom, 
    717                  text_align = Qt.AlignHCenter | Qt.AlignBottom, 
    718                  axis_scale = (0.0, 1.0)): 
    719         QGraphicsWidget.__init__(self, parent)  
     851                 tick_align=Qt.AlignBottom, 
     852                 text_align=Qt.AlignHCenter | Qt.AlignBottom, 
     853                 axis_scale=(0.0, 1.0)): 
     854        QGraphicsWidget.__init__(self, parent) 
    720855        self.orientation = orientation 
    721856        self.tick_count = tick_count 
     
    723858        self.text_align = text_align 
    724859        self.axis_scale = axis_scale 
    725          
     860 
    726861    def set_orientation(self, orientation): 
    727862        self.orientation = orientation 
     
    731866            self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding) 
    732867        self.updateGeometry() 
    733          
     868 
    734869    def ticks(self): 
    735870        minval, maxval = self.axis_scale 
    736         ticks = ["%.2f" % val for val in numpy.linspace(minval, maxval, self.tick_count)] 
     871        ticks = ["%.2f" % val 
     872                 for val in numpy.linspace(minval, maxval, self.tick_count)] 
    737873        return ticks 
    738          
     874 
    739875    def paint(self, painter, option, widget=0): 
    740876        painter.setFont(self.font()) 
     
    743879        minval, maxval = self.axis_scale 
    744880        tick_count = self.tick_count 
    745          
     881 
    746882        if self.orientation == Qt.Horizontal: 
    747883            spanx, spany = size.width(), 0.0 
    748             xadv, yadv =  spanx / tick_count, 0.0 
     884            xadv, yadv = spanx / tick_count, 0.0 
    749885            tick_w, tick_h = 0.0, -5.0 
    750886            tick_offset = QPointF(0.0, tick_h) 
     
    753889            xadv, yadv = 0.0, spany / tick_count 
    754890            tick_w, tick_h = 5.0, 0.0 
    755             tick_func = lambda : (y / spany) 
    756             tick_offset = QPointF(tick_w + 1.0, metrics.ascent()/2) 
    757              
     891            tick_func = lambda: (y / spany) 
     892            tick_offset = QPointF(tick_w + 1.0, metrics.ascent() / 2) 
     893 
    758894        ticks = self.ticks() 
    759              
     895 
    760896        xstart, ystart = 0.0, 0.0 
    761          
     897 
    762898        if self.orientation == Qt.Horizontal: 
    763899            painter.translate(0.0, size.height()) 
    764              
    765         painter.drawLine(xstart, ystart, xstart + tick_count*xadv, ystart + tick_count*yadv) 
    766          
     900 
     901        painter.drawLine(xstart, ystart, 
     902                         xstart + tick_count * xadv, 
     903                         ystart + tick_count * yadv) 
     904 
    767905        linspacex = numpy.linspace(0.0, spanx, tick_count) 
    768906        linspacey = numpy.linspace(0.0, spany, tick_count) 
    769          
     907 
    770908        metrics = painter.fontMetrics() 
    771909        for x, y, tick in zip(linspacex, linspacey, ticks): 
     
    773911            if self.orientation == Qt.Horizontal: 
    774912                rect = QRectF(metrics.boundingRect(tick)) 
    775                 rect.moveCenter(QPointF(x, y) + tick_offset + QPointF(0.0, -rect.height()/2.0)) 
     913                rect.moveCenter(QPointF(x, y) + tick_offset + \ 
     914                                QPointF(0.0, -rect.height() / 2.0)) 
    776915                painter.drawText(rect, tick) 
    777916            else: 
    778917                painter.drawText(QPointF(x, y) + tick_offset, tick) 
    779                  
    780 #        rect =  self.geometry() 
    781 #        rect.translate(-self.pos()) 
    782 #        painter.drawRect(rect) 
    783          
     918 
    784919    def setGeometry(self, rect): 
    785920        self.prepareGeometryChange() 
    786921        return QGraphicsWidget.setGeometry(self, rect) 
    787          
     922 
    788923    def sizeHint(self, which, *args): 
    789924        if which == Qt.PreferredSize: 
     
    793928            if self.orientation == Qt.Horizontal: 
    794929                h = metrics.height() + 5 
    795                 w = 100  
     930                w = 100 
    796931            else: 
    797932                h = 100 
     
    807942        if self.orientation == Qt.Horizontal: 
    808943            h = 5 + metrics.height() 
    809             left = - metrics.boundingRect(ticks[0]).width()/2.0 #+ geometry.left()  
    810             right = geometry.width() + metrics.boundingRect(ticks[-1]).width()/2.0 
     944            left = - metrics.boundingRect(ticks[0]).width() / 2.0 
     945            right = geometry.width() + \ 
     946                    metrics.boundingRect(ticks[-1]).width() / 2.0 
    811947            rect = QRectF(left, 0.0, right - left, h) 
    812948        else: 
    813949            h = geometry.height() 
    814950            w = max([metrics.width(t) for t in ticks]) + 5 
    815             rect = QRectF(0.0, 0.0, w, h)  
     951            rect = QRectF(0.0, 0.0, w, h) 
    816952        return rect 
    817      
     953 
    818954    def set_axis_scale(self, min, max): 
    819955        self.axis_scale = (min, max) 
    820956        self.updateGeometry() 
    821          
     957 
    822958    def set_axis_ticks(self, ticks): 
    823959        if isinstance(ticks, dict): 
    824960            self.ticks = ticks 
    825961        self.updateGeometry() 
    826              
     962 
    827963    def tick_layout(self): 
    828         """ Return the tick layout 
     964        """ 
     965        Return the tick layout 
    829966        """ 
    830967        minval, maxval = self.axis_scale 
    831968        ticks = numpy.linspace(minval, maxval, self.tick_count) 
    832969        return zip(ticks, self.ticks()) 
    833      
    834 #        min, max = self.axis_scale 
    835 #        ticks = self.ticks() 
    836 #        span = max - min 
    837 #        span_log = math.log10(span) 
    838 #        log_sign = -1 if log_sign < 0.0 else 1 
    839 #        span_log = math.floor(span_log) 
    840 #        major_ticks = [(x, 5.0, tick(i, span_log)) for i in range(self.tick_count)] 
    841 #        minor_ticks = [(x, 3.0, tick(i, span_log + log_sign))  for i in range(self.tick_count * 2)] 
    842 #        return [(i, major, label) for i, tick, label in major_ticks] 
    843      
    844      
     970 
     971 
    845972class ScaleScene(QGraphicsScene): 
    846973    def __init__(self, widget, parent=None): 
     
    859986        self.addItem(self.scale_widget) 
    860987        self.addItem(self.marker) 
    861         self.setSceneRect(QRectF(0, 0, self.scale_widget.size().height(), 25.0)) 
    862          
     988        self.setSceneRect(QRectF(0, 0, 
     989                                 self.scale_widget.size().height(), 25.0)) 
     990 
    863991    def set_scale(self, min, max): 
    864992        self.scale_widget.set_axis_scale(min, max) 
    865          
     993 
    866994    def set_scale_bounds(self, start, end): 
    867995        self.scale_widget.setPos(start, 0) 
    868996        size_hint = self.scale_widget.sizeHint(Qt.PreferredSize) 
    869997        self.scale_widget.resize(end - start, self.scale_widget.size().height()) 
    870          
     998 
    871999    def scene_rect_update(self, rect): 
    8721000        scale_rect = self.scale_widget.sceneBoundingRect() 
    873         rect = QRectF(rect.x(), scale_rect.y(), rect.width(), scale_rect.height()) 
     1001        rect = QRectF(rect.x(), scale_rect.y(), 
     1002                      rect.width(), scale_rect.height()) 
    8741003        rect = QRectF(rect.x(), 0.0, rect.width(), scale_rect.height()) 
    8751004        self.marker.setLine(0, 0, 0, scale_rect.height()) 
    8761005        self.setSceneRect(rect) 
    877          
     1006 
    8781007    def set_marker(self, pos): 
    8791008        pos = self.scale_widget.mapToScene(pos) 
    8801009        self.marker.setPos(pos.x(), 0.0) 
    881          
     1010 
    8821011    def mousePressEvent(self, event): 
    8831012        if event.button() == Qt.LeftButton: 
    8841013            pos = self.scale_widget.mapFromScene(event.scenePos()) 
    8851014            self.widget.set_cuttof_position_from_scale(pos) 
    886              
     1015 
    8871016    def mouseMoveEvent(self, event): 
    8881017        if event.buttons() & Qt.LeftButton: 
    8891018            pos = self.scale_widget.mapFromScene(event.scenePos()) 
    8901019            self.widget.set_cuttof_position_from_scale(pos) 
    891          
     1020 
    8921021    def mouseReleaseEvent(self, event): 
    8931022        if event.button() == Qt.LeftButton: 
    8941023            pos = self.scale_widget.mapFromScene(event.scenePos()) 
    8951024            self.widget.set_cuttof_position_from_scale(pos) 
    896              
    897                  
     1025 
     1026 
    8981027class ScaleView(QGraphicsView): 
    8991028    def __init__(self, scene=None, parent=None): 
     
    9061035 
    9071036def test(): 
    908     app=QApplication(sys.argv) 
    909     w=OWHierarchicalClustering() 
     1037    app = QApplication(sys.argv) 
     1038    w = OWHierarchicalClustering() 
    9101039    w.show() 
    911     data=orange.ExampleTable("../../doc/datasets/iris.tab") 
    912     id=orange.newmetaid() 
     1040    data = orange.ExampleTable("../../doc/datasets/iris.tab") 
     1041    id = orange.newmetaid() 
    9131042    data.domain.addmeta(id, orange.FloatVariable("a")) 
    9141043    data.addMetaAttribute(id) 
     
    9181047    matrix.setattr('items', data) 
    9191048    for i in range(len(data)): 
    920         for j in range(i+1): 
     1049        for j in range(i + 1): 
    9211050            matrix[i, j] = dist(data[i], data[j]) 
    9221051 
    9231052    w.set_matrix(matrix) 
    9241053    app.exec_() 
    925      
    926 if __name__=="__main__": 
     1054 
     1055if __name__ == "__main__": 
    9271056    test() 
Note: See TracChangeset for help on using the changeset viewer.