Ignore:
Files:
6 edited

Legend:

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

    r11096 r11313  
    691691    settingsList = ["commitOnChange"] 
    692692    def __init__(self, parent=None, signalManager=None, name="Data Generator"): 
    693         OWWidget.__init__(self, parent, signalManager, name, wantGraph=True) 
     693        OWWidget.__init__(self, parent, signalManager, name) 
    694694         
    695695        self.outputs = [("Data", ExampleTable)] 
  • Orange/OrangeWidgets/OWDlgs.py

    r10463 r11314  
    2222class OWChooseImageSizeDlg(OWBaseWidget): 
    2323    settingsList = ["selectedSize", "customX", "customY", "lastSaveDirName", "penWidthFactor"] 
    24     def __init__(self, graph, extraButtons = [], defaultName="graph", parent=None): 
     24    def __init__(self, graph, extraButtons = [], defaultName="graph", parent=None, saveMatplotlib=None): 
    2525        OWBaseWidget.__init__(self, parent, None, "Image settings", modal = TRUE, resizingEnabled = 0) 
    2626 
     
    5555        #self.printButton =          OWGUI.button(self.space, self, "Print", callback = self.printPic) 
    5656        self.saveImageButton =      OWGUI.button(box, self, "Save Image", callback = self.saveImage) 
    57         if not (_have_gl and isinstance(graph, QGLWidget)): 
     57 
     58        # If None we try to determine if save can succeed automatically 
     59        if saveMatplotlib is None: 
     60            saveMatplotlib = self.canSaveToMatplotlib(graph) 
     61 
     62        if saveMatplotlib and not (_have_gl and isinstance(graph, QGLWidget)): 
    5863            self.saveMatplotlibButton = OWGUI.button(box, self, "Save Graph as matplotlib Script", callback = self.saveToMatplotlib) 
    5964        for (text, funct) in extraButtons: 
     
    214219        QDialog.accept(self) 
    215220 
     221    def canSaveToMatplotlib(self, graph): 
     222        if _have_qwt and isinstance(graph, QwtPlot): 
     223            # TODO: check all curve items. 
     224            return True 
     225 
     226        elif isinstance(graph, QGraphicsScene): 
     227            items = graph.items() 
     228            supported = set([QGraphicsRectItem, QGraphicsLineItem, 
     229                             QGraphicsTextItem, OWQCanvasFuncts.OWCanvasText]) 
     230            return all(type(item) in supported for item in items) 
     231        else: 
     232            return False 
     233 
    216234    # ############################################################ 
    217235    # EXTRA FUNCTIONS ############################################ 
  • Orange/OrangeWidgets/Unsupervised/OWExampleDistance.py

    r11217 r11316  
    66<priority>1300</priority> 
    77""" 
    8 import orange, math 
     8 
    99import OWGUI 
    1010from OWWidget import * 
    11 import random 
    12 import orngClustering 
    13 import orngMisc 
    1411 
    15 ############################################################################## 
    16 # main class 
     12import Orange 
     13 
     14from Orange import distance 
     15from Orange.utils import progress_bar_milestones 
     16 
    1717 
    1818class OWExampleDistance(OWWidget): 
     
    2020    contextHandlers = {"": DomainContextHandler("", ["Label"])} 
    2121 
    22     def __init__(self, parent=None, signalManager = None): 
    23         OWWidget.__init__(self, parent, signalManager, 'ExampleDistance', wantMainArea = 0, resizingEnabled = 0) 
     22    def __init__(self, parent=None, signalManager=None): 
     23        OWWidget.__init__(self, parent, signalManager, 'ExampleDistance', 
     24                          wantMainArea=False, resizingEnabled=False) 
    2425 
    25         self.inputs = [("Data", ExampleTable, self.dataset)] 
    26         self.outputs = [("Distances", orange.SymMatrix)] 
     26        self.inputs = [("Data", Orange.data.Table, self.dataset)] 
     27        self.outputs = [("Distances", Orange.misc.SymMatrix)] 
    2728 
    2829        self.Metrics = 0 
    2930        self.Normalize = True 
     31        self.Absolute = False 
    3032        self.Label = "" 
    3133        self.loadSettings() 
     
    3436 
    3537        self.metrics = [ 
    36             ("Euclidean", orange.ExamplesDistanceConstructor_Euclidean), 
    37             ("Pearson Correlation", orngClustering.ExamplesDistanceConstructor_PearsonR), 
    38             ("Spearman Rank Correlation", orngClustering.ExamplesDistanceConstructor_SpearmanR), 
    39             ("Manhattan", orange.ExamplesDistanceConstructor_Manhattan), 
    40             ("Hamming", orange.ExamplesDistanceConstructor_Hamming), 
    41             ("Relief", orange.ExamplesDistanceConstructor_Relief), 
     38            ("Euclidean", distance.Euclidean), 
     39            ("Pearson Correlation", distance.PearsonR), 
     40            ("Spearman Rank Correlation", distance.SpearmanR), 
     41            ("Manhattan", distance.Manhattan), 
     42            ("Hamming", distance.Hamming), 
     43            ("Relief", distance.Relief), 
    4244            ] 
    4345 
    44         cb = OWGUI.comboBox(self.controlArea, self, "Metrics", box="Distance Metrics", 
     46        cb = OWGUI.comboBox( 
     47            self.controlArea, self, "Metrics", box="Distance Metrics", 
    4548            items=[x[0] for x in self.metrics], 
    46             tooltip="Choose metrics to measure pairwise distance between examples.", 
    47             callback=self.distMetricChanged, valueType=str) 
     49            tooltip=("Choose metrics to measure pairwise distance between " 
     50                     "examples."), 
     51            callback=self.distMetricChanged, 
     52            valueType=str 
     53        ) 
     54 
    4855        cb.setMinimumWidth(170) 
    49          
     56 
    5057        OWGUI.separator(self.controlArea) 
    51          
    52         box = OWGUI.widgetBox(self.controlArea, "Normalization",  
     58 
     59        box = OWGUI.widgetBox(self.controlArea, "Settings", 
    5360                              addSpace=True) 
    54         self.normalizeCB = OWGUI.checkBox(box, self, "Normalize", "Normalize data",  
     61 
     62        self.normalizeCB = OWGUI.checkBox(box, self, "Normalize", 
     63                                          "Normalize data", 
    5564                                          callback=self.computeMatrix) 
    56          
     65 
    5766        self.normalizeCB.setEnabled(self.Metrics in [0, 3]) 
    58          
    59         self.labelCombo = OWGUI.comboBox(self.controlArea, self, "Label", box="Example Label", 
     67 
     68        self.absoluteCB = OWGUI.checkBox( 
     69            box, self, "Absolute", 
     70            "Absolute correlations", 
     71            tooltip=("Use absolute correlations " 
     72                     "for distances."), 
     73            callback=self.computeMatrix 
     74        ) 
     75 
     76        self.absoluteCB.setEnabled(self.Metrics in [1, 2]) 
     77 
     78        self.labelCombo = OWGUI.comboBox( 
     79            self.controlArea, self, "Label", 
     80            box="Example Label", 
    6081            items=[], 
    6182            tooltip="Attribute used for example labels", 
    62             callback=self.setLabel, sendSelectedValue = 1) 
     83            callback=self.setLabel, 
     84            sendSelectedValue=True 
     85        ) 
    6386 
    64         self.labelCombo.setDisabled(1) 
    65          
     87        self.labelCombo.setDisabled(True) 
     88 
    6689        OWGUI.rubber(self.controlArea) 
    6790 
    6891    def sendReport(self): 
     92        metric = self.metrics[self.Metrics][0] 
     93        if self.Metrics in [0, 3] and self.Normalize: 
     94            metric = "Normalized " + metric 
     95        elif self.Metrics in [1, 2] and self.Absolute: 
     96            metric = "Absolute " + metric 
     97 
    6998        self.reportSettings("Settings", 
    70                             [("Metrics", self.metrics[self.Metrics][0]), 
     99                            [("Metrics", metric), 
    71100                             ("Label", self.Label)]) 
    72101        self.reportData(self.data) 
     
    74103    def distMetricChanged(self): 
    75104        self.normalizeCB.setEnabled(self.Metrics in [0, 3]) 
     105        self.absoluteCB.setEnabled(self.Metrics in [1, 2]) 
    76106        self.computeMatrix() 
    77107 
     
    79109        if not self.data: 
    80110            return 
     111 
    81112        data = self.data 
    82         constructor = self.metrics[self.Metrics][1]() 
    83         constructor.normalize = self.Normalize 
    84         dist = constructor(data) 
     113        if self.Metrics in [1, 2] and self.Absolute: 
     114            if self.Metrics == 1: 
     115                constructor = distance.PearsonRAbsolute() 
     116            else: 
     117                constructor = distance.SpearmanRAbsolute() 
     118        else: 
     119            constructor = self.metrics[self.Metrics][1]() 
     120            constructor.normalize = self.Normalize 
     121 
    85122        self.error(0) 
     123        self.progressBarInit() 
    86124        try: 
    87             self.matrix = orange.SymMatrix(len(data)) 
    88         except orange.KernelException, ex: 
     125            matrix = distance.distance_matrix(data, constructor, 
     126                                              self.progressBarSet) 
     127        except Orange.core.KernelException, ex: 
    89128            self.error(0, "Could not create distance matrix! %s" % str(ex)) 
    90             self.matrix = None 
    91             self.send("Distances", None) 
    92             return 
    93         self.matrix.setattr('items', data) 
    94         pb = OWGUI.ProgressBar(self, 100) 
    95         milestones  = orngMisc.progressBarMilestones(len(data)*(len(data)-1)/2, 100) 
    96         count = 0 
    97         for i in range(len(data)): 
    98             for j in range(i+1): 
    99                 self.matrix[i, j] = dist(data[i], data[j]) 
    100                 if count in milestones: 
    101                     pb.advance() 
    102                 count += 1 
    103         pb.finish() 
     129            matrix = None 
     130 
     131        self.progressBarFinished() 
     132 
     133        if matrix: 
     134            matrix.setattr('items', data) 
     135 
     136        self.matrix = matrix 
    104137        self.send("Distances", self.matrix) 
    105138 
     
    116149                 [a.name for a in d.domain.variables] 
    117150        self.labelCombo.addItems(labels) 
    118         # here we would need to use the domain dependent setting of the label id 
    119         self.labelCombo.setCurrentIndex(0); self.Label = labels[0] 
     151 
     152        # here we would need to use the domain dependent setting of the 
     153        # label id 
     154        self.labelCombo.setCurrentIndex(0) 
     155        self.Label = labels[0] 
    120156        self.setLabel() 
    121157 
     
    126162            self.computeMatrix() 
    127163        else: 
     164            self.data = None 
     165            self.matrix = None 
     166            self.labelCombo.clear() 
    128167            self.send("Distances", None) 
    129168 
    130 ################################################################################################## 
    131 # test script 
    132169 
    133 if __name__=="__main__": 
    134     import os 
    135     data = orange.ExampleTable(r'../../doc/datasets/glass') 
    136     data = orange.ExampleTable('glass') 
     170if __name__ == "__main__": 
     171    data = Orange.data.Table('glass') 
    137172    a = QApplication(sys.argv) 
    138173    ow = OWExampleDistance() 
  • Orange/OrangeWidgets/Unsupervised/OWSOM.py

    r11217 r11319  
    33<description>Self organizing maps learner.</description> 
    44<icon>icons/SOM.svg</icon> 
    5 <contact>Ales Erjavec (ales.erjevec(@at@)fri.uni.lj.si)</contact>  
     5<contact>Ales Erjavec (ales.erjevec(@at@)fri.uni.lj.si)</contact> 
    66<priority>5010</priority> 
    77""" 
    88 
    9 import orange 
    10 import orngSOM 
     9import Orange 
     10from Orange.projection import som 
     11 
    1112from OWWidget import * 
    1213import OWGUI 
    1314 
    14 #class orange_input(object): 
    15 #    def __init__(self, input_type, check=None): 
    16 #        pass 
    17 #     
    18 #    def __get__(self, instance): 
    19 #        return self.__call__         
    2015 
    2116class OWSOM(OWWidget): 
    22     settingsList=["xdim", "ydim", "neighborhood", "topology", "alphaType", "iterations1", "iterations2", 
    23                   "radius1", "radius2", "alpha1", "alpha2", "initialization", "eps"] 
    24     def __init__(self ,parent=None , signalManager=None, name="SOM"): 
    25         OWWidget.__init__(self, parent, signalManager, name, wantMainArea=False) 
    26  
    27         self.inputs = [("Data", ExampleTable, self.setData)] 
    28         self.outputs = [("Classifier", orange.Classifier), ("Learner", orange.Learner), ("SOM", orngSOM.SOMMap)] 
    29  
    30         self.LearnerName="SOM Map" 
     17    settingsList = ["xdim", "ydim", "neighborhood", "topology", "alphaType", 
     18                    "iterations1", "iterations2", "radius1", "radius2", 
     19                    "alpha1", "alpha2", "initialization", "eps"] 
     20 
     21    def __init__(self, parent=None, signalManager=None, name="SOM"): 
     22        OWWidget.__init__(self, parent, signalManager, name, 
     23                          wantMainArea=False) 
     24 
     25        self.inputs = [("Data", Orange.data.Table, self.setData)] 
     26        self.outputs = [("Classifier", Orange.core.Classifier), 
     27                        ("Learner", Orange.core.Learner), 
     28                        ("SOM", som.SOMMap), 
     29                        ("Codebook vectors", Orange.data.Table)] 
     30 
     31        self.LearnerName = "SOM Map" 
    3132        self.xdim = 5 
    3233        self.ydim = 10 
    33         self.initialization = orngSOM.InitializeLinear 
     34        self.initialization = som.InitializeLinear 
    3435        self.neighborhood = 0 
    3536        self.topology = 0 
     
    4344        self.alpha2 = 0.01 
    4445        self.loadSettings() 
    45 ##        self.TopolMap=[orangeom.SOMLearner.HexagonalTopology, orangeom.SOMLearner.RectangularTopology] 
    46         self.TopolMap = [orngSOM.HexagonalTopology, orngSOM.RectangularTopology] 
    47 ##        self.NeighMap=[orangeom.SOMLearner.BubbleNeighborhood, orangeom.SOMLearner.GaussianNeighborhood] 
    48         self.NeighMap = [orngSOM.NeighbourhoodGaussian, orngSOM.NeighbourhoodBubble] 
    49 ##        self.AlphaMap=[orangeom.SOMLearner.LinearFunction, orangeom.SOMLearner.InverseFunction] 
    50 ##        self.AlphaMap=[1, 2] 
    51         self.learnerName = OWGUI.lineEdit(self.controlArea, self, "LearnerName", box="Learner/Classifier Name", tooltip="Name to be used by other widgets to identify yor Learner/Classifier") 
    52 ##        self.learnerName.setText("SOM Classifier") 
    53 ##        box = OWGUI.widgetBox(self.controlArea, self, "Dimensions") 
    54         box = OWGUI.radioButtonsInBox(self.controlArea, self, "topology", ["Hexagonal topology", "Rectangular topology"], box="Topology") 
    55         OWGUI.spin(box, self, "xdim", 4, 1000, orientation="horizontal", label="Columns") 
    56         OWGUI.spin(box, self, "ydim", 4, 1000, orientation="horizontal", label="Rows") 
    57         OWGUI.radioButtonsInBox(self.controlArea, self, "initialization", ["Linear", "Random"], box="Map Initialization") 
    58         OWGUI.radioButtonsInBox(self.controlArea, self, "neighborhood", ["Gaussian neighborhood", "Bubble neighborhood"], box="Neighborhood") 
    59 ##        OWGUI.radioButtonsInBox(self.controlArea, self, "alphaType", ["Linear function", "Inverse function"], box="Alpha Function Type") 
     46 
     47        self.TopolMap = [som.HexagonalTopology, 
     48                         som.RectangularTopology] 
     49 
     50        self.NeighMap = [som.NeighbourhoodGaussian, 
     51                         som.NeighbourhoodBubble] 
     52 
     53        self.learnerName = OWGUI.lineEdit( 
     54            self.controlArea, self, "LearnerName", 
     55            box="Learner/Classifier Name", 
     56            tooltip=("Name to be used by other widgets to identify your " 
     57                     "Learner/Classifier") 
     58        ) 
     59 
     60        box = OWGUI.radioButtonsInBox( 
     61            self.controlArea, self, "topology", 
     62            ["Hexagonal topology", "Rectangular topology"], 
     63            box="Topology" 
     64        ) 
     65 
     66        OWGUI.spin(box, self, "xdim", 4, 1000, 
     67                   orientation="horizontal", 
     68                   label="Columns") 
     69 
     70        OWGUI.spin(box, self, "ydim", 4, 1000, 
     71                   orientation="horizontal", 
     72                   label="Rows") 
     73 
     74        OWGUI.radioButtonsInBox(self.controlArea, self, "initialization", 
     75                                ["Linear", "Random"], 
     76                                box="Map Initialization") 
     77 
     78        OWGUI.radioButtonsInBox(self.controlArea, self, "neighborhood", 
     79                                ["Gaussian neighborhood", 
     80                                 "Bubble neighborhood"], 
     81                                box="Neighborhood") 
     82 
    6083        b = OWGUI.widgetBox(self.controlArea, "Radius") 
    61         OWGUI.spin(b, self, "radius1", 2,50, orientation="horizontal", label="Initial radius") 
    62         OWGUI.spin(b, self, "radius2", 1,50, orientation="horizontal", label="Final radius") 
    63  
    64         b = OWGUI.widgetBox(self.controlArea , "Stoping Conditions") 
     84 
     85        OWGUI.spin(b, self, "radius1", 2, 50, 
     86                   orientation="horizontal", label="Initial radius") 
     87 
     88        OWGUI.spin(b, self, "radius2", 1, 50, 
     89                   orientation="horizontal", label="Final radius") 
     90 
     91        b = OWGUI.widgetBox(self.controlArea, "Stopping Conditions") 
    6592        OWGUI.spin(b, self, "iterations1", 10, 10000, label="Iterations") 
    66 ##        OWGUI.doubleSpin(b, self, "eps", 0.0, 1.0, 1e-5, label="Eps") 
    67 ##        tabW=OWGUI.tabWidget(self.controlArea) 
    68 ##        b1=OWGUI.createTabPage(tabW, "Step 1") 
    69 ##        b2=OWGUI.createTabPage(tabW, "Step 2") 
    70 ##         
    71 ##        OWGUI.spin(b1, self, "iterations1", 10, 100000, orientation="horizontal", label="Num. iter.") 
    72 ##        OWGUI.spin(b2, self, "iterations2", 10, 100000, orientation="horizontal", label="Num. iter.") 
    73 ##        OWGUI.spin(b1, self, "radius1", 2,1000, orientation="horizontal", label="Radius") 
    74 ##        OWGUI.spin(b2, self, "radius2", 2,1000, orientation="horizontal", label="Radius") 
    75 ##        OWGUI.doubleSpin(b1, self, "alpha1", 0.0, 1.0, 0.01, orientation="horizontal", label="Alpha") 
    76 ##        OWGUI.doubleSpin(b2, self, "alpha2", 0.0, 1.0, 0.01, orientation="horizontal", label="Alpha") 
    77 ##        self.alpha1=self.alpha1 
    78 ##        self.alpha2=self.alpha2 
    79         OWGUI.button(self.controlArea, self,  "&Apply", callback=self.ApplySettings, default=True) 
     93 
     94        OWGUI.button(self.controlArea, self, "&Apply", 
     95                     callback=self.ApplySettings, 
     96                     default=True) 
    8097 
    8198        OWGUI.rubber(self.controlArea) 
    82          
    83         self.data = None         
    84          
     99 
     100        self.data = None 
     101        self.classifier = None 
     102        self.learner = None 
     103 
    85104        self.resize(100, 100) 
    86105 
    87     def dataWithDefinedValues(self, data, ): 
     106    def dataWithDefinedValues(self, data): 
    88107        self.warning(1235) 
    89108        self.warning(1236) 
     
    92111            if not any(not ex[attr].isSpecial() for ex in data): 
    93112                exclude.append(attr) 
     113 
    94114        if exclude: 
    95             self.warning(1235, "Excluding attributes with all unknown values: %s." % ", ".join(attr.name for attr in exclude)) 
    96             exclude_class = data.domain.classVar in exclude 
     115            self.warning(1235, 
     116                         "Excluding attributes with all unknown " 
     117                         "values: %s." % \ 
     118                         ", ".join(attr.name for attr in exclude)) 
     119 
     120            exclude_class = data.domain.class_var in exclude 
    97121            if exclude_class: 
    98                 self.warning(1236, "Excluding class attribute: %s" % data.domain.classVar.name)  
    99             domain = orange.Domain([attr for attr in data.domain.variables if attr not in exclude], 
    100                                    data.domain.classVar if not exclude_class else False) 
     122                self.warning(1236, 
     123                             "Excluding class attribute: %s" % \ 
     124                             data.domain.class_var.name) 
     125 
     126            domain = Orange.data.Domain( 
     127                [attr for attr in data.domain.variables 
     128                 if attr not in exclude], 
     129                data.domain.class_var if not exclude_class else False 
     130            ) 
     131 
    101132            domain.addmetas(data.domain.getmetas()) 
    102             data = orange.ExampleTable(domain, data) 
    103              
     133            data = Orange.data.Table(domain, data) 
     134 
    104135        return data 
    105          
     136 
    106137    def setData(self, data=None): 
    107138        self.data = data 
     
    113144            self.send("SOM", None) 
    114145            self.send("Learner", None) 
    115          
     146            self.send("odebook vectors", None) 
    116147 
    117148    def ApplySettings(self): 
    118149        topology = self.TopolMap[self.topology] 
    119150        neigh = self.NeighMap[self.neighborhood] 
    120 ##        alphaT=self.AlphaMap[self.alphaType] 
    121 ##        params=[{"iterations":self.iterations1, "radius":self.radius1, "alpha":self.alpha1}, 
    122 ##                {"iterations":self.iterations2, "radius":self.radius2, "alpha":self.alpha2}] 
    123         self.learner = orngSOM.SOMLearner(name=self.LearnerName, map_shape=(self.xdim, self.ydim), topology=topology, neighbourhood=neigh, 
    124                                         epochs=self.iterations1, eps=self.eps, initialize=self.initialization, 
    125                                         radius_ini=self.radius1, radius_fin=self.radius2) #alphaType=alphaT, parameters=params) 
     151 
     152        self.learner = som.SOMLearner( 
     153            name=self.LearnerName, 
     154            map_shape=(self.xdim, self.ydim), 
     155            topology=topology, 
     156            neighbourhood=neigh, 
     157            epochs=self.iterations1, 
     158            eps=self.eps, 
     159            initialize=self.initialization, 
     160            radius_ini=self.radius1, 
     161            radius_fin=self.radius2 
     162        ) 
    126163 
    127164        self.send("Learner", self.learner) 
     165 
    128166        if self.data: 
    129167            self.progressBarInit() 
    130             self.classifier = self.learner(self.data, progressCallback=self.progressBarSet) 
     168            self.classifier = self.learner( 
     169                self.data, progressCallback=self.progressBarSet 
     170            ) 
     171 
    131172            self.progressBarFinished() 
    132173            self.classifier.name = self.LearnerName 
    133174            self.classifier.setattr("data", self.data) 
    134             if self.data.domain.classVar: 
     175            if self.data.domain.class_var: 
    135176                self.send("Classifier", self.classifier) 
    136177            self.send("SOM", self.classifier) 
    137          
     178            self.send("Codebook vectors", codebook_table(self.classifier)) 
    138179 
    139180    def sendReport(self): 
    140         self.reportSettings("Topology", 
    141                             [("Shape", ["hexagonal", "rectangular"][self.topology]), 
    142                              ("Size", "%i columns, %i rows" % (self.xdim, self.ydim)) 
    143                             ]) 
    144         self.reportSettings("Optimization", 
    145                             [("Initialization", ["linear", "random"][self.initialization]), 
    146                              ("Neighborhood", ["Gaussian", "bubble"][self.neighborhood]), 
    147                              ("Radius", "initial: %i, final: %i" % (self.radius1, self.radius2)), 
    148                              ("Number of iterations", self.iterations1) 
    149                             ]) 
    150          
     181        self.reportSettings( 
     182            "Topology", 
     183            [("Shape", ["hexagonal", "rectangular"][self.topology]), 
     184             ("Size", "%i columns, %i rows" % (self.xdim, self.ydim))] 
     185        ) 
     186 
     187        self.reportSettings( 
     188            "Optimization", 
     189            [("Initialization", ["linear", "random"][self.initialization]), 
     190             ("Neighborhood", ["Gaussian", "bubble"][self.neighborhood]), 
     191             ("Radius", "initial: %i, final: %i" % \ 
     192              (self.radius1, self.radius2)), 
     193             ("Number of iterations", self.iterations1) 
     194            ]) 
     195 
     196 
     197def codebook_table(map): 
     198    """ 
     199    Return n Orange.data.Table instance of all the codebook vectors 
     200    in the given SOMMap instance. 
     201 
     202    """ 
     203    nodes = list(map.map) 
     204    instances = [node.reference_instance for node in nodes] 
     205    return Orange.data.Table(map.data.domain, instances) 
     206 
     207 
    151208if __name__ == "__main__": 
    152209    app = QApplication(sys.argv) 
    153210    w = OWSOM() 
    154 ##    app.setMainWidget(w) 
    155211    w.show() 
    156     data = orange.ExampleTable("../../doc/datasets/iris.tab") 
    157      
     212    data = Orange.data.Table("iris") 
     213 
    158214    w.setData(data) 
    159215    app.exec_() 
  • docs/conf.py

    r11049 r11312  
    177177# relative to this directory. They are copied after the builtin static files, 
    178178# so a file named "default.css" will overwrite the builtin "default.css". 
    179 html_static_path = ["../Orange/doc/widgets"] 
     179# html_static_path = [] 
    180180 
    181181# If not '', a 'Last updated on:' timestamp is inserted at every page bottom, 
  • docs/widgets/rst/index.rst

    r11050 r11312  
    77---- 
    88 
    9 .. The first row shows how to insert rst documentation, the rest  
    10    link to the old documentation that is copied to '_static'  
    119 
    1210.. list-table:: 
     
    656654   unsupervized/kmeansclustering.rst 
    657655   unsupervized/mds.rst 
    658    unsupervized/pca.rst 
     656   unsupervized/PCA.rst 
    659657 
    660658**************** 
Note: See TracChangeset for help on using the changeset viewer.