Ignore:
Location:
Orange
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeWidgets/Data/OWPurgeDomain.py

    r9997 r11380  
    22<name>Purge Domain</name> 
    33<description>Removes redundant values and attributes, sorts values.</description> 
    4 <icon>icons/PurgeDomain.png</icon> 
     4<icon>icons/PurgeDomain.svg</icon> 
    55<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>1105</priority> 
  • Orange/OrangeWidgets/Regression/OWPLS.py

    r10820 r11380  
    22<name>PLS Regression</name> 
    33<description>Partial Least Squares Regression</name> 
    4 <icon>icons/PLSRegression.png</icon> 
     4<icon>icons/PLSRegression.svg</icon> 
    55<priority>15</priority> 
    66<category>Regression</category> 
  • Orange/OrangeWidgets/Unsupervised/OWMDS.py

    r11217 r11379  
    66<priority>2500</priority> 
    77""" 
     8 
     9import sys 
     10import math 
     11 
     12import numpy 
     13 
    814from OWWidget import * 
    915import orange 
    1016import orngMDS 
    1117import OWGUI 
    12 import numpy, sys, math, time, os 
     18 
    1319import OWColorPalette 
    1420import OWToolbars 
    1521from OWGraph import * 
    1622from PyQt4.Qwt5 import * 
     23 
    1724from random import random 
    1825 
    19 try: 
    20     from OWDataFiles import DataFiles 
    21 except: 
    22     class DataFiles(object): 
    23         pass 
    2426 
    2527class OWMDS(OWWidget): 
    26     settingsList=["graph.PointSize", "graph.proportionGraphed", "graph.ColorAttr", "graph.SizeAttr", 
    27                   "graph.ShapeAttr", "graph.NameAttr", "graph.ShowStress", "graph.NumStressLines", 
    28                   "graph.ShowName", "graph.differentWidths", "graph.stressByTransparency", "graph.useAntialiasing" 
    29                   "StressFunc", "applyLSMT", "toolbarSelection", "autoSendSelection", "selectionOptions", "computeStress", 
    30                   "RefreshMode"] 
    31     contextHandlers={"":DomainContextHandler("", [ContextField("graph.ColorAttr", DomainContextHandler.Optional), 
    32                                                   ContextField("graph.SizeAttr", DomainContextHandler.Optional), 
    33                                                   ContextField("graph.ShapeAttr", DomainContextHandler.Optional), 
    34                                                   ContextField("graph.NameAttr", DomainContextHandler.Optional), 
    35                                                   ContextField("graph.ShowName", DomainContextHandler.Optional)])} 
    36      
    37     def __init__(self, parent=None, signalManager=None, name="Multi Dimensional Scaling"): 
     28    settingsList = [ 
     29        "graph.PointSize", "graph.proportionGraphed", "graph.ColorAttr", 
     30        "graph.SizeAttr", "graph.ShapeAttr", "graph.NameAttr", 
     31        "graph.ShowStress", "graph.NumStressLines", "graph.ShowName", 
     32        "graph.differentWidths", "graph.stressByTransparency", 
     33        "graph.useAntialiasing" "StressFunc", "applyLSMT", 
     34        "toolbarSelection", "autoSendSelection", "selectionOptions", 
     35        "computeStress", "RefreshMode" 
     36    ] 
     37 
     38    contextHandlers = { 
     39        "": DomainContextHandler( 
     40             "", 
     41             [ContextField("graph.ColorAttr", DomainContextHandler.Optional), 
     42              ContextField("graph.SizeAttr", DomainContextHandler.Optional), 
     43              ContextField("graph.ShapeAttr", DomainContextHandler.Optional), 
     44              ContextField("graph.NameAttr", DomainContextHandler.Optional), 
     45              ContextField("graph.ShowName", DomainContextHandler.Optional)] 
     46        ) 
     47    } 
     48 
     49    def __init__(self, parent=None, signalManager=None, 
     50                 name="Multi Dimensional Scaling"): 
    3851        OWWidget.__init__(self, parent, signalManager, name, wantGraph=True) 
    39         self.inputs=[("Distances", orange.SymMatrix, self.cmatrix), ("Data Subset", ExampleTable, self.cselected)] 
    40         self.outputs=[("Data", ExampleTable), ("Structured Data Files", DataFiles)] 
    41  
    42         self.StressFunc=3 
    43         self.minStressDelta=5e-5 
    44         self.maxIterations=5000 
    45         self.maxImprovment=10 
    46         self.autoSendSelection=0 
    47         self.toolbarSelection=0 
    48         self.selectionOptions=0 
    49         self.computeStress=1 
    50         self.ReDraw=1 
    51         self.NumIter=1 
    52         self.RefreshMode=0 
     52 
     53        self.inputs = [("Distances", orange.SymMatrix, self.cmatrix), 
     54                       ("Data Subset", ExampleTable, self.cselected)] 
     55        self.outputs = [("Data", ExampleTable)] 
     56 
     57        self.StressFunc = 3 
     58        self.minStressDelta = 5e-5 
     59        self.maxIterations = 5000 
     60        self.maxImprovment = 10 
     61        self.autoSendSelection = 0 
     62        self.toolbarSelection = 0 
     63        self.selectionOptions = 0 
     64        self.computeStress = 1 
     65        self.ReDraw = 1 
     66        self.NumIter = 1 
     67        self.RefreshMode = 0 
    5368        self.applyLSMT = 0 
    5469 
    55         self.stressFunc=[("Kruskal stress", orngMDS.KruskalStress), 
    56                               ("Sammon stress", orngMDS.SammonStress), 
    57                               ("Signed Sammon stress", orngMDS.SgnSammonStress), 
    58                               ("Signed relative stress", orngMDS.SgnRelStress)] 
    59          
    60         self.graph=MDSGraph(self.mainArea) 
     70        self.stressFunc = [("Kruskal stress", orngMDS.KruskalStress), 
     71                           ("Sammon stress", orngMDS.SammonStress), 
     72                           ("Signed Sammon stress", orngMDS.SgnSammonStress), 
     73                           ("Signed relative stress", orngMDS.SgnRelStress)] 
     74 
     75        self.graph = MDSGraph(self.mainArea) 
    6176        self.mainArea.layout().addWidget(self.graph) 
    62          
     77 
    6378        self.loadSettings() 
    6479 
    65         tabs=OWGUI.tabWidget(self.controlArea) 
    66          
    67         mds=OWGUI.createTabPage(tabs, "MDS") 
    68         graph=OWGUI.createTabPage(tabs, "Graph") 
    69  
    70         ##MDS Tab         
    71         init=OWGUI.widgetBox(mds, "Initialization") 
     80        tabs = OWGUI.tabWidget(self.controlArea) 
     81 
     82        mds = OWGUI.createTabPage(tabs, "MDS") 
     83        graph = OWGUI.createTabPage(tabs, "Graph") 
     84 
     85        # MDS Tab 
     86        init = OWGUI.widgetBox(mds, "Initialization") 
    7287        OWGUI.button(init, self, "Randomize", self.randomize) 
    7388        OWGUI.button(init, self, "Jitter", self.jitter) 
    7489        OWGUI.button(init, self, "Torgerson", self.torgerson) 
    75         opt=OWGUI.widgetBox(mds, "Optimization") 
    76  
    77         self.startButton=OWGUI.button(opt, self, "Optimize", self.testStart) 
     90 
     91        opt = OWGUI.widgetBox(mds, "Optimization") 
     92 
     93        self.startButton = OWGUI.button(opt, self, "Optimize", self.testStart) 
    7894        OWGUI.button(opt, self, "Single Step", self.smacofStep) 
    7995        box = OWGUI.widgetBox(opt, "Stress Function") 
    80         OWGUI.comboBox(box, self, "StressFunc", items=[a[0] for a in self.stressFunc], callback=self.updateStress)         
    81         OWGUI.radioButtonsInBox(opt, self, "RefreshMode", ["Every step", "Every 10 steps", "Every 100 steps"], "Refresh During Optimization", callback=lambda :1) 
    82          
    83         self.stopping=OWGUI.widgetBox(opt, "Stopping Conditions") 
    84          
    85         OWGUI.hSlider(OWGUI.widgetBox(self.stopping, "Min. stress change", flat=True), 
    86                       self, "minStressDelta", minValue=5e-5, maxValue=1e-2, step=5e-5,  
    87                       labelFormat="%.5f", intOnly=0) 
    88         OWGUI.hSlider(OWGUI.widgetBox(self.stopping, "Max. number of steps", flat=True),  
    89                       self, "maxIterations", minValue=10, maxValue=5000, step=10,  
    90                       labelFormat="%i") 
    91  
    92         ##Graph Tab         
    93         OWGUI.hSlider(graph, self, "graph.PointSize", box="Point Size", minValue=1, maxValue=20, callback=self.graph.updateData) 
    94         self.colorCombo=OWGUI.comboBox(graph, self, "graph.ColorAttr", box="Color", callback=self.graph.updateData) 
    95         self.sizeCombo=OWGUI.comboBox(graph, self, "graph.SizeAttr", box="Size", callback=self.graph.updateData) 
    96         self.shapeCombo=OWGUI.comboBox(graph, self, "graph.ShapeAttr", box="Shape", callback=self.graph.updateData) 
    97         self.nameCombo=OWGUI.comboBox(graph, self, "graph.NameAttr", box="Label", callback=self.graph.updateData) 
    98          
     96        OWGUI.comboBox(box, self, "StressFunc", 
     97                       items=[a[0] for a in self.stressFunc], 
     98                       callback=self.updateStress) 
     99 
     100        OWGUI.radioButtonsInBox(opt, self, "RefreshMode", 
     101                                ["Every step", "Every 10 steps", 
     102                                 "Every 100 steps"], 
     103                                "Refresh During Optimization") 
     104 
     105        self.stopping = OWGUI.widgetBox(opt, "Stopping Conditions") 
     106 
     107        OWGUI.hSlider(OWGUI.widgetBox(self.stopping, "Min. stress change", 
     108                                      flat=True), 
     109                      self, "minStressDelta", minValue=5e-5, maxValue=1e-2, 
     110                      step=5e-5, labelFormat="%.5f", intOnly=0) 
     111 
     112        OWGUI.hSlider(OWGUI.widgetBox(self.stopping, "Max. number of steps", 
     113                                    flat=True), 
     114                      self, "maxIterations", minValue=10, maxValue=5000, 
     115                      step=10, labelFormat="%i") 
     116 
     117        # Graph Tab 
     118        OWGUI.hSlider(graph, self, "graph.PointSize", box="Point Size", 
     119                      minValue=1, maxValue=20, callback=self.graph.updateData) 
     120 
     121        self.colorCombo = OWGUI.comboBox(graph, self, "graph.ColorAttr", 
     122                                         box="Color", 
     123                                         callback=self.graph.updateData) 
     124        self.sizeCombo = OWGUI.comboBox(graph, self, "graph.SizeAttr", 
     125                                        box="Size", 
     126                                        callback=self.graph.updateData) 
     127        self.shapeCombo = OWGUI.comboBox(graph, self, "graph.ShapeAttr", 
     128                                         box="Shape", 
     129                                         callback=self.graph.updateData) 
     130        self.nameCombo = OWGUI.comboBox(graph, self, "graph.NameAttr", 
     131                                        box="Label", 
     132                                        callback=self.graph.updateData) 
     133 
    99134        box = OWGUI.widgetBox(graph, "Distances & Stress") 
    100         OWGUI.checkBox(box, self, "graph.ShowStress", "Show similar pairs", callback = self.graph.updateLinesRepaint) 
     135 
     136        OWGUI.checkBox(box, self, "graph.ShowStress", "Show similar pairs", 
     137                       callback=self.graph.updateLinesRepaint) 
    101138        b2 = OWGUI.widgetBox(box) 
    102139        OWGUI.widgetLabel(b2, "Proportion of connected pairs") 
    103140        OWGUI.separator(b2, height=3) 
    104         sl = OWGUI.hSlider(b2, self, "graph.proportionGraphed", minValue=0, maxValue=20, callback=self.graph.updateLinesRepaint, tooltip="Proportion of connected pairs (Maximum of 1000 lines will be drawn") 
    105         OWGUI.checkBox(box, self, "graph.differentWidths", "Show distance by line width", callback = self.graph.updateLinesRepaint) 
    106         OWGUI.checkBox(box, self, "graph.stressByTransparency", "Show stress by transparency", callback = self.graph.updateData) 
    107         OWGUI.checkBox(box, self, "graph.stressBySize", "Show stress by symbol size", callback = self.updateStressBySize) 
     141        OWGUI.hSlider(b2, self, "graph.proportionGraphed", minValue=0, 
     142                      maxValue=20, 
     143                      callback=self.graph.updateLinesRepaint, 
     144                      tooltip=("Proportion of connected pairs (Maximum of " 
     145                               "1000 lines will be drawn")) 
     146        OWGUI.checkBox(box, self, "graph.differentWidths", 
     147                       "Show distance by line width", 
     148                       callback=self.graph.updateLinesRepaint) 
     149        OWGUI.checkBox(box, self, "graph.stressByTransparency", 
     150                       "Show stress by transparency", 
     151                       callback=self.graph.updateData) 
     152        OWGUI.checkBox(box, self, "graph.stressBySize", 
     153                       "Show stress by symbol size", 
     154                       callback=self.updateStressBySize) 
    108155        self.updateStressBySize(True) 
    109          
    110         OWGUI.checkBox(graph, self, "graph.useAntialiasing", label="Use antialiasing", box="Antialiasing", tooltip="Use antialiasing for beter quality graphics", callback=self.graph.updateData) 
    111  
    112         self.zoomToolbar=OWToolbars.ZoomSelectToolbar(self, graph, self.graph, self.autoSendSelection) 
    113         self.connect(self.zoomToolbar.buttonSendSelections, SIGNAL("clicked()"), self.sendSelections) 
    114         self.graph.autoSendSelectionCallback = lambda :self.autoSendSelection and self.sendSelections() 
     156 
     157        OWGUI.checkBox(graph, self, "graph.useAntialiasing", 
     158                       label="Use antialiasing", 
     159                       box="Antialiasing", 
     160                       tooltip="Use antialiasing for beter quality graphics", 
     161                       callback=self.graph.updateData) 
     162 
     163        self.zoomToolbar = OWToolbars.ZoomSelectToolbar( 
     164            self, graph, self.graph, self.autoSendSelection 
     165        ) 
     166 
     167        self.connect(self.zoomToolbar.buttonSendSelections, 
     168                     SIGNAL("clicked()"), 
     169                     self.sendSelections) 
     170        self.graph.autoSendSelectionCallback = \ 
     171            lambda: self.autoSendSelection and self.sendSelections() 
    115172 
    116173        OWGUI.checkBox(graph, self, "autoSendSelection", "Auto send selected") 
    117         OWGUI.radioButtonsInBox(graph, self, "selectionOptions", ["Don't append", "Append coordinates", "Append coordinates as meta"], box="Append coordinates", callback=self.sendIf) 
    118  
    119         mds.setSizePolicy(QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)) 
    120         graph.setSizePolicy(QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)) 
     174        OWGUI.radioButtonsInBox(graph, self, "selectionOptions", 
     175                                ["Don't append", "Append coordinates", 
     176                                 "Append coordinates as meta"], 
     177                                box="Append coordinates", 
     178                                callback=self.sendIf) 
     179 
     180        mds.setSizePolicy( 
     181            QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) 
     182        ) 
     183        graph.setSizePolicy( 
     184            QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) 
     185        ) 
     186 
    121187        self.controlArea.setMinimumWidth(250) 
     188 
    122189        OWGUI.rubber(mds) 
    123         infoBox=OWGUI.widgetBox(mds, "Info") 
    124         self.infoA=OWGUI.widgetLabel(infoBox, "Avg. stress:") 
    125         self.infoB=OWGUI.widgetLabel(infoBox, "Num. steps") 
    126 #        OWGUI.button(self.controlArea, self, "Save", self.graph.saveToFile, debuggingEnabled = 0) 
    127         self.connect(self.graphButton, SIGNAL("clicked()"), self.graph.saveToFile) 
    128         self.resize(900,630) 
    129  
    130         self.done=True 
    131         self.data=None 
    132         self.selectedInputExamples=[] 
    133         self.selectedInput=[] 
     190 
     191        infoBox = OWGUI.widgetBox(mds, "Info") 
     192        self.infoA = OWGUI.widgetLabel(infoBox, "Avg. stress:") 
     193        self.infoB = OWGUI.widgetLabel(infoBox, "Num. steps") 
     194 
     195        self.connect(self.graphButton, 
     196                     SIGNAL("clicked()"), 
     197                     self.graph.saveToFile) 
     198 
     199        self.resize(900, 630) 
     200 
     201        self.done = True 
     202        self.data = None 
     203        self.selectedInputExamples = [] 
     204        self.selectedInput = [] 
    134205 
    135206    def cmatrix(self, matrix=None): 
    136207        self.closeContext() 
    137         self.origMatrix=matrix 
    138         self.data=data=None 
     208        self.origMatrix = matrix 
     209        self.data = data = None 
    139210        if matrix: 
    140             self.data=data=getattr(matrix, "items") 
    141             matrix.matrixType = orange.SymMatrix.Symmetric  
    142              
    143         self.graph.ColorAttr=0 
    144         self.graph.SizeAttr=0 
    145         self.graph.ShapeAttr=0 
    146         self.graph.NameAttr=0 
     211            self.data = data = getattr(matrix, "items") 
     212            matrix.matrixType = orange.SymMatrix.Symmetric 
     213 
     214        self.graph.ColorAttr = 0 
     215        self.graph.SizeAttr = 0 
     216        self.graph.ShapeAttr = 0 
     217        self.graph.NameAttr = 0 
    147218        self.graph.closestPairs = None 
     219 
    148220        if isinstance(data, orange.ExampleTable): 
    149221            self.setExampleTable(data) 
    150         elif isinstance(data, list): 
    151             self.setList(data) 
    152222        elif isinstance(data, orange.VarList): 
    153223            self.setVarList(data) 
     224 
    154225        if matrix: 
    155             self.mds=orngMDS.MDS(matrix) 
    156             self.mds.points=numpy.random.random(size=[self.mds.n, self.mds.dim]) 
     226            self.mds = orngMDS.MDS(matrix) 
     227            self.mds.points = numpy.random.random( 
     228                size=[self.mds.n, self.mds.dim] 
     229            ) 
     230 
    157231            self.mds.getStress() 
    158             self.stress=self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
     232            self.stress = self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
    159233            if data and type(data) == orange.ExampleTable: 
    160                 self.openContext("",self.data)  
    161             self.graph.setData(self.mds, self.colors, self.sizes, self.shapes, self.names, self.selectedInput) 
     234                self.openContext("", self.data) 
     235            self.graph.setData(self.mds, self.colors, self.sizes, self.shapes, 
     236                               self.names, self.selectedInput) 
    162237        else: 
    163238            self.graph.clear() 
    164239 
    165240    def cselected(self, selected=[]): 
    166         self.selectedInputExamples=selected and selected or[] 
    167         if self.data and type(self.data)==orange.ExampleTable: 
     241        self.selectedInputExamples = selected and selected or[] 
     242        if self.data and type(self.data) == orange.ExampleTable: 
    168243            self.setExampleTable(self.data) 
    169             self.graph.setData(self.mds, self.colors, self.sizes, self.shapes, self.names, self.selectedInput) 
     244            self.graph.setData(self.mds, self.colors, self.sizes, self.shapes, 
     245                               self.names, self.selectedInput) 
    170246 
    171247    def setExampleTable(self, data): 
     
    174250        self.shapeCombo.clear() 
    175251        self.nameCombo.clear() 
    176         attributes=[attr for attr in data.domain.variables+data.domain.getmetas().values() or [] ] 
    177         discAttributes=filter(lambda a: a.varType==orange.VarTypes.Discrete, attributes) 
    178         contAttributes=filter(lambda a: a.varType==orange.VarTypes.Continuous, attributes) 
    179         attrName=[attr.name for attr in attributes] 
    180         for name in ["Same color"]+attrName: 
     252        attributes = list(data.domain.variables) + \ 
     253                     data.domain.getmetas().values() 
     254        discAttributes = filter( 
     255            lambda a: a.varType == orange.VarTypes.Discrete, 
     256            attributes 
     257        ) 
     258        contAttributes = filter( 
     259            lambda a: a.varType == orange.VarTypes.Continuous, 
     260            attributes 
     261        ) 
     262        attrName = [attr.name for attr in attributes] 
     263        for name in ["Same color"] + attrName: 
    181264            self.colorCombo.addItem(name) 
    182         for name in ["Same size"]+map(lambda a:a.name, contAttributes): 
     265        for name in ["Same size"] + map(lambda a: a.name, contAttributes): 
    183266            self.sizeCombo.addItem(name) 
    184         for name in ["Same shape"]+map(lambda a: a.name, discAttributes): 
     267        for name in ["Same shape"] + map(lambda a: a.name, discAttributes): 
    185268            self.shapeCombo.addItem(name) 
    186         for name in ["No name"]+attrName: 
     269        for name in ["No name"] + attrName: 
    187270            self.nameCombo.addItem(name) 
    188271 
    189 #        if data.domain.classVar: 
    190 #            if data.domain.classVar.varType == orange.VarTypes.Discrete: 
    191 #                self.graph.ColorAttr = len(data.domain.variables) # index 0 is Same color! 
    192 #            elif data.domain.classVar.varType == orange.VarTypes.Continuous: 
    193 #                self.graph.SizeAttr = len(data.domain.variables) # index 0 is Same color! 
    194272        try: 
    195             self.graph.NameAttr = 1 + [name.lower() for name in attrName].index("name") 
     273            self.graph.NameAttr = \ 
     274                1 + [name.lower() for name in attrName].index("name") 
    196275        except: 
    197276            pass 
    198          
    199         self.attributes=attributes 
    200         self.discAttributes=discAttributes 
    201         self.contAttributes=contAttributes 
    202  
    203         self.colors=[[Qt.black]*(len(attributes)+1) for i in range(len(data))] 
    204         self.shapes=[[QwtSymbol.Ellipse]*(len(discAttributes)+1) for i in range(len(data))] 
    205         self.sizes=[[5]*(len(contAttributes)+1) for i in range(len(data))] 
    206         self.names=[[""]*(len(attributes)+1) for i in range(len(data))] 
     277 
     278        self.attributes = attributes 
     279        self.discAttributes = discAttributes 
     280        self.contAttributes = contAttributes 
     281 
     282        self.colors = [[Qt.black] * (len(attributes) + 1) 
     283                       for i in range(len(data))] 
     284        self.shapes = [[QwtSymbol.Ellipse] * (len(discAttributes) + 1) 
     285                       for i in range(len(data))] 
     286        self.sizes = [[5] * (len(contAttributes) + 1) 
     287                      for i in range(len(data))] 
     288        self.names = [[""] * (len(attributes) + 1) 
     289                      for i in range(len(data))] 
    207290        try: 
    208             selectedInput=self.selectedInputExamples.select(data.domain) 
     291            selectedInput = self.selectedInputExamples.select(data.domain) 
    209292        except: 
    210             selectedInput=[] 
    211         self.selectedInput=map(lambda d: selectedInput and (d in selectedInput) or not selectedInput, data) 
    212         contI=discI=attrI=1 
     293            selectedInput = [] 
     294        self.selectedInput = map( 
     295            lambda d: selectedInput and (d in selectedInput) or not selectedInput, 
     296            data 
     297        ) 
     298 
     299        contI = discI = attrI = 1 
     300 
    213301        def check(ex, a): 
    214302            try: 
    215303                ex[a] 
    216             except: 
     304            except Exception: 
    217305                return False 
    218306            return not ex[a].isSpecial() 
    219          
     307 
    220308        for j, attr in enumerate(attributes): 
    221             if attr.varType==orange.VarTypes.Discrete: 
    222                 c=OWColorPalette.ColorPaletteHSV(len(attr.values)) 
     309            if attr.varType == orange.VarTypes.Discrete: 
     310                c = OWColorPalette.ColorPaletteHSV(len(attr.values)) 
    223311                for i in range(len(data)): 
    224                     self.colors[i][attrI]= check(data[i],attr)  and c[int(data[i][attr])] or Qt.black 
    225 ##                    self.shapes[i][discI]= data[i][attr].isSpecial() and self.graph.shapeList[0] or self.graph.shapeList[int(data[i][attr])%len(self.graph.shapeList)] 
    226                     self.shapes[i][discI]= check(data[i],attr) and self.graph.shapeList[int(data[i][attr])%len(self.graph.shapeList)] or self.graph.shapeList[0] 
    227                     self.names[i][attrI]= check(data[i],attr) and " "+str(data[i][attr]) or "" 
    228                     #self.sizes[i][contI]=5 
    229                 attrI+=1 
    230                 discI+=1 
    231             elif attr.varType==orange.VarTypes.Continuous: 
    232                 c=OWColorPalette.ColorPaletteBW(-1) 
    233                 #val=[e[attr] for e in data if not e[attr].isSpecial()] 
    234                 val=[e[attr] for e in data if check(e, attr)] 
    235                 minVal=min(val or [0]) 
    236                 maxVal=max(val or [1]) 
     312                    if check(data[i], attr): 
     313                        self.colors[i][attrI] = c[int(data[i][attr])] 
     314                        self.shapes[i][discI] = self.graph.shapeList[int(data[i][attr]) % len(self.graph.shapeList)] 
     315                        self.names[i][attrI] = " " + str(data[i][attr]) 
     316                    else: 
     317                        self.colors[i][attrI] = Qt.black 
     318                        self.shapes[i][discI] = self.graph.shapeList[0] 
     319                        self.names[i][attrI] = "" 
     320                attrI += 1 
     321                discI += 1 
     322            elif attr.varType == orange.VarTypes.Continuous: 
     323                c = OWColorPalette.ColorPaletteBW(-1) 
     324 
     325                val = [e[attr] for e in data if check(e, attr)] 
     326                minVal = min(val or [0]) 
     327                maxVal = max(val or [1]) 
     328                span = max(maxVal - minVal, 1e-6) 
    237329                for i in range(len(data)): 
    238                     self.colors[i][attrI]=check(data[i],attr) and c.getColor((data[i][attr]-minVal)/max(maxVal-minVal, 1e-6)) or Qt.black  
    239                     #self.shapes[i][discI]=self.graph.shapeList[0] 
    240                     self.names[i][attrI]=check(data[i],attr) and " "+str(data[i][attr]) or "" 
    241                     self.sizes[i][contI]=check(data[i],attr) and int(self.data[i][attr]/maxVal*9)+1 or 5 
    242                 contI+=1 
    243                 attrI+=1 
     330                    if check(data[i], attr): 
     331                        self.colors[i][attrI] = c.getColor((data[i][attr] - minVal) / span) 
     332                        self.names[i][attrI] = " " + str(data[i][attr]) 
     333                        self.sizes[i][contI] = int(self.data[i][attr] / maxVal * 9) + 1 
     334                    else: 
     335                        self.colors[i][attrI] = Qt.black 
     336                        self.names[i][attrI] = "" 
     337                        self.sizes[i][contI] = 5 
     338                contI += 1 
     339                attrI += 1 
    244340            else: 
    245341                for i in range(len(data)): 
    246                     self.colors[i][attrI]=Qt.black 
    247                     #self.shapes[i][j+1]=self.graph.shapeList[0] 
    248                     self.names[i][attrI]= check(data[i],attr) and " "+str(data[i][attr]) or "" 
    249                     #self.sizes[i][j+1]=5 
    250                 attrI+=1 
     342                    self.colors[i][attrI] = Qt.black 
     343                    if check(data[i], attr): 
     344                        self.names[i][attrI] = " " + str(data[i][attr]) 
     345                    else: 
     346                        self.names[i][attrI] = "" 
     347 
     348                attrI += 1 
     349 
    251350        if data and data.domain.classVar: 
    252351            if data.domain.classVar.varType == orange.VarTypes.Discrete: 
    253                 self.graph.ColorAttr = len(self.colors[0]) - 1 # index 0 is Same color! 
     352                self.graph.ColorAttr = len(self.colors[0]) - 1  # index 0 is Same color! 
    254353            elif data.domain.classVar.varType == orange.VarTypes.Continuous: 
    255                 self.graph.SizeAttr = len(self.sizes[0]) - 1 # index 0 is Same color! 
    256  
    257     def setList(self, data): 
    258         self.colorCombo.clear() 
    259         self.sizeCombo.clear() 
    260         self.shapeCombo.clear() 
    261         self.nameCombo.clear() 
    262         for name in ["Same color", "strain"]: 
    263             self.colorCombo.addItem(name) 
    264         for name in ["No name", "name", "strain"]: 
    265             self.nameCombo.addItem(name) 
    266  
    267         self.colors=[[Qt.black]*3 for i in range(len(data))] 
    268         self.shapes=[[QwtSymbol.Ellipse] for i in range(len(data))] 
    269         self.sizes=[[5] for i in range(len(data))] 
    270         self.selectedInput=[False]*len(data) 
    271  
    272         if type(data[0]) in [str, unicode]: 
    273             self.names = [("", di, "", "") for di in data] 
    274         else: 
    275             self.names=[[""]*4 for i in range(len(data))] 
    276             try: 
    277                 strains=list(set([d.strain for d in data])) 
    278                 c=OWColorPalette.ColorPaletteHSV(len(strains)) 
    279                 for i, d in enumerate(data): 
    280                     self.colors[i][1]=c[strains.index(d.strain)] 
    281                     self.names[i][1]=" "+d.name 
    282                     self.names[i][2]=" "+d.strain 
    283             except Exception, val: 
    284                 print val 
     354                self.graph.SizeAttr = len(self.sizes[0]) - 1  # index 0 is Same color! 
    285355 
    286356    def setVarList(self, data): 
     
    293363        for name in ["No name", "Var name"]: 
    294364            self.nameCombo.addItem(name) 
    295         self.colors=[[Qt.black]*3 for i in range(len(data))] 
    296         self.shapes=[[QwtSymbol.Ellipse] for i in range(len(data))] 
    297         self.sizes=[[5] for i in range(len(data))] 
    298         self.names=[[""]*4 for i in range(len(data))] 
    299         self.selectedInput=[False]*len(data) 
     365        self.colors = [[Qt.black] * 3 for i in range(len(data))] 
     366        self.shapes = [[QwtSymbol.Ellipse] for i in range(len(data))] 
     367        self.sizes = [[5] for i in range(len(data))] 
     368        self.names = [[""] * 4 for i in range(len(data))] 
     369        self.selectedInput = [False] * len(data) 
    300370        try: 
    301             c=OWColorPalette.ColorPaletteHSV(len(data)) 
     371            c = OWColorPalette.ColorPaletteHSV(len(data)) 
    302372            for i, d in enumerate(data): 
    303                 self.colors[i][1]=c[i] 
    304                 self.names[i][1]=" " +str(d.name) 
     373                self.colors[i][1] = c[i] 
     374                self.names[i][1] = " " + str(d.name) 
    305375        except Exception, val: 
    306376            print val 
    307377 
    308     def updateStressBySize(self, noRepaint = False): 
     378    def updateStressBySize(self, noRepaint=False): 
    309379        self.sizeCombo.setDisabled(self.graph.stressBySize) 
    310380        if not noRepaint: 
    311381            self.graph.updateData() 
    312          
     382 
    313383    def smacofStep(self): 
    314384        if not getattr(self, "mds", None): 
     
    318388        if self.computeStress: 
    319389            self.mds.getStress(self.stressFunc[self.StressFunc][1]) 
    320             self.stress=self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
    321         #st=time.clock() 
     390            self.stress = self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
     391 
    322392        if self.ReDraw: 
    323393            self.graph.updateData() 
    324         #print "Update:", time.clock()-st 
    325394 
    326395## I (Janez) disabled LSMT because it is implemented as it never should be: 
     
    329398#  user can "untransform" it, except for resending the signal 
    330399#  Since the basic problem is in bad design of orngMDS, I removed the option 
    331 #  from the widget. If somebody has time to fix orngMDS first, he's welcome.  
     400#  from the widget. If somebody has time to fix orngMDS first, he's welcome. 
    332401    def LSMT(self): 
    333402        if not getattr(self, "mds", None): 
     
    336405        if self.computeStress: 
    337406            self.mds.getStress(self.stressFunc[self.StressFunc][1]) 
    338             self.stress=self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
     407            self.stress = self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
    339408        if self.ReDraw: 
    340409            self.graph.updateData() 
     
    346415        if self.computeStress: 
    347416            self.mds.getStress(self.stressFunc[self.StressFunc][1]) 
    348             self.stress=self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
     417            self.stress = self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
    349418        self.graph.updateData() 
    350419 
     
    352421        if not getattr(self, "mds", None): 
    353422            return 
    354         self.mds.points = numpy.random.random(size=[self.mds.n,2]) 
     423        self.mds.points = numpy.random.random(size=[self.mds.n, 2]) 
    355424        if self.computeStress: 
    356425            self.mds.getStress(self.stressFunc[self.StressFunc][1]) 
    357             self.stress=self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
     426            self.stress = self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
    358427        self.graph.updateData() 
    359428 
     
    366435        for i in range(self.mds.n): 
    367436            for j in range(2): 
    368                 self.mds.points[i][j] += st[j]*(random() - 0.5) 
     437                self.mds.points[i][j] += st[j] * (random() - 0.5) 
    369438        if self.computeStress: 
    370439            self.mds.getStress(self.stressFunc[self.StressFunc][1]) 
    371             self.stress=self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
     440            self.stress = self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
    372441        self.graph.updateData() 
    373  
    374     def start(self): 
    375         if not getattr(self, "mds", None): 
    376             return 
    377         if self.done==False: 
    378             self.done=True 
    379             return 
    380         self.done=False 
    381         self.startButton.setText("Stop") 
    382         numIter=0 
    383         self.progressBarInit() 
    384         pcur=0 
    385         startStress=oldStress=stress=self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
    386         startTime=time.clock() 
    387         hist=[stress]*3 
    388         while not self.done and numIter<self.maxIterations: 
    389             for i in range(self.NumIter): 
    390                 self.mds.SMACOFstep() 
    391                 qApp.processEvents() 
    392             if self.computeStress: 
    393                 self.mds.getStress(self.stressFunc[self.StressFunc][1]) 
    394                 self.stress=stress=self.getAvgStress(self.stressFunc[self.StressFunc][1]) 
    395                 hist.pop(0) 
    396                 hist.append(abs(oldStress-stress)) 
    397             numIter+=1 
    398             self.infoB.setText("Num. steps: %i" % numIter) 
    399             qApp.processEvents() 
    400             if self.ReDraw: 
    401                 self.graph.updateData() 
    402             qApp.processEvents() 
    403             if self.computeStress and abs(sum(hist)/3)<abs(self.minStressDelta*oldStress): 
    404                 break 
    405             ## Update progress bar 
    406             p1=abs(self.minStressDelta*oldStress)/max(sum(hist)/3, 1e-6)*100 
    407             if p1>100: p1=0 
    408             pcur=min(max([p1, float(numIter)/self.maxIterations*100, pcur]),99) 
    409             self.progressBarSet(int(pcur)) 
    410  
    411             oldStress=stress 
    412         self.startButton.setText("Optimize") 
    413         self.progressBarFinished() 
    414         #if not self.ReDraw: 
    415         self.graph.updateData() 
    416         self.done=True 
    417         #print "time %i " % (time.clock()-startTime) 
    418442 
    419443    def testStart(self): 
    420444        if not getattr(self, "mds", None): 
    421445            return 
    422         if self.done==False: 
    423             self.done=True 
    424             return 
    425         self.done=False 
     446        if self.done == False: 
     447            self.done = True 
     448            return 
     449        self.done = False 
    426450        self.startButton.setText("Stop Optimization") 
    427451        self.stopping.setDisabled(1) 
    428452        self.progressBarInit() 
    429         self.iterNum=0 
    430         self.mds.progressCallback=self.callback 
    431         # The name mangling for orange2.5 does not seem to work for orangeom.MDS 
    432         # so I set this explicitly   
    433         self.mds.progress_callback=self.callback 
    434          
    435         self.mds.mds.optimize(self.maxIterations, self.stressFunc[self.StressFunc][1], self.minStressDelta) 
    436         if self.iterNum%(math.pow(10,self.RefreshMode)): 
     453        self.iterNum = 0 
     454        self.mds.progressCallback = self.callback 
     455        # The name mangling for orange2.5 does not seem to work for 
     456        # orangeom.MDS so I set this explicitly 
     457        self.mds.progress_callback = self.callback 
     458 
     459        self.mds.mds.optimize(self.maxIterations, 
     460                              self.stressFunc[self.StressFunc][1], 
     461                              self.minStressDelta) 
     462        if self.iterNum % (math.pow(10, self.RefreshMode)): 
    437463            self.graph.updateData() 
    438464        self.startButton.setText("Optimize") 
    439465        self.stopping.setDisabled(0) 
    440466        self.progressBarFinished() 
    441         self.done=True 
    442  
    443     def callback(self, a,b=None): 
    444         if not self.iterNum%(math.pow(10,self.RefreshMode)): 
     467        self.done = True 
     468 
     469    def callback(self, a, b=None): 
     470        if not self.iterNum % (math.pow(10, self.RefreshMode)): 
    445471            self.graph.updateData() 
    446         self.iterNum+=1 
     472        self.iterNum += 1 
    447473        self.infoB.setText("Num. steps: %i" % self.iterNum) 
    448474        self.infoA.setText("Avg. Stress: %f" % self.mds.avgStress) 
    449         self.progressBarSet(int(a*100)) 
    450         qApp.processEvents() 
     475        self.progressBarSet(int(a * 100)) 
    451476        if self.done: 
    452477            return 0 
     
    454479            return 1 
    455480 
    456  
    457481    def getAvgStress(self, stressf=orngMDS.SgnRelStress): 
    458482        return self.mds.avgStress 
    459         """ 
    460         self.mds.getDistance() 
    461         total=0.0 
    462         total=sum([abs(a[0]) for a in self.mds.arr]) 
    463         self.infoA.setText("Avg. stress: %.7f" % (total/(self.mds.n*self.mds.n))) 
    464         return total/(self.mds.n*self.mds.n) 
    465         """ 
    466483 
    467484    def sendIf(self, i=-1): 
    468485        if self.autoSendSelection: 
    469486            self.sendSelections() 
    470          
     487 
    471488    def sendSelections(self): 
    472489        if not getattr(self, "mds", None): 
    473490            return 
    474         selectedInd=[] 
    475         for i,(x,y) in enumerate(self.mds.points): 
    476             if self.graph.isPointSelected(x,y): 
    477                 selectedInd+=[i] 
    478         if type(self.data)==orange.ExampleTable: 
     491        selectedInd = [] 
     492        for i, (x, y) in enumerate(self.mds.points): 
     493            if self.graph.isPointSelected(x, y): 
     494                selectedInd += [i] 
     495        if type(self.data) == orange.ExampleTable: 
    479496            self.sendExampleTable(selectedInd) 
    480         elif type(self.data)==list: 
    481             self.sendList(selectedInd) 
    482  
    483497 
    484498    def sendExampleTable(self, selectedInd): 
    485         if self.selectionOptions==0: 
     499        if self.selectionOptions == 0: 
    486500            self.send("Data", orange.ExampleTable(self.data.getitems(selectedInd))) 
    487501        else: 
    488             xAttr=orange.FloatVariable("X") 
    489             yAttr=orange.FloatVariable("Y") 
    490             if self.selectionOptions==1: 
    491                 domain=orange.Domain([xAttr, yAttr]+[v for v in self.data.domain.variables]) 
     502            xAttr = orange.FloatVariable("X") 
     503            yAttr = orange.FloatVariable("Y") 
     504            if self.selectionOptions == 1: 
     505                domain = orange.Domain([xAttr, yAttr] +  
     506                                       [v for v in self.data.domain.variables]) 
    492507                domain.addmetas(self.data.domain.getmetas()) 
    493508            else: 
    494                 domain=orange.Domain(self.data.domain) 
     509                domain = orange.Domain(self.data.domain) 
    495510                domain.addmeta(orange.newmetaid(), xAttr) 
    496511                domain.addmeta(orange.newmetaid(), yAttr) 
    497             selection=orange.ExampleTable(domain) 
     512            selection = orange.ExampleTable(domain) 
    498513            selection.extend(self.data.getitems(selectedInd)) 
    499514            for i in range(len(selectedInd)): 
    500                 selection[i][xAttr]=self.mds.points[selectedInd[i]][0] 
    501                 selection[i][yAttr]=self.mds.points[selectedInd[i]][1] 
     515                selection[i][xAttr] = self.mds.points[selectedInd[i]][0] 
     516                selection[i][yAttr] = self.mds.points[selectedInd[i]][1] 
    502517            self.send("Data", selection) 
    503  
    504     def sendList(self, selectedInd): 
    505         if self.data and type(self.data[0]) == str: 
    506             xAttr=orange.FloatVariable("X") 
    507             yAttr=orange.FloatVariable("Y") 
    508             nameAttr=  orange.StringVariable("name") 
    509             if self.selectionOptions == 1: 
    510                 domain = orange.Domain([xAttr, yAttr, nameAttr]) 
    511                 selection = orange.ExampleTable(domain) 
    512                 for i in range(len(selectedInd)): 
    513                     selection.append(list(self.mds.points[selectedInd[i]]) + [self.data[i]]) 
    514             else: 
    515                 domain = orange.Domain([nameAttr]) 
    516                 if self.selectionOptions: 
    517                     domain.addmeta(orange.newmetaid(), xAttr) 
    518                     domain.addmeta(orange.newmetaid(), yAttr) 
    519                 selection = orange.ExampleTable(domain) 
    520                 for i in range(len(selectedInd)): 
    521                     selection.append([self.data[i]]) 
    522                     if self.selectionOptions: 
    523                         selection[i][xAttr]=self.mds.points[selectedInd[i]][0] 
    524                         selection[i][yAttr]=self.mds.points[selectedInd[i]][1] 
    525             self.send("Data", selection) 
    526             return 
    527                 
    528         if not selectedInd: 
    529             self.send("Structured Data Files", None) 
    530         else: 
    531             datasets=[self.data[i] for i in selectedInd] 
    532             names=list(set([d.dirname for d in datasets])) 
    533             data=[(name, [d for d in filter(lambda a:a.strain==name, datasets)]) for name in names] 
    534             self.send("Structured Data Files",data) 
    535518 
    536519    def updateStress(self): 
     
    541524 
    542525    def sendReport(self): 
    543         self.reportSettings("Optimization", 
    544                             [("Stress function", self.stressFunc[self.StressFunc][0]), 
    545                              ("Minimal stress change", self.minStressDelta), 
    546                              ("Maximal number of steps", self.maxIterations)]) 
    547         if self.graph.ColorAttr or self.graph.stressBySize or self.graph.SizeAttr or self.graph.ShapeAttr or self.graph.NameAttr or self.graph.ShowStress: 
    548             self.reportSettings("Visual settings", 
    549                                 [self.graph.ColorAttr and ("Point color", self.colorCombo.currentText()), 
    550                                  self.graph.stressBySize  and ("Point size", "&lt;stress&gt;") 
    551                                     or self.graph.SizeAttr and ("Point size", self.sizeCombo.currentText()), 
    552                                  self.graph.ShapeAttr and ("Point shape", self.shapeCombo.currentText()), 
    553                                  self.graph.NameAttr and ("Labels", self.nameCombo.currentText()), 
    554                                  self.graph.ShowStress and ("Proportion of connected pairs", self.graph.proportionGraphed)]) 
     526        self.reportSettings( 
     527            "Optimization", 
     528            [("Stress function", self.stressFunc[self.StressFunc][0]), 
     529             ("Minimal stress change", self.minStressDelta), 
     530             ("Maximal number of steps", self.maxIterations)] 
     531        ) 
     532 
     533        if self.graph.ColorAttr or self.graph.stressBySize or \ 
     534                self.graph.SizeAttr or self.graph.ShapeAttr or \ 
     535                self.graph.NameAttr or self.graph.ShowStress: 
     536            self.reportSettings( 
     537                "Visual settings", 
     538                [self.graph.ColorAttr and ("Point color", self.colorCombo.currentText()), 
     539                 self.graph.stressBySize and ("Point size", "&lt;stress&gt;") 
     540                    or self.graph.SizeAttr and ("Point size", self.sizeCombo.currentText()), 
     541                 self.graph.ShapeAttr and ("Point shape", self.shapeCombo.currentText()), 
     542                 self.graph.NameAttr and ("Labels", self.nameCombo.currentText()), 
     543                 self.graph.ShowStress and ("Proportion of connected pairs", self.graph.proportionGraphed)] 
     544            ) 
     545 
    555546        self.reportSection("Chart") 
    556547        self.reportImage(self.graph.saveToFileDirect) 
    557                               
     548 
    558549 
    559550class MDSGraph(OWGraph): 
     
    574565        self.proportionGraphed = 20 
    575566        self.ShowName = True 
    576         #self.curveKeys=[] 
     567        # self.curveKeys=[] 
    577568        self.pointKeys = [] 
    578569        self.points = [] 
     
    584575        self.closestPairs = None 
    585576        self.shapeList = [QwtSymbol.Ellipse, 
    586                                 QwtSymbol.Rect, 
    587                                 QwtSymbol.Diamond, 
    588                                 QwtSymbol.Triangle, 
    589                                 QwtSymbol.DTriangle , 
    590                                 QwtSymbol.UTriangle, 
    591                                 QwtSymbol.LTriangle, 
    592                                 QwtSymbol.RTriangle, 
    593                                 QwtSymbol.Cross, 
    594                                 QwtSymbol.XCross ] 
    595          
     577                          QwtSymbol.Rect, 
     578                          QwtSymbol.Diamond, 
     579                          QwtSymbol.Triangle, 
     580                          QwtSymbol.DTriangle, 
     581                          QwtSymbol.UTriangle, 
     582                          QwtSymbol.LTriangle, 
     583                          QwtSymbol.RTriangle, 
     584                          QwtSymbol.Cross, 
     585                          QwtSymbol.XCross] 
     586 
    596587        self.axis_margin = 10 
    597588 
    598589    def setData(self, mds, colors, sizes, shapes, names, showFilled): 
    599590        self.mds = mds 
    600         #self.data=data 
     591        # self.data=data 
    601592        self.colors = colors 
    602593        self.sizes = sizes 
    603594        self.shapes = shapes 
    604595        self.names = names 
    605         self.showFilled = showFilled #map(lambda d: not d, showFilled) 
     596        self.showFilled = showFilled  # map(lambda d: not d, showFilled) 
    606597        self.updateData() 
    607598 
     
    619610            return 
    620611        N = len(self.mds.points) 
    621         np = min(int(N*(N-1)/2. * self.proportionGraphed/100.), 1000) # draw maximum of 1000 closest pairs 
    622         needlines = int(math.ceil((1 + math.sqrt(1+8*np)) / 2))  
     612        # draw maximum of 1000 closest pairs 
     613        np = min(int(N * (N - 1) / 2. * self.proportionGraphed / 100.), 1000) 
     614        needlines = int(math.ceil((1 + math.sqrt(1 + 8 * np)) / 2)) 
    623615 
    624616        if self.closestPairs is None or len(self.closestPairs) < np: 
     
    626618            m = self.mds.originalDistances 
    627619            self.closestPairs = sorted(heapq.nsmallest(np, ((m[i, j], i, j) for i in range(m.dim) for j in range(i)))) 
    628                  
     620 
    629621        for c in self.distanceLineKeys: 
    630622            try: 
    631623                c.detach() 
    632             except RuntimeError, ex: #underlying C/C++ object has been deleted 
     624            except RuntimeError: 
     625                # underlying C/C++ object has been deleted 
    633626                pass 
    634627        self.distanceLineKeys = [] 
    635                  
     628 
    636629        hdist = self.closestPairs[:np] 
    637630        if not hdist: 
    638631            return 
    639      
    640         black = QColor(192,192,192) 
     632 
     633        black = QColor(192, 192, 192) 
    641634        if self.differentWidths: 
    642635            mindist = hdist[0][0] 
     
    645638            mindist = maxdist = 0 
    646639        if maxdist != mindist: 
    647             k = 3 / (maxdist - mindist)**2 
     640            k = 3 / (maxdist - mindist) ** 2 
    648641            for dist, i, j in hdist: 
    649642                pti, ptj = self.mds.points[i], self.mds.points[j] 
    650                 c = self.addCurve("A", black, black, 0, QwtPlotCurve.Lines, xData=[pti[0],ptj[0]], yData=[pti[1],ptj[1]], lineWidth = max(1, (maxdist - dist)**2 * k)) 
     643                c = self.addCurve("A", black, black, 0, QwtPlotCurve.Lines, 
     644                                  xData=[pti[0], ptj[0]], yData=[pti[1], ptj[1]], 
     645                                  lineWidth=max(1, (maxdist - dist) ** 2 * k)) 
    651646                c.setZ(10) 
    652647                self.distanceLineKeys.append(c) 
     
    654649            for dist, i, j in hdist: 
    655650                pti, ptj = self.mds.points[i], self.mds.points[j] 
    656                 c = self.addCurve("A", black, black, 0, QwtPlotCurve.Lines, xData=[pti[0],ptj[0]], yData=[pti[1],ptj[1]], lineWidth = 2) 
     651                c = self.addCurve("A", black, black, 0, QwtPlotCurve.Lines, 
     652                                  xData=[pti[0], ptj[0]], yData=[pti[1], ptj[1]], 
     653                                  lineWidth=2) 
    657654                c.setZ(10) 
    658655                self.distanceLineKeys.append(c) 
    659          
    660                      
     656 
    661657    def updateLinesRepaint(self): 
    662658        if self.mds: 
     
    667663                    try: 
    668664                        c.detach() 
    669                     except RuntimeError, ex: #underlying C/C++ object has been deleted 
    670                         pass  
     665                    except RuntimeError: 
     666                        # underlying C/C++ object has been deleted 
     667                        pass 
    671668                self.distanceLineKeys = [] 
    672669            self.replot() 
     
    674671    def setPoints(self): 
    675672        if not self.mds: 
    676             return  
    677         if self.ShapeAttr==0 and self.SizeAttr==0 and self.NameAttr==0 and not self.stressBySize and not self.stressByTransparency: 
    678             colors=[c[self.ColorAttr] for c in self.colors] 
    679  
    680             set=[] 
     673            return 
     674        if self.ShapeAttr == 0 and self.SizeAttr == 0 and \ 
     675                self.NameAttr == 0 and not self.stressBySize and \ 
     676                not self.stressByTransparency: 
     677            colors = [c[self.ColorAttr] for c in self.colors] 
     678 
     679            set = [] 
    681680            for c in colors: 
    682                 if  c not in set: 
     681                if c not in set: 
    683682                    set.append(c) 
    684             #set=reduce(lambda set,a: (not(a in set)) and set.append(a), colors, []) 
    685             #set=sets.ImmutableSet([c[self.ColorAttr] for c in self.colors]) 
    686  
    687             dict={} 
     683 
     684            dict = {} 
    688685            for i in range(len(self.colors)): 
    689686                hsv = QColor(self.colors[i][self.ColorAttr]).getHsv() 
     
    691688                    dict[hsv].append(i) 
    692689                else: 
    693                     dict[hsv]=[i] 
    694 #            maxX, maxY = self.mds.points[0] if len(self.mds.points)>0 else (0, 0) 
    695 #            minX, minY = self.mds.points[0] if len(self.mds.points)>0 else (0, 0) 
     690                    dict[hsv] = [i] 
     691 
    696692            for color in set: 
    697                 #print len(dict[color.getHsv()]), color.name() 
    698                 X=[self.mds.points[i][0] for i in dict[QColor(color).getHsv()] if self.showFilled[i]] 
    699                 Y=[self.mds.points[i][1] for i in dict[QColor(color).getHsv()] if self.showFilled[i]] 
    700                 c = self.addCurve("A", color, color, self.PointSize, symbol=QwtSymbol.Ellipse, xData=X, yData=Y) 
     693                X = [self.mds.points[i][0] for i in dict[QColor(color).getHsv()] 
     694                     if self.showFilled[i]] 
     695                Y = [self.mds.points[i][1] for i in dict[QColor(color).getHsv()] 
     696                     if self.showFilled[i]] 
     697                c = self.addCurve("A", color, color, self.PointSize, 
     698                                  symbol=QwtSymbol.Ellipse, xData=X, yData=Y) 
    701699                c.setZ(100) 
    702                  
    703                 X=[self.mds.points[i][0] for i in dict[QColor(color).getHsv()] if not self.showFilled[i]] 
    704                 Y=[self.mds.points[i][1] for i in dict[QColor(color).getHsv()] if not self.showFilled[i]] 
    705                 c = self.addCurve("A", color, color, self.PointSize, symbol=QwtSymbol.Ellipse, xData=X, yData=Y, showFilledSymbols=False) 
     700 
     701                X = [self.mds.points[i][0] for i in dict[QColor(color).getHsv()] 
     702                     if not self.showFilled[i]] 
     703                Y = [self.mds.points[i][1] for i in dict[QColor(color).getHsv()] 
     704                     if not self.showFilled[i]] 
     705                c = self.addCurve("A", color, color, self.PointSize, 
     706                                  symbol=QwtSymbol.Ellipse, xData=X, yData=Y, 
     707                                  showFilledSymbols=False) 
    706708                c.setZ(100) 
    707709        else: 
     
    709711                stresses = map(sum, self.mds.stress) 
    710712                mins, maxs = min(stresses), max(stresses) 
    711                 ks = self.PointSize / max(1, maxs-mins) 
    712                 cs = 1 / max(1., maxs-mins) 
     713                ks = self.PointSize / max(1, maxs - mins) 
     714                cs = 1 / max(1., maxs - mins) 
    713715            for i in range(len(self.colors)): 
    714716                cq = QColor(self.colors[i][self.ColorAttr]) 
     
    716718                    cq.setAlpha(255 * (1 - cs * (stresses[i] - mins))) 
    717719                c = self.addCurve("a", cq, self.colors[i][self.ColorAttr], 
    718                                   max(5, ks*(1 + maxs - stresses[i])) if self.stressBySize else self.sizes[i][self.SizeAttr]*1.0/5*self.PointSize, 
    719                                   symbol=self.shapes[i][self.ShapeAttr], xData=[self.mds.points[i][0]],yData=[self.mds.points[i][1]], showFilledSymbols=self.showFilled[i]) 
     720                                  (max(5, ks * (1 + maxs - stresses[i])) 
     721                                   if self.stressBySize else 
     722                                   self.sizes[i][self.SizeAttr] * 1.0 / 5 * self.PointSize), 
     723                                  symbol=self.shapes[i][self.ShapeAttr], 
     724                                  xData=[self.mds.points[i][0]], 
     725                                  yData=[self.mds.points[i][1]], 
     726                                  showFilledSymbols=self.showFilled[i]) 
     727 
    720728                c.setZ(100) 
    721                 if self.NameAttr!=0: 
    722                     c = self.addMarker(self.names[i][self.NameAttr], self.mds.points[i][0], self.mds.points[i][1], Qt.AlignBottom) 
     729                if self.NameAttr != 0: 
     730                    c = self.addMarker(self.names[i][self.NameAttr], 
     731                                       self.mds.points[i][0], 
     732                                       self.mds.points[i][1], 
     733                                       Qt.AlignBottom) 
    723734                    c.setZ(100) 
    724735 
    725 #            for i in range(len(self.colors)): 
    726 #                c = self.addCurve("a", self.colors[i][self.ColorAttr], self.colors[i][self.ColorAttr], self.sizes[i][self.SizeAttr]*1.0/5*self.PointSize, 
    727 #                              symbol=self.shapes[i][self.ShapeAttr], xData=[self.mds.points[i][0]],yData=[self.mds.points[i][1]], showFilledSymbols=self.showFilled[i]) 
    728 #                c.setZ(100) 
    729 #                if self.NameAttr!=0: 
    730 #                    c = self.addMarker(self.names[i][self.NameAttr], self.mds.points[i][0], self.mds.points[i][1], Qt.AlignRight) 
    731 #                    c.setZ(100) 
    732  
    733  
    734         if len(self.mds.points)>0: 
     736        if len(self.mds.points) > 0: 
    735737            X = [point[0] for point in self.mds.points] 
    736738            Y = [point[1] for point in self.mds.points] 
     
    739741            span_x = max_x - min_x 
    740742            span_y = max_y - min_y 
    741             self.setAxisScale(QwtPlot.xBottom, min_x - 0.05 * span_x, max_x + 0.05 * span_x) 
    742             self.setAxisScale(QwtPlot.yLeft, min_y - 0.05 * span_y, max_y + 0.05 * span_y) 
    743              
     743            self.setAxisScale(QwtPlot.xBottom, 
     744                              min_x - 0.05 * span_x, max_x + 0.05 * span_x) 
     745            self.setAxisScale(QwtPlot.yLeft, 
     746                              min_y - 0.05 * span_y, max_y + 0.05 * span_y) 
    744747 
    745748    def sendData(self, *args): 
    746749        pass 
    747750 
    748 if __name__=="__main__": 
    749     app=QApplication(sys.argv) 
    750     w=OWMDS() 
     751 
     752if __name__ == "__main__": 
     753    app = QApplication(sys.argv) 
     754    w = OWMDS() 
    751755    w.show() 
    752     data=orange.ExampleTable("../../doc/datasets/iris.tab") 
    753 ##    data = orange.ExampleTable(r"E:\Development\Orange Datasets\UCI\iris.tab") 
    754 ##    data=orange.ExampleTable("/home/ales/src/MDSjakulin/eu_nations.txt") 
     756    data = orange.ExampleTable("iris") 
     757 
    755758    matrix = orange.SymMatrix(len(data)) 
    756759    dist = orange.ExamplesDistanceConstructor_Euclidean(data) 
     
    758761    matrix.setattr('items', data) 
    759762    for i in range(len(data)): 
    760         for j in range(i+1): 
     763        for j in range(i + 1): 
    761764            matrix[i, j] = dist(data[i], data[j]) 
    762765 
    763766    w.cmatrix(matrix) 
    764767    app.exec_() 
    765  
  • Orange/classification/svm/__init__.py

    r10955 r11377  
    8686    :param shrinking: use shrinking heuristics 
    8787    :type shrinking: bool 
    88     :param normalization: normalize the input data prior to learning 
     88    :param normalization: normalize the input data prior to learning into 
     89        range [0..1] and replace discrete features with indicator columns 
     90        one for each value of the feature using 
     91        :class:`~Orange.data.continuization.DomainContinuizer` class 
    8992        (default ``True``) 
    9093    :type normalization: bool 
     
    826829        :type bias: float 
    827830 
    828         :param normalization: Normalize the input data prior to learning 
    829             (default True) 
     831        :param normalization: Normalize the input data into range [0..1] prior 
     832            to learning (default ``True``) 
    830833        :type normalization: bool 
     834 
     835        .. note:: If the training data contains discrete features they are 
     836            replaced by indicator columns one for each value of the feature 
     837            regardless of the value of `normalization`. This is different 
     838            then in :class:`SVMLearner` where this is done only if 
     839            `normalization` is ``True``. 
    831840 
    832841        Example 
Note: See TracChangeset for help on using the changeset viewer.