Changeset 8399:b15a18a07bab in orange


Ignore:
Timestamp:
07/19/11 21:48:35 (3 years ago)
Author:
matejd <matejd@…>
Branch:
default
Convert:
baad30b112c1d533fd73d85b0114360a8c4fde42
Message:

owplot3d: improved scaling

File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/owplot3d.py

    r8398 r8399  
    238238        self.minx = self.miny = self.minz = 0 
    239239        self.maxx = self.maxy = self.maxz = 0 
    240         self.center = numpy.array([0,   0,   0]) 
    241240        self.view_cube_edge = 10 
    242241        self.camera_distance = 30 
     
    249248            sin(self.pitch)*sin(self.yaw)] 
    250249 
     250        self.ortho_scale = 80. 
     251        self.ortho_near = -1 
     252        self.ortho_far = 2000 
     253        self.perspective_near = 0.1 
     254        self.perspective_far = 2000 
    251255        self.camera_fov = 30. 
    252         self.zoom_factor = 500. 
     256        self.zoom_factor = 2000. 
    253257        self.move_factor = 100. 
    254258 
     
    278282        self.grid = True 
    279283        self.scale = numpy.array([1., 1., 1.]) 
    280         self.add_scale = [0, 0, 0] 
     284        self.additional_scale = [0, 0, 0] 
    281285        self.scale_x_axis = True 
    282286        self.scale_factor = 30. 
     287        self.initial_scale = numpy.array([1., 1., 1.]) 
     288        self.initial_center = numpy.array([0, 0, 0]) 
    283289 
    284290        # Beside n-gons, symbols should also include cubes, spheres and other stuff. TODO 
     
    346352                offset_rotated = invs * offset_rotated; 
    347353 
    348               position += translation; 
     354              //position += translation; 
    349355              position *= scale; 
    350356              vec4 off_pos = vec4(position+offset_rotated, 1); 
     
    416422        glLoadIdentity() 
    417423        width, height = self.width(), self.height() 
    418         denominator = 80. 
    419424        if self.ortho: 
    420             glOrtho(-width / denominator, 
    421                      width / denominator, 
    422                     -height / denominator, 
    423                      height / denominator, -1, 2000) 
     425            glOrtho(-width / self.ortho_scale, 
     426                     width / self.ortho_scale, 
     427                    -height / self.ortho_scale, 
     428                     height / self.ortho_scale, 
     429                     self.ortho_near, 
     430                     self.ortho_far) 
    424431        else: 
    425432            aspect = float(width) / height if height != 0 else 1 
    426             gluPerspective(self.camera_fov, aspect, 0.1, 2000) 
     433            gluPerspective(self.camera_fov, aspect, self.perspective_near, self.perspective_far) 
    427434        glMatrixMode(GL_MODELVIEW) 
    428435        glLoadIdentity() 
     
    446453                glUniform1f(self.symbol_shader_symbol_scale, self.symbol_scale) 
    447454                glUniform1f(self.symbol_shader_transparency, self.transparency) 
    448                 scale = numpy.maximum([0, 0, 0], self.scale + self.add_scale) 
     455                scale = numpy.maximum([0, 0, 0], self.scale + self.additional_scale) 
    449456                glUniform3f(self.symbol_shader_scale,        *scale) 
    450                 glUniform3f(self.symbol_shader_translation,  *(-self.center)) 
    451457 
    452458                if self.filled_symbols: 
     
    461467 
    462468                if labels != None: 
    463                     glScalef(*scale) 
    464                     glTranslatef(*(-self.center)) 
    465469                    for x, y, z, label in zip(X, Y, Z, labels): 
     470                        x -= self.initial_center[0] 
     471                        y -= self.initial_center[1] 
     472                        z -= self.initial_center[2] 
     473                        x *= self.initial_scale[0] * scale[0] 
     474                        y *= self.initial_scale[1] * scale[1] 
     475                        z *= self.initial_scale[2] * scale[2] 
    466476                        self.renderText(x,y,z, ('%f' % label).rstrip('0').rstrip('.'), font=self.labels_font) 
    467477 
     
    572582                glVertex3f(*(position+normal*0.2)) 
    573583                glEnd() 
     584                value = position[coord_index] / (self.scale[coord_index] + self.additional_scale[coord_index]) 
     585                value /= self.initial_scale[coord_index] 
     586                value += self.initial_center[coord_index] 
    574587                position += offset 
    575                 value = position[coord_index] / (self.scale[coord_index] + self.add_scale[coord_index]) 
    576                 value += self.center[coord_index] 
    577588                self.renderText(position[0], 
    578589                                position[1], 
     
    733744 
    734745        if symbols == None: 
    735             symbols = [0 for _ in range(num_points)] 
     746            symbols = [Symbol.TRIANGLE for _ in range(num_points)] 
    736747 
    737748        min = self.min_x, self.min_y, self.min_z = numpy.min(X), numpy.min(Y), numpy.min(Z) 
     
    739750        min = numpy.array(min) 
    740751        max = numpy.array(max) 
    741         self.range_x, self.range_y, self.range_z = max-min 
    742         self.middle_x, self.middle_y, self.middle_z = (min+max) / 2. 
    743         self.center = (min + max) / 2  
    744         self.normal_size = 0.2 
    745  
    746         self.scale[0] = self.view_cube_edge / self.range_x 
    747         self.scale[1] = self.view_cube_edge / self.range_y 
    748         self.scale[2] = self.view_cube_edge / self.range_z 
     752        range_x, range_y, range_z = max-min 
     753        middle_x, middle_y, middle_z = (min+max) / 2. 
     754        self.initial_center = (min + max) / 2  
     755 
     756        scale_x = self.view_cube_edge / range_x 
     757        scale_y = self.view_cube_edge / range_y 
     758        scale_z = self.view_cube_edge / range_z 
     759 
     760        self.initial_scale = [scale_x, scale_y, scale_z] 
    749761 
    750762        # Generate vertices for shapes and also indices for outlines. 
     
    753765        index = 0 
    754766        for x, y, z, (r,g,b,a), size, symbol in zip(X, Y, Z, colors, sizes, symbols): 
    755             sO2 = size * self.normal_size / 2. 
     767            x -= self.initial_center[0] 
     768            y -= self.initial_center[1] 
     769            z -= self.initial_center[2] 
     770            x *= scale_x 
     771            y *= scale_y 
     772            z *= scale_z 
     773            sO2 = size * 0.1 
    756774            n = self.available_symbols[symbol % len(self.available_symbols)] 
    757775            angle_inc = 2.*pi / n 
     
    841859            return [] 
    842860 
     861        width, height = self.width(), self.height() 
     862 
    843863        projection = QMatrix4x4() 
    844         projection.perspective(self.camera_fov, float(self.width())/self.height(), 0.1, 2000) 
     864        if self.ortho: 
     865            projection.ortho(-width / self.ortho_scale, width / self.ortho_scale, 
     866                             -height / self.ortho_scale, height / self.ortho_scale, 
     867                             self.ortho_near, self.ortho_far) 
     868        else: 
     869            projection.perspective(self.camera_fov, float(self.width())/self.height(), 
     870                                   self.perspective_near, self.perspective_far) 
    845871 
    846872        modelview = QMatrix4x4() 
     
    851877                         QVector3D(0, 1, 0)) 
    852878 
    853         modelview.scale(*(numpy.maximum([0, 0, 0], self.scale + self.add_scale))) 
    854         modelview.translate(*(-self.center)) 
     879        modelview.scale(*(numpy.maximum([0, 0, 0], self.scale + self.additional_scale))) 
    855880 
    856881        proj_model = projection * modelview 
     
    898923            self.state = PlotState.SCALING 
    899924            self.scaling_init_pos = self.mouse_pos 
    900             self.add_scale = [0, 0, 0] 
     925            self.additional_scale = [0, 0, 0] 
    901926            self.updateGL() 
    902927 
     
    917942                #off_y = numpy.cross(self.camera, [1,0,0]) * (dy / self.move_factor) 
    918943                # TODO: this incidentally works almost fine, but the math is wrong and should be fixed 
    919                 self.center += off_x 
     944                #self.initial_center += off_x 
    920945            else: 
    921946                self.yaw += dx / self.rotation_factor 
     
    930955            dx = pos.x() - self.scaling_init_pos.x() 
    931956            dy = pos.y() - self.scaling_init_pos.y() 
    932             self.add_scale = [dx / self.scale_factor, dy / self.scale_factor, 0]\ 
     957            self.additional_scale = [dx / self.scale_factor, dy / self.scale_factor, 0]\ 
    933958                if self.scale_x_axis else [0, dy / self.scale_factor, dx / self.scale_factor] 
    934959 
     
    938963    def mouseReleaseEvent(self, event): 
    939964        if self.state == PlotState.SCALING: 
    940             self.scale = numpy.maximum([0, 0, 0], self.scale + self.add_scale) 
    941             self.add_scale = [0, 0, 0] 
     965            self.scale = numpy.maximum([0, 0, 0], self.scale + self.additional_scale) 
     966            self.additional_scale = [0, 0, 0] 
    942967        elif self.state == PlotState.SELECTING: 
    943968            if self.new_selection[3] != None: 
Note: See TracChangeset for help on using the changeset viewer.