axis.py

CNC 的开放码,EMC2 V2.2.8版

                    f = fmt % ((g.max_extents[y] - g.min_extents[y]) * dimscale)

                    glTranslatef(x_pos, (g.max_extents[y] + g.min_extents[y])/2,
                                z_pos)
                    glRotatef(-90, 0, 0, 1)
                    if view == x:
                        glRotatef(-90, 1, 0, 0)
                        glTranslatef(0, halfchar, 0)
                    glScalef(charsize, charsize, charsize)
                    hershey.plot_string(f, .5)
                    glPopMatrix()

                if view != x and g.max_extents[x] > g.min_extents[x]:
                    y_pos = g.min_extents[y] - 6.0*dashwidth;

                    bbox = color_limit(g.min_extents[x] < machine_limit_min[x])
                    glPushMatrix()
                    f = fmt % ((g.min_extents[x] - offset[x]) * dimscale)
                    glTranslatef(g.min_extents[x] - halfchar, y_pos, z_pos)
                    glRotatef(-90, 0, 0, 1)
                    if view == y:
                        glRotatef(90, 0, 1, 0)
                        glTranslatef(dashwidth*1.5, 0, 0)
                    glScalef(charsize, charsize, charsize)
                    hershey.plot_string(f, 0, bbox)
                    glPopMatrix()

                    bbox = color_limit(g.max_extents[x] > machine_limit_max[x])
                    glPushMatrix()
                    f = fmt % ((g.max_extents[x] - offset[x]) * dimscale)
                    glTranslatef(g.max_extents[x] - halfchar, y_pos, z_pos)
                    glRotatef(-90, 0, 0, 1)
                    if view == y:
                        glRotatef(90, 0, 1, 0)
                        glTranslatef(dashwidth*1.5, 0, 0)
                    glScalef(charsize, charsize, charsize)
                    hershey.plot_string(f, 0, bbox)
                    glPopMatrix()

                    color_limit(0)
                    glPushMatrix()
                    f = fmt % ((g.max_extents[x] - g.min_extents[x]) * dimscale)

                    glTranslatef((g.max_extents[x] + g.min_extents[x])/2, y_pos,
                                z_pos)
                    if view == y:
                        glRotatef(-90, 1, 0, 0)
                        glTranslatef(0, halfchar, 0)
                    glScalef(charsize, charsize, charsize)
                    hershey.plot_string(f, .5)
                    glPopMatrix()

        if vars.show_live_plot.get() or vars.show_program.get():
            s.poll()
            glPushMatrix()

            if vars.coord_type.get() and (s.origin[0] or s.origin[1] or 
                                          s.origin[2]):
                draw_small_origin()
                origin = to_internal_units(s.origin)[:3]
                glTranslatef(*origin)
                draw_axes()
            else:
                draw_axes()
            glPopMatrix()

        if vars.show_machine_limits.get():
            glLineWidth(1)
            glColor3f(1.0,0.0,0.0)
            glLineStipple(1, 0x1111)
            glEnable(GL_LINE_STIPPLE)
            glBegin(GL_LINES)

            glVertex3f(machine_limit_min[0], machine_limit_min[1], machine_limit_max[2])
            glVertex3f(machine_limit_min[0], machine_limit_min[1], machine_limit_min[2])

            glVertex3f(machine_limit_min[0], machine_limit_min[1], machine_limit_min[2])
            glVertex3f(machine_limit_min[0], machine_limit_max[1], machine_limit_min[2])

            glVertex3f(machine_limit_min[0], machine_limit_max[1], machine_limit_min[2])
            glVertex3f(machine_limit_min[0], machine_limit_max[1], machine_limit_max[2])

            glVertex3f(machine_limit_min[0], machine_limit_max[1], machine_limit_max[2])
            glVertex3f(machine_limit_min[0], machine_limit_min[1], machine_limit_max[2])

            
            glVertex3f(machine_limit_max[0], machine_limit_min[1], machine_limit_max[2])
            glVertex3f(machine_limit_max[0], machine_limit_min[1], machine_limit_min[2])

            glVertex3f(machine_limit_max[0], machine_limit_min[1], machine_limit_min[2])
            glVertex3f(machine_limit_max[0], machine_limit_max[1], machine_limit_min[2])

            glVertex3f(machine_limit_max[0], machine_limit_max[1], machine_limit_min[2])
            glVertex3f(machine_limit_max[0], machine_limit_max[1], machine_limit_max[2])

            glVertex3f(machine_limit_max[0], machine_limit_max[1], machine_limit_max[2])
            glVertex3f(machine_limit_max[0], machine_limit_min[1], machine_limit_max[2])


            glVertex3f(machine_limit_min[0], machine_limit_min[1], machine_limit_min[2])
            glVertex3f(machine_limit_max[0], machine_limit_min[1], machine_limit_min[2])

            glVertex3f(machine_limit_min[0], machine_limit_max[1], machine_limit_min[2])
            glVertex3f(machine_limit_max[0], machine_limit_max[1], machine_limit_min[2])

            glVertex3f(machine_limit_min[0], machine_limit_max[1], machine_limit_max[2])
            glVertex3f(machine_limit_max[0], machine_limit_max[1], machine_limit_max[2])

            glVertex3f(machine_limit_min[0], machine_limit_min[1], machine_limit_max[2])
            glVertex3f(machine_limit_max[0], machine_limit_min[1], machine_limit_max[2])
            
            glEnd()
            glDisable(GL_LINE_STIPPLE)
            glLineStipple(2, 0xffff)
            
        if vars.show_live_plot.get():
            glDepthFunc(GL_LEQUAL)
            glLineWidth(3)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
            glEnable(GL_BLEND)
            glPushMatrix()
            lu = 1/((s.linear_units or 1)*25.4)
            glScalef(lu, lu, lu);
            glMatrixMode(GL_PROJECTION)
            glPushMatrix()
            glTranslatef(0,0,.003)

            live_plotter.logger.call()

            glDrawArrays(GL_LINE_STRIP, 0, o.live_plot_size)
            glPopMatrix()
            glMatrixMode(GL_MODELVIEW)
            glPopMatrix();
            glDisable(GL_BLEND)
            glLineWidth(1)
            glDepthFunc(GL_LESS);
            
        if live_plotter.running.get() and vars.show_tool.get():
            pos = None
            if vars.show_live_plot.get():
                pos = live_plotter.logger.last()
            if pos is None:
                pos = live_plotter.stat.actual_position
            if program is not None:
                g = self.g
                x,y,z = 0,1,2
                cone_scale = max(g.max_extents[x] - g.min_extents[x],
                               g.max_extents[y] - g.min_extents[y],
                               g.max_extents[z] - g.min_extents[z],
                               2 ) * .5
            else:
                cone_scale = 1
            pos = to_internal_units(pos[:3])
            glPushMatrix()
            glTranslatef(*pos)
            if s.axis_mask & (1<<3):
                glRotatef(s.position[3], 1, 0, 0)

            glEnable(GL_BLEND)
            glEnable(GL_CULL_FACE);
            glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA);

            if lathe and current_tool and current_tool.orientation != 0:
                glBlendColor(0,0,0,o.colors['lathetool_alpha'])
                lathetool()
            else:
                glBlendColor(0,0,0,o.colors['tool_alpha'])
                if lathe:
                    glRotatef(90, 0, 1, 0)
                if current_tool and current_tool.diameter != 0:
                    dia = current_tool.diameter
                    r = to_internal_linear_unit(dia) / 2.
                    q = gluNewQuadric()
                    glEnable(GL_LIGHTING)
                    glColor3f(*o.colors['cone'])
                    gluCylinder(q, r, r, 8*r, 32, 1)
                    gluDisk(q, 0, -r, 32, 1)
                    glTranslatef(0,0,8*r)
                    gluDisk(q, 0, r, 32, 1)
                    glDisable(GL_LIGHTING)
                    gluDeleteQuadric(q)
                else:    
                    glScalef(cone_scale, cone_scale, cone_scale)
                    glCallList(cone_program)
            glPopMatrix()

        glMatrixMode(GL_PROJECTION)
        glPushMatrix()
        glLoadIdentity()
        ypos = self.winfo_height()
        glOrtho(0.0, self.winfo_width(), 0.0, ypos, -1.0, 1.0)
        glMatrixMode(GL_MODELVIEW)
        glPushMatrix()
        glLoadIdentity()
        s.poll()

        limit = []
        for i,l in enumerate(s.limit):
            if s.axis_mask & (1<<i):
                limit.append(l)

        homed = []
        for i,h in enumerate(s.homed):
            if s.axis_mask & (1<<i):
                homed.append(h)
        if lathe and not s.axis_mask & 2:
            homed.insert(1, 0)
            limit.insert(1, 0)

        if s.kinematics_type == emc.KINEMATICS_IDENTITY or s.motion_mode != emc.TRAJ_MODE_FREE:
            if vars.display_type.get():
                positions = s.position
            else:
                positions = s.actual_position

            positions = [(i-j) for i, j in zip(positions, s.tool_offset)]

            if vars.coord_type.get():
                positions = [(i-j) for i, j in zip(positions, s.origin)]

            positions = to_internal_units(positions)

            if vars.metric.get():
                positions = from_internal_units(positions, 1)
                format = "%3s:% 9.3f"
            else:
                format = "%3s:% 9.4f"

            posstrs = [format % j for i, j in zip(range(9), zip("XYZABCUVW", positions)) if s.axis_mask & (1<<i)]

            if lathe:
                posstrs.insert(1, format % ("Dia", positions[0]*2.0))

            if vars.show_machine_speed.get():
                spd = to_internal_linear_unit(s.current_vel)
                if vars.metric.get():
                    spd = spd * 25.4 * 60
                else:
                    spd = spd * 60
                posstrs.append(format % ("Vel", spd))

            if vars.show_distance_to_go.get():
                dtg = to_internal_linear_unit(s.distance_to_go)
                if vars.metric.get():
                    dtg *= 25.4
                posstrs.append(format % ("DTG", dtg))
        else:
            # N.B. no conversion here because joint positions are unitless
            posstrs = ["  %s:% 9.4f" % i for i in
                zip(jointnames, s.joint_actual_position)]

        maxlen = max([len(p) for p in posstrs])
        pixel_width = max([int(o.tk.call("font", "measure", coordinate_font, p))
                        for p in posstrs])
        glDepthFunc(GL_ALWAYS)
        glDepthMask(GL_FALSE)
        glEnable(GL_BLEND)
        glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA)
        glColor3f(*o.colors['overlay_background'])
        glBlendColor(0,0,0,1-o.colors['overlay_alpha'])
        glBegin(GL_QUADS)
        glVertex3f(0, ypos, 1)
        glVertex3f(0, ypos - 8 - coordinate_linespace*len(posstrs), 1)
        glVertex3f(pixel_width+24, ypos - 8 - coordinate_linespace*len(posstrs), 1)
        glVertex3f(pixel_width+24, ypos, 1)
        glEnd()
        glDisable(GL_BLEND)

        maxlen = 0
        ypos -= coordinate_linespace+5
        i=0
        glColor3f(*o.colors['overlay_foreground'])
        for string in posstrs:
            maxlen = max(maxlen, len(string))
            if i < len(homed) and homed[i]:
                glRasterPos2i(6, ypos)
                glBitmap(13, 16, 0, 3, 17, 0, homeicon)
            glRasterPos2i(5, ypos)
            for char in string:
                glCallList(fontbase + ord(char))
            if i < len(homed) and limit[i]:
                glBitmap(13, 16, -5, 3, 17, 0, limiticon)
            ypos -= coordinate_linespace
            i = i + 1
        glDepthFunc(GL_LESS)
        glDepthMask(GL_TRUE)

        glPopMatrix()
        glMatrixMode(GL_PROJECTION)
        glPopMatrix()
        glMatrixMode(GL_MODELVIEW)

