Changeset 8378:c04b98476f4e in orange


Ignore:
Timestamp:
07/06/11 17:38:29 (3 years ago)
Author:
Noughmad <Noughmad@…>
Branch:
default
Convert:
14ef41a6e5c8832648c15eb349c5114b012d791a
Message:

Merge changes from trunk

Files:
20 added
2 deleted
50 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/__init__.py

    r8342 r8378  
    5050_import("projection.mds") 
    5151_import("projection.som") 
     52_import("projection.pca") 
    5253 
    5354_import("ensemble") 
     
    6364 
    6465_import("preprocess") 
    65 #import preprocess.value 
    66 #import preprocess.data 
     66_import("preprocess.outliers") 
     67_import("preprocess.scaling") 
    6768 
    68 _import("distances") 
     69_import("distance") 
     70_import("distance.instances") 
    6971 
    7072_import("wrappers") 
  • orange/Orange/classification/lookup.py

    r8042 r8066  
    1919 
    2020A natural habitat for these classifiers is feature construction: 
    21 they usually reside in :obj:`getValueFrom` fields of constructed 
     21they usually reside in :obj:`~Orange.data.variable.Variable.get_value_from` fields of constructed 
    2222features to facilitate their automatic computation. For instance, 
    2323the following script shows how to translate the `monks-1.tab`_ dataset 
     
    5757for instance:: 
    5858 
    59     e2.getValueFrom = lambda ex, rw: orange.Value(e2, ex["e"]=="1") 
     59    e2.get_value_from = lambda ex, rw: orange.Value(e2, ex["e"]=="1") 
    6060 
    6161 
     
    301301    ['1', '3', '2', '0'] <12.000, 0.000> 
    302302 
    303 ClassifierByDataTable will usually be used by getValueFrom. So, we 
     303ClassifierByDataTable will usually be used by :obj:`Orange.data.variable.Variable.get_value_from`. So, we 
    304304would probably continue this by constructing a new feature and put the 
    305 classifier into its getValueFrom. 
     305classifier into its :obj:`Orange.data.variable.Variable.get_value_from`. 
    306306 
    307307    >>> y2 = Orange.data.variable.Discrete("y2", values = ["0", "1"]) 
    308     >>> y2.getValueFrom = abe 
     308    >>> y2.get_value_from = abe 
    309309 
    310310There's something disturbing here. Although abe determines the value of 
     
    320320the new class variable and the features that should be used for 
    321321classification. This saves us from constructing data_s and reassigning 
    322 the class_var. It doesn't set the getValueFrom, though. 
     322the class_var. It doesn't set the :obj:`Orange.data.variable.Variable.get_value_from`, though. 
    323323 
    324324part of `lookup-table.py`_ (uses: `monks-1.tab`_):: 
     
    408408        >>> newVar = Orange.data.variable.Discrete("a=b", values=["no", "yes"]) 
    409409        >>> lookup = lookup_from_function(newVar, bound, lambda x: x[0]==x[1]) 
    410         >>> newVar.getValueFrom = lookup 
     410        >>> newVar.get_value_from = lookup 
    411411        >>> import orngCI 
    412412        >>> table2 = orngCI.addAnAttribute(newVar, table) 
     
    425425 
    426426    The feature was inserted with use of orngCI.addAnAttribute. By setting 
    427     newVar.getValueFrom to lookup we state that when converting domains 
     427    newVar.get_value_from to lookup we state that when converting domains 
    428428    (either when needed by addAnAttribute or at some other place), lookup 
    429429    should be used to compute newVar's value. (A bit off topic, but 
    430     important: you should never call getValueFrom directly, but always call 
     430    important: you should never call :obj:`Orange.data.variable.Variable.get_value_from` directly, but always call 
    431431    it through computeValue.) 
    432432 
     
    449449    dump_lookup_function returns a string with a lookup function in 
    450450    tab-delimited format. Argument func can be any of the above-mentioned 
    451     classifiers or a feature whose getValueFrom points to one of such 
     451    classifiers or a feature whose :obj:`Orange.data.variable.Variable.get_value_from` points to one of such 
    452452    classifiers. 
    453453 
     
    541541def dump_lookup_function(func): 
    542542    if isinstance(func, Orange.data.variable.Variable): 
    543         if not func.getValueFrom: 
     543        if not func.get_value_from: 
    544544            raise TypeError, "attribute '%s' does not have an associated function" % func.name 
    545545        else: 
    546             func = func.getValueFrom 
     546            func = func.get_value_from 
    547547 
    548548    outp = "" 
  • orange/Orange/clustering/hierarchical.py

    r8342 r8378  
    5555            4. ``HierarchicalClustering.Ward`` uses Ward's distance. 
    5656             
    57     .. attribute:: overwriteMatrix 
    58          
     57    .. attribute:: overwrite_matrix 
     58 
    5959        If true (default is false), the algorithm will work on the original 
    6060        distance matrix, destroying it in the process. The benefit is that it 
     
    6262        the tree of clusters). 
    6363         
    64     .. attribute:: progressCallback 
     64    .. attribute:: progress_callback 
    6565         
    6666        A callback function (None by default). It can be any function or 
     
    317317    import Orange 
    318318    from Orange.clustering import hierarchical 
    319     from Orange import distances 
    320      
     319 
    321320    data = Orange.data.Table("iris") 
    322321    matrix = Orange.core.SymMatrix(len(data)) 
    323322    matrix.setattr("objects", data) 
    324     distance = distances.ExamplesDistanceConstructor_Euclidean(data) 
     323    distance = Orange.distance.instances.EuclideanConstructor(data) 
    325324    for i1, instance1 in enumerate(data): 
    326325        for i2 in range(i1+1, len(data)): 
     
    485484    :type data: :class:`Orange.data.Table` 
    486485    :param distance_constructor: Instance distance constructor 
    487     :type distance_constructor: :class:`Orange.distances.ExamplesDistanceConstructor` 
     486    :type distance_constructor: :class:`Orange.distance.instances.ExamplesDistanceConstructor` 
    488487    :param linkage: Linkage flag. Must be one of global module level flags: 
    489488     
     
    799798    from matplotlib.artist import Artist 
    800799##    import  matplotlib.pyplot as plt 
    801 except (ImportError, IOError), ex: 
     800except (ImportError, IOError, RuntimeError), ex: 
    802801    matplotlib = None 
    803802    Text , Artist, Table, Cell = object, object, object, object 
     
    10251024""" 
    10261025 
    1027 from orngMisc import ColorPalette, EPSRenderer 
     1026from Orange.misc.render import EPSRenderer, ColorPalette 
     1027 
    10281028class DendrogramPlot(object): 
    10291029    """ A class for drawing dendrograms 
     
    11681168    """ 
    11691169    import os 
    1170     from orngMisc import PILRenderer, EPSRenderer, SVGRenderer 
     1170    from Orange.misc.render import PILRenderer, EPSRenderer, SVGRenderer 
    11711171    name, ext = os.path.splitext(filename) 
    11721172    kwargs["renderer"] = {".eps":EPSRenderer, ".svg":SVGRenderer, ".png":PILRenderer}.get(ext.lower(), PILRenderer) 
     
    13751375     
    13761376    :param distance_constructor: An ExamplesDistance_Constructor instance. 
    1377     :type distance_constructor: :class:`Orange.distances.ExampleDistConstructor` 
     1377    :type distance_constructor: :class:`Orange.distance.instances.ExampleDistConstructor` 
    13781378     
    13791379    """ 
  • orange/Orange/data/io.py

    r8042 r8057  
    208208    for a in as0: 
    209209        labels.append(str(a.name)) 
    210         atyp.append(a.var_ype) 
     210        atyp.append(a.var_type) 
    211211        aord.append(a.ordered) 
    212212 
  • orange/Orange/ensemble/forest.py

    r8042 r8043  
    117117            for j in range(n): 
    118118                selection.append(self.rand.randrange(n)) 
    119             data = instances.getitems(selection) 
     119            data = instances.get_items_ref(selection) 
    120120            # build the model from the bootstrap sample 
    121121            classifiers.append(learner(data, weight)) 
  • orange/Orange/evaluation/reliability.py

    r8042 r8059  
    453453    def __call__(self, examples, learner): 
    454454        nearest_neighbours_constructor = Orange.classification.knn.FindNearestConstructor() 
    455         nearest_neighbours_constructor.distanceConstructor = Orange.distances.EuclideanConstructor() 
     455        nearest_neighbours_constructor.distanceConstructor = Orange.distance.instances.EuclideanConstructor() 
    456456         
    457457        distance_id = Orange.core.newmetaid() 
     
    516516    def __call__(self, examples, learner): 
    517517        nearest_neighbours_constructor = Orange.classification.knn.FindNearestConstructor() 
    518         nearest_neighbours_constructor.distanceConstructor = Orange.distances.EuclideanConstructor() 
     518        nearest_neighbours_constructor.distanceConstructor = Orange.distance.instances.EuclideanConstructor() 
    519519         
    520520        distance_id = Orange.core.newmetaid() 
     
    562562    def __call__(self, examples, *args): 
    563563        nnm = Orange.classification.knn.FindNearestConstructor() 
    564         nnm.distanceConstructor = Orange.distances.MahalanobisConstructor() 
     564        nnm.distanceConstructor = Orange.distance.instances.MahalanobisConstructor() 
    565565         
    566566        mid = Orange.core.newmetaid() 
  • orange/Orange/misc/environ.py

    r8042 r8378  
    1414installation). Further, it will look for and try to load a user specific 
    1515configuration file located in $(HOME)/.orangerc.cfg or  
    16 `application_dir`/.orangerc.cfg where `application_dir` is a variable defined 
     16`application_dir`/orangerc.cfg where `application_dir` is a variable defined 
    1717in the global configuration file. 
    1818 
     
    5555 
    5656`doc_install_dir`: 
    57     Directory where Orange documentation 
    58      
     57    Directory with Orange documentation. 
     58  
     59`dataset_install_dir`: 
     60    Directory with example data sets. 
     61 
     62`network_install_dir`: 
     63    Directory with example networks. 
     64 
    5965`add_ons_dir`: 
    6066    Directory where system-wide add-ons are installed  
     
    113119def _get_default_env(): 
    114120    """ Return a dictionary with default Orange environment.""" 
     121 
    115122    version = "orange" 
    116123    version_display = "Orange 2.5" 
     
    127134 
    128135    doc_install_dir = os.path.join(install_dir, "doc")  
     136    dataset_install_dir = os.path.join(install_dir, "doc", "datasets")  
     137    network_install_dir = os.path.join(install_dir, "doc", "networks") 
    129138 
    130139    canvas_install_dir = os.path.join(install_dir, "OrangeCanvas") 
     
    170179_ALL_DIR_OPTIONS = ["install_dir", "canvas_install_dir", 
    171180                    "widget_install_dir", "icons_install_dir", 
    172                     "doc_install_dir", "add_ons_dir", "add_ons_dir_user", 
     181                    "doc_install_dir", "dataset_install_dir",  
     182                    "network_install_dir", "add_ons_dir", "add_ons_dir_user", 
    173183                    "application_dir", "output_dir", "default_reports_dir", 
    174184                    "orange_settings_dir", "canvas_settings_dir", 
     
    182192    except Exception: 
    183193        return parser.get(section, option) 
    184      
     194 
     195#options read from environment variables 
     196_ENVIRON_OPTIONS = [ "orange_no_deprecated_members" ] 
     197 
    185198def _configure_env(defaults=None): 
    186199    """ Apply the configuration files on the default environment 
     
    191204        defaults = dict(os.environ) 
    192205        defaults.update(_get_default_env()) 
    193          
     206 
     207    for opt in _ENVIRON_OPTIONS: 
     208        if opt in os.environ: 
     209            defaults[opt] = os.environ[opt] 
     210     
    194211    parser = ConfigParser.SafeConfigParser(defaults) 
    195212    global_cfg = os.path.join(defaults["install_dir"], "orangerc.cfg") 
  • orange/Orange/misc/render.py

    r8042 r8053  
    1111from __future__ import with_statement 
    1212 
     13import sys 
    1314import numpy 
     15import math 
     16 
     17 
     18class GeneratorContextManager(object): 
     19   def __init__(self, gen): 
     20       self.gen = gen 
     21   def __enter__(self): 
     22       try: 
     23           return self.gen.next() 
     24       except StopIteration: 
     25           raise RuntimeError("generator didn't yield") 
     26   def __exit__(self, type, value, traceback): 
     27       if type is None: 
     28           try: 
     29               self.gen.next() 
     30           except StopIteration: 
     31               return 
     32           else: 
     33               raise RuntimeError("generator didn't stop") 
     34       else: 
     35           try: 
     36               self.gen.throw(type, value, traceback) 
     37               raise RuntimeError("generator didn't stop after throw()") 
     38           except StopIteration: 
     39               return True 
     40           except: 
     41               # only re-raise if it's *not* the exception that was 
     42               # passed to throw(), because __exit__() must not raise 
     43               # an exception unless __exit__() itself failed.  But 
     44               # throw() has to raise the exception to signal 
     45               # propagation, so this fixes the impedance mismatch  
     46               # between the throw() protocol and the __exit__() 
     47               # protocol. 
     48               # 
     49               if sys.exc_info()[1] is not value: 
     50                   raise 
    1451 
    1552def contextmanager(func): 
     
    4077            return func(*args, **kwargs) 
    4178    return wrapper 
     79 
     80 
     81class ColorPalette(object): 
     82    def __init__(self, colors, gamma=None, overflow=(255, 255, 255), underflow=(255, 255, 255), unknown=(0, 0, 0)): 
     83        self.colors = colors 
     84        self.gammaFunc = lambda x, gamma:((math.exp(gamma*math.log(2*x-1)) if x > 0.5 else -math.exp(gamma*math.log(-2*x+1)) if x!=0.5 else 0.0)+1)/2.0 
     85        self.gamma = gamma 
     86        self.overflow = overflow 
     87        self.underflow = underflow 
     88        self.unknown = unknown 
     89 
     90    def get_rgb(self, val, gamma=None): 
     91        if val is None: 
     92            return self.unknown 
     93        gamma = self.gamma if gamma is None else gamma 
     94        index = int(val * (len(self.colors) - 1)) 
     95        if val < 0.0: 
     96            return self.underflow 
     97        elif val > 1.0: 
     98            return self.overflow 
     99        elif index == len(self.colors) - 1: 
     100            return tuple(self.colors[-1][i] for i in range(3)) # self.colors[-1].green(), self.colors[-1].blue()) 
     101        else: 
     102            red1, green1, blue1 = [self.colors[index][i] for i in range(3)] #, self.colors[index].green(), self.colors[index].blue() 
     103            red2, green2, blue2 = [self.colors[index + 1][i] for i in range(3)] #, self.colors[index + 1].green(), self.colors[index + 1].blue() 
     104            x = val * (len(self.colors) - 1) - index 
     105            if gamma is not None: 
     106                x = self.gammaFunc(x, gamma) 
     107            return [(c2 - c1) * x + c1 for c1, c2 in [(red1, red2), (green1, green2), (blue1, blue2)]] 
     108         
     109    def __call__(self, val, gamma=None): 
     110        return self.get_rgb(val, gamma) 
     111     
    42112 
    43113class Renderer(object): 
     
    335405        return len(text) * self.font()[1] 
    336406         
    337          
     407def _int_color(color): 
     408    """ Transform the color tuple (with floats) to tuple with ints 
     409    (needed by PIL)  
     410    """ 
     411    return tuple(map(int, color)) 
     412 
    338413class PILRenderer(Renderer): 
    339414    def __init__(self, width, height): 
    340415        Renderer.__init__(self, width, height) 
    341416        import Image, ImageDraw, ImageFont 
    342         self._pil_image = Image.new("RGB", (width, height), (255, 255, 255)) 
     417        self._pil_image = Image.new("RGB", (int(width), int(height)), (255, 255, 255)) 
    343418        self._draw =  ImageDraw.Draw(self._pil_image, "RGB") 
    344419        self._pil_font = ImageFont.load_default() 
     
    366441        sx, sy = self._transform(sx, sy) 
    367442        ex, ey = self._transform(ex, ey) 
    368         self._draw.line((sx, sy, ex, ey), fill=self.stroke_color(), width=int(self.stroke_width())) 
     443        self._draw.line((sx, sy, ex, ey), fill=_int_color(self.stroke_color()), 
     444                        width=int(self.stroke_width())) 
    369445 
    370446    @with_state 
     
    372448        x1, y1 = self._transform(x, y) 
    373449        x2, y2 = self._transform(x + w, y + h) 
    374         self._draw.rectangle((x1, y1, x2 ,y2), fill=self.fill_color(), outline=self.stroke_color()) 
     450        self._draw.rectangle((x1, y1, x2 ,y2), fill=_int_color(self.fill_color()), 
     451                             outline=_int_color(self.stroke_color())) 
    375452         
    376453    @with_state 
    377454    def draw_text(self, x, y, text, **kwargs): 
    378455        x, y = self._transform(x, y - self.font()[1]) 
    379         self._draw.text((x, y), text, font=self._pil_font, fill=self.stroke_color()) 
     456        self._draw.text((x, y), text, font=self._pil_font, 
     457                        fill=_int_color(self.stroke_color())) 
    380458         
    381459    def save(self, file): 
     
    384462    def string_size_hint(self, text, **kwargs): 
    385463        return self._pil_font.getsize(text)[1] 
     464     
    386465 
    387466class SVGRenderer(Renderer): 
  • orange/Orange/misc/testing.py

    r7903 r8378  
    55This module contains some classes in common use by Orange unit testing 
    66framework. In particular its most useful feature is the BaseTestOnData 
    7 (along with test_on_data function and expand_tests class decorators)  
    8 class for automating tests on datasets. 
    9    
    10 .. todo:: read datasets to include in the run from a file (maybe command line??) 
    11  
    12 .. todo:: add a flag (maybe also datasets) parameter to test_on_data 
    13           to override the default class member  
     7(along with ``test_on_data`` function and ``datasets_driven`` class decorators)  
     8class for automating data driven tests. 
     9  
     10           
     11Example of use :: 
     12 
     13    from Orange.misc import testing 
     14    import unittest 
     15     
     16    data = [("one", 1), 
     17            ("two", 2)] 
     18     
     19    # Data driven with data_iter argument 
     20    # data must be reiterable multiple times if more than one test member defined 
     21    @data_driven(data_iter=data) 
     22    class TestDemo(unittest.TestCase): 
     23        @test_on_data 
     24        def test_instance_on(self, arg): 
     25            self.assertIsInstance(arg, int) 
     26             
     27        @test_on_data 
     28        def test_add(self, arg): 
     29            res = arg + arg 
     30             
     31    # data_driven without argument 
     32    @data_driven 
     33    class TestDemo1(unittest.TestCase): 
     34        @test_on_data(data_iter=data) 
     35        def test_instance_on(self, arg): 
     36            self.assertIsInstance(arg, int) 
     37             
     38        @test_on_data(data_iter=data) 
     39        def test_add(self, arg): 
     40            res = arg + arg 
     41     
     42    # data_driven without arg, using a static data_iter method 
     43    @data_driven 
     44    class TestDemo1(unittest.TestCase): 
     45        @test_on_data 
     46        def test_instance_on(self, arg): 
     47            self.assertIsInstance(arg, int) 
     48             
     49        @test_on_data 
     50        def test_add(self, arg): 
     51            res = arg + arg 
     52             
     53        @staticmethod 
     54        def data_iter(): 
     55            yield "iris", Orange.data.Table("doc:iris") 
     56         
     57    #@data_driven(data_iter=testing.datasets_iter(testing.CLASSIFICATION_DATASETS | testing.CLASSLES_DATASETS)) 
     58    @datasets_driven(data_iter=testing.CLASSIFICATION_DATASETS |\ 
     59                     testing.CLASSLESS_DATASETS) 
     60    class TestDefaultLearner(unittest.TestCase): 
     61        @test_on_data 
     62        def test_learner_on(self, dataset): 
     63            import Orange 
     64            Orange.classifcation.majority.MajorityLearner(dataset) 
     65             
     66        # this overloads the class decorator's flags  
     67        @test_on_datasets(testing.CLASSLES_DATASETS) 
     68        def test_raise_missing_class_on(self, dataset): 
     69            import Orange 
     70            Orange.classifcation.majority.MajorityLearner(dataset) 
     71         
    1472""" 
    15  
     73from __future__ import absolute_import 
    1674import unittest 
    1775import os, sys 
    1876 
    19 import orange 
    20 import orngTest, orngStat 
    2177import itertools 
    2278import cPickle 
    23  
     79from functools import partial 
     80 
     81import orange 
    2482from Orange.preprocess import Preprocessor_discretize, Preprocessor_continuize 
    2583 
     
    3391 
    3492TEST_CLASSLESS = 8 
     93 
    3594DISCRETIZE_DOMAIN = 16 
    3695CONTINUIZE_DOMAIN = 32 
     
    3897datasetsdir = os.path.join(os.path.dirname(orange.__file__), "doc", "datasets") 
    3998 
    40 def openData(name, flags=0): 
     99def open_data(name, flags=0): 
     100    """ Open a named data-set return it.  
     101    """ 
    41102    dataset = orange.ExampleTable(os.path.join(datasetsdir, name)) 
    42103    if flags & CONTINUIZE_DOMAIN: 
     
    44105        dataset = preprocessor(dataset) 
    45106    elif flags & DISCRETIZE_DOMAIN: 
    46         preprocessor = Preprocessor_discretize(orange.EquiNDiscretization()) 
     107        preprocessor = Preprocessor_discretize(method=orange.EquiNDiscretization(), 
     108                                               discretize_class=False) 
    47109        dataset = preprocessor(dataset) 
    48110    dataset.name = name 
    49111    return dataset 
    50112 
    51 CLASSIFICATION_DATASETS = ["iris", "brown-selected", "lenses"] 
     113CLASSIFICATION_DATASETS = ["iris", "brown-selected", "lenses", "monks-1"] 
    52114REGRESSION_DATASETS = ["housing", "auto-mpg"] 
    53115CLASSLES_DATASETS =  ["water-treatment"] 
    54  
    55 def classificationDatasets(flags=0): 
    56     """ Return an iterator over classification datasets. 
    57      
    58     :param flags: `DISCRETIZE_DOMAIN`, `CONTINUIZE_DOMAIN` or 0 
    59     :param flags: int 
    60      
    61     """ 
    62     for name in CLASSIFICATION_DATASETS: 
    63         yield openData(name, flags) 
    64              
    65 def regressionDatasets(flags=0): 
    66     """ Return an iterator over regression datasets. 
    67      
    68     :param flags: `DISCRETIZE_DOMAIN`, `CONTINUIZE_DOMAIN` or 0 
    69     :type flags: int 
    70      
    71     """ 
    72     for name in REGRESSION_DATASETS: 
    73         yield openData(name, flags) 
    74          
    75 def classlessDatasets(flags=0): 
    76     """ Return an iterator over classless datasets. 
    77      
    78     :param flags: `DISCRETIZE_DOMAIN`, `CONTINUIZE_DOMAIN` or 0 
    79     :type flags: int 
    80      
    81     """ 
    82     for name in CLASSLES_DATASETS: 
    83         yield openData(name, flags) 
    84          
    85 def datasets(flags=0): 
    86     """ Return an iterator over classification, regression  and classless datasets. 
    87      
    88     :param flags: `DISCRETIZE_DOMAIN`, `CONTINUIZE_DOMAIN`, `TEST_CLASSIFICATION`, `TEST_REGRESSION` or 0 
    89     :type flags: int 
    90      
    91     """ 
    92     datasets = [] 
    93     if flags & TEST_CLASSIFICATION: 
    94         datasets.append(classificationDatasets(flags)) 
    95     if flags & TEST_REGRESSION: 
    96         datasets.append(regressionDatasets(flags)) 
    97     if flags & TEST_CLASSLESS: 
    98         datasets.append(classlessDatasets(flags)) 
    99     return itertools.chain(*datasets)  
    100  
    101  
    102 def _expanded(func, data): 
    103     """ Return a expanded function name and the function itself. 
     116ALL_DATASETS  = CLASSIFICATION_DATASETS + REGRESSION_DATASETS + CLASSLES_DATASETS 
     117 
     118 
     119from collections import namedtuple 
     120ExtraArgs = namedtuple("ExtraArgs", "args kwargs") 
     121 
     122 
     123def _expanded(func, name, extra_args): 
     124    """ Return an expanded function name and the function itself. 
     125    """ 
     126    from functools import wraps 
     127    if isinstance(extra_args, ExtraArgs): 
     128        extra_args, extra_kwargs = extra_args 
     129    else: 
     130        extra_kwargs = {} 
     131    @wraps(func) 
     132    def expanded(*fixed_args, **fixed_kwargs): 
     133        call = partial(partial(func, *fixed_args, **fixed_kwargs), *extra_args, **extra_kwargs) 
     134        return call() 
     135#    expanded = partial(func, args, kwargs) 
     136#    expanded = wraps(func)(expanded) 
     137    newname = func.__name__ + "_" + name.replace("-", "_") 
     138    expanded.__name__ = newname 
     139    return newname, expanded 
     140 
     141def _expanded_lazy(func, name, args_getter): 
     142    """ Return an expanded function name and the function itself. 
     143    arge_getter must return the expanded arguments when called. 
     144     
    104145    """ 
    105146    from functools import wraps 
    106147    @wraps(func) 
    107     def expanded(self): 
    108         return func(self, data) 
    109     newname = func.__name__ + "_" + data.name.replace("-", "_") 
     148    def expanded(*fixed_args, **kwargs): 
     149        kwargs = kwargs.copy() 
     150        extra_args = args_getter() 
     151        if isinstance(extra_args, ExtraArgs): 
     152            extra_args, extra_kwargs = extra_args 
     153        else: 
     154            extra_kwargs = {} 
     155        call = partial(partial(func, fixed_args, kwargs), extra_args, extra_kwargs) 
     156        return call() 
     157     
     158    newname = func.__name__ + "_" + name.replace("-", "_") 
    110159    expanded.__name__ = newname 
    111160    return newname, expanded 
     161 
    112162                 
    113  
    114 def test_on_data(test_func): 
     163def _data_driven_cls_decorator(cls, data_iter=None, lazy=False): 
     164    """ A class decorator that expands TestCase subclass 
     165    methods decorated with `test_on_data` or `data_driven` 
     166    decorator. 
     167     
     168    """  
     169    if data_iter is None: 
     170        data_iter = getattr(cls, "data_iter", None) # data_iter should be a staticmethod or classmethod 
     171        if data_iter is not None: 
     172            data_iter = data_iter() 
     173             
     174    if data_iter is not None: 
     175        data_iter = list(data_iter) # Because it needs to be iterated multiple times (each member not overriding it) 
     176     
     177    for test_name in dir(cls): 
     178        val = getattr(cls, test_name) 
     179        if hasattr(val, "_data_iter"): 
     180            member_data_iter = val._data_iter 
     181            if member_data_iter is None or member_data_iter == (None, False): 
     182                member_data_iter, lazy_iter = data_iter, lazy 
     183            else: 
     184                if isinstance(member_data_iter, tuple): 
     185                    member_data_iter, lazy_iter = member_data_iter 
     186                else: 
     187                    lazy_iter = lazy 
     188                     
     189            assert(member_data_iter is not None) 
     190            for name, expand_args in iter(member_data_iter): 
     191                if lazy: 
     192                    newname, expanded = _expanded_lazy(val, name, expand_args) 
     193                else: 
     194                    newname, expanded = _expanded(val, name, expand_args) 
     195                setattr(cls, newname, expanded) 
     196            setattr(cls, test_name, None) 
     197            setattr(cls, "__" + test_name, val) 
     198    return cls 
     199 
     200def data_driven(cls=None, data_iter=None): 
     201    """ Class decorator for building data driven test cases. 
     202     
     203    :param data_iter: An iterator supplying the names and arguments for 
     204        the expanded test. 
     205     
     206    Example :: 
     207     
     208        data_for_tests = [("one", (1, )), ("two", (2, ))] 
     209         
     210        @data_driven(data_iter=data_for_tests) 
     211        class MyTestCase(unittest.TestCase): 
     212            @test_on_data 
     213            def test_add_on(self, number): 
     214                number + number 
     215                 
     216    The tests are then accessible from the command line :: 
     217     
     218        python -m unittest MyTestCase.MyTestCase.test_add_on_one 
     219         
     220    """ 
     221    if data_iter is not None: 
     222        #Used as 
     223        # @data_driven(data_iter=...) 
     224        # class ... 
     225        return partial(_data_driven_cls_decorator, data_iter=data_iter) 
     226    elif cls is not None: 
     227        #Used as 
     228        # @data_driven 
     229        # class ... 
     230        return _data_driven_cls_decorator(cls) 
     231      
     232 
     233 
     234def data_driven_lazy(cls=None, data_iter=None): 
     235    if lazy_data_iter is not None:  
     236        #Used as 
     237        # @data_driven_lazy(data_iter= ...) 
     238        # class ... 
     239        return partial(_data_driven_cls_decorator, data_iter=data_iter, lazy=True) 
     240    elif cls is not None: 
     241        #Used as 
     242        # @data_driven_lazy 
     243        # class ... 
     244        return _data_driven_cls_decorator(cls, lazy=True) 
     245     
     246def test_on_data(test_func=None, data_iter=None): 
    115247    """ Decorator for test member of unittest.TestCase, signaling that it 
    116     wants to be expanded (replicated) for each test data-set. The actual 
    117     expanding is done by `expand_tests` class decorator. 
     248    wants to be expanded (replicated) on each test's data case. This decorator 
     249    accepts an optional parameter (an data case iterator, see  
     250    `Data Iterators`_) which overrides the iterator passed to  
     251    :obj:`data_driven` decorator. 
    118252     
    119253    Example :: 
    120254     
    121         @test_on_data 
    122         class Test(BaseTestOnData): 
    123             FLAGS = TEST_CLASSIFICATION 
    124             @test_on_data 
     255        @data_driven 
     256        class MyTestCase(TestCase): 
     257            @test_on_data(datasets_iterator()) 
    125258            def test_on(self, data) 
    126259                ''' This will be a separate test case for each data-set 
     
    129262                print data.name 
    130263                 
    131     .. note:: Within the unittest framework `test_on` test will be expanded to `test_on_iris`, 
    132               `test_on_lenses` ... for each dataset in the testing run indicating by the `FLAGS` 
    133               class attribute 
    134                
    135     ... note:: You can run individual tests from the command line :: 
    136      
    137         python -m unittest mymodule.Test.test_on_iris 
    138          
    139     """ 
    140     test_func._expand_data = True 
    141     return test_func 
    142  
    143 def expand_tests(cls): 
    144     """ A class decorator that expands BaseTestOnData subclass 
    145     methods decorated with `test_on_data` decorator.  
    146     """  
    147     FLAGS = getattr(cls, "FLAGS", TEST_ALL) 
    148     for name in dir(cls): 
    149         val = getattr(cls, name) 
    150         if getattr(val, "_expand_data", False): 
    151             for data in datasets(FLAGS): 
    152                 newname, expanded = _expanded(val, data) 
    153                 setattr(cls, newname, expanded) 
    154             setattr(cls, name, None) 
    155             setattr(cls, "_" + name, val) 
    156     return cls 
    157              
    158              
    159 class BaseTestOnData(unittest.TestCase): 
    160     """ Base class for tests which use data (orange example tables) 
    161     """ 
    162      
    163     FLAGS = TEST_ALL 
    164     """ A bitwise or of module level flags. 
    165     """ 
    166      
    167     def classificationDatasets(self): 
    168         return classificationDatasets(self.FLAGS) 
    169      
    170     def regressionDatasets(self): 
    171         return regressionDatasets(self.FLAGS) 
    172      
    173     def classlessDatasets(self): 
    174         return classlessDatasets(self.FLAGS) 
    175          
    176     def datasets(self): 
    177         return datasets(self.FLAGS) 
    178      
    179      
    180 class LearnerTestCase(BaseTestOnData): 
     264    .. note:: The actual expanding is done by `data_driven` class decorator. 
     265     
     266    .. note:: Within the unittest framework `test_on` test will be expanded 
     267        to `test_on_iris`, `test_on_lenses` ... for each dataset returned 
     268        by :obj:`datasets_iterator`. You can then run individual tests from 
     269        the command line (requires Python 2.7) :: 
     270                    
     271           python -m unittest mymodule.MyTestCase.test_on_iris 
     272     
     273    """ 
     274    def set_iter(func): 
     275        func._data_iter = data_iter, False 
     276        return func 
     277     
     278    if data_iter is not None: 
     279        return set_iter 
     280    else: 
     281        return set_iter(test_func) 
     282     
     283     
     284def test_on_data_lazy(test_func=None, data_iter=None): 
     285    """ Same as :func:`test_on_data` except the ``data_iter`` is  
     286    interpreted as a lazy data iterator (see `Data Iterators`_). 
     287     
     288    """ 
     289    def set_iter(func): 
     290        func._data_iter = data_iter, True 
     291        return func 
     292     
     293    if data_iter is not None: 
     294        return set_iter 
     295    else: 
     296        return set_iter(test_func) 
     297     
     298     
     299def datasets_iter(datasets=ALL_DATASETS, preprocess=0): 
     300    for name in datasets: 
     301        data = open_data(name, flags=preprocess) 
     302        name = name.replace("-", "_") 
     303        yield name, (data,) 
     304         
     305         
     306def datasets_iter_lazy(datasets=ALL_DATASETS, preprocess=0): 
     307    for name in datasets: 
     308        data = lambda : (open_data(name, flags=preprocess), ) 
     309        name = name.replace("-", "_") 
     310        yield name, data 
     311     
     312 
     313def test_on_datasets(test_func=None, datasets=ALL_DATASETS): 
     314    """ same as ``test_on_data(data_iter=datasests_iter(datasets))`` 
     315    """ 
     316    if test_func is None: 
     317        return test_on_data(data_iter=datasets_iter(datasets)) 
     318    else: 
     319        return test_on_data(data_iter=datasets_iter(datasets))(test_func) 
     320 
     321 
     322def datasets_driven(cls=None, datasets=ALL_DATASETS, preprocess=0): 
     323    """ same as ```data_driven(data_iter=datasets_iter(datasets)``` 
     324    """ 
     325    if  cls is None: 
     326        return data_driven(data_iter=datasets_iter(datasets, preprocess)) 
     327    else: 
     328        return data_driven(data_iter=datasets_iter(datasets, preprocess))(cls) 
     329     
     330 
     331class DataTestCase(unittest.TestCase): 
     332    """ Base class for data driven tests. 
     333    """ 
     334     
     335import Orange 
     336from Orange.evaluation import testing as _testing 
     337from Orange.evaluation import scoring as _scoring 
     338from Orange.core import MakeRandomIndices2 as _MakeRandomIndices2 
     339 
     340 
     341class LearnerTestCase(DataTestCase): 
    181342    """ A basic test class for orange learner class. Must define 
    182343    class variable `LEARNER` in a subclass or define the proper 
    183     setUp method. 
     344    setUp method which sets ``self.learner``. 
    184345     
    185346    """  
    186347     
    187348    LEARNER = None 
    188     FLAGS = TEST_ALL_CLASSIFICATION 
    189349     
    190350    def setUp(self): 
    191         """ Set up the learner for the test 
     351        """ Set up the learner for the test from the ``LEARNER`` class member. 
    192352        """ 
    193353        self.learner = self.LEARNER 
     
    195355    @test_on_data 
    196356    def test_learner_on(self, dataset): 
    197         """ Test learner {LEARNER!r} '{NAME}' on {DATANAME}. 
    198         """ 
    199         indices = orange.MakeRandomIndices2(p0=20)(dataset) 
     357        """ Default test case for Orange learners. 
     358        """ 
     359        indices = _MakeRandomIndices2(p0=20)(dataset) 
    200360        learn = dataset.select(indices, 1) 
    201361        test = dataset.select(indices, 0) 
     
    204364         
    205365        # Test for classVar  
    206         self.assertTrue(hasattr(classifier, "classVar")) 
    207         self.assertTrue(classifier.classVar is not None) 
    208          
    209         res = orngTest.testOnData([classifier], test) 
     366        self.assertTrue(hasattr(classifier, "class_var")) 
     367        self.assertTrue(classifier.class_var is not None) 
     368         
     369        res = _testing.test_on_data([classifier], test) 
    210370         
    211371        for ex in test: 
    212             self.assertIsInstance(classifier(ex, orange.GetValue), orange.Value) 
    213             self.assertIsInstance(classifier(ex, orange.GetProbabilities), orange.Distribution) 
    214              
    215             value, dist = classifier(ex, orange.GetBoth) 
    216              
    217             self.assertIsInstance(value, orange.Value) 
    218             self.assertIsInstance(dist, orange.Distribution) 
    219              
    220             if isinstance(dist, orange.ContDistribution): 
     372            self.assertIsInstance(classifier(ex, Orange.core.GetValue), Orange.core.Value) 
     373            self.assertIsInstance(classifier(ex, Orange.core.GetProbabilities), Orange.core.Distribution) 
     374             
     375            value, dist = classifier(ex, Orange.core.GetBoth) 
     376             
     377            self.assertIsInstance(value, Orange.core.Value) 
     378            self.assertIsInstance(dist, Orange.core.Distribution) 
     379             
     380            if isinstance(dist, Orange.core.ContDistribution): 
    221381                dist_sum = sum(dist.values()) 
    222382            else: 
     
    233393        self.classifier = classifier 
    234394 
    235     def test_pickling(self): 
    236         """ Test learner {LEARNER!r} '{NAME}' pickling. 
    237         """ 
    238         if not self.FLAGS & TEST_PICKLE: 
    239             return  
    240          
    241         datasets = [] 
    242         if self.FLAGS & TEST_CLASSIFICATION: 
    243             data = iter(self.classificationDatasets()).next() 
    244             classifier = self.learner(data) 
    245              
    246             import cPickle 
    247             s = cPickle.dumps(classifier) 
    248             classifier_clone = cPickle.loads(s) 
    249              
    250             indices = orange.MakeRandomIndices2(p0=20)(data) 
    251             test = data.select(indices, 0) 
    252              
    253             for ex in test: 
    254                 if classifier(ex, orange.GetValue) != classifier_clone(ex, orange.GetValue): 
    255                     print classifier(ex, orange.GetBoth) , classifier_clone(ex, orange.GetBoth) 
    256                     print classifier(ex, orange.GetValue) , classifier_clone(ex, orange.GetValue) 
    257                 self.assertEqual(classifier(ex, orange.GetValue), classifier_clone(ex, orange.GetValue), "Pickled and original classifier return a different value!") 
    258             self.assertTrue(all(classifier(ex, orange.GetValue) == classifier_clone(ex, orange.GetValue) for ex in test)) 
    259              
    260     def shortDescription(self): 
    261         """ Do some magic for prettier output on test failures. 
    262         """ 
    263         doc = self._testMethodDoc or self._testMethodName 
    264         return doc.format(LEARNER=getattr(self, "learner", self.LEARNER),  
    265                           NAME=getattr(self.LEARNER, "name", ""), 
    266                           DATANAME=self._testMethodName.split("_on_", 1)[-1]) 
    267  
    268  
    269 class TestMeasureAttribute(BaseTestOnData): 
     395    @test_on_data 
     396    def test_pickling_on(self, dataset): 
     397        """ Test learner and classifier pickling. 
     398        """ 
     399        classifier = self.learner(dataset) 
     400         
     401        import cPickle 
     402        s = cPickle.dumps(classifier) 
     403        classifier_clone = cPickle.loads(s) 
     404         
     405        indices = orange.MakeRandomIndices2(p0=20)(dataset) 
     406        test = dataset.select(indices, 0) 
     407         
     408        for ex in test: 
     409            if classifier(ex, orange.GetValue) != classifier_clone(ex, orange.GetValue): 
     410                print classifier(ex, orange.GetBoth) , classifier_clone(ex, orange.GetBoth) 
     411                print classifier(ex, orange.GetValue) , classifier_clone(ex, orange.GetValue) 
     412            self.assertEqual(classifier(ex, orange.GetValue), classifier_clone(ex, orange.GetValue), "Pickled and original classifier return a different value!") 
     413        self.assertTrue(all(classifier(ex, orange.GetValue) == classifier_clone(ex, orange.GetValue) for ex in test)) 
     414 
     415 
     416class MeasureAttributeTestCase(DataTestCase): 
    270417    """ Test orange MeasureAttribute subclass. 
    271418     
     
    274421        `thresholdFunction`. 
    275422    """ 
    276     FLAGS = TEST_ALL_CLASSIFICATION 
    277423    MEASURE = None 
    278424    """ MEASURE must be defined in the subclass 
     
    281427    @test_on_data 
    282428    def test_measure_attribute_on(self, data): 
    283         """ Test {MEASURE!r} on {DATANAME} 
     429        """ Default test for attribute measures. 
    284430        """ 
    285431        scores = [] 
    286432        for attr in data.domain.attributes: 
    287433            score = self.MEASURE(attr, data) 
    288             self.assertTrue(score >= 0.0) # Can some scores be negative? 
     434#            self.assertTrue(score >= 0.0) 
    289435            scores.append(score) 
    290436        # any scores actually non zero 
     
    293439         
    294440    def test_pickle(self): 
    295         """ Test {MEASURE!r} pickling 
    296         """ 
    297         if self.FLAGS & TEST_PICKLE: 
    298             import cPickle 
    299             s = cPickle.dumps(self.MEASURE) 
    300             measure = cPickle.loads(s) 
    301             # TODO: make sure measure computes the same scores as measure 
    302      
    303     def shortDescription(self): 
    304         doc = self._testMethodDoc or self._testMethodName 
    305         return doc.format(MEASURE=self.MEASURE, DATANAME=self._testMethodName.split("_on_", 1)[-1]) 
     441        """ Test attribute measure pickling support. 
     442        """ 
     443        import cPickle 
     444        s = cPickle.dumps(self.MEASURE) 
     445        measure = cPickle.loads(s) 
     446        # TODO: make sure measure computes the same scores as measure 
    306447          
    307448 
    308 class TestPreprocessor(BaseTestOnData): 
     449class PreprocessorTestCase(DataTestCase): 
    309450    """ Test orange.Preprocessor subclass 
    310451     
     
    314455    @test_on_data 
    315456    def test_preprocessor_on(self, dataset): 
    316         """ Test {PREPROCESSOR!r} on data {NAME} 
     457        """ Test preprocessor on dataset  
    317458        """ 
    318459        newdata = self.PREPROCESSOR(dataset) 
    319460         
    320461    def test_pickle(self): 
    321         """ Test {PREPROCESSOR!r} pickling 
    322         """ 
    323         if self.FLAGS & TEST_PICKLE: 
    324             if isinstance(self.PREPROCESSOR, type): 
    325                 prep = self.PREPROCESSOR() # Test the default constructed 
    326                 s = cPickle.dumps(prep) 
    327                 prep = cPickle.loads(s) 
     462        """ Test preprocessor pickling 
     463        """ 
     464        if isinstance(self.PREPROCESSOR, type): 
     465            prep = self.PREPROCESSOR() # Test the default constructed 
     466            s = cPickle.dumps(prep) 
     467            prep = cPickle.loads(s) 
    328468                 
    329             s = cPickle.dumps(self.PREPROCESSOR) 
    330             prep = cPickle.loads(s) 
    331             data = iter(self.datasets()).next() 
    332             prep(data) 
    333              
    334     def shortDescription(self): 
    335         doc = self._testMethodDoc or self._testMethodName 
    336         return doc.format(PREPROCESSOR=self.PREPROCESSOR, NAME=self._testMethodName.split("_on_", 1)[-1]) 
    337              
     469        s = cPickle.dumps(self.PREPROCESSOR) 
     470        prep = cPickle.loads(s) 
     471         
    338472             
    339473def test_case_script(path): 
     
    374508    raised exception during the test for interactive debugging. 
    375509     
    376     For example you can examine excaptions in tests from ipython -pdb :: 
     510    For example you can examine exceptions in tests from ipython -pdb :: 
    377511     
    378512        In [1]: import Orange.misc.testing as testing 
     
    397531                testMethod() 
    398532                result.addSuccess(self) 
    399             except self.failureException: 
    400                 result.addFailure(self, self._exc_info()) 
     533#            except self.failureException: 
     534#                result.addFailure(self, self._exc_info()) 
    401535            except KeyboardInterrupt: 
    402536                raise 
     
    417551try: 
    418552    __IPYTHON__  #We are running tests from ipython 
    419     if __IPYTHON__.shell.call_pdb: # Is pdb enabled 
     553    if getattr(__IPYTHON__.shell, "call_pdb", None): # Is pdb enabled 
    420554        enable_pdb() 
    421555except NameError: 
  • orange/Orange/network/network.py

    r8042 r8378  
    5858import numpy 
    5959import networkx as nx 
    60  
    6160import Orange 
    6261import orangeom 
    63  
    6462import readwrite 
    65  
    6663from networkx import algorithms  
    6764from networkx.classes import function 
    68  
    6965 
    7066class MdsTypeClass(): 
     
    7571 
    7672MdsType = MdsTypeClass() 
    77  
    7873 
    7974def _get_doc(doc): 
     
    202197     
    203198    def __init__(self, data=None, name='', **attr):   
    204         nx.Graph.__init__(self, data, name, **attr) 
     199        nx.Graph.__init__(self, data, name=name, **attr) 
    205200        BaseGraph.__init__(self) 
     201     
     202    def subgraph(self, nbunch): 
     203        G = nx.Graph.subgraph(self, nbunch) 
     204        nodes = set(nbunch).intersection(self.nodes()) 
     205         
     206        return G 
     207        # TODO: _items, _links 
    206208     
    207209    __doc__ += _get_doc(nx.Graph.__doc__) 
     
    216218     
    217219    def __init__(self, data=None, name='', **attr): 
    218         nx.DiGraph.__init__(self, data, name, **attr) 
     220        nx.DiGraph.__init__(self, data, name=name, **attr) 
    219221        BaseGraph.__init__(self) 
    220222     
     
    230232     
    231233    def __init__(self, data=None, name='', **attr): 
    232         nx.MultiGraph.__init__(self, data, name, **attr) 
     234        nx.MultiGraph.__init__(self, data, name=name, **attr) 
    233235        BaseGraph.__init__(self) 
    234236     
     
    244246     
    245247    def __init__(self, data=None, name='', **attr): 
    246         nx.MultiDiGraph.__init__(self, data, name, **attr) 
     248        nx.MultiDiGraph.__init__(self, data, name=name, **attr) 
    247249        BaseGraph.__init__(self) 
    248250     
     
    881883    ########################################################################## 
    882884     
    883      
    884      
    885      
     885    def map_to_graph(self, graph): 
     886        nodes = sorted(graph.nodes()) 
     887        return dict((v, (self.coors[0][i], self.coors[1][i])) for i,v in \ 
     888                    enumerate(nodes)) 
     889     
     890class NxView(object): 
     891    """Network View 
     892     
     893    """ 
     894     
     895    def __init__(self, **attr): 
     896        self._network = None 
     897        self._nx_explorer = None 
     898         
     899    def set_nx_explorer(self, _nx_explorer): 
     900        self._nx_explorer = _nx_explorer 
     901         
     902    def init_network(self, graph): 
     903        return graph 
     904         
     905    def nodes_selected(self): 
     906        pass 
  • orange/Orange/preprocess/__init__.py

    r8342 r8378  
    11""" 
    2 .. automodule:: Orange.preprocess.outliers 
     2.. autoclass:: Preprocessor_discretizeEntropy 
     3 
     4.. autoclass:: Preprocessor_removeContinuous 
     5 
     6.. autoclass:: Preprocessor_continuize 
     7 
     8.. autoclass:: Preprocessor_removeDiscrete 
     9 
     10.. autoclass:: Preprocessor_impute 
     11 
     12.. autoclass:: Preprocessor_featureSelection 
     13 
     14.. autofunction:: bestP 
     15 
     16.. autofunction:: bestN 
     17 
     18.. autofunction:: selectNRandom 
     19 
     20.. autofunction:: selectPRandom 
     21 
     22.. autoclass:: Preprocessor_RFE 
     23 
     24.. autoclass:: Preprocessor_sample 
     25 
     26.. autoclass:: Preprocessor_preprocessorList 
     27 
    328""" 
    429 
  • orange/Orange/preprocess/outliers.py

    r7780 r8378  
    11""" 
    2 ================= 
    3 Outlier detection 
    4 ================= 
     2.. index:: outlier detection 
     3 
     4.. index:: 
     5   single: outlier; detection 
     6 
     7******************************** 
     8Outlier detection (``outliers``) 
     9******************************** 
    510 
    611.. autoclass:: OutlierDetection 
     
    1217.. _outliers2.py: code/outlier2.py 
    1318 
    14 The following example prints a list of Z-values of examples in bridges dataset (`outliers1.py`_). 
     19The following example prints a list of Z-values of examples in bridges dataset 
     20(`outliers1.py`_). 
    1521 
    1622.. literalinclude:: code/outlier1.py 
    1723 
    18 The following example prints 5 examples with highest Z-scores. Euclidian distance is used as a distance measurement and average distance is calculated over 3 nearest neighbours (`outliers2.py`_). 
     24The following example prints 5 examples with highest Z-scores. Euclidean 
     25distance is used as a distance measurement and average distance is calculated 
     26over 3 nearest neighbours (`outliers2.py`_). 
    1927 
    2028.. literalinclude:: code/outlier2.py 
     
    6876        self.examples = examples 
    6977        if (distance == None): 
    70           distance = Orange.distances.ManhattanConstructor(self.examples) 
     78          distance = Orange.distance.instances.ManhattanConstructor(self.examples) 
    7179        self.distance = distance 
    7280 
     
    8189    def set_knn(self, knn=0): 
    8290        """ 
    83         Set the number of nearest neighbours considered in determinating outliers. 
     91        Set the number of nearest neighbours considered in determinating. 
    8492        """ 
    8593        self.knn = knn 
    8694   
    8795    def _calc_distance_matrix(self): 
    88         #other distance measures 
     96        """ 
     97        other distance measures 
     98        """ 
    8999        self.distmatrix = Orange.core.SymMatrix(len(self.examples)) #FIXME  
    90100        for i in range(len(self.examples)): 
    91101            for j in range(i+1): 
    92                 self.distmatrix[i, j] = self.distance(self.examples[i], self.examples[j]) 
     102                self.distmatrix[i, j] = self.distance(self.examples[i], 
     103                                                      self.examples[j]) 
    93104        self.distmatrixC = 1 
    94105       
    95106    def distance_matrix(self): 
    96         """ Return the distance matrix of the dataset.""" 
     107        """ 
     108        Return the distance matrix of the dataset. 
     109        """ 
    97110        if (self.distmatrixC == 0):  
    98111            self._calc_distance_matrix() 
  • orange/Orange/statistics/distribution.py

    r8264 r8378  
    1515        >>> import Orange 
    1616        >>> data = Orange.data.Table("adult_sample") 
    17     >>> disc = orange.statistics.distribution.Distribution("workclass", data) 
    18     >>> print disc 
    19     <685.000, 72.000, 28.000, 29.000, 59.000, 43.000, 2.000> 
    20     >> print type(disc) 
    21     <type 'DiscDistribution'> 
     17        >>> disc = orange.statistics.distribution.Distribution("workclass", data) 
     18        >>> print disc 
     19        <685.000, 72.000, 28.000, 29.000, 59.000, 43.000, 2.000> 
     20        >>> print type(disc) 
     21        <type 'DiscDistribution'> 
    2222 
    2323    The resulting distribution is of type :obj:`DiscDistribution` since variable 
     
    2525    attribute value. :: 
    2626 
    27         >>> workclass = data.domain["workclass"] 
    28     >>> for i in range(len(workclass.values)): 
    29     ... print "%20s: %5.3f" % (workclass.values[i], disc[i]) 
     27        >>> workclass = data.domain["workclass"] 
     28        >>> for i in range(len(workclass.values)): 
     29        ...    print "%20s: %5.3f" % (workclass.values[i], disc[i]) 
    3030                 Private: 685.000 
    3131        Self-emp-not-inc: 72.000 
     
    9797        meta-attribute with weights can be passed as the third argument. 
    9898 
    99     If variable is given by descriptor, it doesn't need to exist in the 
    100     domain, but it must be computable from given instances. For example, the 
    101     variable can be a discretized version of a variable from data. 
     99        If variable is given by descriptor, it doesn't need to exist in the 
     100        domain, but it must be computable from given instances. For example, the 
     101        variable can be a discretized version of a variable from data. 
    102102 
    103103    .. method:: keys() 
     
    168168 
    169169        Construct an instance and initialize the frequencies from the list, but 
    170     leave `Distribution.variable` empty. 
     170        leave `Distribution.variable` empty. 
    171171 
    172172        :param frequencies: A list of frequencies 
     
    174174 
    175175        Distribution constructed in this way can be used, for instance, to 
    176     generate random numbers from a given discrete distribution:: 
    177  
    178             disc = Orange.statistics.distributions.Discrete([0.5, 0.3, 0.2]) 
     176        generate random numbers from a given discrete distribution:: 
     177 
     178            disc = Orange.statistics.distribution.Discrete([0.5, 0.3, 0.2]) 
    179179            for i in range(20): 
    180180                print disc.random(), 
    181181 
    182182        This prints out approximatelly ten 0's, six 1's and four 2's. The values 
    183     can be named by assigning a variable:: 
     183        can be named by assigning a variable:: 
    184184 
    185185            v = orange.EnumVariable(values = ["red", "green", "blue"]) 
     
    249249 
    250250        For example, if `d_age` is a continuous distribution, the quartiles can 
    251     be printed by :: 
     251        be printed by :: 
    252252 
    253253            print "Quartiles: %5.3f - %5.3f - %5.3f" % (  
     
    257257 
    258258        Return the probability density at `x`. If the value is not in 
    259     :obj:`Distribution.keys`, it is interpolated. 
     259        :obj:`Distribution.keys`, it is interpolated. 
    260260 
    261261 
     
    291291        Construct a distribution which approximates the given distribution, 
    292292        which must be either :obj:`Continuous`, in which case its 
    293     average and deviation will be used for mean and sigma, or and existing 
     293        average and deviation will be used for mean and sigma, or and existing 
    294294        :obj:`GaussianDistribution`, which will be copied. Attribute :obj:`abs` 
    295295        is set to the given distribution's ``abs``. 
     
    310310 
    311311        Return the density at point ``x``, that is, the Gaussian distribution 
    312     density multiplied by :obj:`abs`. 
     312        density multiplied by :obj:`abs`. 
    313313 
    314314 
     
    351351prints out distributions for discrete and averages for continuous attributes. :: 
    352352 
    353     dist = Orange.statistics.distributions.Domain(data) 
     353    dist = Orange.statistics.distribution.Domain(data) 
    354354 
    355355        for d in dist: 
    356         if d.variable.varType == orange.VarTypes.Discrete: 
     356            if d.variable.varType == orange.VarTypes.Discrete: 
    357357                 print "%30s: %s" % (d.variable.name, d) 
    358         else: 
     358            else: 
    359359                 print "%30s: avg. %5.3f" % (d.variable.name, d.average()) 
    360360 
  • orange/OrangeCanvas/orngDoc.py

    r8042 r8052  
    639639        n = "\n" 
    640640 
    641         start = """#This file is automatically created by Orange Canvas and containing an Orange schema 
     641        start = """#!/usr/bin/env python 
     642 
     643#This file is automatically created by Orange Canvas and containing an Orange schema 
    642644 
    643645import orngEnviron 
  • orange/OrangeWidgets/Unsupervised/OWNxCanvas.py

    r8042 r8378  
    1515from orngScaleScatterPlotData import * 
    1616 
    17 class NetworkVertex(): 
     17class NodeItem(): 
    1818    def __init__(self, index=-1): 
    1919        self.index = index 
     
    3434        self.style = 1 
    3535     
    36 class NetworkEdge(): 
     36class EdgeItem(): 
    3737    def __init__(self, u=None, v=None, weight=0, arrowu=0, arrowv=0,  
    3838                 links_index=None, label=[]): 
     
    5252      QwtPlotCurve.__init__(self, "Network Curve") 
    5353 
    54       self.coors = None 
    55       self.vertices = [] 
     54      self.coors = {} 
     55      self.vertices = {} 
    5656      self.edges = [] 
    5757      self.setItemAttribute(QwtPlotItem.Legend, 0) 
    5858      self.showEdgeLabels = 0 
    5959 
    60   def moveSelectedVertices(self, dx, dy): 
    61     selected = self.getSelectedVertices() 
     60  def move_selected_nodes(self, dx, dy): 
     61    selected = self.get_selected_nodes() 
    6262     
    6363    self.coors[0][selected] = self.coors[0][selected] + dx 
     
    6767    return selected 
    6868   
    69   def setVertexColor(self, v, color): 
     69  def set_node_color(self, v, color): 
    7070      pen = self.vertices[v].pen 
    7171      self.vertices[v].color = color 
    7272      self.vertices[v].pen = QPen(color, pen.width()) 
     73 
     74  def set_nodes_color(self, vertices, color): 
     75      for v in vertices: 
     76          v.color = color 
     77          v.pen = QPen(color, v.pen.width()) 
    7378       
    74   def setEdgeColor(self, index, color, nocolor=0): 
     79  def set_edge_color(self, index, color, nocolor=0): 
    7580      pen = self.edges[index].pen 
    7681      if nocolor: 
     
    7984      self.edges[index].pen.setCapStyle(Qt.RoundCap) 
    8085   
    81   def getSelectedVertices(self): 
    82     return [vertex.index for vertex in self.vertices if vertex.selected] 
    83  
    84   def getUnselectedVertices(self): 
    85     return [vertex.index for vertex in self.vertices if not vertex.selected] 
    86  
    87   def getMarkedVertices(self): 
    88     return [vertex.index for vertex in self.vertices if vertex.marked] 
     86  def get_selected_nodes(self): 
     87    return [vertex.index for vertex in self.vertices.itervalues() if vertex.selected] 
     88 
     89  def get_unselected_nodes(self): 
     90    return [vertex.index for vertex in self.vertices.itervalues() if not vertex.selected] 
     91 
     92  def get_marked_nodes(self): 
     93    return [vertex.index for vertex in self.vertices.itervalues() if vertex.marked] 
    8994   
    90   def setMarkedVertices(self, vertices): 
    91     for vertex in self.vertices: 
     95  def set_marked_nodes(self, vertices): 
     96    for vertex in self.vertices.itervalues(): 
    9297      if vertex.index in vertices: 
    9398        vertex.marked = True 
     
    95100        vertex.marked = False 
    96101         
    97   def markToSel(self): 
    98     for vertex in self.vertices: 
     102  def mark_to_sel(self): 
     103    for vertex in self.vertices.itervalues(): 
    99104      if vertex.marked == True: 
    100105          vertex.selected = True 
    101106           
    102   def selToMark(self): 
    103     for vertex in self.vertices: 
     107  def sel_to_mark(self): 
     108    for vertex in self.vertices.itervalues(): 
    104109      if vertex.selected == True: 
    105110          vertex.selected = False 
    106111          vertex.marked = True 
    107112   
    108   def unMark(self): 
    109     for vertex in self.vertices: 
     113  def unmark(self): 
     114    for vertex in self.vertices.itervalues(): 
    110115      vertex.marked = False 
    111116       
    112   def unSelect(self): 
    113     for vertex in self.vertices: 
     117  def unselect(self): 
     118    for vertex in self.vertices.itervalues(): 
    114119        vertex.selected = False 
    115120         
    116   def setHiddenVertices(self, nodes): 
    117     for vertex in self.vertices: 
     121  def set_hidden_nodes(self, nodes): 
     122    for vertex in self.vertices.itervalues(): 
    118123      if vertex.index in nodes: 
    119124        vertex.show = False 
     
    121126        vertex.show = True 
    122127       
    123   def hideSelectedVertices(self): 
    124     for vertex in self.vertices: 
     128  def hide_selected_nodes(self): 
     129    for vertex in self.vertices.itervalues(): 
    125130      if vertex.selected: 
    126131        vertex.show = False 
    127132   
    128   def hideUnSelectedVertices(self): 
    129     for vertex in self.vertices: 
     133  def hide_unselected_nodes(self): 
     134    for vertex in self.vertices.itervalues(): 
    130135      if not vertex.selected: 
    131136        vertex.show = False 
    132137     
    133   def showAllVertices(self): 
    134     for vertex in self.vertices: 
     138  def show_all_vertices(self): 
     139    for vertex in self.vertices.itervalues(): 
    135140      vertex.show = True 
    136141     
     
    143148        painter.setPen(edge.pen) 
    144149 
    145         px1 = xMap.transform(self.coors[0][edge.u.index])   #ali pa tudi self.x1, itd 
    146         py1 = yMap.transform(self.coors[1][edge.u.index]) 
    147         px2 = xMap.transform(self.coors[0][edge.v.index]) 
    148         py2 = yMap.transform(self.coors[1][edge.v.index]) 
     150        px1 = xMap.transform(self.coors[edge.u.index][0])   #ali pa tudi self.x1, itd 
     151        py1 = yMap.transform(self.coors[edge.u.index][1]) 
     152        px2 = xMap.transform(self.coors[edge.v.index][0]) 
     153        py2 = yMap.transform(self.coors[edge.v.index][1]) 
    149154         
    150155        painter.drawLine(px1, py1, px2, py2) 
     
    185190            painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl) 
    186191     
    187     for vertex in self.vertices: 
     192    for key, vertex in self.vertices.iteritems(): 
    188193      if vertex.show: 
    189         pX = xMap.transform(self.coors[0][vertex.index])   #dobimo koordinati v pikslih (tipa integer) 
    190         pY = yMap.transform(self.coors[1][vertex.index])   #ki se stejeta od zgornjega levega kota canvasa 
     194        pX = xMap.transform(self.coors[vertex.index][0])   #dobimo koordinati v pikslih (tipa integer) 
     195        pY = yMap.transform(self.coors[vertex.index][1])   #ki se stejeta od zgornjega levega kota canvasa 
    191196        if vertex.selected:     
    192197          painter.setPen(QPen(Qt.yellow, 3)) 
     
    205210          painter.drawEllipse(rect) 
    206211         
     212  def closest_node(self, px, py): 
     213    ndx = min(self.coors, key=lambda x: abs(self.coors[x][0]-px) + abs(self.coors[x][1]-py)) 
     214    return ndx, math.sqrt((self.coors[ndx][0]-px)**2 + (self.coors[ndx][0]-px)**2) 
     215 
     216  def get_nodes_in_rect(self, x1, y1, x2, y2): 
     217      if x1 > x2: 
     218          x1, x2 = x2, x1 
     219      if y1 > y2: 
     220          y1, y2 = y2, y1 
     221      return [key for key in self.coors if x1 < self.coors[key][0] < x2 and y1 < self.coors[key][1] < y2] 
     222         
    207223class OWNxCanvas(OWGraph): 
    208224    def __init__(self, master, parent=None, name="None"): 
     
    212228        self.labelText = [] 
    213229        self.tooltipText = [] 
    214         self.vertices_old = {}         # distionary of nodes (orngIndex: vertex_objekt) 
    215         self.edges_old = {}            # distionary of edges (curveKey: edge_objekt) 
    216         self.vertices = [] 
    217         self.edges = [] 
     230        #self.vertices_old = {}         # distionary of nodes (orngIndex: vertex_objekt) 
     231        #self.edges_old = {}            # distionary of edges (curveKey: edge_objekt) 
     232        #self.vertices = [] 
     233        #self.edges = [] 
    218234        self.indexPairs = {}       # distionary of type CurveKey: orngIndex   (for nodes) 
    219235        #self.selection = []        # list of selected nodes (indices) 
     
    274290        self.controlPressed = False 
    275291        self.altPressed = False 
     292        self.items = None 
     293        self.links = None 
    276294         
    277295        self.setFocusPolicy(Qt.StrongFocus) 
    278296         
    279297    def getSelection(self): 
    280       return self.networkCurve.getSelectedVertices() 
    281      
    282     def getMarkedVertices(self): 
    283       return self.networkCurve.getMarkedVertices() 
     298      return self.networkCurve.get_selected_nodes() 
     299     
     300    def get_marked_nodes(self): 
     301      return self.networkCurve.get_marked_nodes() 
    284302         
    285303    def getVertexSize(self, index): 
    286304        return 6 
    287305         
    288     def setHiddenVertices(self, nodes): 
    289         self.networkCurve.setHiddenVertices(nodes) 
    290      
    291     def hideSelectedVertices(self): 
    292       self.networkCurve.hideSelectedVertices() 
     306    def set_hidden_nodes(self, nodes): 
     307        self.networkCurve.set_hidden_nodes(nodes) 
     308     
     309    def hide_selected_nodes(self): 
     310      self.networkCurve.hide_selected_nodes() 
    293311      self.drawPlotItems() 
    294312       
    295     def hideUnSelectedVertices(self): 
    296       self.networkCurve.hideUnSelectedVertices() 
     313    def hide_unselected_nodes(self): 
     314      self.networkCurve.hide_unselected_nodes() 
    297315      self.drawPlotItems() 
    298316       
    299     def showAllVertices(self): 
    300       self.networkCurve.showAllVertices() 
     317    def show_all_vertices(self): 
     318      self.networkCurve.show_all_vertices() 
    301319      self.drawPlotItems() 
    302320       
     
    329347                 
    330348    def markedToSelection(self): 
    331         self.networkCurve.markToSel() 
     349        self.networkCurve.mark_to_sel() 
    332350        self.drawPlotItems() 
    333351         
    334352    def selectionToMarked(self): 
    335         self.networkCurve.selToMark() 
     353        self.networkCurve.sel_to_mark() 
    336354        self.drawPlotItems() 
    337355         
    338356        if self.sendMarkedNodes != None: 
    339             self.sendMarkedNodes(self.networkCurve.getMarkedVertices()) 
     357            self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    340358         
    341359    def removeSelection(self, replot=True): 
    342         self.networkCurve.unSelect() 
     360        self.networkCurve.unselect() 
    343361         
    344362        if replot: 
     
    356374         
    357375    def getSelectedExamples(self): 
    358         selection = self.networkCurve.getSelectedVertices() 
    359          
    360         if len(selection) == 0: 
    361             return None 
    362          
    363         if self.graph.items() is not None: 
    364             return self.graph.items().getitems(selection) 
    365         else: 
    366             return None 
     376        return self.networkCurve.get_selected_nodes() 
    367377         
    368378    def getUnselectedExamples(self): 
    369         unselection = self.networkCurve.getUnselectedVertices() 
    370          
    371         if len(unselection) == 0: 
    372             return None 
    373          
    374         if self.graph.items() is not None: 
    375             return self.graph.items().getitems(unselection) 
    376         else: 
    377             return None 
     379        return self.networkCurve.get_unselected_nodes() 
    378380     
    379381    def getSelectedGraph(self): 
    380       selection = self.networkCurve.getSelectedVertices() 
     382      selection = self.networkCurve.get_selected_nodes() 
    381383       
    382384      if len(selection) == 0: 
     
    387389      return subnet 
    388390     
    389     def getSelectedVertices(self): 
    390       return self.networkCurve.getSelectedVertices() 
     391    def get_selected_nodes(self): 
     392      return self.networkCurve.get_selected_nodes() 
    391393     
    392394    def getNeighboursUpTo(self, ndx, dist): 
     
    403405        if not self.freezeNeighbours and self.selectionNeighbours: 
    404406            toMark = set() 
    405             for ndx in self.networkCurve.getSelectedVertices(): 
     407            for ndx in self.networkCurve.get_selected_nodes(): 
    406408                toMark |= self.getNeighboursUpTo(ndx, self.selectionNeighbours) 
    407409             
    408             self.networkCurve.setMarkedVertices(toMark) 
     410            self.networkCurve.set_marked_nodes(toMark) 
    409411            self.drawPlotItems() 
    410412                 
    411413        elif not self.freezeNeighbours and self.selectionNeighbours == 0: 
    412             self.networkCurve.setMarkedVertices(self.networkCurve.getSelectedVertices()) 
     414            self.networkCurve.set_marked_nodes(self.networkCurve.get_selected_nodes()) 
    413415            self.drawPlotItems() 
    414416             
    415417        if self.sendMarkedNodes != None: 
    416             self.sendMarkedNodes(self.networkCurve.getMarkedVertices()) 
    417                  
    418     def unMark(self): 
    419       self.networkCurve.unMark() 
     418            self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
     419                 
     420    def unmark(self): 
     421      self.networkCurve.unmark() 
    420422      self.drawPlotItems(replot=0) 
    421423       
     
    423425            self.sendMarkedNodes([]) 
    424426             
    425     def setMarkedVertices(self, vertices): 
    426       self.networkCurve.setMarkedVertices(vertices) 
     427    def set_marked_nodes(self, vertices): 
     428      self.networkCurve.set_marked_nodes(vertices) 
    427429      self.drawPlotItems(replot=0) 
    428430       
    429431      if self.sendMarkedNodes != None: 
    430             self.sendMarkedNodes(self.networkCurve.getMarkedVertices()) 
     432            self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    431433         
    432434    def activateMoveSelection(self): 
     
    443445            dx = newX - self.invTransform(2, self.GMmouseMoveEvent.x()) 
    444446            dy = newY - self.invTransform(0, self.GMmouseMoveEvent.y()) 
    445             movedVertices = self.networkCurve.moveSelectedVertices(dx, dy) 
     447            movedVertices = self.networkCurve.move_selected_nodes(dx, dy) 
    446448             
    447449            self.GMmouseMoveEvent.setX(event.pos().x())  #zacetni dogodek postane trenutni 
     
    457459            px = self.invTransform(2, event.x()) 
    458460            py = self.invTransform(0, event.y())    
    459             ndx, mind = self.layout.closest_vertex(px, py) 
    460             dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - event.x() 
    461             dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - event.y() 
     461            ndx, mind = self.networkCurve.closest_node(px, py) 
     462            dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - event.x() 
     463            dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - event.y() 
    462464            # transform to pixel distance 
    463465            distance = math.sqrt(dX**2 + dY**2)  
    464466               
    465             if ndx != -1 and distance <= self.vertices[ndx].size / 2: 
     467            if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    466468                toMark = set(self.getNeighboursUpTo(ndx, self.tooltipNeighbours)) 
    467                 self.networkCurve.setMarkedVertices(toMark) 
     469                self.networkCurve.set_marked_nodes(toMark) 
    468470                self.drawPlotItems() 
    469471                 
    470472                if self.sendMarkedNodes != None: 
    471                     self.sendMarkedNodes(self.networkCurve.getMarkedVertices()) 
     473                    self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    472474            else: 
    473                 self.networkCurve.unMark() 
     475                self.networkCurve.unmark() 
    474476                self.drawPlotItems() 
    475477                 
     
    478480         
    479481        if self.showDistances: 
    480             selection = self.networkCurve.getSelectedVertices() 
     482            selection = self.networkCurve.get_selected_nodes() 
    481483            if len(selection) > 0: 
    482484                px = self.invTransform(2, event.x()) 
    483485                py = self.invTransform(0, event.y())   
    484486                  
    485                 v, mind = self.layout.closest_vertex(px, py) 
    486                 dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][v]) - event.x() 
    487                 dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][v]) - event.y() 
     487                v, mind = self.networkCurve.closest_node(px, py) 
     488                dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[v][0]) - event.x() 
     489                dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[v][1]) - event.y() 
    488490                # transform to pixel distance 
    489491                distance = math.sqrt(dX**2 + dY**2)                
    490                 if v != -1 and distance <= self.vertices[v].size / 2: 
     492                if v != -1 and distance <= self.networkCurve.vertices[v].size: 
    491493                    if self.items_matrix == None: 
    492494                        dst = 'vertex distance signal not set' 
     
    557559            elif self.mouseSelectedVertex == 0: 
    558560                  
    559                 selection = self.layout.get_vertices_in_rect(x1, y1, x2, y2) 
     561                selection = self.networkCurve.get_nodes_in_rect(x1, y1, x2, y2) 
    560562     
    561563                def selectVertex(ndx): 
    562                     if self.vertices[ndx].show: 
    563                         self.vertices[ndx].selected = True 
     564                    if self.networkCurve.vertices[ndx].show: 
     565                        self.networkCurve.vertices[ndx].selected = True 
    564566                         
    565567                map(selectVertex, selection) 
     
    567569                if len(selection) == 0 and x1 == x2 and y1 == y2: 
    568570                    self.removeSelection() 
    569                     self.unMark() 
     571                    self.unmark() 
    570572             
    571573                self.markSelectionNeighbours() 
     
    591593           
    592594        if e.key() == 87 or e.key() == 81: 
    593             selection = [v.index for v in self.vertices if v.selected] 
     595            selection = [v.index for v in self.networkCurve.vertices.itervalues() if v.selected] 
    594596            if len(selection) > 0: 
    595597                phi = [math.pi / -180 if e.key() == 87 else math.pi / 180] 
     
    617619        OWGraph.keyReleaseEvent(self, e) 
    618620         
    619      
    620621    def clickedSelectedOnVertex(self, pos): 
    621622        min = 1000000 
     
    625626        py = self.invTransform(0, pos.y())    
    626627     
    627         ndx, min = self.layout.closest_vertex(px, py) 
    628         dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - pos.x() 
    629         dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - pos.y() 
     628        ndx, min = self.networkCurve.closest_node(px, py) 
     629        dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
     630        dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    630631        # transform to pixel distance 
    631632        distance = math.sqrt(dX**2 + dY**2) 
    632         if ndx != -1 and distance <= self.vertices[ndx].size / 2: 
    633             return self.vertices[ndx].selected 
     633         
     634        #self.networkCurve 
     635         
     636        if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
     637            return self.networkCurve.vertices[ndx].selected 
    634638        else: 
    635639            return False 
     
    642646        py = self.invTransform(0, pos.y())    
    643647     
    644         ndx, min = self.layout.closest_vertex(px, py) 
    645         dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - pos.x() 
    646         dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - pos.y() 
     648        ndx, min = self.networkCurve.closest_node(px, py) 
     649        dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
     650        dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    647651        # transform to pixel distance 
    648652        distance = math.sqrt(dX**2 + dY**2) 
    649         if ndx != -1 and distance <= self.vertices[ndx].size / 2: 
     653        if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    650654            return True 
    651655        else: 
     
    659663        py = self.invTransform(0, pos.y())    
    660664     
    661         ndx, min = self.layout.closest_vertex(px, py) 
    662          
    663         dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - pos.x() 
    664         dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - pos.y() 
     665        ndx, min = self.networkCurve.closest_node(px, py) 
     666         
     667        dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
     668        dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    665669        # transform to pixel distance 
    666670        distance = math.sqrt(dX**2 + dY**2) 
    667         if ndx != -1 and distance <= self.vertices[ndx].size / 2: 
     671        if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    668672            if not self.appendToSelection and not self.controlPressed: 
    669673                self.removeSelection() 
    670674                       
    671675            if self.insideview: 
    672                 self.networkCurve.unSelect() 
    673                 self.vertices[ndx].selected = not self.vertices[ndx].selected 
     676                self.networkCurve.unselect() 
     677                self.networkCurve.vertices[ndx].selected = not self.networkCurve.vertices[ndx].selected 
    674678                self.optimize(100) 
    675679                 
    676680                self.markSelectionNeighbours() 
    677681            else: 
    678                 self.vertices[ndx].selected = not self.vertices[ndx].selected 
     682                self.networkCurve.vertices[ndx].selected = not self.networkCurve.vertices[ndx].selected 
    679683                self.markSelectionNeighbours() 
    680684             
     
    683687            return False 
    684688            self.removeSelection() 
    685             self.unMark() 
     689            self.unmark() 
    686690     
    687691    def updateData(self): 
     
    721725    #          edges = [(ind / matrix.dim, ind % matrix.dim) for v, ind in vals] 
    722726    #          print "number of component edges:", len(edges), "number of components:", len(components) 
    723             components_c = [(sum(self.layout.coors[0][c]) / len(c), sum(self.layout.coors[1][c]) / len(c)) for c in components] 
     727            components_c = [(sum(self.networkCurve.coors[c][0]) / len(c), sum(self.networkCurve.coors[c][1]) / len(c)) for c in components] 
    724728            weights = [1 - matrix[u,v] for u,v in edges] 
    725729             
     
    734738                 
    735739                pen = QPen() 
    736                 pen.setWidth(w) 
     740                pen.setWidth(int(w)) 
    737741                pen.setBrush(QColor(50,200,255,15)) 
    738742                pen.setCapStyle(Qt.FlatCap) 
     
    744748         
    745749        if self.insideview == 1: 
    746             selection = self.networkCurve.getSelectedVertices() 
     750            selection = self.networkCurve.get_selected_nodes() 
    747751            if len(selection) >= 1: 
    748752                visible = set() 
    749753                visible |= set(selection) 
    750754                visible |= self.getNeighboursUpTo(selection[0], self.insideviewNeighbours) 
    751                 self.networkCurve.setHiddenVertices(set(range(self.graph.number_of_nodes())) - visible) 
     755                self.networkCurve.set_hidden_nodes(set(range(self.graph.number_of_nodes())) - visible) 
    752756     
    753757        edgesCount = 0 
     
    783787        if len(vertices) > 0: 
    784788            for vertex in vertices: 
    785                 x1 = float(self.layout.coors[0][vertex]) 
    786                 y1 = float(self.layout.coors[1][vertex]) 
     789                x1 = float(self.networkCurve.coors[vertex][0]) 
     790                y1 = float(self.networkCurve.coors[vertex][1]) 
    787791                 
    788792                if vertex in self.markerKeys: 
     
    813817            return 
    814818         
    815         if self.layout is None or self.graph is None or self.graph.items() is None: 
     819        if self.layout is None or self.graph is None or self.items is None: 
    816820            return 
    817821         
    818         if str(self.showComponentAttribute) not in self.graph.items().domain: 
     822        if str(self.showComponentAttribute) not in self.items.domain: 
    819823            self.showComponentAttribute = None 
    820824            return 
     
    826830                continue 
    827831             
    828             vertices = [vertex for vertex in component if self.vertices[vertex].show] 
     832            vertices = [vertex for vertex in component if self.networkCurve.vertices[vertex].show] 
    829833     
    830834            if len(vertices) == 0: 
    831835                continue 
    832836             
    833             xes = [self.layout.coors[0][vertex] for vertex in vertices]   
    834             yes = [self.layout.coors[1][vertex] for vertex in vertices]   
     837            xes = [self.networkCurve.coors[vertex][0] for vertex in vertices]   
     838            yes = [self.networkCurve.coors[vertex][1] for vertex in vertices]   
    835839                                   
    836840            x1 = sum(xes) / len(xes) 
    837841            y1 = sum(yes) / len(yes) 
    838842             
    839             lbl = str(self.graph.items()[component[0]][str(self.showComponentAttribute)]) 
     843            lbl = str(self.items[component[0]][str(self.showComponentAttribute)]) 
    840844             
    841845            mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignCenter, size=self.fontSize) 
     
    847851      self.tips.removeAll() 
    848852      if len(self.tooltipText) > 0: 
    849         for vertex in self.vertices: 
     853        for vertex in self.networkCurve.vertices.itervalues(): 
    850854          if not vertex.show: 
    851855            continue 
    852856           
    853           x1 = self.layout.coors[0][vertex.index] 
    854           y1 = self.layout.coors[1][vertex.index] 
     857          x1 = self.networkCurve.coors[vertex.index][0] 
     858          y1 = self.networkCurve.coors[vertex.index][1] 
    855859          lbl = "" 
    856           values = self.graph.items()[vertex.index] 
     860          values = self.items[vertex.index] 
    857861          for ndx in self.tooltipText: 
    858               if not ndx in self.graph.items().domain: 
     862              if not ndx in self.items.domain: 
    859863                  continue 
    860864               
     
    875879    def drawLabels(self): 
    876880        if len(self.labelText) > 0: 
    877             for vertex in self.vertices: 
     881            for vertex in self.networkCurve.vertices.itervalues(): 
    878882                if not vertex.show: 
    879883                    continue 
     
    882886                    continue 
    883887                                   
    884                 x1 = self.layout.coors[0][vertex.index] 
    885                 y1 = self.layout.coors[1][vertex.index] 
     888                x1 = self.networkCurve.coors[vertex.index][0] 
     889                y1 = self.networkCurve.coors[vertex.index][1] 
    886890                lbl = "" 
    887                 values = self.graph.items()[vertex.index] 
     891                values = self.items[vertex.index] 
    888892                if self.showMissingValues: 
    889893                    lbl = ", ".join([str(values[ndx]) for ndx in self.labelText]) 
     
    900904    def drawIndexes(self): 
    901905        if self.showIndexes: 
    902             for vertex in self.vertices: 
     906            for vertex in self.networkCurve.vertices.itervalues(): 
    903907                if not vertex.show: 
    904908                    continue 
     
    907911                    continue 
    908912                                   
    909                 x1 = self.layout.coors[0][vertex.index] 
    910                 y1 = self.layout.coors[1][vertex.index] 
     913                x1 = self.networkCurve.coors[vertex.index][0] 
     914                y1 = self.networkCurve.coors[vertex.index][1] 
    911915     
    912916                lbl = str(vertex.index) 
     
    923927                    continue 
    924928                                   
    925                 x1 = (self.layout.coors[0][edge.u.index] + self.layout.coors[0][edge.v.index]) / 2 
    926                 y1 = (self.layout.coors[1][edge.u.index] + self.layout.coors[1][edge.v.index]) / 2 
     929                x1 = (self.networkCurve.coors[edge.u.index][0] + self.networkCurve.coors[edge.v.index][0]) / 2 
     930                y1 = (self.networkCurve.coors[edge.u.index][1] + self.networkCurve.coors[edge.v.index][1]) / 2 
    927931                 
    928932                if edge.weight == None: 
     
    965969        return colorIndices, colorIndex, minValue, maxValue 
    966970     
    967     def setEdgeColor(self, attribute): 
     971    def set_edge_color(self, attribute): 
    968972        if self.graph is None: 
    969973            return 
    970974         
    971         colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.graph.links(), attribute, self.discEdgePalette) 
     975        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.links, attribute, self.discEdgePalette) 
    972976     
    973977        for index in range(len(self.networkCurve.edges)): 
     
    977981                    continue 
    978982                 
    979                 if self.graph.links().domain[colorIndex].varType == orange.VarTypes.Continuous: 
     983                if self.links.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    980984                    newColor = self.discEdgePalette[0] 
    981                     if str(self.graph.links()[links_index][colorIndex]) != "?": 
     985                    if str(self.links[links_index][colorIndex]) != "?": 
    982986                        if maxValue == minValue: 
    983987                            newColor = self.discEdgePalette[0] 
    984988                        else: 
    985                             value = (float(self.graph.links()[links_index][colorIndex].value) - minValue) / (maxValue - minValue) 
     989                            value = (float(self.links[links_index][colorIndex].value) - minValue) / (maxValue - minValue) 
    986990                            newColor = self.contEdgePalette[value] 
    987991                         
    988                     self.networkCurve.setEdgeColor(index, newColor) 
     992                    self.networkCurve.set_edge_color(index, newColor) 
    989993                     
    990                 elif self.graph.links().domain[colorIndex].varType == orange.VarTypes.Discrete: 
    991                     newColor = self.discEdgePalette[colorIndices[self.graph.links()[links_index][colorIndex].value]] 
    992                     if self.graph.links()[links_index][colorIndex].value == "0": 
    993                       self.networkCurve.setEdgeColor(index, newColor, nocolor=1) 
     994                elif self.links.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     995                    newColor = self.discEdgePalette[colorIndices[self.links[links_index][colorIndex].value]] 
     996                    if self.links[links_index][colorIndex].value == "0": 
     997                      self.networkCurve.set_edge_color(index, newColor, nocolor=1) 
    994998                    else: 
    995                       self.networkCurve.setEdgeColor(index, newColor) 
     999                      self.networkCurve.set_edge_color(index, newColor) 
    9961000                     
    9971001            else: 
    9981002                newColor = self.discEdgePalette[0] 
    999                 self.networkCurve.setEdgeColor(index, newColor) 
     1003                self.networkCurve.set_edge_color(index, newColor) 
    10001004         
    10011005        self.replot() 
    10021006     
    1003     def setVertexColor(self, attribute): 
     1007    def set_node_color(self, attribute, nodes=None): 
    10041008        if self.graph is None: 
    10051009            return 
    10061010         
    1007         colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.graph.items(), attribute, self.discPalette) 
    1008      
    1009         for v in range(self.graph.number_of_nodes()): 
    1010             if colorIndex != None:     
    1011                 if self.graph.items().domain[colorIndex].varType == orange.VarTypes.Continuous: 
    1012                     newColor = self.discPalette[0] 
     1011        if nodes is None: 
     1012            nodes = self.networkCurve.vertices.itervalues() 
     1013        else: 
     1014            nodes = (self.networkCurve.vertices[nodes] for node in nodes)  
     1015             
     1016        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette) 
     1017     
     1018        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     1019            for vertex in nodes: 
     1020                v = vertex.index 
     1021                newColor = self.discPalette[0] 
     1022                 
     1023                if str(self.items[v][colorIndex]) != "?": 
     1024                    if maxValue == minValue: 
     1025                        newColor = self.discPalette[0] 
     1026                    else: 
     1027                        value = (float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue) 
     1028                        newColor = self.contPalette[value] 
    10131029                     
    1014                     if str(self.graph.items()[v][colorIndex]) != "?": 
    1015                         if maxValue == minValue: 
    1016                             newColor = self.discPalette[0] 
    1017                         else: 
    1018                             value = (float(self.graph.items()[v][colorIndex].value) - minValue) / (maxValue - minValue) 
    1019                             newColor = self.contPalette[value] 
    1020                          
    1021                     self.networkCurve.setVertexColor(v, newColor) 
    1022                      
    1023                 elif self.graph.items().domain[colorIndex].varType == orange.VarTypes.Discrete: 
    1024                     newColor = self.discPalette[colorIndices[self.graph.items()[v][colorIndex].value]] 
    1025                     #print newColor 
    1026                     self.networkCurve.setVertexColor(v, newColor) 
    1027                      
    1028             else: 
    1029                 newColor = self.discPalette[0] 
    1030                 self.networkCurve.setVertexColor(v, newColor) 
    1031          
     1030                self.networkCurve.set_node_color(v, newColor) 
     1031                 
     1032        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     1033            for vertex in nodes: 
     1034                v = vertex.index 
     1035                newColor = self.discPalette[colorIndices[self.items[v][colorIndex].value]] 
     1036                self.networkCurve.set_node_color(v, newColor) 
     1037        else: 
     1038            self.networkCurve.set_nodes_color(nodes, self.discPalette[0]) 
     1039             
    10321040        self.replot() 
    10331041         
    10341042    def setLabelText(self, attributes): 
    10351043        self.labelText = [] 
    1036         if self.layout is None or self.graph is None or self.graph.items() is None: 
     1044        if self.layout is None or self.graph is None or self.items is None: 
    10371045            return 
    10381046         
    1039         if isinstance(self.graph.items(), orange.ExampleTable): 
    1040             data = self.graph.items() 
     1047        if isinstance(self.items, orange.ExampleTable): 
     1048            data = self.items 
    10411049            for att in attributes: 
    10421050                for i in range(len(data.domain)): 
     
    10441052                        self.labelText.append(i) 
    10451053                         
    1046                 if self.graph.items().domain.hasmeta(att): 
    1047                         self.labelText.append(self.graph.items().domain.metaid(att)) 
     1054                if self.items.domain.hasmeta(att): 
     1055                        self.labelText.append(self.items.domain.metaid(att)) 
    10481056     
    10491057    def setTooltipText(self, attributes): 
    10501058        self.tooltipText = [] 
    1051         if self.layout is None or self.graph is None or self.graph.items() is None: 
     1059        if self.layout is None or self.graph is None or self.items is None: 
    10521060            return 
    10531061         
    1054         if isinstance(self.graph.items(), orange.ExampleTable): 
    1055             data = self.graph.items() 
     1062        if isinstance(self.items, orange.ExampleTable): 
     1063            data = self.items 
    10561064            for att in attributes: 
    10571065                for i in range(len(data.domain)): 
     
    10591067                        self.tooltipText.append(i) 
    10601068                         
    1061                 if self.graph.items().domain.hasmeta(att): 
    1062                         self.tooltipText.append(self.graph.items().domain.metaid(att)) 
     1069                if self.items.domain.hasmeta(att): 
     1070                        self.tooltipText.append(self.items.domain.metaid(att)) 
    10631071                         
    10641072    def setEdgeLabelText(self, attributes): 
    10651073        self.edgeLabelText = [] 
    1066         if self.layout is None or self.graph is None or self.graph.items() is None: 
     1074        if self.layout is None or self.graph is None or self.items is None: 
    10671075            return 
    10681076         
    1069     def set_graph_layout(self, graph, layout, curve=None): 
     1077    def change_graph(self, newgraph, inter_nodes, add_nodes, remove_nodes): 
     1078        self.graph = newgraph 
     1079         
     1080        [self.networkCurve.vertices.pop(key) for key in remove_nodes] 
     1081        self.networkCurve.vertices.update(dict((v, NodeItem(v)) for v in add_nodes)) 
     1082        vertices = self.networkCurve.vertices 
     1083         
     1084        #build edge index 
     1085        row_ind = {} 
     1086        if self.links is not None and len(self.links) > 0: 
     1087          for i, r in enumerate(self.links): 
     1088              u = int(r['u'].value) 
     1089              v = int(r['v'].value) 
     1090              if u in self.graph and v in self.graph: 
     1091                  u_dict = row_ind.get(u, {}) 
     1092                  v_dict = row_ind.get(v, {}) 
     1093                  u_dict[v] = i 
     1094                  v_dict[u] = i 
     1095                  row_ind[u] = u_dict 
     1096                  row_ind[v] = v_dict 
     1097                   
     1098        #add edges 
     1099        if self.links is not None and len(self.links) > 0: 
     1100            links = self.links 
     1101            links_indices = (row_ind[i + 1][j + 1] for (i, j) in self.graph.edges()) 
     1102            labels = ([str(row[r].value) for r in range(2, len(row))] for row in (links[links_index] for links_index in links_indices)) 
     1103             
     1104            if self.graph.is_directed(): 
     1105                edges = [EdgeItem(vertices[i], vertices[j], 
     1106                    self.graph[i][j].get('weight', 1), 0, 1, links_index, label) for \ 
     1107                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
     1108                                                        links_indices, labels)] 
     1109            else: 
     1110                edges = [EdgeItem(vertices[i], vertices[j], 
     1111                    self.graph[i][j].get('weight', 1), links_index, label) for \ 
     1112                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
     1113                                                        links_indices, labels)] 
     1114        elif self.graph.is_directed(): 
     1115            edges = [EdgeItem(vertices[i], vertices[j], 
     1116                                      self.graph[i][j].get('weight', 1), 0, 1) for (i, j) in self.graph.edges()] 
     1117        else: 
     1118            edges = [EdgeItem(vertices[i], vertices[j], 
     1119                                      self.graph[i][j].get('weight', 1)) for (i, j) in self.graph.edges()] 
     1120                   
     1121        #self.minEdgeWeight = min(edge.weight for edge in edges) if len(edges) > 0 else 0 
     1122        #self.maxEdgeWeight = max(edge.weight for edge in edges) if len(edges) > 0 else 0 
     1123         
     1124        #if self.minEdgeWeight is None:  
     1125        #    self.minEdgeWeight = 0  
     1126         
     1127        #if self.maxEdgeWeight is None:  
     1128        #    self.maxEdgeWeight = 0  
     1129                           
     1130        #self.maxEdgeSize = 10 
     1131             
     1132        #self.setEdgesSize() 
     1133        #self.setVerticesSize() 
     1134         
     1135        self.networkCurve.coors = self.layout.map_to_graph(self.graph) 
     1136        self.networkCurve.edges = edges 
     1137        self.networkCurve.changed() 
     1138         
     1139    def set_graph_layout(self, graph, layout, curve=None, items=None, links=None): 
    10701140        self.clear() 
    10711141        self.vertexDegree = [] 
    1072         self.vertices_old = {} 
    1073         self.vertices = [] 
    1074         self.edges_old = {} 
    1075         self.edges = [] 
     1142        #self.vertices_old = {} 
     1143        #self.vertices = [] 
     1144        #self.edges_old = {} 
     1145        #self.edges = [] 
    10761146        self.minEdgeWeight = sys.maxint 
    10771147        self.maxEdgeWeight = 0 
     
    10811151            self.layout = None 
    10821152            self.networkCurve = None 
     1153            self.items = None 
     1154            self.links = None 
    10831155            xMin = self.axisScaleDiv(QwtPlot.xBottom).interval().minValue() 
    10841156            xMax = self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue() 
     
    10931165        self.layout = layout 
    10941166        self.networkCurve = NetworkCurve(self) if curve is None else curve 
     1167        self.items = items if items is not None else self.graph.items() 
     1168        self.links = links if links is not None else self.graph.links() 
    10951169         
    10961170        #add nodes 
    1097         self.vertices_old = [(None, []) for v in self.graph] 
    1098         self.vertices = [NetworkVertex(v) for v in self.graph] 
     1171        #self.vertices_old = [(None, []) for v in self.graph] 
     1172        vertices = dict((v, NodeItem(v)) for v in self.graph) 
    10991173         
    11001174        #build edge index 
    11011175        row_ind = {} 
    1102         if self.graph.links() is not None and len(self.graph.links()) > 0: 
    1103           for i, r in enumerate(self.graph.links()): 
     1176        if self.links is not None and len(self.links) > 0: 
     1177          for i, r in enumerate(self.links): 
    11041178              u = int(r['u'].value) 
    11051179              v = int(r['v'].value) 
    1106               u_dict = row_ind.get(u, {}) 
    1107               v_dict = row_ind.get(v, {}) 
    1108               u_dict[v] = i 
    1109               v_dict[u] = i 
    1110               row_ind[u] = u_dict 
    1111               row_ind[v] = v_dict 
     1180              if u in self.graph and v in self.graph: 
     1181                  u_dict = row_ind.get(u, {}) 
     1182                  v_dict = row_ind.get(v, {}) 
     1183                  u_dict[v] = i 
     1184                  v_dict[u] = i 
     1185                  row_ind[u] = u_dict 
     1186                  row_ind[v] = v_dict 
    11121187               
    11131188        #add edges 
    1114         if self.graph.links() is not None and len(self.graph.links()) > 0: 
    1115             links = self.graph.links() 
     1189        if self.links is not None and len(self.links) > 0: 
     1190            links = self.links 
    11161191            links_indices = (row_ind[i + 1][j + 1] for (i, j) in self.graph.edges()) 
    11171192            labels = ([str(row[r].value) for r in range(2, len(row))] for row in (links[links_index] for links_index in links_indices)) 
    11181193             
    11191194            if self.graph.is_directed(): 
    1120                 self.edges = [NetworkEdge(self.vertices[i], self.vertices[j], 
     1195                edges = [EdgeItem(vertices[i], vertices[j], 
    11211196                    graph[i][j].get('weight', 1), 0, 1, links_index, label) for \ 
    11221197                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
    11231198                                                        links_indices, labels)] 
    11241199            else: 
    1125                 self.edges = [NetworkEdge(self.vertices[i], self.vertices[j], 
     1200                edges = [EdgeItem(vertices[i], vertices[j], 
    11261201                    graph[i][j].get('weight', 1), links_index, label) for \ 
    11271202                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
    11281203                                                        links_indices, labels)] 
    11291204        elif self.graph.is_directed(): 
    1130             self.edges = [NetworkEdge(self.vertices[i], self.vertices[j], 
     1205            edges = [EdgeItem(vertices[i], vertices[j], 
    11311206                                      graph[i][j].get('weight', 1), 0, 1) for (i, j) in self.graph.edges()] 
    11321207        else: 
    1133             self.edges = [NetworkEdge(self.vertices[i], self.vertices[j],  
     1208            edges = [EdgeItem(vertices[i], vertices[j], 
    11341209                                      graph[i][j].get('weight', 1)) for (i, j) in self.graph.edges()] 
    11351210         
    1136         self.minEdgeWeight = min(edge.weight for edge in self.edges) if len(self.edges) > 0 else 0 
    1137         self.maxEdgeWeight = max(edge.weight for edge in self.edges) if len(self.edges) > 0 else 0 
     1211        self.minEdgeWeight = min(edge.weight for edge in edges) if len(edges) > 0 else 0 
     1212        self.maxEdgeWeight = max(edge.weight for edge in edges) if len(edges) > 0 else 0 
    11381213         
    11391214        if self.minEdgeWeight is None:  
     
    11481223        self.setVerticesSize() 
    11491224         
    1150         self.networkCurve.coors = self.layout.coors 
    1151         self.networkCurve.vertices = self.vertices 
    1152         self.networkCurve.edges = self.edges 
     1225        self.networkCurve.coors = self.layout.map_to_graph(self.graph) 
     1226        self.networkCurve.vertices = vertices 
     1227        self.networkCurve.edges = edges 
    11531228        self.networkCurve.changed() 
    11541229         
     
    11591234            #print 'minEdgeWeight',self.minEdgeWeight 
    11601235            k = (self.maxEdgeSize - 1) / (self.maxEdgeWeight - self.minEdgeWeight) 
    1161             for edge in self.edges: 
     1236            for edge in self.networkCurve.edges: 
    11621237                if edge.weight == None: 
    11631238                    size = 1 
     
    11721247                    edge.pen.setCapStyle(Qt.RoundCap) 
    11731248        else: 
    1174             for edge in self.edges: 
     1249            for edge in self.networkCurve.edges: 
    11751250                edge.pen = QPen(edge.pen.color(), 1) 
    11761251                edge.pen.setCapStyle(Qt.RoundCap) 
    11771252                 
    11781253    def setVerticesSize(self, column=None, inverted=0): 
    1179         if self.layout is None or self.graph is None or self.graph.items() is None: 
     1254        if self.layout is None or self.graph is None or self.items is None: 
    11801255            return 
    11811256         
    11821257        column = str(column) 
    11831258         
    1184         if column in self.graph.items().domain or (column.startswith("num of ") and column.replace("num of ", "") in self.graph.items().domain): 
     1259        if column in self.items.domain or (column.startswith("num of ") and column.replace("num of ", "") in self.items.domain): 
    11851260            values = [] 
    11861261             
    1187             if column in self.graph.items().domain: 
    1188                 values = [x[column].value for x in self.graph.items() if not x[column].isSpecial()] 
     1262            if column in self.items.domain: 
     1263                values = [self.items[x][column].value for x in self.graph if not self.items[x][column].isSpecial()] 
    11891264            else: 
    1190                 values = [len(x[column.replace("num of ", "")].value.split(',')) for x in self.graph.items()] 
     1265                values = [len(self.items[x][column.replace("num of ", "")].value.split(',')) for x in self.graph] 
    11911266           
    11921267            minVertexWeight = float(min(values or [0])) 
     
    12051280                  
    12061281            if inverted: 
    1207                 for vertex in self.vertices: 
    1208                     if column in self.graph.items().domain: 
    1209                         vertex.size = self.maxVertexSize - ((getValue(self.graph.items()[vertex.index][column]) - minVertexWeight) * k) 
     1282                for key, vertex in self.networkCurve.vertices.iteritems(): 
     1283                    if column in self.items.domain: 
     1284                        vertex.size = self.maxVertexSize - ((getValue(self.items[vertex.index][column]) - minVertexWeight) * k) 
    12101285                    else: 
    1211                         vertex.size = self.maxVertexSize - ((len(self.graph.items()[vertex.index][column.replace("num of ", "")].value.split(',')) - minVertexWeight) * k) 
     1286                        vertex.size = self.maxVertexSize - ((len(self.items[vertex.index][column.replace("num of ", "")].value.split(',')) - minVertexWeight) * k) 
    12121287                     
    12131288                     
    12141289                    vertex.pen.setWidthF(1 + float(vertex.size) / 20) 
    12151290            else: 
    1216                 for vertex in self.vertices: 
    1217                     if column in self.graph.items().domain: 
    1218                         vertex.size = (getValue(self.graph.items()[vertex.index][column]) - minVertexWeight) * k + self.minVertexSize 
     1291                for key, vertex in self.networkCurve.vertices.iteritems(): 
     1292                    if column in self.items.domain: 
     1293                        vertex.size = (getValue(self.items[vertex.index][column]) - minVertexWeight) * k + self.minVertexSize 
    12191294                    else: 
    1220                         vertex.size = (float(len(self.graph.items()[vertex.index][column.replace("num of ", "")].value.split(','))) - minVertexWeight) * k + self.minVertexSize 
     1295                        vertex.size = (float(len(self.items[vertex.index][column.replace("num of ", "")].value.split(','))) - minVertexWeight) * k + self.minVertexSize 
    12211296                         
    12221297                    #print vertex.size 
    12231298                    vertex.pen.setWidthF(1 + float(vertex.size) / 20) 
    12241299        else: 
    1225             for vertex in self.vertices: 
     1300            for key, vertex in self.networkCurve.vertices.iteritems(): 
    12261301                vertex.size = self.maxVertexSize 
    12271302                vertex.pen.setWidthF(1 + float(vertex.size) / 20) 
     
    12391314         
    12401315    def zoomSelection(self): 
    1241         selection = self.networkCurve.getSelectedVertices() 
     1316        selection = self.networkCurve.get_selected_nodes() 
    12421317        if len(selection) > 0:  
    1243             x = [self.layout.coors[0][v] for v in selection] 
    1244             y = [self.layout.coors[1][v] for v in selection] 
     1318            x = [self.networkCurve.coors[v][0] for v in selection] 
     1319            y = [self.networkCurve.coors[v][1] for v in selection] 
    12451320     
    12461321            oldXMin = self.axisScaleDiv(QwtPlot.xBottom).interval().minValue() 
  • orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r8042 r8378  
    4545        OWWidget.__init__(self, parent, signalManager, name) 
    4646        #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
    47         self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default),  
     47        self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default), 
     48                       ("Nx View", Orange.network.NxView, self.set_network_view), 
    4849                       ("Items", Orange.data.Table, self.setItems), 
    4950                       ("Items to Mark", Orange.data.Table, self.markItems),  
     
    118119        self.loadSettings() 
    119120         
     121        self._network_view = None 
    120122        self.layout = Orange.network.GraphLayout() 
    121123        self.graph = None 
     124        self.graph_base = None 
    122125        self.markInputItems = None 
    123126         
     
    172175        self.vertexSizeCombo.addItem("(none)") 
    173176         
    174         OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback = self.setVertexSize) 
    175         OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback = self.setVertexSize) 
     177        OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback=self.setVertexSize) 
     178        OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback=self.setVertexSize) 
    176179        OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback = self.setVertexSize) 
    177180         
     
    376379     
    377380    def setAutoSendAttributes(self): 
    378         if self.autoSendAttributes: 
    379             self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
    380         else: 
    381             self.networkCanvas.callbackSelectVertex = None 
     381        print 'TODO setAutoSendAttributes' 
     382        #if self.autoSendAttributes: 
     383        #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
     384        #else: 
     385        #    self.networkCanvas.callbackSelectVertex = None 
    382386 
    383387    def sendAttSelectionList(self): 
    384388        if not self.graph is None: 
    385             vars = [x.name for x in self.graph.items_vars()] 
     389            vars = [x.name for x in self.graph_base.links_vars()] 
    386390            if not self.comboAttSelection.currentText() in vars: 
    387391                return 
    388392            att = str(self.comboAttSelection.currentText()) 
    389             vertices = self.networkCanvas.networkCurve.getSelectedVertices() 
     393            vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    390394             
    391395            if len(vertices) != 1: 
    392396                return 
    393397             
    394             attributes = str(self.graph.items()[vertices[0]][att]).split(', ') 
     398            attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
    395399        else: 
    396400            attributes = None 
     
    401405            return 
    402406         
    403         vars = [x.name for x in self.graph.items_vars()] 
     407        vars = [x.name for x in self.graph_base.items_vars()] 
    404408        if not self.editCombo.currentText() in vars: 
    405409            return 
    406410        att = str(self.editCombo.currentText()) 
    407         vertices = self.networkCanvas.networkCurve.getSelectedVertices() 
     411        vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    408412         
    409413        if len(vertices) == 0: 
    410414            return 
    411415         
    412         if self.graph.items().domain[att].var_type == Orange.data.Type.Continuous: 
     416        if self.graph_base.items().domain[att].var_type == Orange.data.Type.Continuous: 
    413417            for v in vertices: 
    414                 self.graph.items()[v][att] = float(self.editValue) 
     418                self.graph_base.items()[v][att] = float(self.editValue) 
    415419        else: 
    416420            for v in vertices: 
    417                 self.graph.items()[v][att] = str(self.editValue) 
    418          
    419         self.setItems(self.graph.items()) 
     421                self.graph_base.items()[v][att] = str(self.editValue) 
     422         
     423        self.setItems(self.graph_base.items()) 
    420424         
    421425    def drawForce(self): 
     
    587591            return 
    588592         
    589         if self.graph is not None and self.graph.items() is not None: 
    590             items = self.graph.items().getitems(markedNodes) 
     593        if self.graph is not None and self.graph_base.items() is not None: 
     594            items = self.graph_base.items().getitems(markedNodes) 
    591595            self.send("Marked Items", items) 
    592596            return 
     
    619623         
    620624    def showComponents(self): 
    621         if self.graph is None or self.graph.items() is None: 
    622             return 
    623          
    624         vars = [x.name for x in self.graph.items_vars()] 
     625        if self.graph is None or self.graph_base.items() is None: 
     626            return 
     627         
     628        vars = [x.name for x in self.graph_base.items_vars()] 
    625629         
    626630        if not self.showComponentCombo.currentText() in vars: 
     
    637641        self.lastNameComponentAttribute = None 
    638642         
    639         if self.graph is None or self.graph.items() is None: 
    640             return 
    641          
    642         vars = [x.name for x in self.graph.items_vars()] 
     643        if self.graph is None or self.graph_base.items() is None: 
     644            return 
     645         
     646        vars = [x.name for x in self.graph_base.items_vars()] 
    643647        if not self.nameComponentCombo.currentText() in vars: 
    644648            return 
     
    646650        self.progressBarInit() 
    647651        components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
    648         if 'component name' in self.graph.items().domain: 
    649             keyword_table = self.graph.items() 
    650         else: 
    651             keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph.items()))])  
     652        if 'component name' in self.graph_base.items().domain: 
     653            keyword_table = self.graph_base.items() 
     654        else: 
     655            keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    652656         
    653657        import obiGO  
     
    655659        annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
    656660 
    657         allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph.items()]) 
     661        allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
    658662        foundGenesets = False 
    659663        if len(annotations.geneNames & allGenes) < 1: 
    660             allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph.items()])) 
     664            allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
    661665            if len(annotations.geneNames & allGenes) < 1:             
    662666                self.warning('no genes found') 
     
    724728             
    725729            if foundGenesets: 
    726                 genes = reduce(operator.add, [self.graph.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
     730                genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
    727731            else: 
    728                 genes = [self.graph.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
     732                genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
    729733                     
    730734            res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
    731735            res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
    732             res = res1.items() + res2.items() 
     736            res = res1_base.items() + res2.items() 
    733737            #namingScore = [[(1-p_value) * (float(len(g)) / len(genes)) / (float(ref) / len(annotations.geneNames)), ontology.terms[GOId].name, len(g), ref, p_value] for GOId, (g, p_value, ref) in res.items() if p_value < 0.1] 
    734738            #namingScore = [[(1-p_value) * len(g) / ref, ontology.terms[GOId].name, len(g), ref, p_value] for GOId, (g, p_value, ref) in res.items() if p_value < 0.1] 
     
    765769                 
    766770        self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    767         self.setItems(Orange.data.Table([self.graph.items(), keyword_table])) 
     771        self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table])) 
    768772        self.progressBarFinished()    
    769773         
    770774    def nameComponents_old(self): 
    771         if self.graph is None or self.graph.items() is None: 
    772             return 
    773          
    774         vars = [x.name for x in self.graph.items_vars()] 
     775        if self.graph is None or self.graph_base.items() is None: 
     776            return 
     777         
     778        vars = [x.name for x in self.graph_base.items_vars()] 
    775779         
    776780        if not self.nameComponentCombo.currentText() in vars: 
     
    778782         
    779783        components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    780         keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph.items()))])  
     784        keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    781785         
    782786        excludeWord = ["AND", "OF", "KEGG", "ST", "IN", "SIG"] 
     
    790794            for vertex in component: 
    791795                values = [] 
    792                 value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     796                value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    793797                 
    794798                value = value.replace(" ", ",") 
     
    892896            for vertex in component: 
    893897                values = [] 
    894                 value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     898                value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    895899                 
    896900                value = value.replace(" ", ",") 
     
    977981        self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    978982        #print "self.lastNameComponentAttribute:", self.lastNameComponentAttribute 
    979         items = Orange.data.Table([self.graph.items(), keyword_table]) 
     983        items = Orange.data.Table([self.graph_base.items(), keyword_table]) 
    980984        self.setItems(items) 
    981985         
     
    10051009         
    10061010        hubs = self.hubs 
    1007         vgraph = self.graph 
    1008  
    10091011        if hubs == 0: 
    10101012            self.networkCanvas.setMarkedVertices([]) 
     
    10181020            self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200 
    10191021             
    1020             toMark = [i for i, values in enumerate(vgraph.items()) if txt.lower() in " ".join([str(values[ndx]).decode("ascii", "ignore").lower() for ndx in range(len(vgraph.items().domain)) + vgraph.items().domain.getmetas().keys()])] 
     1022            toMark = [i for i, values in enumerate(self.graph_base.items()) if txt.lower() in " ".join([str(values[ndx]).decode("ascii", "ignore").lower() for ndx in range(len(self.graph_base.items().domain)) + self.graph_base.items().domain.getmetas().keys()])] 
    10211023            self.networkCanvas.setMarkedVertices(toMark) 
    10221024            self.networkCanvas.replot() 
     
    10251027        elif hubs == 2: 
    10261028            #print "mark on focus" 
    1027             self.networkCanvas.unMark() 
     1029            self.networkCanvas.unmark() 
    10281030            self.networkCanvas.tooltipNeighbours = self.markDistance 
    10291031            return 
     
    10311033        elif hubs == 3: 
    10321034            #print "mark selected" 
    1033             self.networkCanvas.unMark() 
     1035            self.networkCanvas.unmark() 
    10341036            self.networkCanvas.selectionNeighbours = self.markDistance 
    10351037            self.networkCanvas.markSelectionNeighbours() 
     
    10371039         
    10381040        self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0 
    1039         powers = vgraph.degree() 
     1041        powers = self.graph.degree() 
    10401042        powers = [powers[key] for key in sorted(powers.keys())] 
    10411043         
     
    10521054        elif hubs == 6: 
    10531055            #print "mark more than any" 
    1054             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in vgraph.getNeighbours(i)])]) 
     1056            self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    10551057            self.networkCanvas.replot() 
    10561058        elif hubs == 7: 
    10571059            #print "mark more than avg" 
    1058             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in vgraph.getNeighbours(i)])]) 
     1060            self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    10591061            self.networkCanvas.replot() 
    10601062        elif hubs == 8: 
     
    11051107                self.send("Selected Items", graph.items()) 
    11061108            else: 
    1107                 self.send("Selected Items", self.networkCanvas.getSelectedExamples()) 
    1108              
    1109             #print "sendData:", self.visualize.graph.items().domain 
    1110             self.send("Unselected Items", self.networkCanvas.getUnselectedExamples())     
     1109                nodes = self.networkCanvas.getSelectedExamples() 
     1110                 
     1111                if len(nodes) > 0 and self.graph_base.items() is not None: 
     1112                    self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
     1113                else: 
     1114                    self.send("Selected Items", None) 
     1115                 
     1116            nodes = self.networkCanvas.getUnselectedExamples() 
     1117            if len(nodes) > 0 and self.graph_base.items() is not None: 
     1118                self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
     1119            else: 
     1120                self.send("Unselected Items", None) 
     1121                 
    11111122            self.send("Selected Network", graph) 
    11121123        else: 
    1113             items = self.networkCanvas.getSelectedExamples() 
    1114             self.send("Selected Items", items) 
    1115                  
    1116             items = self.networkCanvas.getUnselectedExamples() 
    1117             self.send("Unselected Items", items) 
     1124            nodes = self.networkCanvas.getSelectedExamples() 
     1125            if len(nodes) > 0 and self.graph_base.items() is not None: 
     1126                self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
     1127            else: 
     1128                self.send("Selected Items", None) 
     1129                 
     1130            nodes = self.networkCanvas.getUnselectedExamples() 
     1131            if len(nodes) > 0 and self.graph_base.items() is not None: 
     1132                self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
     1133            else: 
     1134                self.send("Unselected Items", None) 
    11181135         
    11191136        matrix = None 
     
    11241141                 
    11251142    def setCombos(self): 
    1126         vars = self.graph.items_vars() 
    1127         edgeVars = self.graph.links_vars() 
     1143        vars = self.graph_base.items_vars() 
     1144        edgeVars = self.graph_base.links_vars() 
    11281145        lastLabelColumns = self.lastLabelColumns 
    11291146        lastTooltipColumns = self.lastTooltipColumns 
     
    11361153        for var in vars: 
    11371154            if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    1138                 self.colorCombo.addItem(self.icons[var.varType], unicode(var.name)) 
    1139                  
    1140             if var.varType in [Orange.data.Type.String] and hasattr(self.graph, 'items') and self.graph.items() is not None and len(self.graph.items()) > 0: 
    1141                  
    1142                 value = self.graph.items()[0][var].value 
     1155                self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     1156                 
     1157            if var.varType in [Orange.data.Type.String] and hasattr(self.graph, 'items') and self.graph_base.items() is not None and len(self.graph_base.items()) > 0: 
     1158                 
     1159                value = self.graph_base.items()[0][var].value 
    11431160                 
    11441161                # can value be a list? 
    11451162                try: 
    11461163                    if type(eval(value)) == type([]): 
    1147                         self.vertexSizeCombo.addItem(self.icons[var.varType], unicode(var.name)) 
     1164                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    11481165                        continue 
    11491166                except: 
     
    11511168                 
    11521169                if len(value.split(',')) > 1: 
    1153                     self.vertexSizeCombo.addItem(self.icons[var.varType], "num of " + unicode(var.name)) 
     1170                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
    11541171                 
    11551172            elif var.varType in [Orange.data.Type.Continuous]: 
    1156                 self.vertexSizeCombo.addItem(self.icons[var.varType], unicode(var.name)) 
    1157  
    1158             self.nameComponentCombo.addItem(self.icons[var.varType], unicode(var.name)) 
    1159             self.showComponentCombo.addItem(self.icons[var.varType], unicode(var.name)) 
    1160             self.editCombo.addItem(self.icons[var.varType], unicode(var.name)) 
    1161             self.comboAttSelection.addItem(self.icons[var.varType], unicode(var.name)) 
     1173                self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     1174 
     1175            self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     1176            self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     1177            self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     1178            self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    11621179         
    11631180        for var in edgeVars: 
    11641181            if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    1165                 self.edgeColorCombo.addItem(self.icons[var.varType], unicode(var.name)) 
     1182                self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    11661183                 
    11671184        for i in range(self.vertexSizeCombo.count()): 
     
    12061223        self.comboAttSelection.addItem("Select attribute") 
    12071224       
     1225    def change_graph(self, newgraph): 
     1226        old_nodes = set(self.graph.nodes_iter()) 
     1227        new_nodes = set(newgraph.nodes_iter()) 
     1228        inter_nodes = old_nodes.intersection(new_nodes) 
     1229        remove_nodes = old_nodes.difference(inter_nodes) 
     1230        add_nodes = new_nodes.difference(inter_nodes) 
     1231         
     1232        [self.networkCanvas.networkCurve.coors.pop(c) for c in remove_nodes] 
     1233        self.networkCanvas.networkCurve.coors.update((node, (0,0)) for node in add_nodes) 
     1234        positions = [self.networkCanvas.networkCurve.coors[key] for key in sorted(self.networkCanvas.networkCurve.coors.iterkeys())] 
     1235        self.layout.set_graph(newgraph, positions) 
     1236         
     1237        self.graph = newgraph 
     1238        self.number_of_nodes_label = self.graph.number_of_nodes() 
     1239        self.number_of_edges_label = self.graph.number_of_edges() 
     1240         
     1241        self.networkCanvas.change_graph(self.graph, inter_nodes, add_nodes, remove_nodes) 
     1242         
     1243#        self.nShown = self.graph.number_of_nodes() 
     1244#         
     1245#        if self.graph.number_of_edges() > 0: 
     1246#            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
     1247#        else: 
     1248#            self.verticesPerEdge = 0 
     1249#             
     1250#        if self.graph.number_of_nodes() > 0: 
     1251#            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
     1252#        else: 
     1253#            self.edgesPerVertex = 0 
     1254#         
     1255#        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
     1256#        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
     1257#        if len(components) > 1: 
     1258#            self.diameter = -1 
     1259#        else: 
     1260#            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
     1261#        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
     1262         
     1263        k = 1.13850193174e-008 
     1264        nodes = self.graph.number_of_nodes() 
     1265        t = k * nodes * nodes 
     1266        self.frSteps = int(5.0 / t) 
     1267        if self.frSteps <   1: self.frSteps = 1; 
     1268        if self.frSteps > 3000: self.frSteps = 3000; 
     1269         
     1270        if self.frSteps < 10: 
     1271            self.renderAntialiased = 0 
     1272            self.minVertexSize = 5 
     1273            self.maxVertexSize = 5 
     1274            self.maxLinkSize = 1 
     1275            self.optMethod = 0 
     1276            self.graph_layout_method()             
     1277             
     1278        #self.setVertexColor() 
     1279        #self.setEdgeColor() 
     1280        #self.networkCanvas.setEdgesSize() 
     1281         
     1282        #self.clickedAttLstBox() 
     1283        #self.clickedTooltipLstBox() 
     1284        #self.clickedEdgeLabelListBox() 
     1285         
     1286        self.optButton.setChecked(1) 
     1287        self.graph_layout()         
     1288        self.information(0) 
     1289         
    12081290    def set_graph(self, graph): 
    12091291        self.set_items_distance_matrix(None) 
     
    12111293        if graph is None: 
    12121294            self.graph = None 
     1295            self.graph_base = None 
    12131296            self.layout.set_graph(None) 
    12141297            self.networkCanvas.set_graph_layout(None, None) 
     
    12161299            self.number_of_nodes_label = -1 
    12171300            self.number_of_edges_label = -1 
    1218             return 
     1301            self._items = None 
     1302            self._links = None 
     1303            return 
     1304         
     1305        self.graph_base = graph 
     1306         
     1307        if self._network_view is not None: 
     1308            graph = self._network_view.init_network(graph) 
     1309         
    12191310         
    12201311        #print "OWNetwork/setGraph: new visualizer..." 
    12211312        self.graph = graph 
    12221313         
    1223         if graph.items() is not None and 'x' in graph.items().domain and 'y' in graph.items().domain: 
    1224             positions = [(ex['x'].value, ex['y'].value) for ex in graph.items() if ex['x'].value != '?' and ex['y'].value != '?'] 
    1225             self.layout.set_graph(graph, positions) 
    1226         else: 
    1227             self.layout.set_graph(graph) 
     1314        if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
     1315            positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
     1316                         for node in sorted(self.graph) if self._items[node]['x'].value != '?' \ 
     1317                         and self._items[node]['y'].value != '?'] 
     1318            self.layout.set_graph(self.graph, positions) 
     1319        else: 
     1320            self.layout.set_graph(self.graph) 
    12281321         
    12291322        self.number_of_nodes_label = self.graph.number_of_nodes() 
    12301323        self.number_of_edges_label = self.graph.number_of_edges() 
    12311324         
    1232         self.networkCanvas.set_graph_layout(self.graph, self.layout) 
     1325        self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
    12331326        self.networkCanvas.renderAntialiased = self.renderAntialiased 
    12341327        self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
     
    12361329        self.networkCanvas.maxVertexSize = self.maxVertexSize 
    12371330        self.networkCanvas.maxEdgeSize = self.maxLinkSize 
     1331        self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
     1332        self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    12381333        self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    12391334        self.lastColorColumn = self.colorCombo.currentText() 
    1240         self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    1241         self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    1242          
    1243          
    1244  
    1245         #for i in range(graph.nVertices): 
    1246         #    print "x:", graph.coors[0][i], " y:", graph.coors[1][i] 
    1247  
    1248         self.nShown = graph.number_of_nodes() 
     1335         
     1336        self.nShown = self.graph.number_of_nodes() 
    12491337         
    12501338        if self.graph.number_of_edges() > 0: 
     
    12581346            self.edgesPerVertex = 0 
    12591347         
    1260         undirected_graph = graph.to_undirected() if graph.is_directed() else graph 
     1348        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    12611349        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
    12621350        if len(components) > 1: 
    12631351            self.diameter = -1 
    12641352        else: 
    1265             self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(graph) 
     1353            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    12661354        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    12671355         
     
    13181406        self.graph_layout()         
    13191407        self.information(0) 
    1320         #self.controlArea.setEnabled(True) 
    1321         self.networkCanvas.updateCanvas() 
     1408        #self.networkCanvas.updateCanvas() 
     1409         
     1410    def set_network_view(self, nxView): 
     1411        self._network_view = nxView 
     1412        self._network_view.set_nx_explorer(self) 
     1413        self.networkCanvas.callbackSelectVertex = self._network_view.nodes_selected 
     1414        self.set_graph(self.graph_base) 
    13221415         
    13231416    def setItems(self, items=None): 
     
    13271420            return 
    13281421         
    1329         if len(items) != self.graph.number_of_nodes(): 
     1422        if len(items) != self.graph_base.number_of_nodes(): 
    13301423            self.error('ExampleTable items must have one example for each vertex.') 
    13311424            return 
    13321425         
    1333         self.graph.set_items(items) 
     1426        self.graph_base.set_items(items) 
    13341427         
    13351428        self.setVertexSize() 
    13361429        self.networkCanvas.showIndexes = self.showIndexes 
    13371430        self.networkCanvas.showWeights = self.showWeights 
    1338         self.networkCanvas.showEdgeLabels = self.showEdgeLabels  
     1431        self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    13391432        self.setCombos() 
    13401433        self.networkCanvas.updateData() 
     
    13451438        if self.markInputItems is not None and len(self.markInputItems) > 0: 
    13461439            values = [str(x[var]).strip().upper() for x in self.markInputItems] 
    1347             toMark = [i for (i,x) in enumerate(self.graph.items()) if str(x[var]).strip().upper() in values] 
     1440            toMark = [i for (i,x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values] 
    13481441            #print "mark:", toMark 
    13491442            self.networkCanvas.setMarkedVertices(list(toMark)) 
     
    13591452        self.markInputItems = items 
    13601453         
    1361         if self.graph is None or self.graph.items() is None or items is None: 
     1454        if self.graph is None or self.graph_base.items() is None or items is None: 
    13621455            return 
    13631456         
    13641457        if len(items) > 0: 
    1365             lstOrgDomain = [x.name for x in self.graph.items().domain] + [self.graph.items().domain[x].name for x in self.graph.items().domain.getmetas()] 
     1458            lstOrgDomain = [x.name for x in self.graph_base.items().domain] + [self.graph_base.items().domain[x].name for x in self.graph_base.items().domain.getmetas()] 
    13661459            lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()] 
    13671460            commonVars = set(lstNewDomain) & set(lstOrgDomain) 
     
    13691462            if len(commonVars) > 0: 
    13701463                for var in commonVars: 
    1371                     orgVar = self.graph.items().domain[var] 
     1464                    orgVar = self.graph_base.items().domain[var] 
    13721465                    mrkVar = items.domain[var] 
    13731466 
     
    14831576             
    14841577        self.optButton.setChecked(False) 
     1578        self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    14851579        self.networkCanvas.updateCanvas() 
    14861580        qApp.processEvents() 
     
    15481642                iteration += 1 
    15491643                qApp.processEvents() 
     1644                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    15501645                self.networkCanvas.updateCanvas() 
    15511646             
     
    15551650            initTemp = self.layout.fr(o, initTemp, coolFactor, weighted) 
    15561651            qApp.processEvents() 
     1652            self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    15571653            self.networkCanvas.updateCanvas() 
    15581654        else: 
     
    15641660                iteration += 1 
    15651661                qApp.processEvents() 
     1662                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    15661663                self.networkCanvas.updateCanvas() 
    15671664                 
     
    16701767            return 
    16711768         
    1672         self.networkCanvas.setVertexColor(self.colorCombo.currentText()) 
     1769        self.networkCanvas.set_node_color(self.colorCombo.currentText()) 
    16731770        self.lastColorColumn = self.colorCombo.currentText() 
    16741771        self.networkCanvas.updateData() 
     
    16791776            return 
    16801777         
    1681         self.networkCanvas.setEdgeColor(self.edgeColorCombo.currentText()) 
     1778        self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText()) 
    16821779        self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
    16831780        self.networkCanvas.updateData() 
  • orange/OrangeWidgets/Unsupervised/OWNxFile.py

    r8042 r8378  
    339339            try: 
    340340                import orngConfiguration 
    341                 startfile = orngConfiguration.datasetsPath 
     341                startfile = Orange.misc.environ.network_install_dir 
    342342            except: 
    343343                startfile = "" 
     
    380380                startfile = self.recentFiles[0] 
    381381                 
    382         filename = str(QFileDialog.getOpenFileName(self, 'Open a Network File', startfile, "NetworkX graph as Python pickle (*.gpickle)\nPajek files (*.net)\nGML files (*.gml)\nAll files (*.*)")) 
     382        filename = str(QFileDialog.getOpenFileName(self, 'Open a Network File', startfile, "All network files (*.gpickle *.net *.gml)\nNetworkX graph as Python pickle (*.gpickle)\nPajek files (*.net)\nGML files (*.gml)\nAll files (*.*)")) 
    383383         
    384384        if filename == "": return 
  • orange/doc/Orange/rst/Orange.preprocess.rst

    r7780 r8033  
    33############################## 
    44 
    5 .. toctree:: 
    6    :maxdepth: 1 
     5.. automodule:: Orange.preprocess 
    76 
    8 .. automodule:: Orange.preprocess 
     7.. automodule:: Orange.preprocess.outliers 
     8 
     9.. automodule:: Orange.preprocess.scaling 
  • orange/doc/Orange/rst/Orange.projection.rst

    r8021 r8040  
    88   Orange.projection.linear 
    99   Orange.projection.mds 
     10   Orange.projection.pca 
    1011   orange.projection.som 
    1112 
  • orange/doc/Orange/rst/Orange.regression.mean.rst

    r8264 r8378  
     1################ 
     2Mean (``mean``) 
     3################ 
     4 
    15.. automodule:: Orange.regression.mean 
  • orange/doc/Orange/rst/code/distances-test.py

    r8042 r8059  
    55 
    66# Euclidean distance constructor 
    7 d2Constr = Orange.distances.EuclideanConstructor() 
     7d2Constr = Orange.distance.instances.EuclideanConstructor() 
    88d2 = d2Constr(table) 
    99 
    1010# Constructs  
    11 dPears = Orange.distances.PearsonRConstructor(table) 
     11dPears = Orange.distance.instances.PearsonRConstructor(table) 
    1212 
    1313#reference instance 
  • orange/doc/Orange/rst/code/mds-euclid-torgerson-3d.py

    r8042 r8059  
    1111 
    1212# Construct a distance matrix using Euclidean distance 
    13 dist = Orange.distances.EuclideanConstructor(table) 
     13dist = Orange.distance.instances.EuclideanConstructor(table) 
    1414matrix = Orange.core.SymMatrix(len(table)) 
    1515matrix.setattr('items', table) 
  • orange/doc/Orange/rst/code/mds-scatterplot.py

    r8042 r8059  
    1111 
    1212# Construct a distance matrix using Euclidean distance 
    13 euclidean = Orange.distances.EuclideanConstructor(table) 
     13euclidean = Orange.distance.instances.EuclideanConstructor(table) 
    1414distance = Orange.core.SymMatrix(len(table)) 
    1515for i in range(len(table)): 
  • orange/doc/Orange/rst/code/outlier2.py

    r7780 r8059  
    33data = Orange.data.Table("bridges") 
    44outlier_det = Orange.preprocess.outliers.OutlierDetection() 
    5 outlier_det.set_examples(data, Orange.distances.EuclideanConstructor(data)) 
     5outlier_det.set_examples(data, Orange.distance.instances.EuclideanConstructor(data)) 
    66outlier_det.set_knn(3) 
    77z_values = outlier_det.z_values() 
  • orange/doc/Orange/rst/conf.py

    r8042 r8378  
    1212# serve to show the default. 
    1313 
    14 import sys, os 
     14import sys, os, os.path 
     15 
     16#rewrite formatargs function with different defaults 
     17sys.path.insert(0, os.path.dirname(__file__)) 
     18import myinspect 
     19import sphinx.ext.autodoc 
     20sphinx.ext.autodoc.inspect = myinspect 
     21 
     22#disable deprecation decorators for the documentation 
     23os.environ["orange_no_deprecated_members"] = "1" 
    1524 
    1625# If extensions (or modules to document with autodoc) are in another directory, 
  • orange/doc/Orange/rst/index.rst

    r8264 r8378  
    1919   Orange.clustering 
    2020    
    21    Orange.distances 
     21   Orange.distance 
    2222 
    2323   Orange.ensemble 
  • orange/fixes/fix_changed_names.py

    r8342 r8378  
    9191           "orange.ImputerConstructor_average": "Orange.feature.imputation.ImputerConstructor_average", 
    9292  
    93            "orange.ExamplesDistance_Normalized": "Orange.distances.ExamplesDistance_Normalized", 
    94            "orange.ExamplesDistanceConstructor": "Orange.distances.ExamplesDistanceConstructor", 
    95            "orange.ExamplesDistance_Hamming": "Orange.distances.Hamming", 
    96            "orange.ExamplesDistance_DTW": "Orange.distances.DTW",  
    97            "orange.ExamplesDistance_Euclidean": "Orange.distances.Euclidean",  
    98            "orange.ExamplesDistance_Manhattan": "Orange.distances.Manhattan",  
    99            "orange.ExamplesDistance_Maximal": "Orange.distances.Maximal",  
    100            "orange.ExamplesDistance_Relief": "Orange.distances.Relief",  
    101             
    102            "orange.ExamplesDistanceConstructor_DTW": "Orange.distances.DTWConstructor",  
    103            "orange.ExamplesDistanceConstructor_Euclidean": "Orange.distances.EuclideanConstructor",  
    104            "orange.ExamplesDistanceConstructor_Hamming": "Orange.distances.HammingConstructor", 
    105            "orange.ExamplesDistanceConstructor_Manhattan": "Orange.distances.ManhattanConstructor", 
    106            "orange.ExamplesDistanceConstructor_Maximal": "Orange.distances.MaximalConstructor", 
    107            "orange.ExamplesDistanceConstructor_Relief": "Orange.distances.ReliefConstructor", 
    108             
    109            "orngClustering.ExamplesDistanceConstructor_PearsonR": "Orange.distances.PearsonRConstructor", 
    110            "orngClustering.ExamplesDistance_PearsonR": "Orange.distances.PearsonR", 
    111            "orngClustering.ExamplesDistanceConstructor_SpearmanR": "Orange.distances.SpearmanRConstructor", 
    112            "orngClustering.ExamplesDistance_SpearmanR": "Orange.distances.SpearmanR", 
     93           "orange.ExamplesDistance_Normalized": "Orange.distance.instances.ExamplesDistance_Normalized", 
     94           "orange.ExamplesDistanceConstructor": "Orange.distance.instances.ExamplesDistanceConstructor", 
     95           "orange.ExamplesDistance_Hamming": "Orange.distance.instances.Hamming", 
     96           "orange.ExamplesDistance_DTW": "Orange.distance.instances.DTW",  
     97           "orange.ExamplesDistance_Euclidean": "Orange.distance.instances.Euclidean",  
     98           "orange.ExamplesDistance_Manhattan": "Orange.distance.instances.Manhattan",  
     99           "orange.ExamplesDistance_Maximal": "Orange.distance.instances.Maximal",  
     100           "orange.ExamplesDistance_Relief": "Orange.distance.instances.Relief",  
     101            
     102           "orange.ExamplesDistanceConstructor_DTW": "Orange.distance.instances.DTWConstructor",  
     103           "orange.ExamplesDistanceConstructor_Euclidean": "Orange.distance.instances.EuclideanConstructor",  
     104           "orange.ExamplesDistanceConstructor_Hamming": "Orange.distance.instances.HammingConstructor", 
     105           "orange.ExamplesDistanceConstructor_Manhattan": "Orange.distance.instances.ManhattanConstructor", 
     106           "orange.ExamplesDistanceConstructor_Maximal": "Orange.distance.instances.MaximalConstructor", 
     107           "orange.ExamplesDistanceConstructor_Relief": "Orange.distance.instances.ReliefConstructor", 
     108            
     109           "orngClustering.ExamplesDistanceConstructor_PearsonR": "Orange.distance.instances.PearsonRConstructor", 
     110           "orngClustering.ExamplesDistance_PearsonR": "Orange.distance.instances.PearsonR", 
     111           "orngClustering.ExamplesDistanceConstructor_SpearmanR": "Orange.distance.instances.SpearmanRConstructor", 
     112           "orngClustering.ExamplesDistance_SpearmanR": "Orange.distance.instances.SpearmanR", 
    113113            
    114114           "orngClustering.KMeans": "Orange.clustering.kmeans.Clustering", 
     
    476476           "orngLinProj.FreeVizLearner": "Orange.projection.linear.FreeVizLearner", 
    477477           "orngLinProj.S2NHeuristicLearner": "Orange.projection.linear.S2NHeuristicLearner", 
     478            
     479           "orngScaleData.getVariableValuesSorted": "Orange.preprocess.scaling.get_variable_values_sorted", 
     480           "orngScaleData.getVariableValueIndices": "Orange.preprocess.scaling.get_variable_value_indices", 
     481           "orngScaleData.discretizeDomain": "Orange.preprocess.scaling.discretize_domain", 
     482           "orngScaleData.orngScaleData": "Orange.preprocess.scaling.ScaleData", 
     483           "orngScaleLinProjData.orngScaleLinProjData": "Orange.preprocess.scaling.ScaleLinProjData", 
     484           "orngScalePolyvizData.orngScalePolyvizData": "Orange.preprocess.scaling.ScalePolyvizData", 
     485           "orngScaleScatterPlotData.orngScaleScatterPlotData": "Orange.preprocess.scaling.ScaleScatterPlotData", 
    478486           } 
    479487 
  • orange/orange-canvas

    • Property exe set to *
    r7033 r8039  
    1 #!/bin/env python 
     1#!/usr/bin/env python 
    22 
    33import os 
  • orange/orngCA.py

    r3402 r8078  
    77import numpy.linalg 
    88import orange 
    9 #import pylab 
    109import operator 
    1110 
     
    166165        a.reverse() 
    167166        return a 
    168 #    def PlotScreeDiagram(self): 
    169         ## todo: legend, axis, etc 
    170 #        pylab.plot(range(1, min(self.__dataMatrix.shape) + 1), self.InertiaOfAxis(1)) 
    171 #        pylab.axis([0, min(self.__dataMatrix.shape) + 1, 0, 100]) 
    172 #        pylab.show() 
    173          
    174 #    def Biplot(self, dim = (0, 1)): 
    175 #        if len(dim) != 2: 
    176 #           raise Exception("Dim tuple must be of length two") 
    177 #        pylab.plot(self.getPrincipalRowProfilesCoordinates()[:, dim[0]], self.getPrincipalRowProfilesCoordinates()[:, dim[1]], 'ro', 
    178 #            self.getPrincipalColProfilesCoordinates()[:, dim[0]], self.getPrincipalColProfilesCoordinates()[:, dim[1]], 'bs') 
    179 #        if self.labelR: 
    180 #            for i, x, y in zip(range(len(self.getPrincipalRowProfilesCoordinates()[:, dim[0]])), \ 
    181 #                                    self.getPrincipalRowProfilesCoordinates()[:, dim[0]], \ 
    182 #                                    self.getPrincipalRowProfilesCoordinates()[:, dim[1]]): 
    183 #                pylab.text(x, y, self.labelR[i], horizontalalignment='center') 
    184 #        if self.labelC: 
    185 #            for i, x, y in zip(range(len(self.getPrincipalColProfilesCoordinates()[:, dim[0]])), \ 
    186 #                                    self.getPrincipalColProfilesCoordinates()[:, dim[0]], \ 
    187 #                                    self.getPrincipalColProfilesCoordinates()[:, dim[1]]): 
    188 #                pylab.text(x, y, self.labelC[i], horizontalalignment='center')                 
    189 #        pylab.grid() 
    190 #        pylab.show()                 
     167     
     168    def PlotScreeDiagram(self): 
     169        # todo: legend, axis, etc 
     170        import pylab 
     171        pylab.plot(range(1, min(self.__dataMatrix.shape) + 1), self.InertiaOfAxis(1)) 
     172        pylab.axis([0, min(self.__dataMatrix.shape) + 1, 0, 100]) 
     173        pylab.show() 
     174         
     175    def Biplot(self, dim = (0, 1)): 
     176        import pylab 
     177        if len(dim) != 2: 
     178           raise Exception("Dim tuple must be of length two") 
     179        pylab.plot(self.getPrincipalRowProfilesCoordinates()[:, dim[0]], self.getPrincipalRowProfilesCoordinates()[:, dim[1]], 'ro', 
     180            self.getPrincipalColProfilesCoordinates()[:, dim[0]], self.getPrincipalColProfilesCoordinates()[:, dim[1]], 'bs') 
     181        if self.labelR: 
     182            for i, x, y in zip(range(len(self.getPrincipalRowProfilesCoordinates()[:, dim[0]])), \ 
     183                                    self.getPrincipalRowProfilesCoordinates()[:, dim[0]], \ 
     184                                    self.getPrincipalRowProfilesCoordinates()[:, dim[1]]): 
     185                pylab.text(x, y, self.labelR[i], horizontalalignment='center') 
     186        if self.labelC: 
     187            for i, x, y in zip(range(len(self.getPrincipalColProfilesCoordinates()[:, dim[0]])), \ 
     188                                    self.getPrincipalColProfilesCoordinates()[:, dim[0]], \ 
     189                                    self.getPrincipalColProfilesCoordinates()[:, dim[1]]): 
     190                pylab.text(x, y, self.labelC[i], horizontalalignment='center')                 
     191        pylab.grid() 
     192        pylab.show()                 
    191193     
    192194    A = property(getA) 
  • orange/orngClustering.py

    r8042 r8059  
    22# from Orange.cluster.hierarchical import *  
    33 
    4 from Orange.distances import \ 
     4from Orange.distance.instances import \ 
    55     AlignmentList, \ 
    66     DistanceMap, \ 
     
    1313     ExamplesDistanceConstructor 
    1414 
    15 from Orange.distances import Hamming as ExamplesDistance_Hamming 
    16 from Orange.distances import DTW as ExamplesDistance_DTW 
    17 from Orange.distances import Euclidean as ExamplesDistance_Euclidean 
    18 from Orange.distances import Manhattan as ExamplesDistance_Manhattan 
    19 from Orange.distances import Maximal as ExamplesDistance_Maximal 
    20 from Orange.distances import Relief as ExamplesDistance_Relief 
     15from Orange.distance.instances import Hamming as ExamplesDistance_Hamming 
     16from Orange.distance.instances import DTW as ExamplesDistance_DTW 
     17from Orange.distance.instances import Euclidean as ExamplesDistance_Euclidean 
     18from Orange.distance.instances import Manhattan as ExamplesDistance_Manhattan 
     19from Orange.distance.instances import Maximal as ExamplesDistance_Maximal 
     20from Orange.distance.instances import Relief as ExamplesDistance_Relief 
    2121 
    22 from Orange.distances import DTWConstructor as ExamplesDistanceConstructor_DTW 
    23 from Orange.distances import EuclideanConstructor as ExamplesDistanceConstructor_Euclidean 
    24 from Orange.distances import HammingConstructor as ExamplesDistanceConstructor_Hamming 
    25 from Orange.distances import ManhattanConstructor as ExamplesDistanceConstructor_Manhattan 
    26 from Orange.distances import MaximalConstructor as ExamplesDistanceConstructor_Maximal  
    27 from Orange.distances import ReliefConstructor as ExamplesDistanceConstructor_Relief 
     22from Orange.distance.instances import DTWConstructor as ExamplesDistanceConstructor_DTW 
     23from Orange.distance.instances import EuclideanConstructor as ExamplesDistanceConstructor_Euclidean 
     24from Orange.distance.instances import HammingConstructor as ExamplesDistanceConstructor_Hamming 
     25from Orange.distance.instances import ManhattanConstructor as ExamplesDistanceConstructor_Manhattan 
     26from Orange.distance.instances import MaximalConstructor as ExamplesDistanceConstructor_Maximal  
     27from Orange.distance.instances import ReliefConstructor as ExamplesDistanceConstructor_Relief 
    2828 
    29 from Orange.distances import PearsonRConstructor as ExamplesDistanceConstructor_PearsonR 
    30 from Orange.distances import PearsonR as ExamplesDistance_PearsonR 
    31 from Orange.distances import SpearmanRConstructor as ExamplesDistanceConstructor_SpearmanR 
    32 from Orange.distances import SpearmanR as ExamplesDistance_SpearmanR 
     29from Orange.distance.instances import PearsonRConstructor as ExamplesDistanceConstructor_PearsonR 
     30from Orange.distance.instances import PearsonR as ExamplesDistance_PearsonR 
     31from Orange.distance.instances import SpearmanRConstructor as ExamplesDistanceConstructor_SpearmanR 
     32from Orange.distance.instances import SpearmanR as ExamplesDistance_SpearmanR 
    3333 
    3434 
  • orange/orngConfiguration.py

    r7354 r8045  
    1 # datasetsPath = "/path/to/datasets/" 
     1import Orange.misc.environ 
     2datasetsPath = Orange.misc.environ.dataset_install_dir 
  • orange/orngInteractions.py

    • Property exe deleted
  • orange/orngScaleData.py

    r8264 r8378  
    1 # OWGraph.py 
    2 # extension for the base graph class that is used in all visualization widgets 
    3 #from OWGraph import * 
    4 import sys, math 
    5 import orange 
    6 import numpy 
    7 from orngDataCaching import * 
    8 try: 
    9     import numpy.ma as MA 
    10 except: 
    11     import numpy.core.ma as MA 
    12  
    13 import warnings 
    14  
    15 # #################################################################### 
    16 # return a list of sorted values for attribute at index index 
    17 # EXPLANATION: if variable values have values 1,2,3,4,... then their order in orange depends on when they appear first 
    18 # in the data. With this function we get a sorted list of values 
    19 def getVariableValuesSorted(variable): 
    20     if variable.varType == orange.VarTypes.Continuous: 
    21         print "getVariableValuesSorted - attribute %s is a continuous variable" % (variable) 
    22         return [] 
    23  
    24     values = list(variable.values) 
    25     intValues = [] 
    26  
    27     # do all attribute values containt integers? 
    28     try: 
    29         intValues = [(int(val), val) for val in values] 
    30     except: 
    31         return values 
    32  
    33     # if all values were intergers, we first sort them ascendently 
    34     intValues.sort() 
    35     return [val[1] for val in intValues] 
    36  
    37 # #################################################################### 
    38 # create a dictionary with variable at index index. Keys are variable values, key values are indices (transform from string to int) 
    39 # in case all values are integers, we also sort them 
    40 def getVariableValueIndices(variable, sortValuesForDiscreteAttrs = 1): 
    41     if variable.varType == orange.VarTypes.Continuous: 
    42         print "getVariableValueIndices - attribute %s is a continuous variable" % (str(index)) 
    43         return {} 
    44  
    45     if sortValuesForDiscreteAttrs: 
    46         values = getVariableValuesSorted(variable) 
    47     else: 
    48         values = list(variable.values) 
    49     return dict([(values[i], i) for i in range(len(values))]) 
    50  
    51  
    52 # discretize the domain 
    53 # if we have a class remove the examples with missing class value 
    54 # discretize the continuous class into discrete class with two values 
    55 # discretize continuous attributes using entropy discretization (or equiN if we don't have a class or class is continuous) 
    56 def discretizeDomain(data, removeUnusedValues = 1, numberOfIntervals = 2): 
    57     entroDisc = orange.EntropyDiscretization() 
    58     equiDisc  = orange.EquiNDiscretization(numberOfIntervals = numberOfIntervals) 
    59     discAttrs = [] 
    60  
    61     className = data and len(data) > 0 and data.domain.classVar and data.domain.classVar.name or None 
    62 #    if className: 
    63 #        data = data.filterref(orange.Filter_hasClassValue())  # remove examples with missing classes 
    64  
    65     if not data or len(data) == 0: 
    66         return None 
    67  
    68     # if we have a continuous class we have to discretize it before we can discretize the attributes 
    69     if className and data.domain.classVar.varType == orange.VarTypes.Continuous: 
    70         try: 
    71             newClass = equiDisc(data.domain.classVar.name, data) 
    72             newClass.name = className 
    73         except orange.KernelException, ex: 
    74             warnings.warn("Could not discretize class variable '%s'. %s" % (data.domain.classVar.name, ex.message)) 
    75             newClass = None 
    76             className = None 
    77         newDomain = orange.Domain(data.domain.attributes, newClass) 
    78         data = orange.ExampleTable(newDomain, data) 
    79  
    80     for attr in data.domain.attributes: 
    81         try: 
    82             name = attr.name 
    83             if attr.varType == orange.VarTypes.Continuous:  # if continuous attribute then use entropy discretization 
    84                 if data.domain.classVar and data.domain.classVar.varType == orange.VarTypes.Discrete: 
    85                     new_attr = entroDisc(attr, data) 
    86                 else: 
    87                     new_attr = equiDisc(attr, data) 
    88             else: 
    89                 new_attr = attr 
    90             if removeUnusedValues: 
    91                 new_attr = orange.RemoveUnusedValues(new_attr, data) 
    92                 if new_attr is None: 
    93                     raise orange.KernelException, "No values" 
    94              
    95             new_attr.name = name 
    96             discAttrs.append(new_attr) 
    97         except orange.KernelException, ex:     # if all values are missing, entropy discretization will throw an exception. in such cases ignore the attribute 
    98             warnings.warn("Could not discretize %s attribute. %s" % (attr.name, ex.message)) 
    99  
    100     if className: discAttrs.append(data.domain.classVar) 
    101     d2 = data.translate(discAttrs, True) 
    102     return d2 
    103  
    104  
    105 class orngScaleData: 
    106     def __init__(self): 
    107         self.rawData = None                     # input data 
    108         self.rawSubsetData = None 
    109         self.attributeNames = []                # list of attribute names from self.rawData 
    110         self.attributeNameIndex = {}            # dict with indices to attributes 
    111         self.attributeFlipInfo = {}             # dictionary with attrName: 0/1 attribute is flipped or not 
    112          
    113         self.dataHasClass = False 
    114         self.dataHasContinuousClass = False 
    115         self.dataHasDiscreteClass = False 
    116         self.dataClassName = None 
    117         self.dataDomain = None 
    118         self.dataClassIndex = None 
    119         self.haveData = False 
    120         self.haveSubsetData = False 
    121  
    122         self.jitterSize = 10 
    123         self.jitterContinuous = 0 
    124  
    125         self.attrValues = {} 
    126         self.domainDataStat = [] 
    127         self.originalData = self.originalSubsetData = None    # input (nonscaled) data in a numpy array 
    128         self.scaledData = self.scaledSubsetData = None        # scaled data to the interval 0-1 
    129         self.noJitteringScaledData = self.noJitteringScaledSubsetData = None 
    130         self.validDataArray = self.validSubsetDataArray = None 
    131  
    132     # take examples from data and subsetData and merge them into one dataset 
    133     def mergeDataSets(self, data, subsetData): 
    134         if data == None and subsetData == None: None 
    135         if subsetData == None: 
    136             fullData = data 
    137         elif data == None: 
    138             fullData = subsetData 
    139         else: 
    140             fullData = orange.ExampleTable(data) 
    141             fullData.extend(subsetData) 
    142         return fullData 
    143  
    144     # force the exising data to be rescaled do to changes like, jitterContinuous, jitterSize, ... 
    145     def rescaleData(self): 
    146         self.setData(self.rawData, self.rawSubsetData, skipIfSame = 0) 
    147  
    148     # this function has to be called before setData or setSubsetData 
    149     # because it computes the minimum and maximum values in the dataset 
    150     def setData(self, data, subsetData = None, **args): 
    151         if args.get("skipIfSame", 1): 
    152             if ((data == None and self.rawData == None) or (self.rawData != None and data != None and self.rawData.checksum() == data.checksum())) and  \ 
    153                ((subsetData == None and self.rawSubsetData == None) or (self.rawSubsetData != None and subsetData != None and self.rawSubsetData.checksum() == subsetData.checksum())): 
    154                     return 
    155  
    156         self.domainDataStat = [] 
    157         self.attrValues = {} 
    158         self.originalData = self.originalSubsetData = None 
    159         self.scaledData = self.scaledSubsetData = None 
    160         self.noJitteringScaledData = self.noJitteringScaledSubsetData = None 
    161         self.validDataArray = self.validSubsetDataArray = None 
    162  
    163         self.rawData = None 
    164         self.rawSubsetData = None 
    165         self.haveData = False 
    166         self.haveSubsetData = False 
    167         self.dataHasClass = False 
    168         self.dataHasContinuousClass = False 
    169         self.dataHasDiscreteClass = False 
    170         self.dataClassName = None 
    171         self.dataDomain = None 
    172         self.dataClassIndex = None 
    173                  
    174         if data == None: return 
    175         fullData = self.mergeDataSets(data, subsetData) 
    176                  
    177         self.rawData = data 
    178         self.rawSubsetData = subsetData 
    179  
    180         lenData = data and len(data) or 0 
    181         numpy.random.seed(1)     # we always reset the random generator, so that if we receive the same data again we will add the same noise 
    182  
    183         self.attributeNames = [attr.name for attr in fullData.domain] 
    184         self.attributeNameIndex = dict([(fullData.domain[i].name, i) for i in range(len(fullData.domain))]) 
    185         self.attributeFlipInfo = {}         # dict([(attr.name, 0) for attr in fullData.domain]) # reset the fliping information 
    186          
    187         self.dataDomain = fullData.domain 
    188         self.dataHasClass = bool(fullData.domain.classVar) 
    189         self.dataHasContinuousClass = bool(self.dataHasClass and fullData.domain.classVar.varType == orange.VarTypes.Continuous) 
    190         self.dataHasDiscreteClass = bool(self.dataHasClass and fullData.domain.classVar.varType == orange.VarTypes.Discrete) 
    191         self.dataClassName = self.dataHasClass and fullData.domain.classVar.name 
    192         if self.dataHasClass: 
    193             self.dataClassIndex = self.attributeNameIndex[self.dataClassName] 
    194         self.haveData = bool(self.rawData and len(self.rawData) > 0) 
    195         self.haveSubsetData = bool(self.rawSubsetData and len(self.rawSubsetData) > 0) 
    196          
    197         self.domainDataStat = getCached(fullData, orange.DomainBasicAttrStat, (fullData,)) 
    198  
    199         sortValuesForDiscreteAttrs = args.get("sortValuesForDiscreteAttrs", 1) 
    200  
    201         for index in range(len(fullData.domain)): 
    202             attr = fullData.domain[index] 
    203             if attr.varType == orange.VarTypes.Discrete: 
    204                 self.attrValues[attr.name] = [0, len(attr.values)] 
    205             elif attr.varType == orange.VarTypes.Continuous: 
    206                 self.attrValues[attr.name] = [self.domainDataStat[index].min, self.domainDataStat[index].max] 
    207          
    208         # the originalData, noJitteringScaledData and validArray are arrays that we can cache so that other visualization widgets 
    209         # don't need to compute it. The scaledData on the other hand has to be computed for each widget separately because of different 
    210         # jitterContinuous and jitterSize values 
    211         if getCached(data, "visualizationData") and subsetData == None: 
    212             self.originalData, self.noJitteringScaledData, self.validDataArray = getCached(data, "visualizationData") 
    213             self.originalSubsetData = self.noJitteringScaledSubsetData = self.validSubsetDataArray = numpy.array([]).reshape([len(self.originalData), 0]) 
    214         else: 
    215             noJitteringData = fullData.toNumpyMA("ac")[0].T 
    216             validDataArray = numpy.array(1-noJitteringData.mask, numpy.short)  # have to convert to int array, otherwise when we do some operations on this array we get overflow 
    217             noJitteringData = numpy.array(MA.filled(noJitteringData, orange.Illegal_Float)) 
    218             originalData = noJitteringData.copy() 
    219              
    220             for index in range(len(data.domain)): 
    221                 attr = data.domain[index] 
    222                 if attr.varType == orange.VarTypes.Discrete: 
    223                     # see if the values for discrete attributes have to be resorted 
    224                     variableValueIndices = getVariableValueIndices(data.domain[index], sortValuesForDiscreteAttrs) 
    225                     if 0 in [i == variableValueIndices[attr.values[i]] for i in range(len(attr.values))]: 
    226                         line = noJitteringData[index].copy()  # make the array a contiguous, otherwise the putmask function does not work 
    227                         indices = [numpy.where(line == val, 1, 0) for val in range(len(attr.values))] 
    228                         for i in range(len(attr.values)): 
    229                             numpy.putmask(line, indices[i], variableValueIndices[attr.values[i]]) 
    230                         noJitteringData[index] = line   # save the changed array 
    231                         originalData[index] = line     # reorder also the values in the original data 
    232                     noJitteringData[index] = (noJitteringData[index]*2.0 + 1.0)/ float(2*len(attr.values)) 
    233                      
    234                 elif attr.varType == orange.VarTypes.Continuous: 
    235                     diff = self.domainDataStat[index].max - self.domainDataStat[index].min or 1     # if all values are the same then prevent division by zero 
    236                     noJitteringData[index] = (noJitteringData[index] - self.domainDataStat[index].min) / diff 
    237  
    238             self.originalData = originalData[:,:lenData]; self.originalSubsetData = originalData[:,lenData:] 
    239             self.noJitteringScaledData = noJitteringData[:,:lenData]; self.noJitteringScaledSubsetData = noJitteringData[:,lenData:] 
    240             self.validDataArray = validDataArray[:,:lenData]; self.validSubsetDataArray = validDataArray[:,lenData:] 
    241          
    242         if data: setCached(data, "visualizationData", (self.originalData, self.noJitteringScaledData, self.validDataArray)) 
    243         if subsetData: setCached(subsetData, "visualizationData", (self.originalSubsetData, self.noJitteringScaledSubsetData, self.validSubsetDataArray)) 
    244              
    245         # compute the scaledData arrays 
    246         scaledData = numpy.concatenate([self.noJitteringScaledData, self.noJitteringScaledSubsetData], axis = 1) 
    247         for index in range(len(data.domain)): 
    248             attr = data.domain[index] 
    249             if attr.varType == orange.VarTypes.Discrete: 
    250                 scaledData[index] += (self.jitterSize/(50.0*max(1,len(attr.values))))*(numpy.random.random(len(fullData)) - 0.5) 
    251                  
    252             elif attr.varType == orange.VarTypes.Continuous and self.jitterContinuous: 
    253                 scaledData[index] += self.jitterSize/50.0 * (0.5 - numpy.random.random(len(fullData))) 
    254                 scaledData[index] = numpy.absolute(scaledData[index])       # fix values below zero 
    255                 ind = numpy.where(scaledData[index] > 1.0, 1, 0)     # fix values above 1 
    256                 numpy.putmask(scaledData[index], ind, 2.0 - numpy.compress(ind, scaledData[index])) 
    257         self.scaledData = scaledData[:,:lenData]; self.scaledSubsetData = scaledData[:,lenData:] 
    258  
    259  
    260    
    261     # scale example's value at index index to a range between 0 and 1 with respect to self.rawData 
    262     def scaleExampleValue(self, example, index): 
    263         if example[index].isSpecial(): 
    264             print "Warning: scaling example with missing value" 
    265             return 0.5     #1e20 
    266         if example.domain[index].varType == orange.VarTypes.Discrete: 
    267             d = getVariableValueIndices(example.domain[index]) 
    268             return (d[example[index].value]*2 + 1) / float(2*len(d)) 
    269         elif example.domain[index].varType == orange.VarTypes.Continuous: 
    270             diff = self.domainDataStat[index].max - self.domainDataStat[index].min 
    271             if diff == 0: diff = 1          # if all values are the same then prevent division by zero 
    272             return (example[index] - self.domainDataStat[index].min) / diff 
    273  
    274  
    275     def getAttributeLabel(self, attrName): 
    276         if self.attributeFlipInfo.get(attrName, 0) and self.dataDomain[attrName].varType == orange.VarTypes.Continuous: 
    277             return "-" + attrName 
    278         return attrName 
    279  
    280     def flipAttribute(self, attrName): 
    281         if attrName not in self.attributeNames: return 0 
    282         if self.dataDomain[attrName].varType == orange.VarTypes.Discrete: return 0 
    283  
    284         index = self.attributeNameIndex[attrName] 
    285         self.attributeFlipInfo[attrName] = 1 - self.attributeFlipInfo.get(attrName, 0) 
    286         if self.dataDomain[attrName].varType == orange.VarTypes.Continuous: 
    287             self.attrValues[attrName] = [-self.attrValues[attrName][1], -self.attrValues[attrName][0]] 
    288  
    289         self.scaledData[index] = 1 - self.scaledData[index] 
    290         self.scaledSubsetData[index] = 1 - self.scaledSubsetData[index] 
    291         self.noJitteringScaledData[index] = 1 - self.noJitteringScaledData[index] 
    292         self.noJitteringScaledSubsetData[index] = 1 - self.noJitteringScaledSubsetData[index] 
    293         return 1 
    294  
    295     def getMinMaxVal(self, attr): 
    296         if type(attr) == int: 
    297             attr = self.attributeNames[attr] 
    298         diff = self.attrValues[attr][1] - self.attrValues[attr][0] 
    299         return diff or 1.0 
    300  
    301     # get array of 0 and 1 of len = len(self.rawData). if there is a missing value at any attribute in indices return 0 for that example 
    302     def getValidList(self, indices, alsoClassIfExists = 1): 
    303         if self.validDataArray == None or len(self.validDataArray) == 0: 
    304             return numpy.array([], numpy.bool) 
    305          
    306         inds = indices[:] 
    307         if alsoClassIfExists and self.dataHasClass:  
    308             inds.append(self.dataClassIndex)  
    309         selectedArray = self.validDataArray.take(inds, axis = 0) 
    310         arr = numpy.add.reduce(selectedArray) 
    311         return numpy.equal(arr, len(inds)) 
    312  
    313     # get array of 0 and 1 of len = len(self.rawSubsetData). if there is a missing value at any attribute in indices return 0 for that example 
    314     def getValidSubsetList(self, indices, alsoClassIfExists = 1): 
    315         if self.validSubsetDataArray == None or len(self.validSubsetDataArray) == 0: 
    316             return numpy.array([], numpy.bool) 
    317         inds = indices[:] 
    318         if alsoClassIfExists and self.dataClassIndex:  
    319             inds.append(self.dataClassIndex) 
    320         selectedArray = self.validSubsetDataArray.take(inds, axis = 0) 
    321         arr = numpy.add.reduce(selectedArray) 
    322         return numpy.equal(arr, len(inds)) 
    323  
    324     # get array with numbers that represent the example indices that have a valid data value 
    325     def getValidIndices(self, indices): 
    326         validList = self.getValidList(indices) 
    327         return numpy.nonzero(validList)[0] 
    328  
    329     # get array with numbers that represent the example indices that have a valid data value 
    330     def getValidSubsetIndices(self, indices): 
    331         validList = self.getValidSubsetList(indices) 
    332         return numpy.nonzero(validList)[0] 
    333  
    334     # returns a number from -max to max 
    335     def rndCorrection(self, max): 
    336         return (random() - 0.5)*2*max 
    337  
     1from Orange.preprocess.scaling import get_variable_values_sorted as getVariableValuesSorted 
     2from Orange.preprocess.scaling import get_variable_value_indices as getVariableValueIndices 
     3from Orange.preprocess.scaling import discretize_domain as discretizeDomain 
     4from Orange.preprocess.scaling import ScaleData as orngScaleData 
  • orange/orngScaleLinProjData.py

    r6538 r8378  
    11from orngScaleData import * 
    2 from copy import copy 
    3 from math import sqrt 
    4  
    5 class orngScaleLinProjData(orngScaleData): 
    6     def __init__(self): 
    7         orngScaleData.__init__(self) 
    8         self.normalizeExamples = 1 
    9         self.anchorData =[]        # form: [(anchor1x, anchor1y, label1),(anchor2x, anchor2y, label2), ...] 
    10         self.lastAttrIndices = None 
    11         self.anchorDict = {} 
    12  
    13     def setAnchors(self, xAnchors, yAnchors, attributes): 
    14         if attributes: 
    15             if xAnchors != None and yAnchors != None: 
    16                 self.anchorData = [(xAnchors[i], yAnchors[i], attributes[i]) for i in range(len(attributes))] 
    17             else: 
    18                 self.anchorData = self.createAnchors(len(attributes), attributes) 
    19  
    20     # create anchors around the circle 
    21     def createAnchors(self, numOfAttr, labels = None): 
    22         xAnchors = self.createXAnchors(numOfAttr) 
    23         yAnchors = self.createYAnchors(numOfAttr) 
    24         if labels: 
    25             return [(xAnchors[i], yAnchors[i], labels[i]) for i in range(numOfAttr)] 
    26         else: 
    27             return [(xAnchors[i], yAnchors[i]) for i in range(numOfAttr)] 
    28  
    29     def createXAnchors(self, numOfAttrs): 
    30         if not self.anchorDict.has_key(numOfAttrs): 
    31             self.anchorDict[numOfAttrs] = (numpy.cos(numpy.arange(numOfAttrs) * 2*math.pi / float(numOfAttrs)), numpy.sin(numpy.arange(numOfAttrs) * 2*math.pi / float(numOfAttrs))) 
    32         return self.anchorDict[numOfAttrs][0] 
    33  
    34     def createYAnchors(self, numOfAttrs): 
    35         if not self.anchorDict.has_key(numOfAttrs): 
    36             self.anchorDict[numOfAttrs] = (numpy.cos(numpy.arange(numOfAttrs) * 2*math.pi / float(numOfAttrs)), numpy.sin(numpy.arange(numOfAttrs) * 2*math.pi / float(numOfAttrs))) 
    37         return self.anchorDict[numOfAttrs][1] 
    38  
    39  
    40      # save projection (xAttr, yAttr, classVal) into a filename fileName 
    41     def saveProjectionAsTabData(self, fileName, attrList, useAnchorData = 0): 
    42         orange.saveTabDelimited(fileName, self.createProjectionAsExampleTable([self.attributeNameIndex[i] for i in attrList], useAnchorData = useAnchorData)) 
    43  
    44     # for attributes in attrIndices and values of these attributes in values compute point positions 
    45     # this function has more sense in radviz and polyviz methods 
    46     def getProjectedPointPosition(self, attrIndices, values, **settingsDict): 
    47         # load the elements from the settings dict 
    48         useAnchorData = settingsDict.get("useAnchorData") 
    49         XAnchors = settingsDict.get("XAnchors") 
    50         YAnchors = settingsDict.get("YAnchors") 
    51         anchorRadius = settingsDict.get("anchorRadius") 
    52         normalizeExample = settingsDict.get("normalizeExample") 
    53  
    54         if attrIndices != self.lastAttrIndices: 
    55             print "getProjectedPointPosition. Warning: Possible bug. The set of attributes is not the same as when computing the whole projection" 
    56  
    57         if XAnchors != None and YAnchors != None: 
    58             XAnchors = numpy.array(XAnchors) 
    59             YAnchors = numpy.array(YAnchors) 
    60             if anchorRadius == None: anchorRadius = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors) 
    61         elif useAnchorData and self.anchorData: 
    62             XAnchors = numpy.array([val[0] for val in self.anchorData]) 
    63             YAnchors = numpy.array([val[1] for val in self.anchorData]) 
    64             if anchorRadius == None: anchorRadius = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors) 
    65         else: 
    66             XAnchors = self.createXAnchors(len(attrIndices)) 
    67             YAnchors = self.createYAnchors(len(attrIndices)) 
    68             anchorRadius = numpy.ones(len(attrIndices), numpy.float) 
    69  
    70         if normalizeExample == 1 or (normalizeExample == None and self.normalizeExamples): 
    71             m = min(values); M = max(values) 
    72             if m < 0.0 or M > 1.0:  # we have to do rescaling of values so that all the values will be in the 0-1 interval 
    73                 #print "example values are not in the 0-1 interval" 
    74                 values = [max(0.0, min(val, 1.0)) for val in values] 
    75                 #m = min(m, 0.0); M = max(M, 1.0); diff = max(M-m, 1e-10) 
    76                 #values = [(val-m) / float(diff) for val in values] 
    77  
    78             s = sum(numpy.array(values)*anchorRadius) 
    79             if s == 0: return [0.0, 0.0] 
    80             x = self.trueScaleFactor * numpy.dot(XAnchors*anchorRadius, values) / float(s) 
    81             y = self.trueScaleFactor * numpy.dot(YAnchors*anchorRadius, values) / float(s) 
    82         else: 
    83             x = self.trueScaleFactor * numpy.dot(XAnchors, values) 
    84             y = self.trueScaleFactor * numpy.dot(YAnchors, values) 
    85  
    86         return [x, y] 
    87  
    88     # create the projection of attribute indices given in attrIndices and create an example table with it. 
    89     def createProjectionAsExampleTable(self, attrIndices, **settingsDict): 
    90         if self.dataDomain.classVar: 
    91             domain = settingsDict.get("domain") or orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar"), orange.EnumVariable(self.dataDomain.classVar.name, values = getVariableValuesSorted(self.dataDomain.classVar))]) 
    92         else: 
    93             domain = settingsDict.get("domain") or orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar")]) 
    94         data = self.createProjectionAsNumericArray(attrIndices, **settingsDict) 
    95         if data != None: 
    96             return orange.ExampleTable(domain, data) 
    97         else: 
    98             return orange.ExampleTable(domain) 
    99  
    100  
    101     def createProjectionAsNumericArray(self, attrIndices, **settingsDict): 
    102         # load the elements from the settings dict 
    103         validData = settingsDict.get("validData") 
    104         classList = settingsDict.get("classList") 
    105         sum_i     = settingsDict.get("sum_i") 
    106         XAnchors = settingsDict.get("XAnchors") 
    107         YAnchors = settingsDict.get("YAnchors") 
    108         scaleFactor = settingsDict.get("scaleFactor", 1.0) 
    109         normalize = settingsDict.get("normalize") 
    110         jitterSize = settingsDict.get("jitterSize", 0.0) 
    111         useAnchorData = settingsDict.get("useAnchorData", 0) 
    112         removeMissingData = settingsDict.get("removeMissingData", 1) 
    113         useSubsetData = settingsDict.get("useSubsetData", 0)        # use the data or subsetData? 
    114         #minmaxVals = settingsDict.get("minmaxVals", None) 
    115  
    116         # if we want to use anchor data we can get attrIndices from the anchorData 
    117         if useAnchorData and self.anchorData: 
    118             attrIndices = [self.attributeNameIndex[val[2]] for val in self.anchorData] 
    119  
    120         if validData == None: 
    121             if useSubsetData: validData = self.getValidSubsetList(attrIndices) 
    122             else:             validData = self.getValidList(attrIndices) 
    123         if sum(validData) == 0: 
    124             return None 
    125  
    126         if classList == None and self.dataDomain.classVar: 
    127             if useSubsetData: classList = self.originalSubsetData[self.dataClassIndex] 
    128             else:             classList = self.originalData[self.dataClassIndex] 
    129  
    130         # if jitterSize is set below zero we use scaledData that has already jittered data 
    131         if useSubsetData: 
    132             if jitterSize < 0.0: data = self.scaledSubsetData 
    133             else:                data = self.noJitteringScaledSubsetData 
    134         else: 
    135             if jitterSize < 0.0: data = self.scaledData 
    136             else:                data = self.noJitteringScaledData 
    137  
    138         selectedData = numpy.take(data, attrIndices, axis = 0) 
    139         if removeMissingData: 
    140             selectedData = numpy.compress(validData, selectedData, axis = 1) 
    141             if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    142                 classList = numpy.compress(validData, classList) 
    143  
    144         if useAnchorData and self.anchorData: 
    145             XAnchors = numpy.array([val[0] for val in self.anchorData]) 
    146             YAnchors = numpy.array([val[1] for val in self.anchorData]) 
    147             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors)     # compute the distance of each anchor from the center of the circle 
    148             if normalize == 1 or (normalize == None and self.normalizeExamples): 
    149                 XAnchors *= r 
    150                 YAnchors *= r 
    151         elif (XAnchors != None and YAnchors != None): 
    152             XAnchors = numpy.array(XAnchors); YAnchors = numpy.array(YAnchors) 
    153             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors)     # compute the distance of each anchor from the center of the circle 
    154         else: 
    155             XAnchors = self.createXAnchors(len(attrIndices)) 
    156             YAnchors = self.createYAnchors(len(attrIndices)) 
    157             r = numpy.ones(len(XAnchors), numpy.float) 
    158  
    159         x_positions = numpy.dot(XAnchors, selectedData) 
    160         y_positions = numpy.dot(YAnchors, selectedData) 
    161  
    162         if normalize == 1 or (normalize == None and self.normalizeExamples): 
    163             if sum_i == None: 
    164                 sum_i = self._getSum_i(selectedData, useAnchorData, r) 
    165             x_positions /= sum_i 
    166             y_positions /= sum_i 
    167             self.trueScaleFactor = scaleFactor 
    168         else: 
    169             if not removeMissingData: 
    170                 try: 
    171                     x_validData = numpy.compress(validData, x_positions) 
    172                     y_validData = numpy.compress(validData, y_positions) 
    173                 except: 
    174                     print validData 
    175                     print x_positions 
    176                     print numpy.shape(validData) 
    177                     print numpy.shape(x_positions) 
    178             else: 
    179                 x_validData = x_positions 
    180                 y_validData = y_positions 
    181              
    182             dist = math.sqrt(max(x_validData*x_validData + y_validData*y_validData)) or 1 
    183             self.trueScaleFactor = scaleFactor / dist 
    184  
    185         self.unscaled_x_positions = numpy.array(x_positions) 
    186         self.unscaled_y_positions = numpy.array(y_positions) 
    187  
    188         if self.trueScaleFactor != 1.0: 
    189             x_positions *= self.trueScaleFactor 
    190             y_positions *= self.trueScaleFactor 
    191  
    192         if jitterSize > 0.0: 
    193             x_positions += numpy.random.uniform(-jitterSize, jitterSize, len(x_positions)) 
    194             y_positions += numpy.random.uniform(-jitterSize, jitterSize, len(y_positions)) 
    195  
    196         self.lastAttrIndices = attrIndices 
    197         if classList != None: 
    198             return numpy.transpose(numpy.array((x_positions, y_positions, classList))) 
    199         else: 
    200             return numpy.transpose(numpy.array((x_positions, y_positions))) 
    201  
    202  
    203     # ############################################################## 
    204     # function to compute the sum of all values for each element in the data. used to normalize. 
    205     def _getSum_i(self, data, useAnchorData = 0, anchorRadius = None): 
    206         if useAnchorData: 
    207             if anchorRadius == None: 
    208                 anchorRadius = numpy.sqrt([a[0]**2+a[1]**2 for a in self.anchorData]) 
    209             sum_i = numpy.add.reduce(numpy.transpose(numpy.transpose(data)*anchorRadius)) 
    210         else: 
    211             sum_i = numpy.add.reduce(data) 
    212         if len(numpy.nonzero(sum_i)) < len(sum_i):    # test if there are zeros in sum_i 
    213             sum_i += numpy.where(sum_i == 0, 1.0, 0.0) 
    214         return sum_i 
     2from Orange.preprocess.scaling import ScaleLinProjData as orngScaleLinProjData 
  • orange/orngScalePolyvizData.py

    r6538 r8378  
    11from orngScaleLinProjData import * 
    2 from copy import copy 
    3 from math import sqrt 
    4  
    5 class orngScalePolyvizData(orngScaleLinProjData): 
    6     def __init__(self): 
    7         orngScaleLinProjData.__init__(self) 
    8         self.normalizeExamples = 1 
    9         self.anchorData =[]        # form: [(anchor1x, anchor1y, label1),(anchor2x, anchor2y, label2), ...] 
    10          
    11  
    12     # attributeReverse, validData = None, classList = None, sum_i = None, XAnchors = None, YAnchors = None, domain = None, scaleFactor = 1.0, jitterSize = 0.0 
    13     def createProjectionAsExampleTable(self, attrList, **settingsDict): 
    14         if self.dataDomain.classVar: 
    15             domain = settingsDict.get("domain") or orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar"), orange.EnumVariable(self.dataDomain.classVar.name, values = getVariableValuesSorted(self.dataDomain.classVar))]) 
    16         else: 
    17             domain = settingsDict.get("domain") or orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar")]) 
    18         data = self.createProjectionAsNumericArray(attrList, **settingsDict) 
    19         if data != None: 
    20             return orange.ExampleTable(domain, data) 
    21         else: 
    22             return orange.ExampleTable(domain) 
    23          
    24     def createProjectionAsNumericArray(self, attrIndices, **settingsDict): 
    25         # load the elements from the settings dict 
    26         attributeReverse = settingsDict.get("reverse", [0]*len(attrIndices)) 
    27         validData = settingsDict.get("validData") 
    28         classList = settingsDict.get("classList") 
    29         sum_i     = settingsDict.get("sum_i") 
    30         XAnchors  = settingsDict.get("XAnchors") 
    31         YAnchors  = settingsDict.get("YAnchors") 
    32         scaleFactor = settingsDict.get("scaleFactor", 1.0) 
    33         jitterSize  = settingsDict.get("jitterSize", 0.0) 
    34         removeMissingData = settingsDict.get("removeMissingData", 1) 
    35          
    36         if validData == None: 
    37             validData = self.getValidList(attrIndices) 
    38         if sum(validData) == 0: 
    39             return None 
    40  
    41         if classList == None and self.dataHasClass: 
    42             classList = self.originalData[self.dataClassIndex]   
    43  
    44         if removeMissingData: 
    45             selectedData = numpy.compress(validData, numpy.take(self.noJitteringScaledData, attrIndices, axis = 0), axis = 1) 
    46             if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    47                 classList = numpy.compress(validData, classList) 
    48         else: 
    49             selectedData = numpy.take(self.noJitteringScaledData, attrIndices, axis = 0) 
    50          
    51         if sum_i == None: 
    52             sum_i = self._getSum_i(selectedData) 
    53  
    54         if XAnchors == None or YAnchors == None: 
    55             XAnchors = self.createXAnchors(len(attrIndices)) 
    56             YAnchors = self.createYAnchors(len(attrIndices)) 
    57  
    58         xanchors = numpy.zeros(numpy.shape(selectedData), numpy.float) 
    59         yanchors = numpy.zeros(numpy.shape(selectedData), numpy.float) 
    60         length = len(attrIndices) 
    61  
    62         for i in range(length): 
    63             if attributeReverse[i]: 
    64                 xanchors[i] = selectedData[i] * XAnchors[i] + (1-selectedData[i]) * XAnchors[(i+1)%length] 
    65                 yanchors[i] = selectedData[i] * YAnchors[i] + (1-selectedData[i]) * YAnchors[(i+1)%length] 
    66             else: 
    67                 xanchors[i] = (1-selectedData[i]) * XAnchors[i] + selectedData[i] * XAnchors[(i+1)%length] 
    68                 yanchors[i] = (1-selectedData[i]) * YAnchors[i] + selectedData[i] * YAnchors[(i+1)%length] 
    69  
    70         x_positions = numpy.sum(numpy.multiply(xanchors, selectedData), axis=0)/sum_i 
    71         y_positions = numpy.sum(numpy.multiply(yanchors, selectedData), axis=0)/sum_i 
    72         #x_positions = numpy.sum(numpy.transpose(xanchors* numpy.transpose(selectedData)), axis=0) / sum_i 
    73         #y_positions = numpy.sum(numpy.transpose(yanchors* numpy.transpose(selectedData)), axis=0) / sum_i 
    74  
    75         if scaleFactor != 1.0: 
    76             x_positions = x_positions * scaleFactor 
    77             y_positions = y_positions * scaleFactor 
    78         if jitterSize > 0.0: 
    79             x_positions += (numpy.random.random(len(x_positions))-0.5)*jitterSize 
    80             y_positions += (numpy.random.random(len(y_positions))-0.5)*jitterSize 
    81  
    82         if classList != None: 
    83             return numpy.transpose(numpy.array((x_positions, y_positions, classList))) 
    84         else: 
    85             return numpy.transpose(numpy.array((x_positions, y_positions))) 
    86  
    87  
    88     def getProjectedPointPosition(self, attrIndices, values, **settingsDict): 
    89         # load the elements from the settings dict 
    90         attributeReverse = settingsDict.get("reverse", [0]*len(attrIndices)) 
    91         useAnchorData = settingsDict.get("useAnchorData") 
    92         XAnchors = settingsDict.get("XAnchors") 
    93         YAnchors = settingsDict.get("YAnchors") 
    94      
    95         if XAnchors != None and YAnchors != None: 
    96             XAnchors = numpy.array(XAnchors) 
    97             YAnchors = numpy.array(YAnchors) 
    98         elif useAnchorData: 
    99             XAnchors = numpy.array([val[0] for val in self.anchorData]) 
    100             YAnchors = numpy.array([val[1] for val in self.anchorData]) 
    101         else: 
    102             XAnchors = self.createXAnchors(len(attrIndices)) 
    103             YAnchors = self.createYAnchors(len(attrIndices)) 
    104  
    105         m = min(values); M = max(values) 
    106         if m < 0.0 or M > 1.0:  # we have to do rescaling of values so that all the values will be in the 0-1 interval 
    107             values = [max(0.0, min(val, 1.0)) for val in values] 
    108             #m = min(m, 0.0); M = max(M, 1.0); diff = max(M-m, 1e-10) 
    109             #values = [(val-m) / float(diff) for val in values] 
    110          
    111         s = sum(numpy.array(values)) 
    112         if s == 0: return [0.0, 0.0] 
    113  
    114         length = len(values) 
    115         xanchors = numpy.zeros(length, numpy.float) 
    116         yanchors = numpy.zeros(length, numpy.float) 
    117         for i in range(length): 
    118             if attributeReverse[i]: 
    119                 xanchors[i] = values[i] * XAnchors[i] + (1-values[i]) * XAnchors[(i+1)%length] 
    120                 yanchors[i] = values[i] * YAnchors[i] + (1-values[i]) * YAnchors[(i+1)%length] 
    121             else: 
    122                 xanchors[i] = (1-values[i]) * XAnchors[i] + values[i] * XAnchors[(i+1)%length] 
    123                 yanchors[i] = (1-values[i]) * YAnchors[i] + values[i] * YAnchors[(i+1)%length] 
    124  
    125         x_positions = numpy.sum(numpy.dot(xanchors, values), axis=0) / float(s) 
    126         y_positions = numpy.sum(numpy.dot(yanchors, values), axis=0) / float(s) 
    127         return [x, y] 
     2from Orange.preprocess.scaling import ScalePolyvizData as orngScalePolyvizData 
  • orange/orngScaleScatterPlotData.py

    r6538 r8378  
    11from orngScaleData import * 
    2  
    3 class orngScaleScatterPlotData(orngScaleData): 
    4  
    5     def getOriginalData(self, indices): 
    6         data = self.originalData.take(indices, axis = 0) 
    7         for i, ind in enumerate(indices): 
    8             [minVal, maxVal] = self.attrValues[self.dataDomain[ind].name] 
    9             if self.dataDomain[ind].varType == orange.VarTypes.Discrete: 
    10                 data[i] += (self.jitterSize/50.0)*(numpy.random.random(len(self.rawData)) - 0.5) 
    11             elif self.dataDomain[ind].varType == orange.VarTypes.Continuous and self.jitterContinuous: 
    12                 data[i] += (self.jitterSize/(50.0*(maxVal-minVal or 1)))*(numpy.random.random(len(self.rawData)) - 0.5) 
    13         return data 
    14      
    15     def getOriginalSubsetData(self, indices): 
    16         data = self.originalSubsetData.take(indices, axis = 0) 
    17         for i, ind in enumerate(indices): 
    18             [minVal, maxVal] = self.attrValues[self.rawSubsetData.domain[ind].name] 
    19             if self.dataDomain[ind].varType == orange.VarTypes.Discrete: 
    20                 data[i] += (self.jitterSize/(50.0*max(1, maxVal)))*(numpy.random.random(len(self.rawSubsetData)) - 0.5) 
    21             elif self.dataDomain[ind].varType == orange.VarTypes.Continuous and self.jitterContinuous: 
    22                 data[i] += (self.jitterSize/(50.0*(maxVal-minVal or 1)))*(numpy.random.random(len(self.rawSubsetData)) - 0.5) 
    23         return data 
    24  
    25     # create x-y projection of attributes in attrList 
    26     def getXYDataPositions(self, xAttr, yAttr): 
    27         xAttrIndex, yAttrIndex = self.attributeNameIndex[xAttr], self.attributeNameIndex[yAttr] 
    28  
    29         xData = self.scaledData[xAttrIndex].copy() 
    30         yData = self.scaledData[yAttrIndex].copy() 
    31          
    32         if self.dataDomain[xAttrIndex].varType == orange.VarTypes.Discrete: xData = ((xData * 2*len(self.dataDomain[xAttrIndex].values)) - 1.0) / 2.0 
    33         else:  xData = xData * (self.attrValues[xAttr][1] - self.attrValues[xAttr][0]) + float(self.attrValues[xAttr][0]) 
    34  
    35         if self.dataDomain[yAttrIndex].varType == orange.VarTypes.Discrete: yData = ((yData * 2*len(self.dataDomain[yAttrIndex].values)) - 1.0) / 2.0 
    36         else:  yData = yData * (self.attrValues[yAttr][1] - self.attrValues[yAttr][0]) + float(self.attrValues[yAttr][0]) 
    37         return (xData, yData) 
    38      
    39      
    40     # create x-y projection of attributes in attrList 
    41     def getXYSubsetDataPositions(self, xAttr, yAttr): 
    42         xAttrIndex, yAttrIndex = self.attributeNameIndex[xAttr], self.attributeNameIndex[yAttr] 
    43  
    44         xData = self.scaledSubsetData[xAttrIndex].copy() 
    45         yData = self.scaledSubsetData[yAttrIndex].copy() 
    46          
    47         if self.dataDomain[xAttrIndex].varType == orange.VarTypes.Discrete: xData = ((xData * 2*len(self.dataDomain[xAttrIndex].values)) - 1.0) / 2.0 
    48         else:  xData = xData * (self.attrValues[xAttr][1] - self.attrValues[xAttr][0]) + float(self.attrValues[xAttr][0]) 
    49  
    50         if self.dataDomain[yAttrIndex].varType == orange.VarTypes.Discrete: yData = ((yData * 2*len(self.dataDomain[yAttrIndex].values)) - 1.0) / 2.0 
    51         else:  yData = yData * (self.attrValues[yAttr][1] - self.attrValues[yAttr][0]) + float(self.attrValues[yAttr][0]) 
    52         return (xData, yData) 
    53      
    54      
    55  
    56     # for attributes in attrIndices and values of these attributes in values compute point positions 
    57     # this function has more sense in radviz and polyviz methods 
    58     def getProjectedPointPosition(self, attrIndices, values, **settingsDict): # settingsDict has to be because radviz and polyviz have this parameter 
    59         return values 
    60  
    61  
    62     # create the projection of attribute indices given in attrIndices and create an example table with it. 
    63     #def createProjectionAsExampleTable(self, attrIndices, validData = None, classList = None, domain = None, jitterSize = 0.0): 
    64     def createProjectionAsExampleTable(self, attrIndices, **settingsDict): 
    65         if self.dataHasClass: 
    66             domain = settingsDict.get("domain") or orange.Domain([orange.FloatVariable(self.dataDomain[attrIndices[0]].name), orange.FloatVariable(self.dataDomain[attrIndices[1]].name), orange.EnumVariable(self.dataDomain.classVar.name, values = getVariableValuesSorted(self.dataDomain.classVar))]) 
    67         else: 
    68             domain = settingsDict.get("domain") or orange.Domain([orange.FloatVariable(self.dataDomain[attrIndices[0]].name), orange.FloatVariable(self.dataDomain[attrIndices[1]].name)]) 
    69  
    70         data = self.createProjectionAsNumericArray(attrIndices, **settingsDict) 
    71         if data != None: 
    72             return orange.ExampleTable(domain, data) 
    73         else: 
    74             return orange.ExampleTable(domain) 
    75  
    76  
    77     def createProjectionAsNumericArray(self, attrIndices, **settingsDict): 
    78         validData = settingsDict.get("validData") 
    79         classList = settingsDict.get("classList") 
    80         jitterSize = settingsDict.get("jitterSize", 0.0) 
    81  
    82         if validData == None: 
    83             validData = self.getValidList(attrIndices) 
    84         if sum(validData) == 0: 
    85             return None 
    86  
    87         if classList == None and self.dataHasClass: 
    88             classList = self.originalData[self.dataClassIndex] 
    89  
    90         xArray = self.noJitteringScaledData[attrIndices[0]] 
    91         yArray = self.noJitteringScaledData[attrIndices[1]] 
    92         if jitterSize > 0.0: 
    93             xArray += (numpy.random.random(len(xArray))-0.5)*jitterSize 
    94             yArray += (numpy.random.random(len(yArray))-0.5)*jitterSize 
    95         if classList != None: 
    96             data = numpy.compress(validData, numpy.array((xArray, yArray, classList)), axis = 1) 
    97         else: 
    98             data = numpy.compress(validData, numpy.array((xArray, yArray)), axis = 1) 
    99         data = numpy.transpose(data) 
    100         return data 
    101  
    102  
    103     def getOptimalClusters(self, attributeNameOrder, addResultFunct): 
    104         if not self.dataHasClass or self.dataHasContinuousClass: 
    105             return 
    106          
    107         jitterSize = 0.001 * self.clusterOptimization.jitterDataBeforeTriangulation 
    108         domain = orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar"), self.dataDomain.classVar]) 
    109  
    110         self.scatterWidget.progressBarInit()  # init again, in case that the attribute ordering took too much time 
    111         startTime = time.time() 
    112         count = len(attributeNameOrder)*(len(attributeNameOrder)-1)/2 
    113         testIndex = 0 
    114  
    115         for i in range(len(attributeNameOrder)): 
    116             for j in range(i): 
    117                 try: 
    118                     attr1 = self.attributeNameIndex[attributeNameOrder[j]] 
    119                     attr2 = self.attributeNameIndex[attributeNameOrder[i]] 
    120                     testIndex += 1 
    121                     if self.clusterOptimization.isOptimizationCanceled(): 
    122                         secs = time.time() - startTime 
    123                         self.clusterOptimization.setStatusBarText("Evaluation stopped (evaluated %d projections in %d min, %d sec)" % (testIndex, secs/60, secs%60)) 
    124                         self.scatterWidget.progressBarFinished() 
    125                         return 
    126  
    127                     data = self.createProjectionAsExampleTable([attr1, attr2], domain = domain, jitterSize = jitterSize) 
    128                     graph, valueDict, closureDict, polygonVerticesDict, enlargedClosureDict, otherDict = self.clusterOptimization.evaluateClusters(data) 
    129  
    130                     allValue = 0.0 
    131                     classesDict = {} 
    132                     for key in valueDict.keys(): 
    133                         addResultFunct(valueDict[key], closureDict[key], polygonVerticesDict[key], [attributeNameOrder[i], attributeNameOrder[j]], int(graph.objects[polygonVerticesDict[key][0]].getclass()), enlargedClosureDict[key], otherDict[key]) 
    134                         classesDict[key] = int(graph.objects[polygonVerticesDict[key][0]].getclass()) 
    135                         allValue += valueDict[key] 
    136                     addResultFunct(allValue, closureDict, polygonVerticesDict, [attributeNameOrder[i], attributeNameOrder[j]], classesDict, enlargedClosureDict, otherDict)     # add all the clusters 
    137                      
    138                     self.clusterOptimization.setStatusBarText("Evaluated %d projections..." % (testIndex)) 
    139                     self.scatterWidget.progressBarSet(100.0*testIndex/float(count)) 
    140                     del data, graph, valueDict, closureDict, polygonVerticesDict, enlargedClosureDict, otherDict, classesDict 
    141                 except: 
    142                     type, val, traceback = sys.exc_info() 
    143                     sys.excepthook(type, val, traceback)  # print the exception 
    144          
    145         secs = time.time() - startTime 
    146         self.clusterOptimization.setStatusBarText("Finished evaluation (evaluated %d projections in %d min, %d sec)" % (testIndex, secs/60, secs%60)) 
    147         self.scatterWidget.progressBarFinished() 
    148  
     2from Orange.preprocess.scaling import ScaleScatterPlotData as orngScaleScatterPlotData 
  • orange/orngVizRank.py

    r8264 r8378  
    101101                import orngScaleLinProjData 
    102102                graph = orngScaleLinProjData.orngScaleLinProjData() 
    103                 graph.normalizeExamples = 1 
     103                graph.normalize_examples = 1 
    104104            elif visualizationMethod in [LINEAR_PROJECTION, KNN_IN_ORIGINAL_SPACE]: 
    105105                import orngScaleLinProjData 
    106106                graph = orngScaleLinProjData.orngScaleLinProjData() 
    107                 graph.normalizeExamples = 0 
     107                graph.normalize_examples = 0 
    108108            elif visualizationMethod == POLYVIZ: 
    109109                import orngScalePolyvizData 
    110110                graph = orngScalePolyvizData.orngScalePolyvizData() 
    111                 graph.normalizeExamples = 1 
     111                graph.normalize_examples = 1 
    112112            else: 
    113113                print "an invalid visualization method was specified. VizRank can not run." 
     
    216216 
    217217    def getkValue(self, kValueFormula = -1): 
    218         if not self.graph.haveData: return 1 
     218        if not self.graph.have_data: return 1 
    219219        if kValueFormula == -1: 
    220220            kValueFormula = self.kValueFormula 
    221         if kValueFormula == 0 or not self.graph.dataHasDiscreteClass or self.graph.dataHasContinuousClass: 
    222             kValue = int(sqrt(len(self.graph.rawData))) 
    223         else: 
    224             kValue = int(len(self.graph.rawData) / max(1, len(self.graph.dataDomain.classVar.values)))    # k = N / c (c = # of class values) 
     221        if kValueFormula == 0 or not self.graph.data_has_discrete_class or self.graph.data_has_continuous_class: 
     222            kValue = int(sqrt(len(self.graph.raw_data))) 
     223        else: 
     224            kValue = int(len(self.graph.raw_data) / max(1, len(self.graph.data_domain.classVar.values)))    # k = N / c (c = # of class values) 
    225225        return kValue 
    226226 
    227227    def createkNNLearner(self, k = -1, kValueFormula = -1): 
    228228        if k == -1: 
    229             if kValueFormula == -1 or not self.graph.haveData or len(self.graph.rawData) == 0: 
     229            if kValueFormula == -1 or not self.graph.have_data or len(self.graph.raw_data) == 0: 
    230230                kValue = self.kValue 
    231231            else: 
     
    244244        self.selectedClasses = [] 
    245245        if self.__class__ == VizRank: 
    246             self.graph.setData(data, self.graph.rawSubsetData) 
    247  
    248         if not self.graph.dataHasDiscreteClass: 
     246            self.graph.setData(data, self.graph.raw_subset_data) 
     247 
     248        if not self.graph.data_has_discrete_class: 
    249249            return 
    250250 
    251         self.selectedClasses = range(len(self.graph.dataDomain.classVar.values)) 
     251        self.selectedClasses = range(len(self.graph.data_domain.classVar.values)) 
    252252 
    253253        if self.autoSetTheKValue: 
     
    259259    def setSubsetData(self, subData): 
    260260        if self.__class__ == VizRank: 
    261             self.graph.setData(self.graph.rawData, subData) 
     261            self.graph.setData(self.graph.raw_data, subData) 
    262262        self.clearArguments() 
    263263 
    264264    def getEvaluatedAttributes(self):         
    265         if self.graph.dataHasDiscreteClass: 
    266             return orngVisFuncts.evaluateAttributesDiscClass(self.graph.rawData, contMeasuresDiscClass[self.attrCont][1], discMeasuresDiscClass[self.attrDisc][1]) 
    267         elif self.graph.dataHasContinuousClass: 
    268             return orngVisFuncts.evaluateAttributesContClass(self.graph.rawData, contMeasuresContClass[self.attrContContClass][1], discMeasuresContClass[self.attrDiscContClass][1]) 
    269         else: 
    270             return orngVisFuncts.evaluateAttributesNoClass(self.graph.rawData, contMeasuresNoClass[self.attrContNoClass][1], discMeasuresNoClass[self.attrDiscNoClass][1]) 
     265        if self.graph.data_has_discrete_class: 
     266            return orngVisFuncts.evaluateAttributesDiscClass(self.graph.raw_data, contMeasuresDiscClass[self.attrCont][1], discMeasuresDiscClass[self.attrDisc][1]) 
     267        elif self.graph.data_has_continuous_class: 
     268            return orngVisFuncts.evaluateAttributesContClass(self.graph.raw_data, contMeasuresContClass[self.attrContContClass][1], discMeasuresContClass[self.attrDiscContClass][1]) 
     269        else: 
     270            return orngVisFuncts.evaluateAttributesNoClass(self.graph.raw_data, contMeasuresNoClass[self.attrContNoClass][1], discMeasuresNoClass[self.attrDiscNoClass][1]) 
    271271         
    272272 
    273273    # return a function that is appropriate to find the best projection in a list in respect to the selected quality measure 
    274274    def getMaxFunct(self): 
    275         if self.graph.dataHasDiscreteClass and self.qualityMeasure == BRIER_SCORE: return min 
     275        if self.graph.data_has_discrete_class and self.qualityMeasure == BRIER_SCORE: return min 
    276276        else: return max 
    277277 
     
    346346        return returnTable, probabilities 
    347347 
    348     # kNNClassifyData - compute classification error for every example in table 
    349     def kNNClassifyData(self, table): 
    350         if len(table) == 0: 
    351             return [], [] 
    352  
    353         # check if we have a discrete class 
    354         if not table.domain.classVar or not table.domain.classVar.varType == orange.VarTypes.Discrete: 
    355             return [], [] 
    356  
    357         if self.externalLearner: learner = self.externalLearner 
    358         else:                    learner = self.createkNNLearner() 
    359         results = apply(testingMethods[self.testingMethod], [[learner], table]) 
    360  
    361         returnTable = [] 
    362  
    363         if table.domain.classVar.varType == orange.VarTypes.Discrete: 
    364             probabilities = numpy.zeros((len(table), len(table.domain.classVar.values)), numpy.float) 
    365             lenClassValues = max(1, len(list(table.domain.classVar.values))) 
    366             if self.qualityMeasure in [AVERAGE_CORRECT, AUC]:       # for AUC we have no way of computing the prediction accuracy for each example 
    367                 for i in range(len(results.results)): 
    368                     res = results.results[i] 
    369                     returnTable.append(res.probabilities[0][res.actualClass]) 
    370                     probabilities[i] = res.probabilities[0] 
    371             elif self.qualityMeasure == BRIER_SCORE: 
    372                 for i in range(len(results.results)): 
    373                     res = results.results[i] 
    374                     s = sum([val*val for val in res.probabilities[0]]) 
    375                     returnTable.append((s + 1 - 2*res.probabilities[0][res.actualClass])/float(lenClassValues)) 
    376                     probabilities[i] = res.probabilities[0] 
    377             elif self.qualityMeasure == CLASS_ACCURACY: 
    378                 for i in range(len(results.results)): 
    379                     res = results.results[i] 
    380                     returnTable.append(res.probabilities[0][res.actualClass] == max(res.probabilities[0])) 
    381                     probabilities[i] = res.probabilities[0] 
    382             else: 
    383                 print "unknown quality measure for kNNClassifyData" 
    384         else: 
    385             probabilities = None 
    386             # for continuous class we can't compute brier score and classification accuracy 
    387             for res in results.results: 
    388                 if not res.probabilities[0]: returnTable.append(0) 
    389                 else:                        returnTable.append(res.probabilities[0].density(res.actualClass)) 
    390  
    391         return returnTable, probabilities 
    392  
    393348    # kNNEvaluate - evaluate class separation in the given projection using a heuristic or k-NN method 
    394349    def kNNComputeAccuracy(self, table): 
     
    498453        # compute accuracy only for classes that are selected as interesting. other class values do not participate in projection evaluation 
    499454        acc = sum(prediction) / float(max(1, len(results.results)))                 # accuracy over all class values 
    500         classes = self.selectedClasses or range(len(self.graph.dataDomain.classVar.values)) 
     455        classes = self.selectedClasses or range(len(self.graph.data_domain.classVar.values)) 
    501456        val = sum([prediction[index] for index in classes])    # accuracy over all selected classes 
    502457 
     
    512467    def findArguments(self, example): 
    513468        self.clearArguments() 
    514         if not self.graph.haveData or not self.graph.dataHasClass or len(self.results) == 0: 
     469        if not self.graph.have_data or not self.graph.data_has_class or len(self.results) == 0: 
    515470            if len(self.results) == 0: print 'To classify an example using VizRank you first have to evaluate some projections.' 
    516             return orange.MajorityLearner(self.graph.rawData)(example, orange.GetBoth) 
    517  
    518         self.arguments = [[] for i in range(len(self.graph.dataDomain.classVar.values))] 
     471            return orange.MajorityLearner(self.graph.raw_data)(example, orange.GetBoth) 
     472 
     473        self.arguments = [[] for i in range(len(self.graph.data_domain.classVar.values))] 
    519474        vals = [0.0 for i in range(len(self.arguments))] 
    520475 
    521476        if self.rankArgumentsByStrength == 1: 
    522477            for index in range(min(len(self.results), self.argumentCount + 50)): 
    523                 classValue, dist = self.computeClassificationForExample(index, example, kValue = len(self.graph.rawData)) 
     478                classValue, dist = self.computeClassificationForExample(index, example, kValue = len(self.graph.raw_data)) 
    524479                if classValue and dist: 
    525480                    for i in range(len(self.arguments)): 
     
    546501        suma = sum(vals) 
    547502        if suma == 0: 
    548             dist = orange.Distribution(self.graph.dataDomain.classVar.name, self.graph.rawData) 
     503            dist = orange.Distribution(self.graph.data_domain.classVar.name, self.graph.raw_data) 
    549504            vals = [dist[i] for i in range(len(dist))]; suma = sum(vals) 
    550505 
    551506        classValue = example.domain.classVar[vals.index(max(vals))] 
    552507        dist = orange.DiscDistribution([val/float(suma) for val in vals]) 
    553         dist.variable = self.graph.dataDomain.classVar 
     508        dist.variable = self.graph.data_domain.classVar 
    554509        return classValue, dist 
    555510 
     
    560515        if 1 in [example[attr].isSpecial() for attr in attrList]: return None, None 
    561516 
    562         attrIndices = [self.graph.attributeNameIndex[attr] for attr in attrList] 
    563         attrVals = [self.graph.scaleExampleValue(example, ind) for ind in attrIndices] 
    564  
    565         table = self.graph.createProjectionAsExampleTable(attrIndices, settingsDict = generalDict) 
    566         [xTest, yTest] = self.graph.getProjectedPointPosition(attrIndices, attrVals, settingsDict = generalDict) 
     517        attrIndices = [self.graph.attribute_name_index[attr] for attr in attrList] 
     518        attrVals = [self.graph.scale_example_value(example, ind) for ind in attrIndices] 
     519 
     520        table = self.graph.create_projection_as_example_table(attrIndices, settingsDict = generalDict) 
     521        [xTest, yTest] = self.graph.get_projected_point_position(attrIndices, attrVals, settingsDict = generalDict) 
    567522 
    568523        learner = self.externalLearner or self.createkNNLearner(k = kValue) 
     
    587542 
    588543    def correctSettingsIfNecessary(self): 
    589         if not self.graph.haveData: return 
     544        if not self.graph.have_data: return 
    590545        # check if we have discrete attributes. if yes, then make sure we are not using s2nMix measure and GAMMA_SINGLE 
    591         if orange.VarTypes.Discrete in [attr.varType for attr in self.graph.dataDomain.attributes]: 
     546        if orange.VarTypes.Discrete in [attr.varType for attr in self.graph.data_domain.attributes]: 
    592547            if self.attrCont == CONT_MEAS_S2NMIX:           self.attrCont = CONT_MEAS_S2N 
    593548            if self.attrSubsetSelection == GAMMA_SINGLE:    self.attrSubsetSelection = GAMMA_ALL 
     
    616571        if self.attrCont == CONT_MEAS_S2NMIX or self.attrSubsetSelection == GAMMA_SINGLE: 
    617572            if not self.evaluationData.has_key("attrs"): 
    618                 attributes, attrsByClass = orngVisFuncts.findAttributeGroupsForRadviz(self.graph.rawData, orngVisFuncts.S2NMeasureMix()) 
    619                 attributes = [self.graph.attributeNameIndex[name] for name in attributes] 
    620                 attrsByClass = [[self.graph.attributeNameIndex[name] for name in arr] for arr in attrsByClass] 
     573                attributes, attrsByClass = orngVisFuncts.findAttributeGroupsForRadviz(self.graph.raw_data, orngVisFuncts.S2NMeasureMix()) 
     574                attributes = [self.graph.attribute_name_index[name] for name in attributes] 
     575                attrsByClass = [[self.graph.attribute_name_index[name] for name in arr] for arr in attrsByClass] 
    621576                self.evaluationData["attrs"] = (attributes, attrsByClass) 
    622577            else: 
     
    624579 
    625580            if z >= len(attributes): return None      # did we already try all the attributes 
    626             numClasses = len(self.graph.dataDomain.classVar.values) 
     581            numClasses = len(self.graph.data_domain.classVar.values) 
    627582            if self.attrSubsetSelection in [GAMMA_ALL, GAMMA_SINGLE]: 
    628583                combinations = self.getAttributeSubsetUsingGammaDistribution(u+1) 
     
    645600                # evaluate attributes 
    646601                evaluatedAttributes = self.getEvaluatedAttributes() 
    647                 attributes = [self.graph.attributeNameIndex[name] for name in evaluatedAttributes] 
     602                attributes = [self.graph.attribute_name_index[name] for name in evaluatedAttributes] 
    648603                self.evaluationData["attrs"] = attributes 
    649604                self.totalPossibilities = 0 
     
    671626                    combination = [] 
    672627                    while len(combination) < u+1: 
    673                         v = random.randint(0, len(self.graph.dataDomain.attributes)-1) 
     628                        v = random.randint(0, len(self.graph.data_domain.attributes)-1) 
    674629                        if v not in combination: combination.append(v) 
    675630                    combinations = [combination] 
     
    699654 
    700655        if self.attrCont == CONT_MEAS_S2NMIX or self.attrSubsetSelection == GAMMA_SINGLE: 
    701             numClasses = len(self.graph.dataDomain.classVar.values) 
     656            numClasses = len(self.graph.data_domain.classVar.values) 
    702657            attributes, attrsByClass = self.evaluationData["attrs"] 
    703658 
     
    705660                attrList = [[] for c in range(numClasses)]; attrs = [] 
    706661                tried = 0 
    707                 while len(attrs) < min(attrCount, len(self.graph.dataDomain.attributes)): 
     662                while len(attrs) < min(attrCount, len(self.graph.data_domain.attributes)): 
    708663                    ind = tried%numClasses 
    709664                    #ind = random.randint(0, numClasses-1)       # warning: this can generate uneven groups for each class value!!! 
     
    759714                permutations.append(reduce(operator.add, combination)) 
    760715            else: 
    761                 for proj in orngVisFuncts.createProjections(len(self.graph.dataDomain.classVar.values), sum([len(group) for group in combination])): 
     716                for proj in orngVisFuncts.createProjections(len(self.graph.data_domain.classVar.values), sum([len(group) for group in combination])): 
    762717                    try: permutations.append([combination[i][j] for (i,j) in proj]) 
    763718                    except: pass 
     
    777732 
    778733    def evaluateProjection(self, data): 
    779         if self.graph.dataHasDiscreteClass: 
     734        if self.graph.data_has_discrete_class: 
    780735            return self.kNNComputeAccuracy(data) 
    781         elif self.graph.dataHasContinuousClass: 
     736        elif self.graph.data_has_continuous_class: 
    782737            return 0 
    783738        else: 
     
    798753    def evaluateProjections(self, clearPreviousProjections = 1): 
    799754        random.seed(0)      # always use the same seed to make results repeatable 
    800         if not self.graph.haveData: return 0 
     755        if not self.graph.have_data: return 0 
    801756         
    802757        # TO DO: remove the following line when we add support for cont class 
    803         if not self.graph.dataHasDiscreteClass: return 0 
     758        if not self.graph.data_has_discrete_class: return 0 
    804759        self.correctSettingsIfNecessary() 
    805760        if self.timeLimit == self.projectionLimit == 0 and self.__class__.__name__ == "VizRank": 
     
    822777            from PyQt4.QtGui import qApp 
    823778 
    824 #        if not self.graph.dataHasDiscreteClass: 
     779#        if not self.graph.data_has_discrete_class: 
    825780#            print "Projections can be evaluated only for data with a discrete class." 
    826781#            return 0 
     
    828783        if self.visualizationMethod == SCATTERPLOT: 
    829784            evaluatedAttributes = self.getEvaluatedAttributes() 
    830             contVars = [orange.FloatVariable(attr.name) for attr in self.graph.dataDomain.attributes] 
    831             attrCount = len(self.graph.dataDomain.attributes) 
     785            contVars = [orange.FloatVariable(attr.name) for attr in self.graph.data_domain.attributes] 
     786            attrCount = len(self.graph.data_domain.attributes) 
    832787 
    833788            count = len(evaluatedAttributes)*(len(evaluatedAttributes)-1)/2 
     
    835790             
    836791            for i in range(len(evaluatedAttributes)): 
    837                 attr1 = self.graph.attributeNameIndex[evaluatedAttributes[i]] 
     792                attr1 = self.graph.attribute_name_index[evaluatedAttributes[i]] 
    838793                for j in range(i): 
    839                     attr2 = self.graph.attributeNameIndex[evaluatedAttributes[j]] 
     794                    attr2 = self.graph.attribute_name_index[evaluatedAttributes[j]] 
    840795                    self.evaluatedProjectionsCount += 1 
    841796                    if self.isEvaluationCanceled(): 
    842797                        return self.evaluatedProjectionsCount 
    843798 
    844                     table = self.graph.createProjectionAsExampleTable([attr1, attr2]) 
     799                    table = self.graph.create_projection_as_example_table([attr1, attr2]) 
    845800                    if len(table) < self.minNumOfExamples: continue 
    846801                    accuracy, other_results = self.evaluateProjection(table) 
    847802                    generalDict = {"Results": self.evaluationResults} if self.saveEvaluationResults else {} 
    848                     self.addResult(accuracy, other_results, len(table), [self.graph.dataDomain[attr1].name, self.graph.dataDomain[attr2].name], self.evaluatedProjectionsCount, generalDict=generalDict) 
     803                    self.addResult(accuracy, other_results, len(table), [self.graph.data_domain[attr1].name, self.graph.data_domain[attr2].name], self.evaluatedProjectionsCount, generalDict=generalDict) 
    849804 
    850805                    if self.__class__ != VizRank: 
     
    856811            if self.projOptimizationMethod != 0: 
    857812                self.freeviz.useGeneralizedEigenvectors = 1 
    858                 self.graph.normalizeExamples = 0 
     813                self.graph.normalize_examples = 0 
    859814 
    860815            # variables and domain for the table 
    861             domain = orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar"), orange.EnumVariable(self.graph.dataDomain.classVar.name, values = getVariableValuesSorted(self.graph.dataDomain.classVar))]) 
     816            domain = orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar"), orange.EnumVariable(self.graph.data_domain.classVar.name, values = getVariableValuesSorted(self.graph.data_domain.classVar))]) 
    862817            minLength = (self.optimizationType == EXACT_NUMBER_OF_ATTRS and self.attributeCount) or 3 
    863818            maxLength = self.attributeCount 
    864             classListFull = self.graph.originalData[self.graph.dataClassIndex] 
     819            classListFull = self.graph.original_data[self.graph.data_class_index] 
    865820 
    866821            # each call to selectNextAttributeSubset gets a new combination of attributes in a range from minLength to maxLength. if we return None for a given number of attributes this 
     
    880835                    if self.projOptimizationMethod != 0 or self.visualizationMethod == KNN_IN_ORIGINAL_SPACE: 
    881836                        if self.visualizationMethod == KNN_IN_ORIGINAL_SPACE: 
    882                             table = self.graph.rawData.select([self.graph.dataDomain[attr] for attr in attrIndices] + [self.graph.dataDomain.classVar] ) 
    883                             xanchors, yanchors = self.graph.createXAnchors(len(attrIndices)), self.graph.createYAnchors(len(attrIndices)) 
    884                             attrNames = [self.graph.dataDomain[attr].name for attr in attrIndices] 
     837                            table = self.graph.raw_data.select([self.graph.data_domain[attr] for attr in attrIndices] + [self.graph.data_domain.classVar] ) 
     838                            xanchors, yanchors = self.graph.create_xanchors(len(attrIndices)), self.graph.create_yanchors(len(attrIndices)) 
     839                            attrNames = [self.graph.data_domain[attr].name for attr in attrIndices] 
    885840                        else: 
    886                             projections = self.freeviz.findProjection(self.projOptimizationMethod, attrIndices, setAnchors = 0, percentDataUsed = self.percentDataUsed) 
     841                            projections = self.freeviz.findProjection(self.projOptimizationMethod, attrIndices, set_anchors = 0, percentDataUsed = self.percentDataUsed) 
    887842                            if projections != None: 
    888843                                xanchors, yanchors, (attrNames, newIndices) = projections 
    889                                 table = self.graph.createProjectionAsExampleTable(newIndices, domain = domain, XAnchors = xanchors, YAnchors = yanchors) 
     844                                table = self.graph.create_projection_as_example_table(newIndices, domain = domain, XAnchors = xanchors, YAnchors = yanchors) 
    890845                        if len(table) < self.minNumOfExamples: continue 
    891846                        self.evaluatedProjectionsCount += 1 
     
    897852                            self.setStatusBarText("Evaluated %s projections..." % (orngVisFuncts.createStringFromNumber(self.evaluatedProjectionsCount))) 
    898853                    else: 
    899                         XAnchors = self.graph.createXAnchors(len(attrIndices)) 
    900                         YAnchors = self.graph.createYAnchors(len(attrIndices)) 
    901                         validData = self.graph.getValidList(attrIndices) 
     854                        XAnchors = self.graph.create_xanchors(len(attrIndices)) 
     855                        YAnchors = self.graph.create_yanchors(len(attrIndices)) 
     856                        validData = self.graph.get_valid_list(attrIndices) 
    902857                        if numpy.sum(validData) >= self.minNumOfExamples: 
    903858                            classList = numpy.compress(validData, classListFull) 
    904                             selectedData = numpy.compress(validData, numpy.take(self.graph.noJitteringScaledData, attrIndices, axis = 0), axis = 1) 
     859                            selectedData = numpy.compress(validData, numpy.take(self.graph.no_jittering_scaled_data, attrIndices, axis = 0), axis = 1) 
    905860                            sum_i = self.graph._getSum_i(selectedData) 
    906861 
     
    912867                                    continue 
    913868 
    914                                 table = self.graph.createProjectionAsExampleTable(permutation, validData = validData, classList = classList, sum_i = sum_i, XAnchors = XAnchors, YAnchors = YAnchors, domain = domain) 
     869                                table = self.graph.create_projection_as_example_table(permutation, validData = validData, classList = classList, sum_i = sum_i, XAnchors = XAnchors, YAnchors = YAnchors, domain = domain) 
    915870                                accuracy, other_results = self.evaluateProjection(table) 
    916871 
     
    918873                                if self.storeEachPermutation: 
    919874                                    generalDict = {"Results": self.evaluationResults} if self.saveEvaluationResults else {} 
    920                                     self.addResult(accuracy, other_results, len(table), [self.graph.attributeNames[i] for i in permutation], self.evaluatedProjectionsCount, generalDict) 
     875                                    self.addResult(accuracy, other_results, len(table), [self.graph.attribute_names[i] for i in permutation], self.evaluatedProjectionsCount, generalDict) 
    921876                                else: 
    922                                     tempList.append((accuracy, other_results, len(table), [self.graph.attributeNames[i] for i in permutation])) 
     877                                    tempList.append((accuracy, other_results, len(table), [self.graph.attribute_names[i] for i in permutation])) 
    923878 
    924879                                self.evaluatedProjectionsCount += 1 
     
    942897 
    943898    def getProjectionQuality(self, attrList, useAnchorData = 0): 
    944         if not self.graph.haveData: return 0.0, None 
    945         table = self.graph.createProjectionAsExampleTable([self.graph.attributeNameIndex[attr] for attr in attrList], useAnchorData = useAnchorData) 
     899        if not self.graph.have_data: return 0.0, None 
     900        table = self.graph.create_projection_as_example_table([self.graph.attribute_name_index[attr] for attr in attrList], useAnchorData = useAnchorData) 
    946901        return self.evaluateProjection(table) 
    947902 
     
    978933 
    979934        attrs = [self.results[i][ATTR_LIST] for i in range(count)]                                   # create a list of attributes that are in the top projections 
    980         attrs = [[self.graph.attributeNameIndex[name] for name in projection] for projection in attrs]    # find indices from the attribute names 
     935        attrs = [[self.graph.attribute_name_index[name] for name in projection] for projection in attrs]    # find indices from the attribute names 
    981936        accuracys = [self.getProjectionQuality(self.results[i][ATTR_LIST])[0] for i in range(count)] 
    982937        projections = [(accuracys[i], attrs[i]) for i in range(len(accuracys))] 
    983938 
    984         domain = orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar"), orange.EnumVariable(self.graph.dataDomain.classVar.name, values = getVariableValuesSorted(self.graph.dataDomain.classVar))]) 
    985         attributes = [self.graph.attributeNameIndex[name] for name in self.getEvaluatedAttributes()[:self.locOptAttrsToTry]] 
     939        domain = orange.Domain([orange.FloatVariable("xVar"), orange.FloatVariable("yVar"), orange.EnumVariable(self.graph.data_domain.classVar.name, values = getVariableValuesSorted(self.graph.data_domain.classVar))]) 
     940        attributes = [self.graph.attribute_name_index[name] for name in self.getEvaluatedAttributes()[:self.locOptAttrsToTry]] 
    986941        self.startTime = time.time() 
    987942        lenOfAttributes = len(attributes) 
     
    989944 
    990945        if self.visualizationMethod == SCATTERPLOT: 
    991             classListFull = self.graph.originalData[self.graph.dataClassIndex] 
     946            classListFull = self.graph.original_data[self.graph.data_class_index] 
    992947 
    993948            tempDict = {} 
     
    1006961 
    1007962                    for testProj in testProjections: 
    1008                         table = self.graph.createProjectionAsExampleTable(testProj, domain = domain) 
     963                        table = self.graph.create_projection_as_example_table(testProj, domain = domain) 
    1009964                        if len(table) < self.minNumOfExamples: continue 
    1010965                        acc, other_results = self.evaluateProjection(table) 
     
    1012967                            self.setStatusBarText("Evaluated %s projections. Last accuracy was: %2.2f%%" % (orngVisFuncts.createStringFromNumber(self.optimizedProjectionsCount), acc)) 
    1013968                        if acc > accuracy: 
    1014                             self.addResult(acc, other_results, len(table), [self.graph.attributeNames[i] for i in testProj], projIndex) 
     969                            self.addResult(acc, other_results, len(table), [self.graph.attribute_names[i] for i in testProj], projIndex) 
    1015970                            self.insertTempProjection(projections, acc, testProj) 
    1016971                            tempDict[tuple(testProj)] = 1 
     
    1026981        # #################### RADVIZ, LINEAR_PROJECTION  ################################ 
    1027982        elif self.visualizationMethod in (RADVIZ, LINEAR_PROJECTION, POLYVIZ): 
    1028             numClasses = len(self.graph.dataDomain.classVar.values) 
    1029  
    1030             classListFull = self.graph.originalData[self.graph.dataClassIndex] 
     983            numClasses = len(self.graph.data_domain.classVar.values) 
     984 
     985            classListFull = self.graph.original_data[self.graph.data_class_index] 
    1031986            newProjDict = {} 
    1032987            projIndex = 0 
     
    1043998                    failedConsecutiveTries = 0 
    1044999                    tries = 0 
    1045                     XAnchors = self.graph.createXAnchors(len(projection)) 
    1046                     YAnchors = self.graph.createYAnchors(len(projection)) 
    1047                     validData = self.graph.getValidList(projection) 
     1000                    XAnchors = self.graph.create_xanchors(len(projection)) 
     1001                    YAnchors = self.graph.create_yanchors(len(projection)) 
     1002                    validData = self.graph.get_valid_list(projection) 
    10481003                    classList = numpy.compress(validData, classListFull) 
    10491004                    while failedConsecutiveTries < 5 and tries < 50: 
     
    10571012                            triedPermutationsDict[str(newProj)] = 1 
    10581013 
    1059                             table = self.graph.createProjectionAsExampleTable(newProj, validData = validData, classList = classList, XAnchors = XAnchors, YAnchors = YAnchors, domain = domain) 
     1014                            table = self.graph.create_projection_as_example_table(newProj, validData = validData, classList = classList, XAnchors = XAnchors, YAnchors = YAnchors, domain = domain) 
    10601015                            if len(table) < self.minNumOfExamples: continue 
    10611016                            acc, other_results = self.evaluateProjection(table) 
     
    10691024                                bestAccuracy = acc 
    10701025                                bestProjection = newProj 
    1071                                 #self.addResult(acc, other_results, len(table), [self.graph.attributeNames[i] for i in newProj], -1, {}) 
     1026                                #self.addResult(acc, other_results, len(table), [self.graph.attribute_names[i] for i in newProj], -1, {}) 
    10721027                            if acc > tempAccuracy or acc > 0.99 * tempAccuracy: 
    10731028                                tempProjection = newProj 
     
    11011056                                if newProjDict.has_key(str(proj)): continue 
    11021057                                newProjDict[str(proj)] = 1 
    1103                                 xanchors, yanchors, (attrNames, newIndices) = self.freeviz.findProjection(self.projOptimizationMethod, proj, setAnchors = 0, percentDataUsed = self.percentDataUsed) 
    1104                                 table = self.graph.createProjectionAsExampleTable(newIndices, domain = domain, XAnchors = xanchors, YAnchors = yanchors) 
     1058                                xanchors, yanchors, (attrNames, newIndices) = self.freeviz.findProjection(self.projOptimizationMethod, proj, set_anchors = 0, percentDataUsed = self.percentDataUsed) 
     1059                                table = self.graph.create_projection_as_example_table(newIndices, domain = domain, XAnchors = xanchors, YAnchors = yanchors) 
    11051060                                if len(table) < self.minNumOfExamples: continue 
    11061061                                self.optimizedProjectionsCount += 1 
     
    11251080                                for i in range(count-1): testProjections[i].insert(i, attr) 
    11261081 
    1127                             XAnchors = self.graph.createXAnchors(count) 
    1128                             YAnchors = self.graph.createYAnchors(count) 
    1129                             validData = self.graph.getValidList(testProjections[0]) 
     1082                            XAnchors = self.graph.create_xanchors(count) 
     1083                            YAnchors = self.graph.create_yanchors(count) 
     1084                            validData = self.graph.get_valid_list(testProjections[0]) 
    11301085                            classList = numpy.compress(validData, classListFull) 
    11311086 
     
    11341089                                newProjDict[str(testProj)] = 1 
    11351090 
    1136                                 table = self.graph.createProjectionAsExampleTable(testProj, validData = validData, classList = classList, XAnchors = XAnchors, YAnchors = YAnchors, domain = domain) 
     1091                                table = self.graph.create_projection_as_example_table(testProj, validData = validData, classList = classList, XAnchors = XAnchors, YAnchors = YAnchors, domain = domain) 
    11371092                                if len(table) < self.minNumOfExamples: continue 
    11381093                                acc, other_results = self.evaluateProjection(table) 
     
    11411096                                    tempList.append((acc, other_results, len(table), testProj, {})) 
    11421097                                if self.storeEachPermutation: 
    1143                                     self.addResult(acc, other_results, len(table), [self.graph.attributeNames[i] for i in testProj], projIndex, {}) 
     1098                                    self.addResult(acc, other_results, len(table), [self.graph.attribute_names[i] for i in testProj], projIndex, {}) 
    11441099 
    11451100                                self.optimizedProjectionsCount += 1 
     
    11531108                        if acc > 1.005*accuracy: 
    11541109                            self.insertTempProjection(projections, acc, attrList) 
    1155                             self.addResult(acc, other_results, lenTable, [self.graph.attributeNames[i] for i in attrList], projIndex , generalDict) 
     1110                            self.addResult(acc, other_results, lenTable, [self.graph.attribute_names[i] for i in attrList], projIndex , generalDict) 
    11561111                            if hasattr(self, "setStatusBarText"): self.setStatusBarText("Found a better projection with accuracy: %2.2f%%" % (acc)) 
    11571112                        if accuracy != 0 and acc > 1.01 * accuracy:  significantImprovement = 1 
     
    11831138        dict = {} 
    11841139        for attr in attrs: dict[attr] = self.__dict__.get(attr) 
    1185         dict["dataCheckSum"] = self.graph.rawData.checksum() 
     1140        dict["dataCheckSum"] = self.graph.raw_data.checksum() 
    11861141        dict["totalProjectionsEvaluated"] = self.evaluatedProjectionsCount + self.optimizedProjectionsCount  # let's also save the total number of projections that we evaluated in order to get this list 
    11871142 
     
    12341189            return [], 0 
    12351190 
    1236         if settings.has_key("dataCheckSum") and settings["dataCheckSum"] != self.graph.rawData.checksum(): 
     1191        if settings.has_key("dataCheckSum") and settings["dataCheckSum"] != self.graph.raw_data.checksum(): 
    12371192            if not ignoreCheckSum and self.__class__.__name__ == "OWVizRank": 
    12381193                if QMessageBox.information(self, 'VizRank', 'The current data set has a different checksum than the data set that was used to evaluate projections in this file.\nDo you want to continue loading anyway, or cancel?','Continue','Cancel', '', 0,1): 
     
    13351290            if self.dialogType == VIZRANK_POINT: 
    13361291                acc, other, tableLen, attrList, tryIndex, generalDict = result 
    1337                 attrIndices = [graph.attributeNameIndex[attr] for attr in attrList] 
    1338                 validDataIndices = graph.getValidIndices(attrIndices) 
    1339                 table = graph.createProjectionAsExampleTable(attrIndices, settingsDict = generalDict)    # TO DO: this does not work with polyviz!!! 
     1292                attrIndices = [graph.attribute_name_index[attr] for attr in attrList] 
     1293                validDataIndices = graph.get_valid_indices(attrIndices) 
     1294                table = graph.create_projection_as_example_table(attrIndices, settingsDict = generalDict)    # TO DO: this does not work with polyviz!!! 
    13401295                acc, probabilities = self.vizrank.kNNClassifyData(table) 
    13411296 
  • source/orange/Makefile

    r8267 r8378  
    1111    $(PYTHON) ../pyxtract/jitlink_build.py R.so r_imports.hpp 
    1212 
    13 obj/daxpy.o : blas/daxpy.c  
    14     $(CCOMPILER) $(COMPILEOPTIONS) -c blas/daxpy.c  -o obj/daxpy.o 
     13 
     14# TODO: Dont compile BLAS if we can link with system (or user 
     15# supplied) blas 
     16