Changeset 8786:5625ec1ac9e6 in orange


Ignore:
Timestamp:
08/26/11 01:06:30 (3 years ago)
Author:
matejd <matejd@…>
Branch:
default
Convert:
ba09618df7bd0044179565b003218213b294ea56
Message:

Python part of the implementation mentioned below

Location:
orange/OrangeWidgets
Files:
6 edited

Legend:

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

    r8742 r8786  
    107107            for i in range(len(self.data_domain[color_attr].values)): 
    108108                c = self.disc_palette[i] 
    109                 colors.append([c.red()/255., c.green()/255., c.blue()/255.]) 
     109                colors.append(c) 
    110110 
    111111        data_scale = [self.attr_values[x_attr][1] - self.attr_values[x_attr][0], 
     
    517517            selected_indices = [1 if i in indices else 0 
    518518                                for i in range(len(self.data))] 
    519             selected = self.plot.rawData.selectref(selected_indices) 
     519            selected = self.plot.raw_data.selectref(selected_indices) 
    520520            x_min = y_min = z_min = 1e100 
    521521            x_max = y_max = z_max = -1e100 
  • orange/OrangeWidgets/plot/generator.gs

    r8731 r8786  
    6969 
    7070    float size = texelFetch(data_buffer, index+size_index).x; 
    71     if (size_index < 0 || size <= 0.) 
     71    if (size_index < 0 || size < 0.) 
    7272        size = 1.; 
    7373 
  • orange/OrangeWidgets/plot/owopenglrenderer.py

    r8736 r8786  
     1 
     2class VAO: 
     3    def __init__(self, data, format_description): 
     4        ''' 
     5        Sample usage: geometry = VAO(data, size, [(3, GL_FLOAT), (4, GL_FLOAT)], GL_STATIC_DRAW) 
     6        ''' 
     7        pass 
    18 
    29class OWOpenGLRenderer: 
  • orange/OrangeWidgets/plot/owplot3d.py

    r8781 r8786  
    399399 
    400400        self.use_fbos = True 
    401         self.use_geometry_shader = True 
    402         # TODO: self.cpu_code_path 
     401 
     402        # If True, do drawing using instancing + geometry shader processing, 
     403        # if False, build VBO every time set_plot_data is called. 
     404        self._use_opengl_3 = False 
    403405 
    404406        self.hide_outside = False 
     
    411413 
    412414    def __del__(self): 
     415        pass 
    413416        # TODO: never reached! 
    414         glDeleteVertexArrays(1, self.dummy_vao) 
    415         glDeleteVertexArrays(1, self.feedback_vao) 
    416         glDeleteBuffers(1, self.symbol_buffer) 
    417         if hasattr(self, 'data_buffer'): 
    418             glDeleteBuffers(1, self.data_buffer) 
     417        #glDeleteVertexArrays(1, self.dummy_vao) 
     418        #glDeleteVertexArrays(1, self.feedback_vao) 
     419        #glDeleteBuffers(1, self.symbol_buffer) 
     420        #if hasattr(self, 'data_buffer'): 
     421        #    glDeleteBuffers(1, self.data_buffer) 
    419422 
    420423    def initializeGL(self): 
     
    430433        glEnable(GL_MULTISAMPLE) 
    431434 
    432         self.feedback_generated = False 
    433  
    434         # Build shader program which will generate triangle data to be outputed 
    435         # to the screen in subsequent frames. Geometry shader is the heart 
    436         # of the process - it will produce actual symbol geometry out of dummy points. 
    437         self.generating_program = QtOpenGL.QGLShaderProgram() 
    438         self.generating_program.addShaderFromSourceFile(QtOpenGL.QGLShader.Geometry, 
    439             os.path.join(os.path.dirname(__file__), 'generator.gs')) 
    440         self.generating_program.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, 
    441             os.path.join(os.path.dirname(__file__), 'generator.vs')) 
    442         varyings = (c_char_p * 5)() 
    443         varyings[:] = ['out_position', 'out_offset', 'out_color', 'out_normal', 'out_index'] 
    444         glTransformFeedbackVaryings(self.generating_program.programId(), 5,  
    445             ctypes.cast(varyings, POINTER(POINTER(c_char))), GL_INTERLEAVED_ATTRIBS) 
    446  
    447         self.generating_program.bindAttributeLocation('index', 0) 
    448  
    449         if not self.generating_program.link(): 
    450             print('Failed to link generating shader! Attribute changes may be slow.') 
    451             self.use_geometry_shader = False 
     435        # TODO: check hardware for OpenGL 3.x+ support 
     436 
     437        if self._use_opengl_3: 
     438            self.feedback_generated = False 
     439 
     440            self.generating_program = QtOpenGL.QGLShaderProgram() 
     441            self.generating_program.addShaderFromSourceFile(QtOpenGL.QGLShader.Geometry, 
     442                os.path.join(os.path.dirname(__file__), 'generator.gs')) 
     443            self.generating_program.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, 
     444                os.path.join(os.path.dirname(__file__), 'generator.vs')) 
     445            varyings = (c_char_p * 5)() 
     446            varyings[:] = ['out_position', 'out_offset', 'out_color', 'out_normal', 'out_index'] 
     447            glTransformFeedbackVaryings(self.generating_program.programId(), 5,  
     448                ctypes.cast(varyings, POINTER(POINTER(c_char))), GL_INTERLEAVED_ATTRIBS) 
     449 
     450            self.generating_program.bindAttributeLocation('index', 0) 
     451 
     452            if not self.generating_program.link(): 
     453                print('Failed to link generating shader! Attribute changes may be slow.') 
     454            else: 
     455                print('Generating shader linked.') 
     456 
     457            # Upload all symbol geometry into a TBO (texture buffer object), so that generating 
     458            # geometry shader will have access to it. (TBO is easier to use than a texture in this use case). 
     459            geometry_data = [] 
     460            symbols_indices = [] 
     461            symbols_sizes = [] 
     462            for symbol in range(len(Symbol)): 
     463                triangles = get_2d_symbol_data(symbol) 
     464                symbols_indices.append(len(geometry_data) / 3) 
     465                symbols_sizes.append(len(triangles)) 
     466                for tri in triangles: 
     467                    geometry_data.extend(chain(*tri)) 
     468 
     469            for symbol in range(len(Symbol)): 
     470                triangles = get_symbol_data(symbol) 
     471                symbols_indices.append(len(geometry_data) / 3) 
     472                symbols_sizes.append(len(triangles)) 
     473                for tri in triangles: 
     474                    geometry_data.extend(chain(*tri)) 
     475 
     476            self.symbols_indices = symbols_indices 
     477            self.symbols_sizes = symbols_sizes 
     478 
     479            tbo = glGenBuffers(1) 
     480            glBindBuffer(GL_TEXTURE_BUFFER, tbo) 
     481            glBufferData(GL_TEXTURE_BUFFER, len(geometry_data)*4, numpy.array(geometry_data, 'f'), GL_STATIC_DRAW) 
     482            glBindBuffer(GL_TEXTURE_BUFFER, 0) 
     483            self.symbol_buffer = glGenTextures(1) 
     484            glBindTexture(GL_TEXTURE_BUFFER, self.symbol_buffer) 
     485            glTexBuffer(GL_TEXTURE_BUFFER, GL_RGB32F, tbo) # 3 floating-point components 
     486            glBindTexture(GL_TEXTURE_BUFFER, 0) 
     487 
     488            # Generate dummy vertex buffer (points which will be fed to the geometry shader). 
     489            self.dummy_vao = GLuint(0) 
     490            glGenVertexArrays(1, self.dummy_vao) 
     491            glBindVertexArray(self.dummy_vao) 
     492            vertex_buffer_id = glGenBuffers(1) 
     493            glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id) 
     494            glBufferData(GL_ARRAY_BUFFER, numpy.arange(50*1000, dtype=numpy.float32), GL_STATIC_DRAW) 
     495            glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 4, c_void_p(0)) 
     496            glEnableVertexAttribArray(0) 
     497            glBindVertexArray(0) 
     498            glBindBuffer(GL_ARRAY_BUFFER, 0) 
     499 
     500            # Specify an output VBO (and VAO) 
     501            self.feedback_vao = feedback_vao = GLuint(0) 
     502            glGenVertexArrays(1, feedback_vao) 
     503            glBindVertexArray(feedback_vao) 
     504            self.feedback_bid = feedback_bid = glGenBuffers(1) 
     505            glBindBuffer(GL_ARRAY_BUFFER, feedback_bid) 
     506            vertex_size = (3+3+3+3+1)*4 
     507            glBufferData(GL_ARRAY_BUFFER, 20*1000*144*vertex_size, c_void_p(0), GL_STATIC_DRAW) 
     508            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(0)) 
     509            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(3*4)) 
     510            glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(6*4)) 
     511            glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(9*4)) 
     512            glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(12*4)) 
     513            glEnableVertexAttribArray(0) 
     514            glEnableVertexAttribArray(1) 
     515            glEnableVertexAttribArray(2) 
     516            glEnableVertexAttribArray(3) 
     517            glEnableVertexAttribArray(4) 
     518            glBindVertexArray(0) 
     519            glBindBuffer(GL_ARRAY_BUFFER, 0) 
    452520        else: 
    453             print('Generating shader linked.') 
     521            # Load symbol geometry and send it to the C++ parent. 
     522            geometry_data = [] 
     523            for symbol in range(len(Symbol)): 
     524                triangles = get_2d_symbol_data(symbol) 
     525                triangles = [QVector3D(*v) for triangle in triangles for v in triangle] 
     526                orangeqt.Plot3D.set_symbol_geometry(self, symbol, 0, triangles) 
     527 
     528                triangles = get_symbol_data(symbol) 
     529                triangles = [QVector3D(*v) for triangle in triangles for v in triangle] 
     530                orangeqt.Plot3D.set_symbol_geometry(self, symbol, 1, triangles) 
    454531 
    455532        self.symbol_program = QtOpenGL.QGLShaderProgram() 
     
    480557        self.symbol_program_encode_color   = self.symbol_program.uniformLocation('encode_color') 
    481558 
    482         # TODO: if not self.use_geometry_shader 
    483  
    484         # Upload all symbol geometry into a TBO (texture buffer object), so that generating 
    485         # geometry shader will have access to it. (TBO is easier to use than a texture in this use case). 
    486         geometry_data = [] 
    487         symbols_indices = [] 
    488         symbols_sizes = [] 
    489         for symbol in range(len(Symbol)): 
    490             triangles = get_2d_symbol_data(symbol) 
    491             symbols_indices.append(len(geometry_data) / 3) 
    492             symbols_sizes.append(len(triangles)) 
    493             for tri in triangles: 
    494                 geometry_data.extend(chain(*tri)) 
    495  
    496         for symbol in range(len(Symbol)): 
    497             triangles = get_symbol_data(symbol) 
    498             symbols_indices.append(len(geometry_data) / 3) 
    499             symbols_sizes.append(len(triangles)) 
    500             for tri in triangles: 
    501                 geometry_data.extend(chain(*tri)) 
    502  
    503         self.symbols_indices = symbols_indices 
    504         self.symbols_sizes = symbols_sizes 
    505  
    506         tbo = glGenBuffers(1) 
    507         glBindBuffer(GL_TEXTURE_BUFFER, tbo) 
    508         glBufferData(GL_TEXTURE_BUFFER, len(geometry_data)*4, numpy.array(geometry_data, 'f'), GL_STATIC_DRAW) 
    509         glBindBuffer(GL_TEXTURE_BUFFER, 0) 
    510         self.symbol_buffer = glGenTextures(1) 
    511         glBindTexture(GL_TEXTURE_BUFFER, self.symbol_buffer) 
    512         glTexBuffer(GL_TEXTURE_BUFFER, GL_RGB32F, tbo) # 3 floating-point components 
    513         glBindTexture(GL_TEXTURE_BUFFER, 0) 
    514  
    515         # Generate dummy vertex buffer (points which will be fed to the geometry shader). 
    516         self.dummy_vao = GLuint(0) 
    517         glGenVertexArrays(1, self.dummy_vao) 
    518         glBindVertexArray(self.dummy_vao) 
    519         vertex_buffer_id = glGenBuffers(1) 
    520         glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id) 
    521         glBufferData(GL_ARRAY_BUFFER, numpy.arange(50*1000, dtype=numpy.float32), GL_STATIC_DRAW) 
    522         glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 4, c_void_p(0)) 
    523         glEnableVertexAttribArray(0) 
    524         glBindVertexArray(0) 
    525         glBindBuffer(GL_ARRAY_BUFFER, 0) 
    526  
    527         # Specify an output VBO (and VAO) 
    528         self.feedback_vao = feedback_vao = GLuint(0) 
    529         glGenVertexArrays(1, feedback_vao) 
    530         glBindVertexArray(feedback_vao) 
    531         self.feedback_bid = feedback_bid = glGenBuffers(1) 
    532         glBindBuffer(GL_ARRAY_BUFFER, feedback_bid) 
    533         vertex_size = (3+3+3+3+1)*4 
    534         glBufferData(GL_ARRAY_BUFFER, 20*1000*144*vertex_size, c_void_p(0), GL_STATIC_DRAW) 
    535         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(0)) 
    536         glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(3*4)) 
    537         glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(6*4)) 
    538         glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(9*4)) 
    539         glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(12*4)) 
    540         glEnableVertexAttribArray(0) 
    541         glEnableVertexAttribArray(1) 
    542         glEnableVertexAttribArray(2) 
    543         glEnableVertexAttribArray(3) 
    544         glEnableVertexAttribArray(4) 
    545         glBindVertexArray(0) 
    546         glBindBuffer(GL_ARRAY_BUFFER, 0) 
    547             
    548559        # Create two FBOs (framebuffer objects): 
     560 
    549561        # - one will be used together with stencil mask to find out which 
    550562        #   examples have been selected (in an efficient way) 
    551         # - the other one will be used for tooltips (data rendered will have 
    552         #   larger screen coverage so it will be easily pointed at) 
     563 
     564        # - the smaller one will be used for tooltips 
    553565        format = QtOpenGL.QGLFramebufferObjectFormat() 
    554566        format.setAttachment(QtOpenGL.QGLFramebufferObject.CombinedDepthStencil) 
     
    566578            print('Failed to create tooltip FBO! Tooltips disabled.') 
    567579            self.use_fbos = False 
    568  
    569         img = QImage(os.path.join(os.path.dirname(__file__), 'noise.jpg')) 
    570         self.fractal_texture = self.bindTexture(img) 
    571         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) 
    572         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) 
    573         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT) 
    574         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT) 
    575580 
    576581    def resizeGL(self, width, height): 
     
    623628            self.draw_axes() 
    624629 
    625         if self.feedback_generated: 
    626             self.symbol_program.bind() 
    627             self.symbol_program.setUniformValue('modelview', self.modelview) 
    628             self.symbol_program.setUniformValue('projection', self.projection) 
    629             self.symbol_program.setUniformValue(self.symbol_program_use_2d_symbols, self.use_2d_symbols) 
    630             self.symbol_program.setUniformValue(self.symbol_program_fade_outside,   self.fade_outside) 
    631             self.symbol_program.setUniformValue(self.symbol_program_hide_outside,   self.hide_outside) 
    632             self.symbol_program.setUniformValue(self.symbol_program_encode_color,   False) 
    633             # Specifying float uniforms with vec2 because of a weird bug in PyQt 
    634             self.symbol_program.setUniformValue(self.symbol_program_symbol_scale,   self.symbol_scale, self.symbol_scale) 
    635             self.symbol_program.setUniformValue(self.symbol_program_alpha_value,    self.alpha_value / 255., self.alpha_value / 255.) 
    636             plot_scale = numpy.maximum([1e-5, 1e-5, 1e-5],                          self.plot_scale+self.additional_scale) 
    637             self.symbol_program.setUniformValue(self.symbol_program_scale,          *plot_scale) 
    638             self.symbol_program.setUniformValue(self.symbol_program_translation,    *self.plot_translation) 
    639             self.symbol_program.setUniformValue(self.symbol_program_force_color,    0., 0., 0., 0.) 
    640             if self.use_2d_symbols: 
    641                 self.symbol_program.setUniformValue('texture', 0) 
    642                 self.symbol_program.setUniformValue('apply_texture', True) 
    643                 self.symbol_program.setUniformValue('screen_size', self.width(), self.height()) 
    644                 glActiveTexture(GL_TEXTURE0) 
    645                 glBindTexture(GL_TEXTURE_2D, self.fractal_texture) 
    646             else: 
    647                 self.symbol_program.setUniformValue('apply_texture', False) 
    648  
     630        self.symbol_program.bind() 
     631        self.symbol_program.setUniformValue('modelview', self.modelview) 
     632        self.symbol_program.setUniformValue('projection', self.projection) 
     633        self.symbol_program.setUniformValue(self.symbol_program_use_2d_symbols, self.use_2d_symbols) 
     634        self.symbol_program.setUniformValue(self.symbol_program_fade_outside,   self.fade_outside) 
     635        self.symbol_program.setUniformValue(self.symbol_program_hide_outside,   self.hide_outside) 
     636        self.symbol_program.setUniformValue(self.symbol_program_encode_color,   False) 
     637        # Specifying float uniforms with vec2 because of a weird bug in PyQt 
     638        self.symbol_program.setUniformValue(self.symbol_program_symbol_scale,   self.symbol_scale, self.symbol_scale) 
     639        self.symbol_program.setUniformValue(self.symbol_program_alpha_value,    self.alpha_value / 255., self.alpha_value / 255.) 
     640        plot_scale = numpy.maximum([1e-5, 1e-5, 1e-5],                          self.plot_scale+self.additional_scale) 
     641        self.symbol_program.setUniformValue(self.symbol_program_scale,          *plot_scale) 
     642        self.symbol_program.setUniformValue(self.symbol_program_translation,    *self.plot_translation) 
     643        self.symbol_program.setUniformValue(self.symbol_program_force_color,    0., 0., 0., 0.) 
     644 
     645        if self._use_opengl_3 and self.feedback_generated: 
    649646            glEnable(GL_DEPTH_TEST) 
    650647            glEnable(GL_BLEND) 
     
    654651            glDrawArrays(GL_TRIANGLES, 0, self.num_primitives_generated*3) 
    655652            glBindVertexArray(0) 
    656  
    657             self.symbol_program.release() 
     653        else: 
     654            glDisable(GL_CULL_FACE) 
     655            glEnable(GL_DEPTH_TEST) 
     656            orangeqt.Plot3D.draw_data(self) 
     657 
     658        self.symbol_program.release() 
    658659 
    659660        self.draw_labels() 
     
    662663            self.after_draw_callback() 
    663664 
    664         if self.tooltip_fbo_dirty and self.feedback_generated: 
     665        if self.tooltip_fbo_dirty: 
    665666            self.tooltip_fbo.bind() 
    666667            glClearColor(1, 1, 1, 1) 
     
    675676            self.symbol_program.bind() 
    676677            self.symbol_program.setUniformValue(self.symbol_program_encode_color, True) 
    677             glBindVertexArray(self.feedback_vao) 
    678             glDrawArrays(GL_TRIANGLES, 0, self.num_primitives_generated*3) 
    679             glBindVertexArray(0) 
     678 
     679            if self._use_opengl_3 and self.feedback_generated: 
     680                glBindVertexArray(self.feedback_vao) 
     681                glDrawArrays(GL_TRIANGLES, 0, self.num_primitives_generated*3) 
     682                glBindVertexArray(0) 
     683            else: 
     684                orangeqt.Plot3D.draw_data(self) 
    680685            self.symbol_program.release() 
    681686            self.tooltip_fbo.release() 
     
    683688            glViewport(0, 0, self.width(), self.height()) 
    684689 
    685         if self.selection_fbo_dirty and self.feedback_generated: 
     690        if self.selection_fbo_dirty: 
    686691            # TODO: use transform feedback instead 
    687692            self.selection_fbo.bind() 
     
    694699            glDisable(GL_DEPTH_TEST) 
    695700            glDisable(GL_BLEND) 
    696             glBindVertexArray(self.feedback_vao) 
    697             glDrawArrays(GL_TRIANGLES, 0, self.num_primitives_generated*3) 
    698             glBindVertexArray(0) 
     701             
     702            if self._use_opengl_3: 
     703                glBindVertexArray(self.feedback_vao) 
     704                glDrawArrays(GL_TRIANGLES, 0, self.num_primitives_generated*3) 
     705                glBindVertexArray(0) 
     706            else: 
     707                orangeqt.Plot3D.draw_data(self) 
    699708            self.symbol_program.release() 
    700709 
     
    962971        self.label_index = label_index 
    963972 
    964         # If color is a discrete attribute, colors should be a list of colors 
    965         # each specified with vec3 (RGB). 
    966  
    967         # Re-run generating program (geometry shader), store 
    968         # results through transform feedback into a VBO on the GPU. 
    969         self.generating_program.bind() 
    970         self.generating_program.setUniformValue('x_index', x_index) 
    971         self.generating_program.setUniformValue('y_index', y_index) 
    972         self.generating_program.setUniformValue('z_index', z_index) 
    973         self.generating_program.setUniformValue('jitter_size', jitter_size) 
    974         self.generating_program.setUniformValue('jitter_continuous', jitter_continuous) 
    975         self.generating_program.setUniformValue('x_discrete', x_discrete) 
    976         self.generating_program.setUniformValue('y_discrete', y_discrete) 
    977         self.generating_program.setUniformValue('z_discrete', z_discrete) 
    978         self.generating_program.setUniformValue('color_index', color_index) 
    979         self.generating_program.setUniformValue('symbol_index', symbol_index) 
    980         self.generating_program.setUniformValue('size_index', size_index) 
    981         self.generating_program.setUniformValue('use_2d_symbols', self.use_2d_symbols) 
    982         self.generating_program.setUniformValue('example_size', self.example_size) 
    983         self.generating_program.setUniformValue('num_colors', len(colors)) 
    984         self.generating_program.setUniformValue('num_symbols_used', num_symbols_used) 
    985         glUniform3fv(glGetUniformLocation(self.generating_program.programId(), 'colors'), 
    986             len(colors), numpy.array(colors, 'f').ravel()) 
    987         glUniform1iv(glGetUniformLocation(self.generating_program.programId(), 'symbols_sizes'), 
    988             len(Symbol)*2, numpy.array(self.symbols_sizes, dtype='i')) 
    989         glUniform1iv(glGetUniformLocation(self.generating_program.programId(), 'symbols_indices'), 
    990             len(Symbol)*2, numpy.array(self.symbols_indices, dtype='i')) 
    991  
    992         glActiveTexture(GL_TEXTURE0) 
    993         glBindTexture(GL_TEXTURE_BUFFER, self.symbol_buffer) 
    994         self.generating_program.setUniformValue('symbol_buffer', 0) 
    995         glActiveTexture(GL_TEXTURE1) 
    996         glBindTexture(GL_TEXTURE_BUFFER, self.data_buffer) 
    997         self.generating_program.setUniformValue('data_buffer', 1) 
    998  
    999         qid = glGenQueries(1) 
    1000         glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, qid) 
    1001         glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, self.feedback_bid) 
    1002         glEnable(GL_RASTERIZER_DISCARD) 
    1003         glBeginTransformFeedback(GL_TRIANGLES) 
    1004  
    1005         glBindVertexArray(self.dummy_vao) 
    1006         glDrawArrays(GL_POINTS, 0, self.num_examples) 
    1007  
    1008         glEndTransformFeedback() 
    1009         glDisable(GL_RASTERIZER_DISCARD) 
    1010  
    1011         glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN) 
    1012         self.num_primitives_generated = glGetQueryObjectuiv(qid, GL_QUERY_RESULT) 
    1013         glBindVertexArray(0) 
    1014         self.feedback_generated = True 
    1015         print('Num generated primitives: ' + str(self.num_primitives_generated)) 
    1016  
    1017         self.generating_program.release() 
    1018         glActiveTexture(GL_TEXTURE0) 
    1019         print('Generation took ' + str(time.time()-start) + ' seconds') 
     973        # If color is a discrete attribute, colors should be a list of QColor 
     974 
     975        if self._use_opengl_3: 
     976            # Re-run generating program (geometry shader), store 
     977            # results through transform feedback into a VBO on the GPU. 
     978            self.generating_program.bind() 
     979            self.generating_program.setUniformValue('x_index', x_index) 
     980            self.generating_program.setUniformValue('y_index', y_index) 
     981            self.generating_program.setUniformValue('z_index', z_index) 
     982            self.generating_program.setUniformValue('jitter_size', jitter_size) 
     983            self.generating_program.setUniformValue('jitter_continuous', jitter_continuous) 
     984            self.generating_program.setUniformValue('x_discrete', x_discrete) 
     985            self.generating_program.setUniformValue('y_discrete', y_discrete) 
     986            self.generating_program.setUniformValue('z_discrete', z_discrete) 
     987            self.generating_program.setUniformValue('color_index', color_index) 
     988            self.generating_program.setUniformValue('symbol_index', symbol_index) 
     989            self.generating_program.setUniformValue('size_index', size_index) 
     990            self.generating_program.setUniformValue('use_2d_symbols', self.use_2d_symbols) 
     991            self.generating_program.setUniformValue('example_size', self.example_size) 
     992            self.generating_program.setUniformValue('num_colors', len(colors)) 
     993            self.generating_program.setUniformValue('num_symbols_used', num_symbols_used) 
     994            # TODO: colors is list of QColor 
     995            glUniform3fv(glGetUniformLocation(self.generating_program.programId(), 'colors'), 
     996                len(colors), numpy.array(colors, 'f').ravel()) 
     997            glUniform1iv(glGetUniformLocation(self.generating_program.programId(), 'symbols_sizes'), 
     998                len(Symbol)*2, numpy.array(self.symbols_sizes, dtype='i')) 
     999            glUniform1iv(glGetUniformLocation(self.generating_program.programId(), 'symbols_indices'), 
     1000                len(Symbol)*2, numpy.array(self.symbols_indices, dtype='i')) 
     1001 
     1002            glActiveTexture(GL_TEXTURE0) 
     1003            glBindTexture(GL_TEXTURE_BUFFER, self.symbol_buffer) 
     1004            self.generating_program.setUniformValue('symbol_buffer', 0) 
     1005            glActiveTexture(GL_TEXTURE1) 
     1006            glBindTexture(GL_TEXTURE_BUFFER, self.data_buffer) 
     1007            self.generating_program.setUniformValue('data_buffer', 1) 
     1008 
     1009            qid = glGenQueries(1) 
     1010            glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, qid) 
     1011            glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, self.feedback_bid) 
     1012            glEnable(GL_RASTERIZER_DISCARD) 
     1013            glBeginTransformFeedback(GL_TRIANGLES) 
     1014 
     1015            glBindVertexArray(self.dummy_vao) 
     1016            glDrawArrays(GL_POINTS, 0, self.num_examples) 
     1017 
     1018            glEndTransformFeedback() 
     1019            glDisable(GL_RASTERIZER_DISCARD) 
     1020 
     1021            glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN) 
     1022            self.num_primitives_generated = glGetQueryObjectuiv(qid, GL_QUERY_RESULT) 
     1023            glBindVertexArray(0) 
     1024            self.feedback_generated = True 
     1025            print('Num generated primitives: ' + str(self.num_primitives_generated)) 
     1026 
     1027            self.generating_program.release() 
     1028            glActiveTexture(GL_TEXTURE0) 
     1029            print('Generation took ' + str(time.time()-start) + ' seconds') 
     1030        else: 
     1031            start = time.time() 
     1032            orangeqt.Plot3D.update_data(self, x_index, y_index, z_index, 
     1033                color_index, symbol_index, size_index, label_index, 
     1034                colors, num_symbols_used, 
     1035                x_discrete, y_discrete, z_discrete, self.use_2d_symbols) 
     1036            print('Data processing took ' + str(time.time() - start) + ' seconds') 
     1037 
    10201038        self.updateGL() 
    10211039 
    10221040    def set_plot_data(self, data, subset_data=None): 
    10231041        self.makeCurrent() 
    1024         #if self.data != None: 
    1025             #TODO: glDeleteBuffers(1, self.data_buffer) 
    1026         start = time.time() 
    1027  
    1028         data_array = numpy.array(data.transpose().flatten(), dtype='f') 
     1042        self.data = data 
     1043        self.data_array = numpy.array(data.transpose().flatten(), dtype=numpy.float32) 
    10291044        self.example_size = len(data) 
    10301045        self.num_examples = len(data[0]) 
    1031         self.data = data 
    1032  
    1033         tbo = glGenBuffers(1) 
    1034         glBindBuffer(GL_TEXTURE_BUFFER, tbo) 
    1035         glBufferData(GL_TEXTURE_BUFFER, len(data_array)*4, data_array, GL_STATIC_DRAW) 
    1036         glBindBuffer(GL_TEXTURE_BUFFER, 0) 
    1037  
    1038         self.data_buffer = glGenTextures(1) 
    1039         glBindTexture(GL_TEXTURE_BUFFER, self.data_buffer) 
    1040         GL_R32F = 0x822E 
    1041         glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, tbo) 
    1042         glBindTexture(GL_TEXTURE_BUFFER, 0) 
    1043  
    1044         print('Uploading data to GPU took ' + str(time.time()-start) + ' seconds') 
     1046 
     1047        if self._use_opengl_3: 
     1048            tbo = glGenBuffers(1) 
     1049            glBindBuffer(GL_TEXTURE_BUFFER, tbo) 
     1050            glBufferData(GL_TEXTURE_BUFFER, len(self.data_array)*4, self.data_array, GL_STATIC_DRAW) 
     1051            glBindBuffer(GL_TEXTURE_BUFFER, 0) 
     1052 
     1053            self.data_buffer = glGenTextures(1) 
     1054            glBindTexture(GL_TEXTURE_BUFFER, self.data_buffer) 
     1055            GL_R32F = 0x822E 
     1056            glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, tbo) 
     1057            glBindTexture(GL_TEXTURE_BUFFER, 0) 
     1058        else: 
     1059            orangeqt.Plot3D.set_data(self, long(self.data_array.ctypes.data), 
     1060                                     self.num_examples, 
     1061                                     self.example_size) 
    10451062 
    10461063    def set_axis_labels(self, axis_id, labels): 
  • orange/OrangeWidgets/plot/symbol.fs

    r8744 r8786  
    22 
    33in vec4 var_color; 
    4 uniform bool apply_texture; 
    5 uniform sampler2D texture; 
    6 uniform vec2 screen_size; 
    74 
    85void main(void) 
    96{ 
    10     if (apply_texture) 
    11     { 
    12         gl_FragColor = mix(var_color, texture2D(texture, vec2(10., 10.)*gl_FragCoord.xy/screen_size), 0.3); 
    13     } 
    14     else 
    15     { 
    16         gl_FragColor = var_color; 
    17     } 
     7    gl_FragColor = var_color; // gl_FragColor is deprecated 
    188} 
  • orange/OrangeWidgets/plot/symbol.vs

    r8742 r8786  
    1010in vec3 normal; 
    1111in float index; 
     12 
     13out vec4 var_color; 
    1214 
    1315uniform bool use_2d_symbols; 
     
    2527uniform mat4 modelview; 
    2628uniform mat4 projection; 
    27  
    28 out vec4 var_color; 
    2929 
    3030void main(void) { 
Note: See TracChangeset for help on using the changeset viewer.