Ignore:
Timestamp:
03/23/12 20:20:57 (2 years ago)
Author:
mstajdohar
Branch:
default
Message:

Changed obsolete names.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/clustering/hierarchical.py

    r10581 r10633  
    368368 
    369369from Orange.utils import progress_bar_milestones, deprecated_keywords 
    370                          
     370 
    371371import sys 
    372372 
     
    408408    matrix = Orange.misc.SymMatrix(len(data)) 
    409409    for i in range(len(data)): 
    410         for j in range(i+1): 
     410        for j in range(i + 1): 
    411411            matrix[i, j] = distance(data[i], data[j]) 
    412     root = HierarchicalClustering(matrix, linkage=linkage, progress_callback=(lambda value, obj=None: progress_callback(value*100.0/(2 if order else 1))) if progress_callback else None) 
     412    root = HierarchicalClustering(matrix, linkage=linkage, progress_callback=(lambda value, obj=None: progress_callback(value * 100.0 / (2 if order else 1))) if progress_callback else None) 
    413413    if order: 
    414         order_leaves(root, matrix, progress_callback=(lambda value: progress_callback(50.0 + value/2)) if progress_callback else None) 
     414        order_leaves(root, matrix, progress_callback=(lambda value: progress_callback(50.0 + value / 2)) if progress_callback else None) 
    415415    return root 
    416416 
     
    447447        for a2 in range(a1): 
    448448            matrix[a1, a2] = (1.0 - orange.PearsonCorrelation(a1, a2, data, 0).r) / 2.0 
    449     root = orange.HierarchicalClustering(matrix, linkage=linkage, progress_callback=(lambda value, obj=None: progress_callback(value*100.0/(2 if order else 1))) if progress_callback else None) 
     449    root = orange.HierarchicalClustering(matrix, linkage=linkage, progress_callback=(lambda value, obj=None: progress_callback(value * 100.0 / (2 if order else 1))) if progress_callback else None) 
    450450    if order: 
    451         order_leaves(root, matrix, progressCallback=(lambda value: progress_callback(50.0 + value/2)) if progress_callback else None) 
     451        order_leaves(root, matrix, progressCallback=(lambda value: progress_callback(50.0 + value / 2)) if progress_callback else None) 
    452452    return root 
    453453 
    454454clustering_features = \ 
    455455    deprecated_keywords({"progressCallback":"progress_callback"})(clustering_features) 
    456      
    457      
     456 
     457 
    458458def cluster_to_list(node, prune=None): 
    459459    """ Return a list of clusters down from the node of hierarchical clustering. 
     
    470470    if prune: 
    471471        if len(node) <= prune: 
    472             return []  
     472            return [] 
    473473    if node.branches: 
    474474        return [node] + cluster_to_list(node.left, prune) + cluster_to_list(node.right, prune) 
     
    528528     
    529529    """ 
    530      
     530 
    531531    objects = getattr(tree.mapping, "objects", None) 
    532532    tree.mapping.setattr("objects", range(len(tree))) 
     
    534534    ordering = {} 
    535535    visited_clusters = set() 
    536      
     536 
    537537#    def opt_ordering_recursive(tree): 
    538538#        if len(tree)==1: 
     
    588588#    with recursion_limit(sys.getrecursionlimit() + len(tree)): 
    589589#        opt_ordering_recursive(tree) 
    590          
     590 
    591591    def opt_ordering_iterative(tree): 
    592         if len(tree)==1: 
     592        if len(tree) == 1: 
    593593            for leaf in tree: 
    594594                M[tree, leaf, leaf] = 0 
     
    596596#            _optOrdering(tree.left) 
    597597#            _optOrdering(tree.right) 
    598              
     598 
    599599            Vl = set(tree.left) 
    600600            Vr = set(tree.right) 
     
    612612                        ordered_k = sorted(other(w, Vrl, Vrr), key=lambda k: M[tree_right, w, k]) 
    613613                        k0 = ordered_k[0] 
    614                         cur_min = 1e30000  
     614                        cur_min = 1e30000 
    615615                        cur_m = cur_k = None 
    616616                        for m in ordered_m: 
     
    639639#                progressCallback(100.0 * len(visited_clusters) / len(tree.mapping)) 
    640640#                visited_clusters.add(tree) 
    641      
     641 
    642642    subtrees = postorder(tree) 
    643643    milestones = progress_bar_milestones(len(subtrees), 1000) 
    644      
     644 
    645645    for i, subtree in enumerate(subtrees): 
    646646        opt_ordering_iterative(subtree) 
     
    661661#            right.swap() 
    662662#        order_recursive(right, k, w) 
    663          
     663 
    664664    def order_iterative(tree, u, w): 
    665665        """ Order the tree based on the computed optimal ordering.  
     
    672672                opt_uw[left] = (u, m) 
    673673                opt_uw[right] = (k, w) 
    674                  
     674 
    675675                if left.branches and m not in left.right: 
    676676                    left.swap() 
    677                  
     677 
    678678                if right.branches and k not in right.left: 
    679679                    right.swap() 
    680      
     680 
    681681    u, w = min([(u, w) for u in tree.left for w in tree.right], key=lambda (u, w): M[tree, u, w]) 
    682      
     682 
    683683##    print "M(v) =", M[tree, u, w] 
    684      
     684 
    685685#    with recursion_limit(sys.getrecursionlimit() + len(tree)): 
    686686#        order_recursive(tree, u, w) 
    687              
     687 
    688688    order_iterative(tree, u, w) 
    689              
     689 
    690690 
    691691#    def _check(tree, u, w): 
     
    722722    """ 
    723723    node_count = iter(range(len(tree))) 
    724      
     724 
    725725    if progress_callback is not None: 
    726726        def p(*args): 
     
    728728    else: 
    729729        p = None 
    730      
     730 
    731731    Orange.core.HierarchicalClusterOrdering(tree, matrix, progress_callback=p) 
    732732 
     
    735735 
    736736order_leaves = order_leaves_cpp 
    737      
     737 
    738738""" 
    739739Matplotlib dendrogram ploting. This is mostly untested, 
     
    774774 
    775775    def add_cell(self, row, col, *args, **kwargs): 
    776         xy = (0,0) 
     776        xy = (0, 0) 
    777777 
    778778        cell = TableCell(xy, *args, **kwargs) 
     
    798798        cells = numpy.array([[self._cells.get((row, col), None) for col in range(max(keys[:, 1] + 1))] \ 
    799799                             for row in range(max(keys[:, 0] + 1))]) 
    800          
     800 
    801801        widths = self._get_column_widths(renderer) 
    802802        x = self.xy[0] + numpy.array([numpy.sum(widths[:i]) for i in range(len(widths))]) 
    803803        y = self.xy[1] - numpy.arange(cells.shape[0]) - 0.5 
    804          
     804 
    805805        for i in range(cells.shape[0]): 
    806806            for j in range(cells.shape[1]): 
     
    816816    def _get_column_widths(self, renderer): 
    817817        keys = numpy.array(self._cells.keys()) 
    818         widths = numpy.zeros(len(keys)).reshape((numpy.max(keys[:,0]+1), numpy.max(keys[:,1]+1))) 
     818        widths = numpy.zeros(len(keys)).reshape((numpy.max(keys[:, 0] + 1), numpy.max(keys[:, 1] + 1))) 
    819819        fontSize = self._calc_fontsize(renderer) 
    820820        for (row, col), cell in self._cells.items(): 
     
    823823            transform = self._axes.transData.inverted() 
    824824            x1, _ = transform.transform_point((0, 0)) 
    825             x2, _ = transform.transform_point((w + w*TableCell.PAD + 10, 0)) 
     825            x2, _ = transform.transform_point((w + w * TableCell.PAD + 10, 0)) 
    826826            w = abs(x1 - x2) 
    827827            widths[row, col] = w 
     
    832832        _, y1 = transform.transform_point((0, 0)) 
    833833        _, y2 = transform.transform_point((0, 1)) 
    834         return min(max(int(abs(y1 - y2)*0.85) ,4), self.max_fontsize) 
     834        return min(max(int(abs(y1 - y2) * 0.85) , 4), self.max_fontsize) 
    835835 
    836836    def get_children(self): 
     
    867867                    points.append(center) 
    868868                self.plt.plot([tree.height, tree.height], [points[0][1], points[-1][1]], color="black") 
    869                 return (tree.height, (points[0][1] + points[-1][1])/2.0) 
     869                return (tree.height, (points[0][1] + points[-1][1]) / 2.0) 
    870870            else: 
    871871                return (0.0, tree.first) 
    872872        draw_tree(self.root) 
    873          
     873 
    874874    def plotHeatMap(self): 
    875875        import numpy.ma as ma 
    876876        import numpy 
    877877        dx, dy = self.root.height, 0 
    878         fx, fy = self.root.height/len(self.data.domain.attributes), 1.0 
     878        fx, fy = self.root.height / len(self.data.domain.attributes), 1.0 
    879879        data, c, w = self.data.toNumpyMA() 
    880         data = (data - ma.min(data))/(ma.max(data) - ma.min(data)) 
    881         x = numpy.arange(data.shape[1] + 1)/float(numpy.max(data.shape)) 
    882         y = numpy.arange(data.shape[0] + 1)/float(numpy.max(data.shape))*len(self.root) 
     880        data = (data - ma.min(data)) / (ma.max(data) - ma.min(data)) 
     881        x = numpy.arange(data.shape[1] + 1) / float(numpy.max(data.shape)) 
     882        y = numpy.arange(data.shape[0] + 1) / float(numpy.max(data.shape)) * len(self.root) 
    883883        self.heatmap_width = numpy.max(x) 
    884884 
     
    892892        if self.plot_attr_names: 
    893893            names = [attr.name for attr in self.data.domain.attributes] 
    894             self.plt.xticks(numpy.arange(data.shape[1] + 1)/float(numpy.max(data.shape)), names) 
     894            self.plt.xticks(numpy.arange(data.shape[1] + 1) / float(numpy.max(data.shape)), names) 
    895895        self.plt.gca().xaxis.tick_top() 
    896896        for label in self.plt.gca().xaxis.get_ticklabels(): 
     
    909909##            tick.label2On = True 
    910910##        text = TableTextLayout(xy=(self.meshXOffset+1, len(self.root)), tableText=[[label] for label in self.labels]) 
    911         text = TableTextLayout(xy=(self.meshXOffset*1.005, len(self.root) - 1), tableText=[[label] for label in self.labels]) 
     911        text = TableTextLayout(xy=(self.meshXOffset * 1.005, len(self.root) - 1), tableText=[[label] for label in self.labels]) 
    912912        text.set_figure(self.plt.gcf()) 
    913913        self.plt.gca().add_artist(text) 
     
    916916    def plotLabels(self): 
    917917##        table = TablePlot(xy=(self.meshXOffset*1.005, len(self.root) -1), axes=self.plt.gca()) 
    918         table = TablePlot(xy=(0, len(self.root) -1), axes=self.plt.gca()) 
     918        table = TablePlot(xy=(0, len(self.root) - 1), axes=self.plt.gca()) 
    919919        table.set_figure(self.plt.gcf()) 
    920         for i,label in enumerate(self.labels): 
     920        for i, label in enumerate(self.labels): 
    921921            table.add_cell(i, 0, width=1, height=1, text=label, loc="left", edgecolor="w") 
    922922        table.set_zorder(0) 
    923923        self.plt.gca().add_artist(table) 
    924924        self.plt.gca()._set_artist_props(table) 
    925      
     925 
    926926    def plot(self, filename=None, show=False): 
    927927        self.plt.rcParams.update(self.params) 
     
    930930        space = 0.01 if self.space_width == None else self.space_width 
    931931        border = self.border_width 
    932         width = 1.0 - 2*border 
    933         height = 1.0 - 2*border 
    934         textLineHeight = min(max(h/len(self.labels), 4), self.plt.rcParams.get("font.size", 12)) 
    935         maxTextLineWidthEstimate = textLineHeight*labelLen 
     932        width = 1.0 - 2 * border 
     933        height = 1.0 - 2 * border 
     934        textLineHeight = min(max(h / len(self.labels), 4), self.plt.rcParams.get("font.size", 12)) 
     935        maxTextLineWidthEstimate = textLineHeight * labelLen 
    936936##        print maxTextLineWidthEstimate 
    937         textAxisWidthRatio = 2.0*maxTextLineWidthEstimate/w 
     937        textAxisWidthRatio = 2.0 * maxTextLineWidthEstimate / w 
    938938##        print textAxisWidthRatio 
    939939        labelsAreaRatio = min(textAxisWidthRatio, 0.4) if self.label_width == None else self.label_width 
    940940        x, y = len(self.data.domain.attributes), len(self.data) 
    941941 
    942         heatmapAreaRatio = min(1.0*y/h*x/w, 0.3) if self.heatmap_width == None else self.heatmap_width 
    943         dendrogramAreaRatio = 1.0 - labelsAreaRatio - heatmapAreaRatio - 2*space if self.dendrogram_width == None else self.dendrogram_width 
     942        heatmapAreaRatio = min(1.0 * y / h * x / w, 0.3) if self.heatmap_width == None else self.heatmap_width 
     943        dendrogramAreaRatio = 1.0 - labelsAreaRatio - heatmapAreaRatio - 2 * space if self.dendrogram_width == None else self.dendrogram_width 
    944944 
    945945        self.fig = self.plt.figure() 
    946         self.labels_offset = self.root.height/20.0 
    947         dendrogramAxes = self.plt.axes([border, border, width*dendrogramAreaRatio, height]) 
     946        self.labels_offset = self.root.height / 20.0 
     947        dendrogramAxes = self.plt.axes([border, border, width * dendrogramAreaRatio, height]) 
    948948        dendrogramAxes.xaxis.grid(True) 
    949949        import matplotlib.ticker as ticker 
     
    953953        dendrogramAxes.invert_xaxis() 
    954954        self.plotDendrogram() 
    955         heatmapAxes = self.plt.axes([border + width*dendrogramAreaRatio + space, border, width*heatmapAreaRatio, height], sharey=dendrogramAxes) 
     955        heatmapAxes = self.plt.axes([border + width * dendrogramAreaRatio + space, border, width * heatmapAreaRatio, height], sharey=dendrogramAxes) 
    956956 
    957957        heatmapAxes.xaxis.set_major_locator(ticker.NullLocator()) 
     
    959959        heatmapAxes.yaxis.set_major_locator(ticker.NullLocator()) 
    960960        heatmapAxes.yaxis.set_minor_locator(ticker.NullLocator()) 
    961          
     961 
    962962        self.plotHeatMap() 
    963         labelsAxes = self.plt.axes([border + width*(dendrogramAreaRatio + heatmapAreaRatio + 2*space), border, width*labelsAreaRatio, height], sharey=dendrogramAxes) 
     963        labelsAxes = self.plt.axes([border + width * (dendrogramAreaRatio + heatmapAreaRatio + 2 * space), border, width * labelsAreaRatio, height], sharey=dendrogramAxes) 
    964964        self.plotLabels() 
    965965        labelsAxes.set_axis_off() 
     
    974974        if show: 
    975975            self.plt.show() 
    976          
    977          
     976 
     977 
    978978""" 
    979979Dendrogram ploting using Orange.utils.render 
     
    994994         
    995995    """ 
    996     def __init__(self, tree, attr_tree = None, labels=None, data=None, width=None, height=None, tree_height=None, heatmap_width=None, text_width=None,  
     996    def __init__(self, tree, attr_tree=None, labels=None, data=None, width=None, height=None, tree_height=None, heatmap_width=None, text_width=None, 
    997997                 spacing=2, cluster_colors={}, color_palette=ColorPalette([(255, 0, 0), (0, 255, 0)]), maxv=None, minv=None, gamma=None, renderer=EPSRenderer, **kwargs): 
    998998        self.tree = tree 
     
    10061006                labels = [""] * len(tree) 
    10071007        self.labels = labels 
    1008          
     1008 
    10091009#        self.attr_labels = [str(attr.name) for attr in data.domain.attributes] if not attr_labels and data else attr_labels or [] 
    10101010        self.data = data 
     
    10251025        self.set_matrix_color_schema(color_palette, minv, maxv, gamma) 
    10261026        self.renderer = renderer 
    1027          
     1027 
    10281028    def set_matrix_color_schema(self, color_palette, minv, maxv, gamma=None): 
    10291029        """ Set the matrix color scheme. 
     
    10361036        self.maxv = maxv 
    10371037        self.gamma = gamma 
    1038          
     1038 
    10391039    def color_shema(self): 
    1040         vals = [float(val) for ex in self.data for val in ex if not val.isSpecial() and val.variable.varType==orange.VarTypes.Continuous] or [0] 
    1041         avg = sum(vals)/len(vals) 
    1042          
     1040        vals = [float(val) for ex in self.data for val in ex if not val.isSpecial() and val.variable.varType == orange.VarTypes.Continuous] or [0] 
     1041        avg = sum(vals) / len(vals) 
     1042 
    10431043        maxVal = self.maxv if self.maxv else max(vals) 
    10441044        minVal = self.minv if self.minv else min(vals) 
    1045          
     1045 
    10461046        def _colorSchema(val): 
    10471047            if val.isSpecial(): 
    10481048                return self.color_palette(None) 
    1049             elif val.variable.varType==orange.VarTypes.Continuous: 
     1049            elif val.variable.varType == orange.VarTypes.Continuous: 
    10501050                r, g, b = self.color_palette((float(val) - minVal) / abs(maxVal - minVal), gamma=self.gamma) 
    1051             elif val.variable.varType==orange.VarTypes.Discrete: 
    1052                 r = g = b = int(255.0*float(val)/len(val.variable.values)) 
     1051            elif val.variable.varType == orange.VarTypes.Discrete: 
     1052                r = g = b = int(255.0 * float(val) / len(val.variable.values)) 
    10531053            return (r, g, b) 
    10541054        return _colorSchema 
    1055      
     1055 
    10561056    def layout(self): 
    10571057        height_final = False 
     
    10611061            height, height_final = self.height, True 
    10621062            heatmap_height = height - (tree_height + self.spacing if self.attr_tree else 0) - 2 * self.horizontal_margin 
    1063             font_size =  heatmap_height / len(self.labels) #self.font_size or (height - (tree_height + self.spacing if self.attr_tree else 0) - 2 * self.horizontal_margin) / len(self.labels) 
     1063            font_size = heatmap_height / len(self.labels) #self.font_size or (height - (tree_height + self.spacing if self.attr_tree else 0) - 2 * self.horizontal_margin) / len(self.labels) 
    10641064        else: 
    10651065            font_size = self.font_size 
    10661066            heatmap_height = font_size * len(self.labels) 
    10671067            height = heatmap_height + (tree_height + self.spacing if self.attr_tree else 0) + 2 * self.horizontal_margin 
    1068               
     1068 
    10691069        text_width = self.text_width or max([len(label) for label in self.labels] + [0]) * font_size #max([self.renderer.string_size_hint(label) for label in self.labels]) 
    1070          
     1070 
    10711071        if self.width: 
    10721072            width = self.width 
     
    10751075            heatmap_width = len(self.data.domain.attributes) * heatmap_height / len(self.data) if self.data else 0 
    10761076            width = 2 * self.vertical_margin + tree_height + (heatmap_width + self.spacing if self.data else 0) + self.spacing + text_width 
    1077              
     1077 
    10781078        return width, height, tree_height, heatmap_width, heatmap_height, text_width, font_size 
    1079      
     1079 
    10801080    def plot(self, filename="graph.eps", **kwargs): 
    10811081        width, height, tree_height, heatmap_width, heatmap_height, text_width, font_size = self.layout() 
     
    10831083 
    10841084        heatmap_cell_width = 0.0 if not self.data else heatmap_width / len(self.data.domain.attributes) 
    1085          
     1085 
    10861086        self.renderer = self.renderer(width, height) 
    1087          
     1087 
    10881088        def draw_tree(cluster, root, treeheight, treewidth, color): 
    10891089            height = treeheight * cluster.height / root.height 
     
    10931093                    center = draw_tree(branch, root, treeheight, treewidth, self.cluster_colors.get(branch, color)) 
    10941094                    centers.append(center) 
    1095                     self.renderer.draw_line(center[0], center[1], center[0], height, stroke_color = self.cluster_colors.get(branch, color)) 
    1096                      
    1097                 self.renderer.draw_line(centers[0][0], height, centers[-1][0], height, stroke_color = self.cluster_colors.get(cluster, color)) 
     1095                    self.renderer.draw_line(center[0], center[1], center[0], height, stroke_color=self.cluster_colors.get(branch, color)) 
     1096 
     1097                self.renderer.draw_line(centers[0][0], height, centers[-1][0], height, stroke_color=self.cluster_colors.get(cluster, color)) 
    10981098                return (centers[0][0] + centers[-1][0]) / 2.0, height 
    10991099            else: 
     
    11031103        self.renderer.rotate(90) 
    11041104#        print self.renderer.transform() 
    1105         draw_tree(self.tree, self.tree, tree_height, heatmap_height, self.cluster_colors.get(self.tree, (0,0,0))) 
     1105        draw_tree(self.tree, self.tree, tree_height, heatmap_height, self.cluster_colors.get(self.tree, (0, 0, 0))) 
    11061106        self.renderer.restore_render_state() 
    11071107        if self.attr_tree: 
     
    11101110            self.renderer.scale(1.0, -1.0) 
    11111111#            print self.renderer.transform() 
    1112             draw_tree(self.attr_tree, self.attr_tree, tree_height, heatmap_width, self.cluster_colors.get(self.attr_tree, (0,0,0))) 
     1112            draw_tree(self.attr_tree, self.attr_tree, tree_height, heatmap_width, self.cluster_colors.get(self.attr_tree, (0, 0, 0))) 
    11131113            self.renderer.restore_render_state() 
    1114          
     1114 
    11151115        self.renderer.save_render_state() 
    11161116        self.renderer.translate(self.vertical_margin + tree_height + self.spacing, self.horizontal_margin + (tree_height + self.spacing if self.attr_tree else 0)) 
     
    11231123                    r, g, b = colorSchema(ex[jj]) 
    11241124                    self.renderer.draw_rect(j * heatmap_cell_width, i * heatmap_cell_height, heatmap_cell_width, heatmap_cell_height, fill_color=(r, g, b), stroke_color=(255, 255, 255)) 
    1125          
     1125 
    11261126        self.renderer.translate(heatmap_width + self.spacing, heatmap_cell_height) 
    11271127#        print self.renderer.transform() 
     
    11321132        self.renderer.restore_render_state() 
    11331133        self.renderer.save(filename, **kwargs) 
    1134          
    1135          
     1134 
     1135 
    11361136def dendrogram_draw(file, cluster, attr_cluster=None, labels=None, data=None, 
    11371137                    width=None, height=None, tree_height=None, 
    1138                     heatmap_width=None, text_width=None,  spacing=2, 
     1138                    heatmap_width=None, text_width=None, spacing=2, 
    11391139                    cluster_colors={}, 
    11401140                    color_palette=ColorPalette([(255, 0, 0), (0, 255, 0)]), 
     
    11931193        name, ext = os.path.splitext(file) 
    11941194        format = ext.lower().lstrip(".") or format 
    1195          
     1195 
    11961196    if format is None: 
    11971197        format = "png" 
    1198          
     1198 
    11991199    renderer = {"eps":EPSRenderer, "svg":SVGRenderer, "png":PILRenderer}.get(format, "png") 
    1200      
     1200 
    12011201    d = DendrogramPlot(cluster, attr_cluster, labels, data, width, height, 
    12021202                       tree_height, heatmap_width, text_width, spacing, 
     
    12071207    else: 
    12081208        d.plot(file) 
    1209      
     1209 
    12101210def postorder(cluster): 
    12111211    """ Return a post order list of clusters. 
     
    12221222    while stack: 
    12231223        cluster = stack.pop(0) 
    1224          
     1224 
    12251225        if cluster.branches: 
    12261226            if cluster in visited: 
     
    12331233            visited.add(cluster) 
    12341234    return order 
    1235      
    1236      
     1235 
     1236 
    12371237def preorder(cluster): 
    12381238    """ Return a pre order list of clusters. 
     
    12521252            stack = cluster.branches + stack 
    12531253    return order 
    1254      
    1255      
     1254 
     1255 
    12561256def dendrogram_layout(cluster, expand_leaves=False): 
    12571257    """ Return a layout of the cluster dendrogram on a 2D plane. The return  
     
    12921292            cluster_geometry[cluster] = (start, center, end) 
    12931293            result.append((cluster, (start, center, end))) 
    1294              
     1294 
    12951295    return result 
    1296      
     1296 
    12971297def clone(cluster): 
    12981298    """ Clone a cluster, including it's subclusters. 
     
    13131313        node_clone.mapping = mapping 
    13141314        clones[node] = node_clone 
    1315          
     1315 
    13161316    return clones[cluster] 
    1317      
     1317 
    13181318def pruned(cluster, level=None, height=None, condition=None): 
    13191319    """ Return a new pruned clustering instance.     
     
    13421342    prune(cluster, level, height, condition) 
    13431343    return cluster 
    1344      
    1345      
     1344 
     1345 
    13461346def prune(cluster, level=None, height=None, condition=None): 
    13471347    """ Prune the clustering instance ``cluster`` in place. 
     
    13651365    if not any(arg is not None for arg in [level, height, condition]): 
    13661366        raise ValueError("At least one pruning argument must be supplied") 
    1367      
     1367 
    13681368    level_check = height_check = condition_check = lambda cl: False 
    13691369    cluster_depth = cluster_depths(cluster) 
    1370      
     1370 
    13711371    if level is not None: 
    13721372        level_check = lambda cl: cluster_depth[cl] >= level 
    1373          
     1373 
    13741374    if height is not None: 
    13751375        height_check = lambda cl: cl.height <= height 
     
    13771377    if condition is not None: 
    13781378        condition_check = condition 
    1379          
     1379 
    13801380    pruned_set = set() 
    1381      
     1381 
    13821382    def check_all(cl): 
    13831383        return any([check(cl) for check in [level_check, height_check, 
    13841384                                            condition_check]]) 
    1385          
     1385 
    13861386    for cluster in preorder(cluster): 
    13871387        if cluster not in pruned_set: 
     
    13911391            else: 
    13921392                pass 
    1393      
    1394      
     1393 
     1394 
    13951395def cluster_depths(cluster): 
    13961396    """ Return a dictionary mapping :class:`HierarchicalCluster` instances to 
     
    14341434    iter_count = matrix.dim * (matrix.dim - 1) / 2 
    14351435    milestones = progress_bar_milestones(iter_count, 100) 
    1436      
     1436 
    14371437    for count, ((i, a1), (j, a2)) in enumerate(_pairs(enumerate(attributes))): 
    14381438        matrix[i, j] = (1.0 - orange.PearsonCorrelation(a1, a2, data, 0).r) / 2.0 
    14391439        if progress_callback and count in milestones: 
    14401440            progress_callback(100.0 * count / iter_count) 
    1441              
     1441 
    14421442    return matrix 
    14431443 
    14441444 
    1445 def _pairs(seq, same = False): 
     1445def _pairs(seq, same=False): 
    14461446    """ Return all pairs from elements of `seq`. 
    14471447    """ 
     
    14511451        for j in range(i + same, len(seq)): 
    14521452            yield seq[i], seq[j] 
    1453      
    1454      
     1453 
     1454 
    14551455def joining_cluster(cluster, item1, item2): 
    14561456    """ Return the cluster where `item1` and `item2` are first joined 
     
    14741474        else: 
    14751475            return cluster 
    1476          
     1476 
    14771477 
    14781478def cophenetic_distances(cluster): 
     
    14881488    """ 
    14891489 
    1490     mapping = cluster.mapping   
     1490    mapping = cluster.mapping 
    14911491    matrix = Orange.misc.SymMatrix(len(mapping)) 
    14921492    for cluster in postorder(cluster): 
     
    14961496                    for idx2 in mapping[branch2.first: branch2.last]: 
    14971497                        matrix[idx1, idx2] = cluster.height 
    1498                  
     1498 
    14991499        else: 
    15001500            for ind1, ind2 in _pairs(mapping[cluster.first: cluster.last]): 
    15011501                matrix[ind1, ind2] = cluster.height 
    1502      
     1502 
    15031503    return matrix 
    15041504 
    1505      
     1505 
    15061506def cophenetic_correlation(cluster, matrix): 
    15071507    """ Return the `cophenetic correlation coefficient 
     
    15251525    original = numpy.ravel(original) 
    15261526    return numpy.corrcoef(cophenetic, original)[0, 1] 
    1527      
    1528      
     1527 
     1528 
Note: See TracChangeset for help on using the changeset viewer.