def add_bond(self, Atom1Pos, Atom2Pos, Radius=0.1, type='cylinder'): Radius2 = Radius if type == 'conus': Radius2 = 0 Rel = [ Atom2Pos[0] - Atom1Pos[0], Atom2Pos[1] - Atom1Pos[1], Atom2Pos[2] - Atom1Pos[2] ] BindingLen = math.sqrt( math.pow(Rel[0], 2) + math.pow(Rel[1], 2) + math.pow(Rel[2], 2)) # высота цилиндра if (BindingLen != 0): Fall = 180.0 / math.pi * math.acos(Rel[2] / BindingLen) Yaw = 180.0 / math.pi * math.atan2(Rel[1], Rel[0]) gl.glPushMatrix() gl.glTranslated(Atom1Pos[0], Atom1Pos[1], Atom1Pos[2]) gl.glRotated(Yaw, 0, 0, 1) gl.glRotated(Fall, 0, 1, 0) glu.gluCylinder( glu.gluNewQuadric(), Radius, # /*baseRadius:*/ Radius2, # /*topRadius:*/ BindingLen, # /*height:*/ self.quality * 15, # /*slices:*/ 1) #/*stacks:*/ gl.glPopMatrix()
def _draw_cylinders(self, length, diffs): for x_translate, y_translate in diffs: gl.glPushMatrix() gl.glTranslate(x_translate, y_translate, 0) glu.gluCylinder(self.quad, self.bond_width, self.bond_width, length, self.cylinder_resolution, 1) gl.glPopMatrix()
def _glcylinder(quadric, radius, height, slices, stacks, loops): """ Internal method to render a quadric cylinder with OpenGL commands @param quadric The OpenGL quadric object @param radius The radius of the cylinder's base. @param height The height of the cylunder. @param slices The number of subdivisions around the z-axis (similar to lines of longitude). @param stacks The number of subdivisions along the z-axis (similar to lines of latitude). @param loops The number of concentric rings about the origin into which the cylinder's base is subdivided. """ GLU.gluCylinder(quadric, radius, radius, height, slices, stacks) # The positive Z-axis is the default direction fo Cylinder Quadrics in OpenGL. # The top disc is 'height' units away from the origin. with GLMatrixScope(GL.GL_MODELVIEW, False): GL.glTranslate(0, 0, height); GLU.gluDisk(quadric, 0.0, radius, slices, loops) # The positive Z-axis is the default direction for Cylinder Quadrics in OpenGL. # The base disc renders at the origin, but must be rotated to face the opposite # along the negative z axis. with GLMatrixScope(GL.GL_MODELVIEW, False): GL.glRotate(180, 0, 1, 0) GLU.gluDisk(quadric, 0.0, radius, slices, loops)
def DrawWire(self, yangle, xangle, vfrom, vto): lm1 = self.colony.polyp_list[vfrom - 1] lm2 = self.colony.polyp_list[vto - 1] # print lm1.x, lm2.x axis_start = [0, 0, 1] axis_end = [lm1.pos[0] - lm2.pos[0], lm1.pos[1] - lm2.pos[1], lm1.pos[2] - lm2.pos[2]] # print vfrom, vto, axis_start, axis_end angle = math.acos(axis_start[0] * axis_end[0] + axis_start[1] * axis_end[1] + axis_start[2] * axis_end[2] / ( (axis_start[0] ** 2 + axis_start[1] ** 2 + axis_start[2] ** 2) ** 0.5 * ( axis_end[0] ** 2 + axis_end[1] ** 2 + axis_end[2] ** 2) ** 0.5)) angle = angle * (180 / math.pi) axis_rotation = [0, 0, 0] axis_rotation[0] = axis_start[1] * axis_end[2] - axis_start[2] * axis_end[1] axis_rotation[1] = axis_start[2] * axis_end[0] - axis_start[0] * axis_end[2] axis_rotation[2] = axis_start[0] * axis_end[1] - axis_start[1] * axis_end[0] if angle == 180: axis_rotation = [1, 0, 0] length = (axis_end[0] ** 2 + axis_end[1] ** 2 + axis_end[2] ** 2) ** 0.5 radius = self.wire_radius cyl = glu.gluNewQuadric() gl.glPushMatrix() gl.glLoadIdentity() # glTranslate(0, 0, self.offset) gl.glRotatef(yangle, 1.0, 0.0, 0.0) gl.glRotatef(xangle, 0.0, 1.0, 0.0) gl.glTranslate(lm2.pos[0], lm2.pos[1], lm2.pos[2]) if (angle != 0): gl.glRotate(angle, axis_rotation[0], axis_rotation[1], axis_rotation[2]) glu.gluCylinder(cyl, radius, radius, length, 10, 10) gl.glPopMatrix()
def render(self, start, dir, length, width, color): if length > 0.0: # Compute the angle-axis rotation require to orient the vector along dir: up_vec = np.array([0.0, 0.0, 1.0]) axis = np.cross(up_vec, dir) trip_prod = np.linalg.det(np.dstack((up_vec, dir, axis))) if trip_prod > 0: angle = np.arccos(np.dot(up_vec, dir)) else: angle = 2 * np.pi - np.arccos(np.dot(up_vec, dir)) # Draw the shaft using a cylinder: gl.glPushMatrix() gl.glColor3f(*color) gl.glTranslatef(*start) gl.glRotate((180.0 / np.pi) * angle, *axis) GLU.gluCylinder(self.quadric, width, width, length, 100, 10) gl.glPopMatrix() # Draw the head using a cylinder having zero width on top: gl.glPushMatrix() gl.glColor3f(*color) gl.glTranslatef(*start) gl.glRotate((180.0 / np.pi) * angle, *axis) gl.glTranslatef(0.0, 0.0, length) GLU.gluCylinder(self.quadric, 2.0 * width, 0.0, 0.1 * length, 100, 10) gl.glPopMatrix()
def draw(self): y1, r1, y2, r2 = self.coords() if y1 > y2: tmp = y1 y1 = y2 y2 = tmp tmp = r1 r1 = r2 r2 = tmp GL.glPushMatrix() # GL creates cylinders along Z, so need to rotate z1 = y1 z2 = y2 GL.glRotatef(-90, 1, 0, 0) # need to translate the whole thing to z1 GL.glTranslatef(0, 0, z1) # the cylinder starts out at Z=0 GLU.gluCylinder(self.q, r1, r2, z2 - z1, 32, 1) # bottom cap GL.glRotatef(180, 1, 0, 0) GLU.gluDisk(self.q, 0, r1, 32, 1) GL.glRotatef(180, 1, 0, 0) # the top cap needs flipped and translated GL.glPushMatrix() GL.glTranslatef(0, 0, z2 - z1) GLU.gluDisk(self.q, 0, r2, 32, 1) GL.glPopMatrix() GL.glPopMatrix()
def applyShape(self): self._Quadric=GLU.gluNewQuadric() GLU.gluQuadricNormals(self._Quadric, self.GL(self._normals)) GLU.gluQuadricTexture(self._Quadric, self.GL(self._texture)) GLU.gluCylinder(self._Quadric, self._base, self._top, self._height, self._subdiv, 1) GLU.gluDeleteQuadric(self._Quadric) self._Quadric = None
def draw(self): quad = glu.gluNewQuadric() ogl.glPushMatrix() ogl.glMultMatrixd(self.frame.matrix()) glu.gluSphere(quad, 0.03, 10, 6) glu.gluCylinder(quad, 0.03, 0.0, 0.09, 10, 1) ogl.glPopMatrix()
def applyShape(self): self._Quadric = GLU.gluNewQuadric() GLU.gluQuadricNormals(self._Quadric, self.GL(self._normals)) GLU.gluQuadricTexture(self._Quadric, self.GL(self._texture)) GLU.gluCylinder(self._Quadric, self._base, self._top, self._height, self._subdiv, 1) GLU.gluDeleteQuadric(self._Quadric) self._Quadric = None
def render_cylinder(self, pos, r, h, num_seg1=20, num_seg2=10): GL.glPushMatrix() GL.glTranslated(*pos) GLU.gluCylinder(self.quadric, r, r, h, num_seg1, num_seg2) GL.glRotatef(180, 1, 0, 0) GLU.gluDisk(self.quadric, 0.0, r, num_seg1, 1) GL.glRotatef(180, 1, 0, 0) GL.glTranslatef(0.0, 0.0, h) GLU.gluDisk(self.quadric, 0.0, r, num_seg1, 1) GL.glPopMatrix()
def to_OpenGL(self): if not GL_enabled: return GL.glPushMatrix() GL.glTranslate(self.center.x, self.center.y, self.center.z) if not hasattr(self, "_sphere"): self._sphere = GLU.gluNewQuadric() GLU.gluSphere(self._sphere, self.radius, 10, 10) if not hasattr(self, "_cylinder"): self._cylinder = GLU.gluNewQuadric() GLU.gluCylinder(self._cylinder, self.radius, self.radius, self.height, 10, 10) GL.glPopMatrix()
def to_OpenGL(self): if not GL_enabled: return GL.glPushMatrix() GL.glTranslate(self.center[0], self.center[1], self.center[2]) if not hasattr(self, "_cylinder"): self._cylinder = GLU.gluNewQuadric() GLU.gluCylinder(self._cylinder, self.radius, self.radius, self.height, 10, 10) if not hasattr(self, "_disk"): self._disk = GLU.gluNewQuadric() GLU.gluDisk(self._disk, 0, self.radius, 10, 10) GL.glPopMatrix()
def to_opengl(self): if not GL_enabled: return GL.glPushMatrix() GL.glTranslate(self.center[0], self.center[1], self.center[2]) if not hasattr(self, "_cylinder"): self._cylinder = GLU.gluNewQuadric() GLU.gluCylinder(self._cylinder, self.radius, self.radius, self.height, 10, 10) if not hasattr(self, "_disk"): self._disk = GLU.gluNewQuadric() GLU.gluDisk(self._disk, 0, self.radius, 10, 10) GL.glPopMatrix()
def drawCylinder(self, X1, X2): from OpenGL import GL,GLUT, GLU z = np.array([0.,0.,1.]) #default cylinder orientation p = X2-X1 #desired cylinder orientation r = np.linalg.norm(p) t = np.cross(z,p) #angle about which to rotate a = np.arccos( np.dot( z,p) / r ) #rotation angle a *= (180. / np.pi) #change units to angles GL.glPushMatrix() GL.glTranslate( X1[0], X1[1], X1[2] ) GL.glRotate( a, t[0], t[1], t[2] ) g=GLU.gluNewQuadric() GLU.gluCylinder(g, .1,0.1,r,30,30) #I can't seem to draw a cylinder GL.glPopMatrix()
def draw_cylinder(self, inside, outside, height, base_thickness): gl.glRotate(180, 0.0, 1.0, 0.0) glu.gluDisk(self.quad, 0, outside, 100, 5) gl.glRotate(-180, 0.0, 1.0, 0.0) gl.glTranslatef(0.0, 0.0, height) glu.gluDisk(self.quad, inside, outside, 100, 5) gl.glTranslatef(0.0, 0.0, -height) gl.glTranslatef(0.0, 0.0, base_thickness) glu.gluQuadricOrientation(self.quad, glu.GLU_INSIDE) glu.gluCylinder(self.quad, inside, inside, height - base_thickness, 100, 1) glu.gluQuadricOrientation(self.quad, glu.GLU_OUTSIDE) glu.gluDisk(self.quad, 0, inside, 100, 5) gl.glTranslatef(0.0, 0.0, -base_thickness) glu.gluCylinder(self.quad, outside, outside, height, 100, 1)
def _draw_projection(self, domain_object): logging.debug("Drawing Projection") gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, [0.8, 0.2, 0.2, 0.1]) gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, [0.9, 0.5, 0.5, 0.3]) gl.glMaterialfv(gl.GL_FRONT, gl.GL_EMISSION, [0.2, 0.1, 0.1, 0.1]) gl.glEnable(gl.GL_BLEND) gl.glDepthMask(gl.GL_FALSE) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) if domain_object.projection_shape == 'Circle': glu.gluCylinder(self.quad, domain_object.radius_at_base, 0.0, domain_object.height_mm, 100, 1) else: self._square_pyrmid(domain_object.radius_at_base * 2.0, 0.0, domain_object.height_mm) gl.glDepthMask(gl.GL_TRUE) gl.glDisable(gl.GL_BLEND)
def drawCylinder(self, X1, X2): from OpenGL import GL, GLU z = np.array([0.,0.,1.]) #default cylinder orientation p = X2-X1 #desired cylinder orientation r = np.linalg.norm(p) t = np.cross(z,p) #angle about which to rotate a = np.arccos( np.dot( z,p) / r ) #rotation angle a *= (180. / np.pi) #change units to angles GL.glPushMatrix() GL.glTranslate( X1[0], X1[1], X1[2] ) GL.glRotate( a, t[0], t[1], t[2] ) g=GLU.gluNewQuadric() GLU.gluCylinder(g, .1,0.1,r,30,30) #I can't seem to draw a cylinder GL.glPopMatrix()
def drawCylinder(Start=np.array([0, 0, 0]), End=np.array([1.0, 0.0, 0.0]), Radius1=1.0, Radius2=1.0, Color=None): if type(Start) is not np.ndarray or type(End) is not np.ndarray: raise RuntimeError('Start and End need to be Numpy arrays.') Direction = End - Start Length = np.linalg.norm(Direction) if (Length <= 0.0): return Direction = Direction / Length # Find out the axis of rotation and angle of rotation to rotate the # gluCylinder (oriented along the z axis) into the desired direction Z = np.array([0., 0., 1.]) Axis = np.cross(Z, Direction) Angle = math.acos(np.dot(Z, Direction)) * (180. / math.pi ) # Should be degrees gl.glPushMatrix() gl.glTranslate(Start[0], Start[1], Start[2]) gl.glRotate(Angle, Axis[0], Axis[1], Axis[2]) # Next the 6 faces if (Color != None): gl.glEnable(gl.GL_DEPTH_TEST) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # Orig gl.glEnable(gl.GL_BLEND) gl.glColor4fv(Color) else: gl.glColor3f(0.0, 0.0, 0.0) # Draw cylinder # Bottom: glu.gluQuadricOrientation(QUADRIC, glu.GLU_INSIDE) glu.gluDisk(QUADRIC, 0, Radius1, 16, 1) glu.gluQuadricOrientation(QUADRIC, glu.GLU_OUTSIDE) glu.gluCylinder(QUADRIC, Radius1, Radius2, Length, 16, 1) # Top: gl.glTranslatef(0, 0, Length) glu.gluQuadricOrientation(QUADRIC, glu.GLU_OUTSIDE) glu.gluDisk(QUADRIC, 0, Radius2, 16, 1) gl.glPopMatrix()
def buildAxisIndicator(self): """Assemble the axis indicator into a display list. """ # single axis specs bodyLen = GLView.axisLen * 0.75 tipLen = GLView.axisLen * 0.25 majDia = GLView.axisLen * 0.125 slices = 8 stacks = 2 # build one axis axisId = gl.glGenLists(1) quadric = glu.gluNewQuadric() gl.glNewList(axisId, gl.GL_COMPILE) glu.gluCylinder(quadric, 0.0, majDia, bodyLen, slices, stacks) gl.glPushMatrix() gl.glTranslate(0, 0, bodyLen) glu.gluCylinder(quadric, majDia, 0, tipLen, slices, stacks) gl.glPopMatrix() gl.glEndList() # now assemble all three self.axisIndicatorId = gl.glGenLists(1) gl.glNewList(self.axisIndicatorId, gl.GL_COMPILE) # always lit and smooth shaded with a bit a spec gl.glEnable(gl.GL_LIGHTING) gl.glPolygonMode(gl.GL_FRONT, gl.GL_FILL) gl.glShadeModel(gl.GL_SMOOTH) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_SPECULAR, [1.0, 1.0, 1.0, 1.0]) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_SHININESS, 64) # X axis, red gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE, [0.7, 0.0, 0.0, 1.0]) gl.glPushMatrix() gl.glRotate(90, 0, 1, 0) gl.glCallList(axisId) gl.glPopMatrix() # Y axis, green gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE, [0.0, 0.7, 0.0, 1.0]) gl.glPushMatrix() gl.glRotate(-90, 1, 0, 0) gl.glCallList(axisId) gl.glPopMatrix() # Z axis, blue gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE, [0.0, 0.0, 0.7, 1.0]) gl.glCallList(axisId) gl.glEndList()
def to_OpenGL(self): if not GL_enabled: return GL.glPushMatrix() GL.glTranslate(self.center.x, self.center.y, self.center.z) GLUT.glutSolidTorus(self.minorradius, self.majorradius, 10, 20) if not hasattr(self, "_cylinder"): self._cylinder = GLU.gluNewQuadric() GLU.gluCylinder(self._cylinder, self.radius, self.radius, self.height, 10, 20) GL.glPopMatrix() GL.glPushMatrix() GL.glTranslate(self.location.x, self.location.y, self.location.z) if not hasattr(self, "_disk"): self._disk = GLU.gluNewQuadric() GLU.gluDisk(self._disk, 0, self.majorradius, 20, 10) GL.glPopMatrix()
def to_OpenGL(self): if not GL_enabled: return GL.glPushMatrix() GL.glTranslate(self.center[0], self.center[1], self.center[2]) GLUT.glutSolidTorus(self.minorradius, self.majorradius, 10, 20) if not hasattr(self, "_cylinder"): self._cylinder = GLU.gluNewQuadric() GLU.gluCylinder(self._cylinder, self.radius, self.radius, self.height, 10, 20) GL.glPopMatrix() GL.glPushMatrix() GL.glTranslate(self.location[0], self.location[1], self.location[2]) if not hasattr(self, "_disk"): self._disk = GLU.gluNewQuadric() GLU.gluDisk(self._disk, 0, self.majorradius, 20, 10) GL.glPopMatrix()
def drawPointAndDirs(self): xAxis = numpy.array([1, 0, 0], 'float') yAxis = numpy.array([0, 1, 0], 'float') zAxis = numpy.array([0, 0, 1], 'float') center = numpy.array([0, 0, 0], 'float') qobj = GLU.gluNewQuadric() sphere_radius = 0.1 cyl_height = 1 cyl_radius = 0.01 z_dir = numpy.array([0., 0., 1.], dtype='float64') genList = GL.glGenLists(1) GL.glNewList(genList, GL.GL_COMPILE) #Cylinder along z, we want it to be allong xAxis #Solution: use the appropriate rotation matrix #We have to choose the right axis, perpendicular to both, and rotate by the appropriate angle, the angle between the 2 vectors self.qglColor(QtGui.QColor.fromCmykF(0., 1., 1., 0.)) rotation_dir = numpy.cross(z_dir, xAxis) angle = math.acos(z_dir.dot(xAxis)) * 180 / 3.14159 GL.glPushMatrix() GL.glTranslatef(center[0], center[1], center[2]) GL.glRotatef(angle, rotation_dir[0], rotation_dir[1], rotation_dir[2]) GLU.gluCylinder(qobj, cyl_radius, cyl_radius, cyl_height, 20, 20) GL.glPopMatrix() self.qglColor(QtGui.QColor.fromCmykF(1., 0., 1., 0.)) rotation_dir = numpy.cross(z_dir, yAxis) angle = math.acos(z_dir.dot(yAxis)) * 180 / 3.14159 GL.glPushMatrix() GL.glTranslatef(center[0], center[1], center[2]) GL.glRotatef(angle, rotation_dir[0], rotation_dir[1], rotation_dir[2]) GLU.gluCylinder(qobj, cyl_radius, cyl_radius, cyl_height, 20, 20) GL.glPopMatrix() GL.glEndList() return genList
def draw_cone(color, pos, vel, speed): gl.glColor(*color) gl.glPushMatrix() x, y = pos gl.glTranslate(x, y, 3) vx, vy = vel gl.glRotate(360 / TAU * math.atan2(vy, vx), 0, 0, 1) gl.glRotate(90, 0, 0, 1) gl.glRotate(90, 1, 0, 0) q = glu.gluNewQuadric() glu.gluCylinder(q, 2, 0, max(1, speed / 3), 20, 20) glu.gluDeleteQuadric(q) gl.glPopMatrix()
def draw_cone(X1, X2, rbase=0.1, rtop=0.0, color=None): """draw a cylinder from X1 to X2""" if color is not None: change_color(color) from OpenGL import GL, GLU z = np.array([0., 0., 1.]) # default cylinder orientation p = X2 - X1 # desired cylinder orientation r = np.linalg.norm(p) t = np.cross(z, p) # angle about which to rotate a = np.arccos(np.dot(z, p) / r) # rotation angle a *= (180. / np.pi) # change units to angles GL.glPushMatrix() GL.glTranslate(X1[0], X1[1], X1[2]) GL.glRotate(a, t[0], t[1], t[2]) g = GLU.gluNewQuadric() GLU.gluCylinder(g, rbase, rtop, r, 30, 30) # I can't seem to draw a cylinder GL.glPopMatrix()
def __drawSaucer(self): quadric = glu.gluNewQuadric() ogl.glTranslatef(0.0, 0.0, -0.014) glu.gluCylinder(quadric, 0.015, 0.03, 0.004, 32, 1) ogl.glTranslatef(0.0, 0.0, 0.004) glu.gluCylinder(quadric, 0.03, 0.04, 0.01, 32, 1) ogl.glTranslatef(0.0, 0.0, 0.01) glu.gluCylinder(quadric, 0.05, 0.03, 0.02, 32, 1) ogl.glTranslatef(0.0, 0.0, 0.02) glu.gluCylinder(quadric, 0.03, 0.0, 0.003, 32, 1) ogl.glTranslatef(0.0, 0.0, -0.02)
def _caped_cylinder( radius, height, segments ): global __quadratic, __legocaptex GL.glPushMatrix() GL.glRotatef(-90, 1.0, 0.0, 0.0) GL.glTranslatef(0.0, 0.0, -height/2.0) #GLU.gluQuadricOrientation(__quadratic, GLU.GLU_INSIDE) #gluDisk(__quadratic,0,radius,segments,1) #GLU.gluQuadricOrientation(__quadratic, GLU.GLU_OUTSIDE) GLU.gluCylinder( __quadratic, radius, radius, height, segments, 1 ) GL.glTranslatef( 0.0, 0.0, height ) GL.glBindTexture( GL.GL_TEXTURE_2D, __legocaptex ) GLU.gluDisk( __quadratic, 0, radius, segments,1 ) GL.glBindTexture( GL.GL_TEXTURE_2D, 0 ) GL.glPopMatrix()
def DrawWire(self, yangle, xangle, vfrom, vto): lm1 = self.colony.polyp_list[vfrom - 1] lm2 = self.colony.polyp_list[vto - 1] # print lm1.x, lm2.x axis_start = [0, 0, 1] axis_end = [ lm1.pos[0] - lm2.pos[0], lm1.pos[1] - lm2.pos[1], lm1.pos[2] - lm2.pos[2] ] # print vfrom, vto, axis_start, axis_end angle = math.acos( axis_start[0] * axis_end[0] + axis_start[1] * axis_end[1] + axis_start[2] * axis_end[2] / ((axis_start[0]**2 + axis_start[1]**2 + axis_start[2]**2)**0.5 * (axis_end[0]**2 + axis_end[1]**2 + axis_end[2]**2)**0.5)) angle = angle * (180 / math.pi) axis_rotation = [0, 0, 0] axis_rotation[ 0] = axis_start[1] * axis_end[2] - axis_start[2] * axis_end[1] axis_rotation[ 1] = axis_start[2] * axis_end[0] - axis_start[0] * axis_end[2] axis_rotation[ 2] = axis_start[0] * axis_end[1] - axis_start[1] * axis_end[0] if angle == 180: axis_rotation = [1, 0, 0] length = (axis_end[0]**2 + axis_end[1]**2 + axis_end[2]**2)**0.5 radius = self.wire_radius cyl = glu.gluNewQuadric() gl.glPushMatrix() gl.glLoadIdentity() # glTranslate(0, 0, self.offset) gl.glRotatef(yangle, 1.0, 0.0, 0.0) gl.glRotatef(xangle, 0.0, 1.0, 0.0) gl.glTranslate(lm2.pos[0], lm2.pos[1], lm2.pos[2]) if (angle != 0): gl.glRotate(angle, axis_rotation[0], axis_rotation[1], axis_rotation[2]) glu.gluCylinder(cyl, radius, radius, length, 10, 10) gl.glPopMatrix()
def render_arrow(self, p, q, r_base=0.01, head_width=0.015, head_len=0.01): # glDisable(GL_LIGHTING) m_quadric = self.quadric GLU.gluQuadricNormals(m_quadric, GLU.GLU_SMOOTH) p = np.array(p) q = np.array(q) u = (q - p) u /= norm(u) P = q - head_len * u z = np.array([0, 0.0, 1.0]) z /= norm(z) if norm(z - u) < 1e-8: axis = np.array([0, 0, 1]) angle = 0.0 else: axis = np.cross(z, u) axis /= norm(axis) angle = math.acos(u.dot(z)) M = R_axis_angle(axis, angle) m = [ M[0, 0], M[1, 0], M[2, 0], 0.0, M[0, 1], M[1, 1], M[2, 1], 0.0, M[0, 2], M[1, 2], M[2, 2], 0.0, P[0], P[1], P[2], 1.0 ] m2 = [ M[0, 0], M[1, 0], M[2, 0], 0.0, M[0, 1], M[1, 1], M[2, 1], 0.0, M[0, 2], M[1, 2], M[2, 2], 0.0, p[0], p[1], p[2], 1.0 ] GL.glPushMatrix() GL.glMultMatrixd(m2) arrow_len = norm(q - p) - head_len # glColor(0.9, 0.2, 0.2) GLU.gluCylinder(m_quadric, r_base, r_base, arrow_len, 10, 10) GL.glPopMatrix() if head_width > 1e-6 and head_len > 1e-6: # glColor(1.0, 0.0, 0.0) GL.glPushMatrix() GL.glMultMatrixd(m) GLUT.glutSolidCone(head_width, head_len, 10, 3) GL.glPopMatrix()
def drawFlashLight(self): glPushMatrix() glRotate(-self.phi, 1.0, 0.0, 0.0) glRotate(-self.theta, 0.0, 1.0, 0.0) glTranslate(0, 0, 4) glMaterialfv(GL_FRONT, GL_AMBIENT, [0.0, 0.0, 0.0, 1.0]) glMaterialfv(GL_FRONT, GL_DIFFUSE, [0.0, 0.0, 0.0, 1.0]) glMaterialfv(GL_FRONT, GL_SPECULAR, [0.0, 0.0, 0.0, 1.0]) glMaterialfv(GL_FRONT, GL_EMISSION, [0.0, 1.0, 0.0, 1.0]) flashlight = GLU.gluNewQuadric() GLU.gluQuadricDrawStyle(flashlight, GLU.GLU_FILL) GLU.gluCylinder(flashlight, 0.3, 0.3, 1.5, 30, 30) GLU.gluCylinder(flashlight, 0.5, 0.3, 0.4, 30, 30) glPushMatrix() glTranslate(0, 0, 1.5) GLU.gluDisk(flashlight, 0.0, 0.3, 30, 30) glPopMatrix() glMaterialfv(GL_FRONT, GL_EMISSION, self.diffuse) GLU.gluDisk(flashlight, 0.0, 0.5, 30, 30) glMaterialfv(GL_FRONT, GL_EMISSION, [0.0, 0.0, 0.0, 1.0]) glPopMatrix()
def draw_arrow(self, pos, ori, length, col): # glfw.make_context_current(self.window) # self.gui_lock.acquire() gl.glLoadIdentity() gl.glTranslatef(pos[0], pos[1], pos[2]) gl.glRotatef(ori[0],1.0,0.0,0.0) gl.glRotatef(ori[1],0.0,1.0,0.0) gl.glRotatef(ori[2],0.0,0.0,1.0) gl.glColor3f(col[0], col[1], col[2]) quadObj=glu.gluNewQuadric() glu.gluCylinder(quadObj, 0.25, 0.25, length, 32, 16) gl.glTranslatef(0, 0, length) quadObj=glu.gluNewQuadric() glu.gluCylinder(quadObj, 0.45, 0., 4, 32, 16)
def render_arrow(self, p, q, r_base=0.01, head_width=0.015, head_len=0.01): # glDisable(GL_LIGHTING) m_quadric = self.quadric GLU.gluQuadricNormals(m_quadric, GLU.GLU_SMOOTH) p = np.array(p) q = np.array(q) u = (q - p) u /= norm(u) P = q - head_len * u z = np.array([0, 0.0, 1.0]) z /= norm(z) if norm(z - u) < 1e-8: axis = np.array([0, 0, 1]) angle = 0.0 else: axis = np.cross(z, u) axis /= norm(axis) angle = math.acos(u.dot(z)) M = R_axis_angle(axis, angle) m = [M[0, 0], M[1, 0], M[2, 0], 0.0, M[0, 1], M[1, 1], M[2, 1], 0.0, M[0, 2], M[1, 2], M[2, 2], 0.0, P[0], P[1], P[2], 1.0] m2 = [M[0, 0], M[1, 0], M[2, 0], 0.0, M[0, 1], M[1, 1], M[2, 1], 0.0, M[0, 2], M[1, 2], M[2, 2], 0.0, p[0], p[1], p[2], 1.0] GL.glPushMatrix() GL.glMultMatrixd(m2) arrow_len = norm(q - p) - head_len # glColor(0.9, 0.2, 0.2) GLU.gluCylinder(m_quadric, r_base, r_base, arrow_len, 10, 10) GL.glPopMatrix() if head_width > 1e-6 and head_len > 1e-6: # glColor(1.0, 0.0, 0.0) GL.glPushMatrix() GL.glMultMatrixd(m) GLUT.glutSolidCone(head_width, head_len, 10, 3) GL.glPopMatrix()
def draw(self): z1, r1, z2, r2 = self.coords() if z1 > z2: tmp = z1 z1 = z2 z2 = tmp tmp = r1 r1 = r2 r2 = tmp # need to translate the whole thing to z1 GL.glPushMatrix() GL.glTranslatef(0, 0, z1) # the cylinder starts out at Z=0 GLU.gluCylinder(self.q, r1, r2, z2 - z1, 32, 1) # bottom cap GL.glRotatef(180, 1, 0, 0) GLU.gluDisk(self.q, 0, r1, 32, 1) GL.glRotatef(180, 1, 0, 0) # the top cap needs flipped and translated GL.glPushMatrix() GL.glTranslatef(0, 0, z2 - z1) GLU.gluDisk(self.q, 0, r2, 32, 1) GL.glPopMatrix() GL.glPopMatrix()
def marker(): GL.glPushMatrix() GL.glTranslate(0.00, 0.00, 0.00) GL.glColor(0, 0, 1) GLU.gluCylinder(GLU.gluNewQuadric(), 0.01, 0.01, 1.0, 6, 1) GL.glRotate(-90, 1, 0, 0) GL.glColor(0, 1, 0) GLU.gluCylinder(GLU.gluNewQuadric(), 0.01, 0.01, 1.0, 6, 1) GL.glRotate(90, 0, 1, 0) GL.glColor(1, 0, 0) GLU.gluCylinder(GLU.gluNewQuadric(), 0.01, 0.01, 1.0, 6, 1) GL.glColor(1, 1, 1) GL.glPopMatrix()
def drawGLScene(): GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) for object in sceneObjects.values(): # apply camera transform for > 3 dimensions iterateCamerasD() # apply 3D camera transform iterateCamerasD() # first we need to project geometry from > 3 dimensions to 3D projectFromHigherDimensions(object) vertexBuffer = object.getVertexData3D() edgesData = object.getEdgesData() #print "edges:", edgesData #print "vertex:", vertexBuffer if vertexBuffer != None: if renderingMode == RENDER_MODE_1: # in this rendering mode we represent edges as # cylinders and vertices as spheres if len(vertexBuffer) == 0: return # draw vertices (spheres) quadObj1 = GLU.gluNewQuadric() GLU.gluQuadricDrawStyle(quadObj1, GLU.GLU_FILL) #GLU.gluQuadricDrawStyle(quadObj1, GL.GL_WIREFRAME) for vertex in vertexBuffer.values(): GL.glLoadIdentity() iterateCameras3D() GL.glTranslatef(vertex[0], vertex[1], vertex[2]) GLU.gluSphere(quadObj1, 0.1, 15, 15) # draw faces GL.glBegin(GL.GL_TRIANGLES) GL.glEnd() # draw edges (cylinders) # initially all the cylinders must points towards the positive z # direction quadObj2 = GLU.gluNewQuadric() GLU.gluQuadricDrawStyle(quadObj2, GLU.GLU_FILL) for edge in edgesData.values(): GL.glLoadIdentity() iterateCameras3D() #modelview = GL.glGetDouble(GL.GL_MODELVIEW_MATRIX) #print "before" #dumpOGLMatrix(modelview) # get 'from' and 'to' vectors for the edge x0, y0, z0 = vertexBuffer[int(edge[0])] x1, y1, z1 = vertexBuffer[int(edge[1])] # position a cylinder GL.glTranslatef(x0, y0, z0) # calculate edge length length = math.sqrt( (x1 - x0) ** 2 + (y1 - y0) ** 2 + (z1 - z0) ** 2 ) tmp = Vector([x1 - x0, y1 - y0, z1 - z0]) # get the cross products if (negZ == tmp.inv().normalize()): axis1 = Vector([0,1.0,0]) else: axis1 = Matrix.crossProduct3D(negZ, tmp.normalize()) axis2 = Matrix.crossProduct3D(negZ, axis1) axis3 = posZ # get the angle we need to rotate to cos_angle = posZ.dotProduct(tmp.normalize()) angle = math.degrees(math.acos(cos_angle)) # calculate the transformation axis1.normalizeSelf() axis2.normalizeSelf() # we need an inverse matrix and we know that the transpose of the rotation matrix is equal to its inverse a1, a2, a3 = axis1.getComponents(), axis2.getComponents(), axis3.getComponents() v1 = [ a1[0], a2[0], a3[0], 0 ] v2 = [ a1[1], a2[1], a3[1], 0 ] v3 = [ a1[2], a2[2], a3[2], 0 ] axis1, axis2, axis3 = v1, v2, v3 # feed to openGL rotTransform = createOGLMatrixFromLists(axis1, axis2, axis3) rotTransform.extend(homogenousVec) GL.glMultMatrixf(rotTransform) # rotate a cylinder around axis1 GL.glRotatef(angle, 1.0, 0.0, 0.0) # draw a cylinder GLU.gluCylinder(quadObj2, 0.05, 0.05, length, 12, 12) GLU.gluDeleteQuadric(quadObj1) GLU.gluDeleteQuadric(quadObj2) GL.glUseProgram(shaders[0]) #renderString(100, 100, GLUT.GLUT_BITMAP_8_BY_13, "Hello World", (1.0, 0.0, 0.0)) GLUT.glutSwapBuffers()
def draw(self): """Draws one frame in the OpenGL window """ blue = (.27, .388, .678) dark_grey = (.235, .243, .266) grey = (.309, .309, .309) light_grey = (.447, .435, .449) sensor_data = self.sensor_data print("\r%s" % sensor_data, end='') #FIXME: Workaround to avoid using quaternions quat = Quaternion(sensor_data.gyro.w, sensor_data.gyro.x, sensor_data.gyro.y, sensor_data.gyro.z)#.unit offset = Quaternion(self.offset.gyro.w, self.offset.gyro.x, self.offset.gyro.y, self.offset.gyro.z) if offset: #TODO: Change back to quaternions # quat = offset.inverse * sensor_data.gyro quat = quat - offset self.flex_bent = self.offset.flex - self.flex_straight + self.flex_bent self.flex_straight = self.offset.flex gyro_euler = quat_to_euler(quat) rotation = quat_to_axis_rotation(quat) flex_angle =\ self.translate_range(self.sensor_data.flex, self.flex_straight, self.flex_bent, 0.0, 90.0) \ if self.sensor_data.flex != 0 else 0 flex_angle = min(170, max(-20, flex_angle)) gl.glClearColor(.8, .8, .8, 1.0) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_LIGHTING) gl.glShadeModel(gl.GL_SMOOTH) gl.glDisable(gl.GL_COLOR_MATERIAL) gl.glDepthFunc(gl.GL_LEQUAL) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT | gl.GL_STENCIL_BUFFER_BIT) gl.glEnable(gl.GL_LIGHT0) gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, (1, 2, 3)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, (.5, .5, .5)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, (.6, .6, .6)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, (0, 0, 0)) # gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPOT_DIRECTION, (-2, -3, -3)) gl.glLightf(gl.GL_LIGHT0, gl.GL_SPOT_CUTOFF, 180) # omnidirectional gl.glLoadIdentity() gl.glTranslatef(0, 0.0, -7.0) osd_line = \ "x: {0:<7.2f}".format(quat.x) + \ "y: {0:<7.2f}".format(quat.y) + \ "z: {0:<7.2f}".format(quat.z) + \ "flex: {0:>8}".format("{0:.2f}°".format(flex_angle)) self.drawText((-2, 1.9, 2), osd_line) gl.glPushMatrix() gl.glTranslatef(0, 2.0, 0.0) gl.glNormal3f(0.0, -1.0, 0.0) #TODO: Change back to quaternions # gl.glRotatef(-gyro_euler.x, 0, 1, 0) # gl.glRotatef(-gyro_euler.y, 1, 0, 0) # gl.glRotatef(gyro_euler.z*2, 0, 0, 1) # gl.glRotatef(quat.x, 0, 1, 0) gl.glRotatef(2*quat.y, 0, 0, 1) gl.glRotatef(quat.z, 1, 0, 0) gl.glRotatef(120, .5, .5, -.5) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE, blue) glu.gluCylinder(self.quad, 0.2, 0.15, 2, 10, 1) gl.glTranslatef(0, 0, 2) # Flex sensor: # Pitch, rotate around x-axis gl.glRotatef(flex_angle, 1.0, 0.0, 0.0) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE,dark_grey) glu.gluSphere(self.quad, 0.2, 6, 6) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE,blue) glu.gluCylinder(self.quad, 0.15, 0.125, 1.8, 9, 1) gl.glTranslatef(0, 0, 1.8) # ------------------- # First part of foot # ------------------- if self.pose == 0: pass elif self.pose == 1: gl.glRotatef(60.0, 1.0, 0.0, 0.0) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE,dark_grey) glu.gluSphere(self.quad, 0.2, 6, 6) gl.glBegin(gl.GL_QUADS) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE,grey) # foot - back gl.glNormal3f(0, -1, 0) gl.glVertex3f(-0.2, -0.1, 0.0) gl.glVertex3f(0.2, -0.1, 0.0) gl.glVertex3f(0.2, -0.1, 0.3) gl.glVertex3f(-0.2, -0.1, 0.3) # foot - right gl.glNormal3f(-1, 0, 0) gl.glVertex3f(-0.2, -0.1, 0.3) gl.glVertex3f(-0.2, 0.8, 0.3) gl.glVertex3f(-0.2, 0.8, 0.1) gl.glVertex3f(-0.2, -0.1, 0.0) # foot - left gl.glNormal3f(1, 0, 0) gl.glVertex3f(0.2, -0.1, 0.3) gl.glVertex3f(0.2, 0.8, 0.3) gl.glVertex3f(0.2, 0.8, 0.1) gl.glVertex3f(0.2, -0.1, 0.0) # foot - top gl.glNormal3f(0, 0, -1) gl.glVertex3f(-0.2, -0.1, 0.0) gl.glVertex3f(-0.2, 0.8, 0.1) gl.glVertex3f(0.2, 0.8, 0.1) gl.glVertex3f(0.2, -0.1, 0.0) # foot - front gl.glNormal3f(0, 1, 0) gl.glVertex3f(-0.2, -0.1, 0.3) gl.glVertex3f(-0.2, 0.8, 0.3) gl.glVertex3f(0.2, 0.8, 0.3) gl.glVertex3f(0.2, -0.1, 0.3) # foot - bottom gl.glNormal3f(0, 0, 1) gl.glVertex3f(-0.2, 0.8, 0.3) gl.glVertex3f(-0.2, 0.8, 0.1) gl.glVertex3f(0.2, 0.8, 0.1) gl.glVertex3f(0.2, 0.8, 0.3) gl.glEnd() gl.glTranslatef(0, 0.8, 0.1) # ------------------- # Second part of foot # ------------------- if self.pose == 0: pass elif self.pose == 1: gl.glRotatef(-60.0, 1.0, 0.0, 0.0) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE,dark_grey) glu.gluSphere(self.quad, 0.1, 6, 6) gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE,grey) gl.glBegin(gl.GL_QUADS) # foot - back gl.glNormal3f(0, -1, 0) gl.glVertex3f(-0.2, 0.02, 0.0) gl.glVertex3f(0.2, 0.02, 0.0) gl.glVertex3f(0.2, 0.02, 0.2) gl.glVertex3f(-0.2, 0.02, 0.2) # foot - right gl.glNormal3f(-1, 0, 0) gl.glVertex3f(-0.2, 0.02, 0.2) gl.glVertex3f(-0.2, 0.4, 0.2) gl.glVertex3f(-0.2, 0.4, 0.1) gl.glVertex3f(-0.2, 0.02, 0.0) # foot - left gl.glNormal3f(1, 0, 0) gl.glVertex3f(0.2, 0.02, 0.2) gl.glVertex3f(0.2, 0.4, 0.2) gl.glVertex3f(0.2, 0.4, 0.1) gl.glVertex3f(0.2, 0.02, 0.0) # foot - top gl.glNormal3f(0, 0, -1) gl.glVertex3f(-0.2, 0.02, 0.0) gl.glVertex3f(-0.2, 0.4, 0.1) gl.glVertex3f(0.2, 0.4, 0.1) gl.glVertex3f(0.2, 0.02, 0.0) # foot - front gl.glNormal3f(0, 1, 0) gl.glVertex3f(-0.2, 0.02, 0.2) gl.glVertex3f(-0.2, 0.4, 0.2) gl.glVertex3f(0.2, 0.4, 0.2) gl.glVertex3f(0.2, 0.02, 0.2) # foot - bottom gl.glNormal3f(0, 0, 1) gl.glVertex3f(-0.2, 0.4, 0.2) gl.glVertex3f(-0.2, 0.4, 0.1) gl.glVertex3f(0.2, 0.4, 0.1) gl.glVertex3f(0.2, 0.4, 0.2) gl.glEnd() gl.glPopMatrix()
def arrow(self): glu.gluCylinder(self.quad, 0.005, 0.005, 0.7, 100, 1) gl.glTranslatef(0.0, 0.0, 0.7) glu.gluCylinder(self.quad, 0.03, 0.0, 0.1, 100, 1) gl.glTranslatef(0.0, 0.0, -0.7)
def prepare(self): """ Build display lists """ # for efficiency, allow skipping the TRANSPARENT render if opaque self._has_transparent = (self.getstyle('colour')[3] < 1) # consts v3 = glVertex3f r = self.getgeom('stick', 0.05) # feet dl = self.newpiece("footL") self.dlists["footR"] = dl # foot is same on both legs glNewList(dl, GL_COMPILE) x = self.getgeom('footX', 0.1) glBegin(GL_TRIANGLES) v3(0, 0, 0) v3(x, -x / 2.0, 0) v3(x, x / 2.0, 0) glEnd() glEndList() # shins dl = self.newpiece("shinL") self.dlists["shinR"] = dl glNewList(dl, GL_COMPILE) z = self.getgeom('shinZ', 0.25) GLU.gluCylinder(self.quadric, r, r, z, 3, 2) glEndList() # thighs dl = self.newpiece("thighL") self.dlists["thighR"] = dl glNewList(dl, GL_COMPILE) z = self.getgeom('thighZ', 0.25) GLU.gluCylinder(self.quadric, r, r, z, 4, 2) glEndList() #hips dl = self.newpiece("hips") glNewList(dl, GL_COMPILE) w = self.getgeom('hipY', 0.1) glBegin(GL_LINES) # simple line across hip joint v3(0, -w, 0) v3(0, w, 0) glEnd() glEndList() #torso dl = self.newpiece("torso") glNewList(dl, GL_COMPILE) z = self.getgeom('torsoZ', 0.5) w = self.getgeom('shoulderY', 0.2) GLU.gluCylinder(self.quadric, r, r, z, 6, 2) glBegin(GL_LINES) # line across shoulders v3(0, -w, z) v3(0, w, z) glEnd() glEndList() # upper arms dl = self.newpiece("upperarmL") self.dlists['upperarmR'] = dl z = self.getgeom('upperarmZ', 0.2) glNewList(dl, GL_COMPILE) GLU.gluCylinder(self.quadric, r, r, z, 4, 2) glEndList() # forearms dl = self.newpiece("forearmL") self.dlists['forearmR'] = dl z = self.getgeom('forearmZ', 0.2) glNewList(dl, GL_COMPILE) GLU.gluCylinder(self.quadric, r, r, z, 3, 2) glEndList() # hands dl = self.newpiece("handL") self.dlists["handR"] = dl # hand is same on both arms glNewList(dl, GL_COMPILE) z = self.getgeom('handZ', 0.1) glBegin(GL_TRIANGLES) v3(0, 0, 0) v3(0, -z / 2.0, -z) v3(0, z / 2.0, -z) glEnd() glEndList() # head dl = self.newpiece("head") z = self.getgeom('headZ', 0.2) glNewList(dl, GL_COMPILE) GLU.gluCylinder(self.quadric, r, r, z, 4, 1) # neck glTranslate(0, 0, z) # centre of head GLU.gluSphere(self.quadric, 2 * r, 8, 6) glTranslate(2 * r, 0, 0) # to nose glColor(1, 0, 0, 1) # red nose for testing GLU.gluSphere(self.quadric, r * 0.5, 6, 4) glEndList()
def prepare(self): """ Build display lists """ # for efficiency, allow skipping the TRANSPARENT render if opaque self._has_transparent = (self.getstyle('colour')[3] < 1) # consts v3 = glVertex3f r = self.getgeom('stick',0.05) # feet dl = self.newpiece("footL") self.dlists["footR"] = dl # foot is same on both legs glNewList(dl,GL_COMPILE) x = self.getgeom('footX',0.1) glBegin(GL_TRIANGLES) v3(0,0,0) v3(x,-x/2.0,0) v3(x,x/2.0,0) glEnd() glEndList() # shins dl = self.newpiece("shinL") self.dlists["shinR"] = dl glNewList(dl,GL_COMPILE) z = self.getgeom('shinZ',0.25) GLU.gluCylinder(self.quadric,r,r,z,3,2) glEndList() # thighs dl = self.newpiece("thighL") self.dlists["thighR"] = dl glNewList(dl,GL_COMPILE) z = self.getgeom('thighZ',0.25) GLU.gluCylinder(self.quadric,r,r,z,4,2) glEndList() #hips dl = self.newpiece("hips") glNewList(dl,GL_COMPILE) w = self.getgeom('hipY',0.1) glBegin(GL_LINES) # simple line across hip joint v3(0,-w,0) v3(0,w,0) glEnd() glEndList() #torso dl = self.newpiece("torso") glNewList(dl,GL_COMPILE) z = self.getgeom('torsoZ',0.5) w = self.getgeom('shoulderY',0.2) GLU.gluCylinder(self.quadric,r,r,z,6,2) glBegin(GL_LINES) # line across shoulders v3(0,-w,z) v3(0,w,z) glEnd() glEndList() # upper arms dl = self.newpiece("upperarmL") self.dlists['upperarmR'] = dl z = self.getgeom('upperarmZ',0.2) glNewList(dl,GL_COMPILE) GLU.gluCylinder(self.quadric,r,r,z,4,2) glEndList() # forearms dl = self.newpiece("forearmL") self.dlists['forearmR'] = dl z = self.getgeom('forearmZ',0.2) glNewList(dl,GL_COMPILE) GLU.gluCylinder(self.quadric,r,r,z,3,2) glEndList() # hands dl = self.newpiece("handL") self.dlists["handR"] = dl # hand is same on both arms glNewList(dl,GL_COMPILE) z = self.getgeom('handZ',0.1) glBegin(GL_TRIANGLES) v3(0,0,0) v3(0,-z/2.0,-z) v3(0,z/2.0,-z) glEnd() glEndList() # head dl = self.newpiece("head") z = self.getgeom('headZ',0.2) glNewList(dl,GL_COMPILE) GLU.gluCylinder(self.quadric,r,r,z,4,1) # neck glTranslate(0,0,z) # centre of head GLU.gluSphere(self.quadric,2*r,8,6) glTranslate(2*r,0,0) # to nose glColor(1,0,0,1) # red nose for testing GLU.gluSphere(self.quadric,r*0.5,6,4) glEndList()
def draw_arrows(pos, edgelist, edge_color, arrow_points, arrow_size, scale, lights, fancy): GL.glDisable(GL.GL_DEPTH_TEST) if lights: GL.glEnable(GL.GL_LIGHTING) k = 0 for (i,j) in edgelist: d = [] for r in range(len(pos[i])): d.append(pos[i][r]-pos[j][r]) d = tuple(d + [0]) GL.glPushMatrix() GL.glTranslate(arrow_points[k][0][0], arrow_points[k][0][1], arrow_points[k][0][2]) GL.glScale(scale,scale,scale) GL.glRotate(arrow_points[k][1],-d[1],d[0],0) GL.glColor(*edge_color[k]) vp = GL.glGetIntegerv(GL.GL_VIEWPORT) arrow_size_scale = 2./(vp[2]+vp[3]) if fancy: cone = GLU.gluNewQuadric() GLU.gluQuadricNormals(cone,GLU.GLU_SMOOTH) GLU.gluQuadricTexture(cone,GLU.GLU_TRUE) GLU.gluCylinder(cone, 0, arrow_size_scale*arrow_size[k]/3., arrow_size_scale*arrow_size[k], 32, 32) else: s1 = arrow_size[k]*arrow_size_scale s2 = arrow_size_scale*arrow_size[k]/3. GL.glBegin(GL.GL_POLYGON); GL.glVertex3d(0, 0, 0); GL.glVertex3d(-s2, s2, s1); GL.glVertex3d(-s2, -s2, s1); GL.glVertex3d(0, 0, 0); GL.glVertex3d(-s2, s2, s1); GL.glVertex3d(s2, s2, s1); GL.glVertex3d(0, 0, 0); GL.glVertex3d(s2, s2, s1); GL.glVertex3d(s2, -s2, s1); GL.glVertex3d(0, 0, 0); GL.glVertex3d(s2, -s2, s1); GL.glVertex3d(-s2, -s2, s1); GL.glVertex3d(-s2, -s2, s1); GL.glVertex3d(s2, -s2, s1); GL.glVertex3d(s2, s2, s1); GL.glVertex3d(-s2, s2, s1); GL.glEnd(); GL.glPopMatrix() k+=1 if lights: GL.glDisable(GL.GL_LIGHTING) GL.glEnable(GL.GL_DEPTH_TEST)
def drawPointAndDirs(self, matrix, color=GREEN): try: xAxis = numpy.array([matrix[0][0], matrix[1][0], matrix[2][0]], 'float') yAxis = numpy.array([matrix[0][1], matrix[1][1], matrix[2][1]], 'float') zAxis = numpy.array([matrix[0][2], matrix[1][2], matrix[2][2]], 'float') center = numpy.array([matrix[0][3], matrix[1][3], matrix[2][3]], 'float') except: print('invalid matrix!') return None qobj = GLU.gluNewQuadric() sphere_radius = 3 cyl_height = 20 cyl_radius = 0.7 z_dir = numpy.array([0., 0., 1.], dtype='float64') genList = GL.glGenLists(1) GL.glNewList(genList, GL.GL_COMPILE) self.qglColor(color) GL.glPushMatrix() GL.glTranslatef(center[0], center[1], center[2]) GLU.gluSphere(qobj, sphere_radius, 20, 20) GL.glPopMatrix() #Cylinder along z, we want it to be allong xAxis #Solution: use the appropriate rotation matrix #We have to choose the right axis, perpendicular to both, and rotate by the appropriate angle, the angle between the 2 vectors self.qglColor(RED) rotation_dir = numpy.cross(z_dir, xAxis) angle = math.acos(z_dir.dot(xAxis)) * 180 / 3.14159 GL.glPushMatrix() GL.glTranslatef(center[0], center[1], center[2]) GL.glRotatef(angle, rotation_dir[0], rotation_dir[1], rotation_dir[2]) GLU.gluCylinder(qobj, cyl_radius, cyl_radius, cyl_height, 20, 20) GL.glPopMatrix() self.qglColor(GREEN) rotation_dir = numpy.cross(z_dir, yAxis) angle = math.acos(z_dir.dot(yAxis)) * 180 / 3.14159 GL.glPushMatrix() GL.glTranslatef(center[0], center[1], center[2]) GL.glRotatef(angle, rotation_dir[0], rotation_dir[1], rotation_dir[2]) GLU.gluCylinder(qobj, cyl_radius, cyl_radius, cyl_height, 20, 20) GL.glPopMatrix() self.qglColor(BLUE) rotation_dir = numpy.cross(z_dir, zAxis) angle = math.acos(z_dir.dot(zAxis)) * 180 / 3.14159 z_axis_center = center - zAxis * 10 GL.glPushMatrix() GL.glTranslatef(z_axis_center[0], z_axis_center[1], z_axis_center[2]) GL.glRotatef(angle, rotation_dir[0], rotation_dir[1], rotation_dir[2]) GLU.gluCylinder(qobj, cyl_radius, cyl_radius, cyl_height * 2, 20, 20) GL.glPopMatrix() GL.glEndList() return genList
def __drawCone(self, zMin, zMax, r1, r2, nbSub): quadric = glu.gluNewQuadric() ogl.glTranslatef(0.0, 0.0, zMin) glu.gluCylinder(quadric, r1, r2, zMax - zMin, nbSub, 1) ogl.glTranslatef(0.0, 0.0, -zMin)