Changeset 9079:e7257ee74959 in orange


Ignore:
Timestamp:
10/08/11 14:01:56 (3 years ago)
Author:
matejd <matejd@…>
Branch:
default
Convert:
1c47e12c107a85dbd4b1c8b371ebfbb45150be4f
Message:

Basic network display + transforms

Location:
orange/OrangeWidgets
Files:
4 added
2 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Visualize Qt/OWNxCanvas3D.py

    r9064 r9079  
    1 from plot.owplot3d import OWPlot3D 
     1from plot.owplot3d import OWPlot3D, GL_FLOAT, GL_LINES, GL_POINTS, glEnable, GL_PROGRAM_POINT_SIZE 
     2from plot.owopenglrenderer import VertexBuffer 
    23from PyQt4.QtCore import Qt 
    34from PyQt4.QtGui import QVBoxLayout 
     5from PyQt4 import QtOpenGL 
    46import orangeqt 
    57import Orange 
     
    79import numpy 
    810import math 
     11import os 
    912 
    1013from orngScaleScatterPlotData import getVariableValueIndices 
    1114 
    1215class Node3D(orangeqt.Node3D): 
     16    # TODO: __slot__ 
    1317    def __init__(self, index, x=None, y=None, z=None): 
    1418        orangeqt.Node3D.__init__(self, index, 0, Qt.blue, 5) 
     
    8791        self.graph_margin = 1 
    8892 
     93        self._markers = [] 
     94        self._edge_buffer = None 
     95        self._node_buffer = None 
     96 
    8997    def draw_callback(self): 
    90         pass 
     98        if not hasattr(self, '_edge_shader'): 
     99            self._edge_shader = QtOpenGL.QGLShaderProgram() 
     100            self._edge_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, 
     101                os.path.join(os.path.dirname(__file__), 'edge.vs')) 
     102            self._edge_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Fragment, 
     103                os.path.join(os.path.dirname(__file__), 'edge.fs')) 
     104 
     105            self._edge_shader.bindAttributeLocation('position', 0) 
     106 
     107            if not self._edge_shader.link(): 
     108                print('Failed to link edge shader!') 
     109 
     110            self._node_shader = QtOpenGL.QGLShaderProgram() 
     111            self._node_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, 
     112                os.path.join(os.path.dirname(__file__), 'node.vs')) 
     113            self._node_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Fragment, 
     114                os.path.join(os.path.dirname(__file__), 'node.fs')) 
     115 
     116            self._node_shader.bindAttributeLocation('position', 0) 
     117 
     118            if not self._node_shader.link(): 
     119                print('Failed to link node shader!') 
     120 
     121        self._edge_shader.bind() 
     122        self._edge_shader.setUniformValue('projection', self.plot.projection) 
     123        self._edge_shader.setUniformValue('model', self.plot.model) 
     124        self._edge_shader.setUniformValue('view', self.plot.view) 
     125        self._edge_shader.setUniformValue('translation', self.plot.plot_translation) 
     126        self._edge_shader.setUniformValue('scale', self.plot.plot_scale) 
     127        self._edge_buffer.draw(GL_LINES) 
     128        self._edge_shader.release() 
     129 
     130        glEnable(GL_PROGRAM_POINT_SIZE) 
     131        self._node_shader.bind() 
     132        self._node_shader.setUniformValue('projection', self.plot.projection) 
     133        self._node_shader.setUniformValue('model', self.plot.model) 
     134        self._node_shader.setUniformValue('view', self.plot.view) 
     135        self._node_shader.setUniformValue('translation', self.plot.plot_translation) 
     136        self._node_shader.setUniformValue('scale', self.plot.plot_scale) 
     137        self._node_buffer.draw(GL_POINTS) 
     138        self._node_shader.release() 
    91139 
    92140    def update_canvas(self): 
    93         self.draw_component_keywords() 
     141        self.update_component_keywords() 
    94142        self.update() 
    95143 
     
    142190            orangeqt.Canvas3D.set_node_marks(self, dict((i, True) for i in toMark)) 
    143191 
    144     def draw_component_keywords(self): 
    145         #self.clear_markers() 
     192    def update_component_keywords(self): 
    146193        if self.show_component_attribute == None or self.graph is None or self.items is None: 
    147194            return 
     
    154201        nodes = self.nodes() 
    155202 
     203        self._markers = [] 
     204 
    156205        for c in components: 
    157206            if len(c) == 0: 
     
    160209            x1 = sum(nodes[n].x() for n in c) / len(c) 
    161210            y1 = sum(nodes[n].y() for n in c) / len(c) 
     211            z1 = sum(nodes[n].z() for n in c) / len(c) 
    162212            lbl = str(self.items[c[0]][str(self.show_component_attribute)]) 
    163213 
     214            self._markers.append((lbl, x1, y1, z1)) 
    164215            #self.add_marker(lbl, x1, y1, alignment=Qt.AlignCenter, size=self.font_size) 
    165216 
     
    170221        maxValue = None 
    171222 
    172         if attribute[0] != "(" or attribute[ -1] != ")": 
     223        if attribute[0] != "(" or attribute[-1] != ")": 
    173224            i = 0 
    174225            for var in table.domain.variables: 
     
    203254        colorIndices, colorIndex, minValue, maxValue = self.get_color_indices(self.items, attribute, self.discPalette) 
    204255        colors = {} 
    205          
     256 
    206257        if nodes is None: 
    207258            nodes = self.graph.nodes() 
     
    209260        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
    210261            colors.update((node, self.discPalette[0]) for node in nodes) 
    211          
     262 
    212263        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    213264            colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)])  
     
    217268        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    218269            colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes) 
    219              
     270 
    220271        else: 
    221272            colors.update((node, self.discPalette[0]) for node in nodes) 
    222          
     273 
    223274        orangeqt.Canvas3D.set_node_colors(self, colors) 
    224275        self.update() 
     
    232283        if attributes is not None: 
    233284            self.node_label_attributes = attributes 
    234          
     285 
    235286        label_attributes = [] 
    236287        if self.items is not None and isinstance(self.items, orange.ExampleTable): 
    237288            label_attributes = [self.items.domain[att] for att in \ 
    238289                self.node_label_attributes if att in self.items.domain] 
    239              
     290 
    240291        indices = [[] for u in nodes] 
    241292        if self.show_indices: 
    242293            indices = [[str(u)] for u in nodes] 
    243              
     294 
    244295        if self.trim_label_words > 0: 
    245296            orangeqt.Canvas3D.set_node_labels(self, dict((node,  
     
    280331        if self.graph is None: 
    281332            return  
    282          
     333 
    283334        edges = self.edge_indices() 
    284335 
    285336        if attributes is not None: 
    286337            self.edge_label_attributes = attributes 
    287          
     338 
    288339        label_attributes = [] 
    289340        if self.links is not None and isinstance(self.links, orange.ExampleTable): 
    290341            label_attributes = [self.links.domain[att] for att in \ 
    291342                self.edge_label_attributes if att in self.links.domain] 
    292              
     343 
    293344        weights = [[] for ex in edges] 
    294345        if self.show_weights: 
    295346            weights = [["%.2f" % self.graph[u][v].get('weight', 1)] for u,v in edges] 
    296              
     347 
    297348        orangeqt.Canvas3D.set_edge_labels(self, 
    298349            [', '.join(weights[i] + [str(self.links[i][att]) for att in label_attributes]) for i,edge in enumerate(edges)]) 
     
    317368 
    318369        self.graph = newgraph 
    319          
     370 
    320371        if len(remove_nodes) == 0 and len(add_nodes) == 0: 
    321372            return False 
    322          
     373 
    323374        current_nodes = self.nodes() 
    324375 
     
    331382            if len(neighbors-nodes) == 0: 
    332383                return [] 
    333              
     384 
    334385            inter = old_nodes.intersection(neighbors) 
    335386            if len(inter) > 0: 
     
    374425 
    375426    def set_graph(self, graph, curve=None, items=None, links=None): 
    376         #self.clear() # TODO which one? 
    377427        # TODO: clear previous nodes and edges? 
    378428 
    379429        if graph is None: 
    380430            self.graph = None 
    381             #self.networkCurve = None 
    382431            self.items = None 
    383432            self.links = None 
     
    386435            yMin = -1.0 
    387436            yMax = 1.0 
    388             #self.addMarker("no network", (xMax - xMin) / 2, (yMax - yMin) / 2, alignment=Qt.AlignCenter, size=self.font_size) 
     437            zMin = -1.0 
     438            zMax = 1.0 
     439            self._markers.append(('no network', (xMax - xMin) / 2, (yMax - yMin) / 2, (zMax - zMin) / 2)) 
    389440            self.update() 
    390441            return 
     
    478529             
    479530            for i, component in enumerate(components):     
    480                  
    481531                if len(mds.points) == len(components):  # if average linkage before 
    482532                    x_avg_mds = mds.points[i][0] 
     
    557607        minStressDelta = 0 
    558608        mdsRefresh = int(steps / 20) 
    559          
     609 
    560610        self.mdsStep = 1 
    561611        self.stopMDS = False 
    562          
     612 
    563613        components = Orange.network.nx.algorithms.components.connected.connected_components(graph) 
    564614        distances.matrixType = Orange.core.SymMatrix.Symmetric 
    565          
     615 
    566616        # scale net coordinates 
    567617        if avgLinkage: 
    568618            distances = distances.avgLinkage(components) 
    569              
     619 
    570620        mds = Orange.projection.mds.MDS(distances) 
    571621        mds.optimize(10, Orange.projection.mds.SgnRelStress, 0) 
     
    574624        h_fr = rect.height() 
    575625        d_fr = math.sqrt(w_fr**2 + h_fr**2) 
    576        
     626 
    577627        x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    578628        y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
     
    580630        h_mds = max(y_mds) - min(y_mds) 
    581631        d_mds = math.sqrt(w_mds**2 + h_mds**2) 
    582          
     632 
    583633        self.set_node_coordinates(dict( 
    584634           (n, (nodes[n].x()*d_mds/d_fr, nodes[n].y()*d_mds/d_fr)) for n in nodes)) 
    585          
     635 
    586636        self.update() 
    587637        qApp.processEvents() 
    588                       
     638 
    589639        if opt_from_curr: 
    590640            if avgLinkage: 
     
    616666            progress_callback(mds.avgStress, self.mdsStep) 
    617667         
    618         #p.animate_points = animate_points 
    619668        return 0 
    620669 
    621670    def mds_callback(self, a, b, mds, mdsRefresh, progress_callback): 
    622671        """Refresh the UI when running  MDS.""" 
    623          
     672 
    624673        if not self.mdsStep % mdsRefresh: 
    625674            self.set_node_coordinates(dict((u, (mds.points[u][0], \ 
    626675                                                mds.points[u][1])) for u in \ 
    627676                                           range(len(mds.points)))) 
    628             #self.plot().replot() 
    629677            self.update() 
    630678            qApp.processEvents() 
    631              
     679 
    632680            if progress_callback is not None: 
    633                 progress_callback(a, self.mdsStep)  
    634              
     681                progress_callback(a, self.mdsStep) 
     682 
    635683        self.mdsStep += 1 
    636684        return 0 if self.stopMDS else 1 
     
    641689        """ 
    642690        nodes = self.nodes() 
    643          
     691 
    644692        if distances == None or distances.dim != len(nodes): 
    645693            self.information('invalid or no distance matrix') 
    646694            return 1 
    647          
    648         #p = self.plot() 
    649          
     695 
    650696        minStressDelta = 0 
    651697        mdsRefresh = int(steps / 20) 
    652          
     698 
    653699        self.mdsStep = 1 
    654700        self.stopMDS = False 
    655          
     701 
    656702        distances.matrixType = Orange.core.SymMatrix.Symmetric 
    657703        mds = Orange.projection.mds.MDS(distances) 
     
    661707        h_fr = rect.height() 
    662708        d_fr = math.sqrt(w_fr**2 + h_fr**2) 
    663        
     709 
    664710        x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    665711        y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
     
    667713        h_mds = max(y_mds) - min(y_mds) 
    668714        d_mds = math.sqrt(w_mds**2 + h_mds**2) 
    669          
    670         #animate_points = p.animate_points 
    671         #p.animate_points = False 
    672          
     715 
    673716        self.set_node_coordinates(dict( 
    674717           (n, (nodes[n].x()*d_mds/d_fr, nodes[n].y()*d_mds/d_fr)) for n in nodes)) 
    675          
     718 
    676719        self.update() 
    677720        qApp.processEvents() 
    678                       
     721 
    679722        if opt_from_curr: 
    680723            for i,u in enumerate(sorted(nodes.iterkeys())): 
     
    692735                                progress_callback=progress_callback:  
    693736                                    self.mds_callback(a, b, mds, mdsRefresh, progress_callback)) 
    694          
     737 
    695738        self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, progress_callback) 
    696          
     739 
    697740        if progress_callback != None: 
    698741            progress_callback(mds.avgStress, self.mdsStep) 
    699          
     742 
    700743        return 0 
    701744 
    702745    def update(self): 
     746        nodes = self.nodes() 
     747        edges = self.edges() 
     748        if len(nodes) == 0: 
     749            return 
     750 
     751        if self._edge_buffer != None: 
     752            del self._edge_buffer 
     753        if self._node_buffer != None: 
     754            del self._node_buffer 
     755 
     756        data = numpy.array([node.coordinates() for key, node in nodes.items()], dtype=numpy.float32).flatten() 
     757        data /= 1000. * 500. 
     758        self._node_buffer = VertexBuffer(data, [(3, GL_FLOAT)]) 
     759        data = numpy.array([(edge.u().coordinates(), edge.v().coordinates()) for edge in edges], dtype=numpy.float32).flatten() 
     760        data /= 1000. * 500. 
     761        self._edge_buffer = VertexBuffer(data, [(3, GL_FLOAT)]) 
     762 
    703763        self.plot.update() 
  • orange/OrangeWidgets/plot/owplot3d.py

    r9064 r9079  
    316316        self.hide_outside = False 
    317317        self.fade_outside = True 
     318 
     319        self.data = self.data_array = None 
     320        self.x_index = -1 
     321        self.y_index = -1 
     322        self.z_index = -1 
    318323        self.label_index = -1 
    319  
    320         self.data = self.data_array = None 
     324        self.color_index = -1 
     325        self.symbol_index = -1 
     326        self.size_index = -1 
     327        self.colors = [] 
     328        self.num_symbols_used = -1 
     329        self.x_discrete = False 
     330        self.y_discrete = False 
     331        self.z_discrete = False 
    321332 
    322333        self.continuous_palette = ColorPaletteGenerator(numberOfColors=-1) 
     
    464475        self.symbol_program.bindAttributeLocation('color',    2) 
    465476        self.symbol_program.bindAttributeLocation('normal',   3) 
    466         self.symbol_program.bindAttributeLocation('index',    4) 
    467477 
    468478        if not self.symbol_program.link(): 
Note: See TracChangeset for help on using the changeset viewer.