Changeset 8497:ecc0af76c584 in orange


Ignore:
Timestamp:
07/28/11 01:20:57 (3 years ago)
Author:
matejd <matejd@…>
Branch:
default
Convert:
657d26b2854988299fe128935a8234f65cdd4890
Message:

Fluid grid resizing, nice label values using Heckberts algorithm

File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/plot/owplot3d.py

    r8490 r8497  
    6060 
    6161import sys 
    62 from math import sin, cos, pi 
     62from math import sin, cos, pi, floor, ceil, log10 
    6363import time 
    6464import struct 
     
    102102    glVertex2f(x1, y1) 
    103103    glEnd() 
     104 
     105def nicenum(x, round): 
     106    expv = floor(log10(x)) 
     107    f = x / pow(10., expv) 
     108    if round: 
     109        if f < 1.5: nf = 1. 
     110        elif f < 3.: nf = 2. 
     111        elif f < 7.: nf = 5. 
     112        else: nf = 10. 
     113    else: 
     114        if f <= 1.: nf = 1. 
     115        elif f <= 2.: nf = 2. 
     116        elif f <= 5.: nf = 5. 
     117        else: nf = 10. 
     118    return nf * pow(10., expv) 
     119 
     120def loose_label(min_value, max_value, num_ticks): 
     121    '''Algorithm by Paul S. Heckbert (Graphics Gems). 
     122       Generates a list of "nice" values between min and max, 
     123       given the number of ticks. Also returns the number 
     124       of fractional digits to use. 
     125    ''' 
     126    range = nicenum(max_value-min_value, False) 
     127    d = nicenum(range / float(num_ticks-1), True) 
     128    plot_min = floor(min_value / d) * d 
     129    plot_max = ceil(max_value / d) * d 
     130    num_frac = int(max(-floor(log10(d)), 0)) 
     131    return numpy.arange(plot_min, plot_max + 0.5*d, d), num_frac 
    104132 
    105133def enum(*sequential): 
     
    191219 
    192220        item_pos_y = y + t + 13 
    193         symbol_to_n = {Symbol.TRIANGLE: 3, 
    194                        Symbol.RECTANGLE: 4, 
    195                        Symbol.PENTAGON: 5, 
    196                        Symbol.CIRCLE: 8} 
    197221 
    198222        for symbol, color, size, text in self.items: 
    199223            glColor4f(*color) 
    200             draw_ngon(symbol_to_n[symbol], x+t+10, item_pos_y-4, size*self.symbol_scale) 
     224            # TODO: 2d symbols 
     225            #draw_ngon(symbol_to_n[symbol], x+t+10, item_pos_y-4, size*self.symbol_scale) 
    201226            self.plot.renderText(x+t+30, item_pos_y, text, font=self.font) 
    202227            item_pos_y += self.metrics.height() 
     
    474499              offset_rotated.x *= symbol_scale; 
    475500              offset_rotated.y *= symbol_scale; 
     501              offset_rotated.z *= symbol_scale; 
    476502 
    477503              if (use_2d_symbols) { 
     
    520546                float diffuse = max(0., dot(normalize((gl_ModelViewMatrix * vec4(normal, 0)).xyz), 
    521547                                    light_direction)); 
    522                 var_color = vec4(color.rgb+diffuse*0.8, a); // Physically wrong, but looks better. 
     548                var_color = vec4(color.rgb+diffuse*0.7, a); // Physically wrong, but looks better. 
    523549              } 
    524550            } 
     
    590616            self.camera[1]*self.camera_distance, 
    591617            self.camera[2]*self.camera_distance, 
    592             0, 0, 0, 
     618            0,-1, 0, 
    593619            0, 1, 0) 
    594620 
     
    598624        glEnable(GL_BLEND) 
    599625        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) 
    600  
    601626 
    602627        for (cmd, params) in self.commands: 
     
    785810                                    axis_map[key], font=self._theme.labels_font) 
    786811 
    787         def draw_values(axis, coord_index, normal, axis_map, sub=10): 
     812        def draw_values(axis, coord_index, normal, axis_map): 
    788813            glColor4f(*self._theme.axis_values_color) 
    789814            glLineWidth(1) 
     
    792817                return 
    793818            start, end = axis 
     819            start_value = self.transform_plot_to_data(numpy.copy(start))[coord_index] 
     820            end_value = self.transform_plot_to_data(numpy.copy(end))[coord_index] 
     821            values, num_frac = loose_label(start_value, end_value, 7) 
     822            format = '%%.%df' % num_frac 
    794823            offset = normal*0.8 
    795             samples = numpy.linspace(0.0, 1.0, num=sub) 
    796             samples = samples[:-1] if coord_index != 1 else samples[1:] 
    797             for sample in samples: 
    798                 position = start + (end-start)*sample 
     824            for value in values: 
     825                if not (start_value <= value <= end_value): 
     826                    continue 
     827                position = start + (end-start)*((value-start_value) / float(end_value-start_value)) 
    799828                glBegin(GL_LINES) 
    800829                glVertex3f(*(position-normal*0.2)) 
     
    806835                                position[1], 
    807836                                position[2], 
    808                                 '%.1f' % value) 
     837                                format % value) 
    809838 
    810839        def draw_axis_title(axis, title, normal): 
     
    815844                            font=self._theme.axis_title_font) 
    816845 
    817         def draw_grid(axis_plane, sub=5): 
    818             p11, p12, p21, p22 = numpy.asarray(axis_plane) 
    819             p22, p21 = p21, p22 
    820             samples = numpy.linspace(0.0, 1.0, num=sub) 
    821             p1211 = p12 - p11 
    822             p2221 = p22 - p21 
    823             p2111 = p21 - p11 
    824             p2212 = p22 - p12 
    825             # Draw grid lines. 
     846        def draw_grid(axis0, axis1, normal0, normal1, i, j): 
    826847            glColor4f(*self._theme.grid_color) 
    827             glBegin(GL_LINES) 
    828             for i, dx in enumerate(samples): 
    829                 start = p11 + p1211*dx 
    830                 end = p21 + p2221*dx 
    831                 glVertex3f(*start) 
    832                 glVertex3f(*end) 
    833  
    834                 start = p11 + p2111*dx 
    835                 end = p12 + p2212*dx 
    836                 glVertex3f(*start) 
    837                 glVertex3f(*end) 
    838             glEnd() 
     848            for axis, normal, coord_index in zip([axis0, axis1], [normal0, normal1], [i, j]): 
     849                start, end = axis 
     850                start_value = self.transform_plot_to_data(numpy.copy(start))[coord_index] 
     851                end_value = self.transform_plot_to_data(numpy.copy(end))[coord_index] 
     852                values, _ = loose_label(start_value, end_value, 7) 
     853                for value in values: 
     854                    if not (start_value <= value <= end_value): 
     855                        continue 
     856                    position = start + (end-start)*((value-start_value) / float(end_value-start_value)) 
     857                    glBegin(GL_LINES) 
     858                    glVertex3f(*position) 
     859                    glVertex3f(*(position-normal*10.)) 
     860                    glEnd() 
    839861 
    840862        glDisable(GL_DEPTH_TEST) 
     
    845867        planes = [self.axis_plane_xy, self.axis_plane_yz, 
    846868                  self.axis_plane_xy_back, self.axis_plane_yz_right] 
     869        axes = [[self.x_axis, self.y_axis], 
     870                [self.y_axis, self.z_axis], 
     871                [self.x_axis+self.unit_z, self.y_axis+self.unit_z], 
     872                [self.z_axis+self.unit_x, self.y_axis+self.unit_x]] 
     873        normals = [[numpy.array([0,-1, 0]), numpy.array([-1, 0, 0])], 
     874                   [numpy.array([0, 0,-1]), numpy.array([ 0,-1, 0])], 
     875                   [numpy.array([0,-1, 0]), numpy.array([-1, 0, 0])], 
     876                   [numpy.array([0,-1, 0]), numpy.array([ 0, 0,-1])]] 
     877        coords = [[0, 1], 
     878                  [1, 2], 
     879                  [0, 1], 
     880                  [2, 1]] 
    847881        visible_planes = map(plane_visible, planes) 
     882        xz_visible = not plane_visible(self.axis_plane_xz) 
    848883        if self.show_grid: 
    849             draw_grid(self.axis_plane_xz) 
    850             for visible, plane in zip(visible_planes, planes): 
     884            if xz_visible: 
     885                draw_grid(self.x_axis, self.z_axis, numpy.array([0,0,-1]), numpy.array([-1,0,0]), 0, 2) 
     886            for visible, (axis0, axis1), (normal0, normal1), (i, j) in\ 
     887                 zip(visible_planes, axes, normals, coords): 
    851888                if not visible: 
    852                     draw_grid(plane) 
     889                    draw_grid(axis0, axis1, normal0, normal1, i, j) 
    853890 
    854891        glEnable(GL_DEPTH_TEST) 
    855892        glDisable(GL_BLEND) 
    856893 
    857         if visible_planes[0]: 
     894        if visible_planes[0 if xz_visible else 2]: 
    858895            draw_axis(self.x_axis) 
    859896            draw_values(self.x_axis, 0, numpy.array([0, 0, -1]), self.x_axis_map) 
    860897            if self.show_x_axis_title: 
    861898                draw_axis_title(self.x_axis, self.x_axis_title, numpy.array([0, 0, -1])) 
    862         elif visible_planes[2]: 
     899        elif visible_planes[2 if xz_visible else 0]: 
    863900            draw_axis(self.x_axis + self.unit_z) 
    864901            draw_values(self.x_axis + self.unit_z, 0, numpy.array([0, 0, 1]), self.x_axis_map) 
     
    867904                                self.x_axis_title, numpy.array([0, 0, 1])) 
    868905 
    869         if visible_planes[1]: 
     906        if visible_planes[1 if xz_visible else 3]: 
    870907            draw_axis(self.z_axis) 
    871908            draw_values(self.z_axis, 2, numpy.array([-1, 0, 0]), self.z_axis_map) 
    872909            if self.show_z_axis_title: 
    873910                draw_axis_title(self.z_axis, self.z_axis_title, numpy.array([-1, 0, 0])) 
    874         elif visible_planes[3]: 
     911        elif visible_planes[3 if xz_visible else 1]: 
    875912            draw_axis(self.z_axis + self.unit_x) 
    876913            draw_values(self.z_axis + self.unit_x, 2, numpy.array([1, 0, 0]), self.z_axis_map) 
     
    9851022            z *= scale_z 
    9861023            triangles = get_symbol_data(symbol) 
    987             ss = size*0.1 
     1024            ss = size*0.08 
    9881025            for v0, v1, v2, n0, n1, n2 in triangles: 
    9891026                vertices.extend([x,y,z, ai, ss*v0[0],ss*v0[1],ss*v0[2], r,g,b,a, n0,n1,n2, 
Note: See TracChangeset for help on using the changeset viewer.