def init():
    glDrawBuffer(GL_BACK)
    glDisable(GL_CULL_FACE)
    glLineStipple(2, 0x5555)
    glDisable(GL_LIGHTING)
    glClearColor(0,0,0,0)
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1)

def draw_small_origin():
    r = 2.0/25.4
    glColor3f(*o.colors['small_origin'])

    glBegin(GL_LINE_STRIP)
    for i in range(37):
        theta = (i*10)*math.pi/180.0
        glVertex3f(r*cos(theta),r*sin(theta),0.0)
    glEnd()
    glBegin(GL_LINE_STRIP)
    for i in range(37):
        theta = (i*10)*math.pi/180.0
        glVertex3f(0.0, r*cos(theta), r*sin(theta))
    glEnd()
    glBegin(GL_LINE_STRIP)
    for i in range(37):
        theta = (i*10)*math.pi/180.0
        glVertex3f(r*cos(theta),0.0, r*sin(theta))
    glEnd()

    glBegin(GL_LINES);
    glVertex3f(-r, -r, 0.0)
    glVertex3f( r,  r, 0.0)
    glVertex3f(-r,  r, 0.0)
    glVertex3f( r, -r, 0.0)

    glVertex3f(-r, 0.0, -r)
    glVertex3f( r, 0.0,  r)
    glVertex3f(-r, 0.0,  r)
    glVertex3f( r, 0.0, -r)

    glVertex3f(0.0, -r, -r)
    glVertex3f(0.0,  r,  r)
    glVertex3f(0.0, -r,  r)
    glVertex3f(0.0,  r, -r)
    glEnd()

def draw_axes():
    x,y,z,p = 0,1,2,3
    if str(widgets.view_x['relief']) == "sunken":
        view = x
    elif str(widgets.view_y['relief']) == "sunken":
        view = y
    elif (str(widgets.view_z['relief']) == "sunken" or
          str(widgets.view_z2['relief']) == "sunken"):
        view = z
    else:
        view = p

    glColor3f(*o.colors['axis_x'])
    glBegin(GL_LINES);
    glVertex3f(1.0,0.0,0.0)
    glVertex3f(0.0,0.0,0.0)
    glEnd();

    if view != x:
        glPushMatrix()
        if lathe:
            glTranslatef(1.3, -0.1, 0)
            glTranslatef(0, 0, -0.1)
            glRotatef(-90, 0, 1, 0)
            glRotatef(90, 1, 0, 0)
            glTranslatef(0.1, 0, 0)
        else:
            glTranslatef(1.2, -0.1, 0)
            if view == y: