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 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.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 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 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 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 __init__(self, world, w, h, d, offset_matrix=None): pynewton.Sphere.__init__( self, world, w, h, d, offset_matrix ) self.width = w self.height = h self.depth = d if GLPresent: self.quad = GLU.gluNewQuadric()
def __init__(self, molecule, hide_hydrogens=False, randomize_single_bonds=False,
bond_width=.1, bond_length=2):
self.molecule = molecule
self.hide_hydrogens = hide_hydrogens
self.randomize_single_bonds = randomize_single_bonds
self.rotate_atoms(self.molecule)
self.bond_width = bond_width
self.bond_length = bond_length
self.quad = glu.gluNewQuadric()
glu.gluQuadricNormals(self.quad, glu.GLU_SMOOTH)
glu.gluQuadricDrawStyle(self.quad, glu.GLU_FILL)
self.cylinder_resolution = 100
self.sphere_resolution = 100
self.zoom = 5
self.rotations = []
self.scroll_up_button = 3
self.scroll_down_button = 4
self.scroll_buttons = [self.scroll_up_button,
self.scroll_down_button]
self.zoom_increment = 0.2
self.default_element_color = (221/255, 119/255, 1)
self.bond_color = (128/255,) * 3
self.drag_start = None
def gl_init( width, height ):
global __legocaptex,__quadratic
setviewport(width, height)
__legocaptex = layer_manager.load_2d_texture(pygame.image.tostring(__image, "RGBA"), LEGO_CAP_WIDTH, LEGO_CAP_HEIGHT)
__quadratic = GLU.gluNewQuadric()
GLU.gluQuadricTexture(__quadratic, GLU.GLU_TRUE)
GLU.gluQuadricDrawStyle(__quadratic,GLU.GLU_FILL)
GLU.gluQuadricOrientation(__quadratic, GLU.GLU_OUTSIDE)
GLU.gluQuadricNormals(__quadratic, GLU.GLU_SMOOTH)
GL.glClearColor( 0.0, 0.2, 0.5, 1.0 )
GL.glEnable(GL.GL_POINT_SMOOTH)
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glEnable(GL.GL_ALPHA_TEST)
GL.glEnable(GL.GL_COLOR_MATERIAL)
GL.glDisable(GL.GL_CULL_FACE)
GL.glAlphaFunc(GL.GL_GREATER,0.1)
GL.glClearAccum(0.0, 0.0, 0.0, 1.0)
GL.glClear(GL.GL_ACCUM_BUFFER_BIT)
#GL.glGenLists(1)
draw_mode_3d()
def paintGL(self):
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# gl.glPushMatrix()
glu.gluLookAt(self.camera[0], self.camera[1], self.camera[2],
self.center[0], self.center[1], self.center[2], 0, 1, 0)
self.paintAxes()
normalSize = numpy.max(self.center - self.b_box[1]) / 100.0
gl.glEnable(gl.GL_BLEND)
gl.glEnable(gl.GL_CULL_FACE)
gl.glCullFace(gl.GL_BACK)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gluQuadric = glu.gluNewQuadric()
for cmd, (array, colors, sizes) in self.commands:
for (x, y, z), (r, g, b), size in zip(array, colors, sizes):
gl.glPushMatrix()
gl.glTranslatef(x, y, z)
gl.glColor4f(r, g, b, 0.3)
glu.gluSphere(gluQuadric, normalSize * size, 10, 10)
gl.glPopMatrix()
glu.gluDeleteQuadric(gluQuadric)
def _draw_one_robot(posture_pos: list, highlight=None):
"""Permet de dessiner un robot avec ces link et ses moteurs.
`posture_pos` - liste de matrice de rotation décrivant le robot dans sa posture"""
global _section_color, _joint_color, _hjoint_color
# Chaque section est representee par un segment noir
gl.glBegin(gl.GL_LINE_STRIP)
gl.glColor4f(_section_color[0], _section_color[1], _section_color[2],
_section_color[3])
for section in posture_pos:
gl.glVertex3f(section[0][3], section[1][3], section[2][3])
gl.glEnd()
# Chaque moteur est represente par une sphere bleue
for i in range(len(posture_pos)):
# Si on veux mettre en valeur un moteur, on l'affiche en rouge (pour l'animation)
if highlight is not None and i == highlight + 1:
gl.glColor4f(_hjoint_color[0], _hjoint_color[1], _hjoint_color[2],
_hjoint_color[3])
else:
gl.glColor4f(_joint_color[0], _joint_color[1], _joint_color[2],
_joint_color[3])
gl.glPushMatrix()
gl.glTranslatef(posture_pos[i][0][3], posture_pos[i][1][3],
posture_pos[i][2][3])
glu.gluSphere(glu.gluNewQuadric(), 0.003, 16, 16)
gl.glPopMatrix()
class BoundingSphere(object):
quadratic = GLU.gluNewQuadric()
def __init__(self, center, radius):
self.center = center
self.radius = radius
def __str__(self):
return "Center: %s, Radius: %s" % (str(self.center), str(self.radius))
def transformedBy(self, transform_matrix):
return BoundingSphere(
MathUtil.transformPoint(self.center, transform_matrix),
self.radius)
def transformedTo(self, position, yaw, pitch, roll):
m = MathUtil.buildTransformMatrix(position, yaw, pitch, roll)
return self.transformedBy(m)
def draw(self):
GL.glPushMatrix()
GL.glTranslatef(self.center.x, self.center.y, self.center.z)
GL.glScalef(self.radius, self.radius, self.radius)
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE)
GL.glDisable(GL.GL_TEXTURE_2D)
GLU.gluSphere(self.quadratic, 1.0, 24, 24)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL)
GL.glPopMatrix()
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 __init__(self,
molecule,
hide_hydrogens=False,
randomize_single_bonds=False,
bond_width=.1,
bond_length=2):
self.molecule = molecule
self.hide_hydrogens = hide_hydrogens
self.randomize_single_bonds = randomize_single_bonds
self.rotate_atoms(self.molecule)
self.bond_width = bond_width
self.bond_length = bond_length
self.quad = glu.gluNewQuadric()
glu.gluQuadricNormals(self.quad, glu.GLU_SMOOTH)
glu.gluQuadricDrawStyle(self.quad, glu.GLU_FILL)
self.cylinder_resolution = 100
self.sphere_resolution = 100
self.zoom = 5
self.rotations = []
self.scroll_up_button = 3
self.scroll_down_button = 4
self.scroll_buttons = [self.scroll_up_button, self.scroll_down_button]
self.zoom_increment = 0.2
self.default_element_color = (221 / 255, 119 / 255, 1)
self.bond_color = (128 / 255, ) * 3
self.drag_start = None
def init_gl(self):
"""
Initialise OpenGL settings
"""
self.sphere = GL.glGenLists(1)
GL.glNewList(self.sphere, GL.GL_COMPILE)
quad_obj = GLU.gluNewQuadric()
GLU.gluQuadricDrawStyle(quad_obj, GLU.GLU_FILL)
GLU.gluQuadricNormals(quad_obj, GLU.GLU_SMOOTH)
GLU.gluSphere(quad_obj, 1, 16, 16)
GL.glEndList()
GL.glShadeModel(GL.GL_SMOOTH)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_CULL_FACE)
GL.glEnable(GL.GL_LIGHTING)
# make sure normal vectors of scaled spheres are normalised
GL.glEnable(GL.GL_NORMALIZE)
GL.glEnable(GL.GL_LIGHT0)
light_pos = list(_LIGHT_POSITION) + [1]
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_pos)
GL.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, [1.0, 1.0, 1.0, 1.0])
GL.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0])
GL.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, [1.0, 1.0, 1.0, 1.0])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, [0.2, .2, .2, 1])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, [0.7, 0.7, 0.7, 1])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, [0.1, 0.1, 0.1, 1])
GL.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, 20)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GLU.gluPerspective(60, 1, .01, 10)
GL.glMatrixMode(GL.GL_MODELVIEW)
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 visualisation_particle(self):
#print('visualisation_particle')
if len(self.list_of_solar_system) == 9:
for k in range(len(self.list_of_solar_system)):
sphere = glu.gluNewQuadric()
gl.glPushMatrix()
gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, self.list_of_solar_system[k].color) #цвет задаем
gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_SPECULAR, self.list_of_solar_system[k].color)
gl.glTranslatef(self.list_of_solar_system[k].x*7, self.list_of_solar_system[k].y*7, self.list_of_solar_system[k].z*7)
glu.gluQuadricDrawStyle(sphere, glu.GLU_FILL)
if k == 0:
glu.gluSphere(sphere, self.list_of_solar_system[k].m / 150000.0, 16, 16)
if k == 1:
glu.gluSphere(sphere, self.list_of_solar_system[k].m * 20, 16, 16)
if k == 2:
glu.gluSphere(sphere, self.list_of_solar_system[k].m * 2, 16, 16)
if k == 3:
glu.gluSphere(sphere, self.list_of_solar_system[k].m * 1.5, 16, 16)
if k == 4:
glu.gluSphere(sphere, self.list_of_solar_system[k].m * 7, 16, 16)
if k == 5:
glu.gluSphere(sphere, self.list_of_solar_system[k].m / 30, 16, 16)
if k == 6:
glu.gluSphere(sphere, self.list_of_solar_system[k].m / 12, 16, 16)
if k == 7:
glu.gluSphere(sphere, self.list_of_solar_system[k].m / 2.3, 16, 16)
if k == 8:
glu.gluSphere(sphere, self.list_of_solar_system[k].m / 3.2, 16, 16)
gl.glTranslatef(-self.list_of_solar_system[k].x*7, -self.list_of_solar_system[k].y*7, -self.list_of_solar_system[k].z*7)
gl.glPopMatrix()
glu.gluDeleteQuadric(sphere)
self.update()
else:
for k in range(len(self.list_of_particles)):
sphere = glu.gluNewQuadric()
gl.glPushMatrix()
gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, self.list_of_particles[k].color) #цвет задаем
gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_SPECULAR, self.list_of_particles[k].color)
gl.glTranslatef(self.list_of_particles[k].x, self.list_of_particles[k].y, self.list_of_particles[k].z)
glu.gluQuadricDrawStyle(sphere, glu.GLU_FILL)
glu.gluSphere(sphere, self.list_of_particles[k].m / 100.0, 16, 16)
gl.glTranslatef(-self.list_of_particles[k].x, -self.list_of_particles[k].y, -self.list_of_particles[k].z)
gl.glPopMatrix()
glu.gluDeleteQuadric(sphere)
self.update()
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 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 __init__(self, node):
"""
Constructor.
@param node The adaptable node.
"""
super(GLQuadricCylinderAdapter, self).__init__(node)
self.__quadric = GLU.gluNewQuadric()
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 __init__(self, radius, pos, color, visible=True):
self.radius = radius
self.pos = pos[:]
self.visible = visible
self.color = color
self.slices = 25 # meridijani
self.stacks = 15 # paralele
self.quadric = glu.gluNewQuadric()
def __init__(self, *args):
if args and isinstance(args[0], hal.component):
self.comp = args[0]
args = args[1:]
else:
self.comp = None
self._coords = args
self.q = GLU.gluNewQuadric()
def draw_points_cloud(end_points: list,
max_dist=0.3,
robot=None,
sphere=0,
rota=False):
"""Dessine un nuage de point 3d.
`end_points` - les coordonnees des points en (x, y, z) ou liste d'end_points"""
global _cloud_point_color
_init_display()
# Calcul de la couleur des points avant affichage
points = []
for ep in end_points:
if isinstance(ep, EndPoint):
pos = ep.get_pos()
else:
pos = ep
if _cloud_point_color is None:
d = 0
for p in pos:
d += p**2
d = math.sqrt(d)
fact = d / max_dist
color = _get_rainbow_color(fact)
points.append((pos, color))
else:
points.append((pos, _cloud_point_color))
while _StaticVars.is_running:
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
if rota:
gl.glRotatef(1, 0, 0, 1)
_draw_axes()
gl.glBegin(gl.GL_POINTS)
for (p, c) in points:
gl.glColor3f(c[0], c[1], c[2])
gl.glVertex3f(p[0], p[1], p[2])
gl.glEnd()
if robot is not None:
posture = robot.get_posture_pos((0, 0, 0, 0, 0, 0))
_draw_one_robot(posture)
if sphere != 0:
gl.glColor4f(_sphere_color[0], _sphere_color[1], _sphere_color[2],
_sphere_color[3])
glu.gluSphere(glu.gluNewQuadric(), sphere, 64, 32)
# _draw_fps()
pg.display.flip()
_event_handler()
pg.time.wait(10)
def __init__(self, node):
"""
Constructor.
@param radius The radius of the sphere.
@param parent The parent SceneGraphNode instance.
"""
super(GLQuadricSphereAdapter, self).__init__(node)
self.__quadric = GLU.gluNewQuadric()
def display(self):
ogl.glPushMatrix()
ogl.glTranslate(-1, -3.3, 1)
ang = ((time.time() / 40) % 1) * 360 # 2*3.14
ogl.glRotate(ang, 0, 0, 1)
quad = oglu.gluNewQuadric()
oglu.gluQuadricDrawStyle(quad, oglu.GLU_LINE)
oglu.gluSphere(quad, 0.7, 15, 15)
ogl.glPopMatrix()
def __init__(self, win, size_px, pos_px=(0,0)):
self.win=win
self._quad=GLU.gluNewQuadric()
#self.winSize = win.monitor.getSizePix()
#print self.winSize
if win.winType == 'pyglet':
self.winSize = win.winHandle.get_size()
self.winAspect = self.winSize[1] / float(self.winSize[0])
self.setSize(size_px, False)
self.setPos(pos_px)
def __init__(self, win, size_px, pos_px=(0, 0)):
self.win = win
self._quad = GLU.gluNewQuadric()
#self.winSize = win.monitor.getSizePix()
#print self.winSize
if win.winType == 'pyglet':
self.winSize = win.winHandle.get_size()
self.winAspect = self.winSize[1] / float(self.winSize[0])
self.setSize(size_px, False)
self.setPos(pos_px)
def paintGL(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glColor3f(1.0, 2.0, 1.0)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glPushMatrix()
gl.glTranslatef(0, 0, 0)
qobj = glu.gluNewQuadric()
glu.gluQuadricOrientation(qobj, glu.GLU_OUTSIDE)
glu.gluSphere(qobj, 0.67, 100, 100)
gl.glPopMatrix()
def add_atoms(self):
prop = self.prop
mendeley = TPeriodTable()
gl.glNewList(self.object, gl.GL_COMPILE)
min_val = 0
max_val = 0
mean_val = 0
if (len(prop) > 0) and (prop != "charge"):
min_val = self.MainModel.atoms[0].properties[prop]
max_val = self.MainModel.atoms[0].properties[prop]
mean_val = self.MainModel.atoms[0].properties[prop]
for at in self.MainModel.atoms:
val = at.properties[prop]
if min_val > val: min_val = val
if max_val < val: max_val = val
mean_val += val
mean_val /= self.MainModel.nAtoms()
for at in self.MainModel.atoms:
gl.glPushMatrix()
gl.glTranslatef(at.x, at.y, at.z)
self.QuadObjS.append(glu.gluNewQuadric())
rad = mendeley.Atoms[at.charge].radius / mendeley.Atoms[6].radius
if at.isSelected() == False:
if (len(prop) > 0) and (prop != "charge"):
val = at.properties[prop]
if val > mean_val:
gl.glColor3f(
0,
math.fabs((val - mean_val) / (max_val - mean_val)),
0)
else:
gl.glColor3f(
0, 0,
math.fabs((val - mean_val) / (min_val - mean_val)))
else:
color = self.color_of_atoms[at.charge]
if (self.SelectedFragmentMode == True) and (at.fragment1
== True):
gl.glColor4f(color[0], color[1], color[2],
self.SelectedFragmentAtomsTransp)
else:
gl.glColor3f(color[0], color[1], color[2])
glu.gluSphere(self.QuadObjS[-1], 0.3 * rad, self.quality * 70,
self.quality * 70)
else:
gl.glColor3f(1, 0, 0)
glu.gluSphere(self.QuadObjS[-1], 0.35 * rad, self.quality * 70,
self.quality * 70)
gl.glPopMatrix()
gl.glEndList()
self.active = True
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 __init__(self,radius=1.0, slices=20, stacks=20):
_engine.Object_model.__init__(self)
prim=_engine.Primitive()
sphere_gl_list=_gl.glGenLists(1)
quadric=_glu.gluNewQuadric()
_gl.glNewList(sphere_gl_list,_gl.GL_COMPILE)
_glu.gluSphere(quadric,radius,slices,stacks)
_gl.glEndList()
prim.gl_list=sphere_gl_list
self.add_primitive(prim)
self.scale=[1.,1.,1.]
def __init__(self, width: int, height: int):
"""
Arguments:
width {int} -- Window width in pixels
height {int} -- Window height in pixels
"""
self.resize(width, height)
self.quad = glu.gluNewQuadric()
glu.gluQuadricDrawStyle(self.quad, gl.GL_LINE)
glu.gluQuadricTexture(self.quad, gl.GL_TRUE)
def add_selected_atom(self):
gl.glNewList(self.object + 7, gl.GL_COMPILE)
for at in self.MainModel.atoms:
if at.isSelected() == True:
gl.glPushMatrix()
gl.glTranslatef(at.x, at.y, at.z)
self.QuadObjS.append(glu.gluNewQuadric())
gl.glColor3f(1, 0, 0)
glu.gluSphere(self.QuadObjS[-1], 0.35, 70, 70)
gl.glPopMatrix()
gl.glEndList()
def draw_sphere(color, pos, radius=2):
gl.glColor(*color)
gl.glPushMatrix()
x, y = pos
gl.glTranslate(x, y, 3)
q = glu.gluNewQuadric()
glu.gluSphere(q, radius, 20, 20)
glu.gluDeleteQuadric(q)
gl.glPopMatrix()
def draw_sphere(color, pos, radius=2):
gl.glColor(*color)
gl.glPushMatrix()
x, y = pos
gl.glTranslate(x, y, 3)
q = glu.gluNewQuadric()
glu.gluSphere(q, radius, 20, 20)
glu.gluDeleteQuadric(q)
gl.glPopMatrix()
def draw_nodes(pos,
nodelist,
node_color,
node_size,
node_border_size,
node_border_color,
scale,
fancy,
lights):
GL.glDisable(GL.GL_DEPTH_TEST)
i = 0
if fancy:
vp = GL.glGetIntegerv(GL.GL_VIEWPORT)
sphere_size_scale = 2./(vp[2]+vp[3])
for n in nodelist:
if fancy:
if lights:
GL.glEnable(GL.GL_LIGHTING)
GL.glPushMatrix()
if len(pos[n]) ==2:
position = tuple(list(pos[n]) + [0.])
else:
position = pos[n]
GL.glTranslate(*position)
GL.glScale(scale,scale,scale)
GL.glColor(*node_color[i])
sphere = GLU.gluNewQuadric()
GLU.gluQuadricNormals(sphere,GLU.GLU_SMOOTH)
GLU.gluQuadricTexture(sphere,GLU.GLU_TRUE)
GLU.gluSphere(sphere,
node_size[i]*sphere_size_scale,
32,
32)
GL.glPopMatrix()
if lights:
GL.glDisable(GL.GL_LIGHTING)
else:
GL.glPointSize(node_size[i]+node_border_size[i])
GL.glBegin(GL.GL_POINTS)
GL.glColor(*node_border_color[i])
GL.glVertex(*tuple(pos[n]))
GL.glEnd()
GL.glPointSize(node_size[i])
GL.glBegin(GL.GL_POINTS)
GL.glColor(*node_color[i])
GL.glVertex(*tuple(pos[n]))
GL.glEnd()
i+=1
GL.glEnable(GL.GL_DEPTH_TEST)
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 add_axes(self):
gl.glNewList(self.object + 7, gl.GL_COMPILE)
gl.glColor3f(self.color_of_axes[0], self.color_of_axes[1],
self.color_of_axes[2])
size = 2
sizeCone = 0.2
letter_height = sizeCone
letter_width = 0.6 * sizeCone
width = 0.06
self.QuadObjS.append(glu.gluNewQuadric())
glu.gluSphere(self.QuadObjS[-1], 2 * width, 70, 70)
p0 = np.array([0, 0, 0])
p1 = np.array([size, 0, 0])
p1cone = np.array([size + sizeCone, 0, 0])
p2 = np.array([0, size, 0])
p2cone = np.array([0, size + sizeCone, 0])
p3 = np.array([0, 0, size])
p3cone = np.array([0, 0, size + sizeCone])
self.add_bond(p0, p1, width)
self.add_bond(p1, p1cone, 2 * width, 'conus')
self.add_bond(p0, p2, width)
self.add_bond(p2, p2cone, 2 * width, 'conus')
self.add_bond(p0, p3, width)
self.add_bond(p3, p3cone, 2 * width, 'conus')
# lets drow "X"
pX = p1cone + np.array([0, 1.5 * sizeCone, 0])
pX1 = pX + np.array([-0.5 * letter_width, -0.5 * letter_height, 0])
pX2 = pX + np.array([+0.5 * letter_width, +0.5 * letter_height, 0])
pX3 = pX + np.array([-0.5 * letter_width, +0.5 * letter_height, 0])
pX4 = pX + np.array([+0.5 * letter_width, -0.5 * letter_height, 0])
self.add_bond(pX1, pX2, 0.5 * width)
self.add_bond(pX3, pX4, 0.5 * width)
# lets drow "Y"
pY = p2cone + np.array([0, 1.5 * sizeCone, 0])
pY1 = pY
pY2 = pY + np.array([0, +0.5 * letter_height, +0.5 * letter_width])
pY3 = pY + np.array([0, -0.5 * letter_height, +0.5 * letter_width])
pY4 = pY + np.array([0, +0.5 * letter_height, -0.5 * letter_width])
self.add_bond(pY1, pY2, 0.5 * width)
self.add_bond(pY3, pY4, 0.5 * width)
# lets drow "Z"
pZ = p3cone + np.array([1.5 * sizeCone, 0, 0])
pZ1 = pZ + np.array([-0.5 * letter_height, 0, -0.5 * letter_width])
pZ2 = pZ + np.array([+0.5 * letter_height, 0, +0.5 * letter_width])
pZ3 = pZ + np.array([-0.5 * letter_height, 0, +0.5 * letter_width])
pZ4 = pZ + np.array([+0.5 * letter_height, 0, -0.5 * letter_width])
self.add_bond(pZ1, pZ3, 0.5 * width)
self.add_bond(pZ1, pZ2, 0.5 * width)
self.add_bond(pZ2, pZ4, 0.5 * width)
gl.glEndList()
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(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 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 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 paintGL(self):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glColor3f(1.0, 1.0, 1.0) # Default color is white
# Draw the flashlight
self.drawFlashLight()
# Draw the sphere
glMaterialfv(GL_FRONT, GL_AMBIENT, [0.3, 0.3, 0.3, 1.0])
glMaterialfv(GL_FRONT, GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0])
glMaterialfv(GL_FRONT, GL_SPECULAR, [1.0, 1.0, 1.0, 1.0])
glLightfv(self.light, GL_POSITION, self.lightposition)
glMaterialf(GL_FRONT, GL_SHININESS, 25.0)
quad = GLU.gluNewQuadric()
GLU.gluQuadricDrawStyle(quad, GLU.GLU_FILL)
GLU.gluQuadricNormals(quad, GLU.GLU_SMOOTH)
GLU.gluSphere(quad, 3.0, 30, 30)
glFlush()
def paintGL(self):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glColor3f(1.0, 1.0, 1.0) # Default color is white
# Draw the flashlight
self.drawFlashLight()
# Draw the sphere
glMaterialfv(GL_FRONT, GL_AMBIENT, [0.3, 0.3, 0.3, 1.0])
glMaterialfv(GL_FRONT, GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0])
glMaterialfv(GL_FRONT, GL_SPECULAR, [1.0, 1.0, 1.0, 1.0])
glLightfv(self.light, GL_POSITION, self.lightposition)
glMaterialf(GL_FRONT, GL_SHININESS, 25.0)
quad = GLU.gluNewQuadric()
GLU.gluQuadricDrawStyle(quad, GLU.GLU_FILL)
GLU.gluQuadricNormals(quad, GLU.GLU_SMOOTH)
GLU.gluSphere(quad, 3.0, 30, 30)
glFlush()
def _initGL(self,Width,Height):
GL.glShadeModel(GL.GL_SMOOTH);
GL.glClearColor(0.0, 0.0, 0.0, 0.0) # This Will Clear The Background Color To Black
GL.glClearDepth(1.0) # Enables Clearing Of The Depth Buffer
GL.glDepthFunc(GL.GL_LESS) # The Type Of Depth Test To Do
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
GL.glEnable(GL.GL_BLEND); # Enable Blending
GL.glLineWidth(1.);
GL.glDisable(GL.GL_LINE_SMOOTH)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
self.width = Width
self.height = Height
self.quad = GLU.gluNewQuadric()
GLU.gluQuadricNormals(self.quad, GLU.GLU_SMOOTH)
GLU.gluQuadricTexture(self.quad, GL.GL_TRUE)
def drawPoints(self) : GL.glEnable(GL.GL_CULL_FACE) GL.glEnable(GL.GL_LIGHTING) quadric = GLU.gluNewQuadric() for e,a,d in self._points : ra, re = math.radians(a), math.radians(e) sa, se = math.sin(ra), math.sin(re) ca, ce = math.cos(ra), math.cos(re) if d<0 : GL.glColor(1., 1., 1., .5) d = -d else : GL.glColor(1., .6, .6, .5) GL.glPushMatrix() GL.glTranslate(d*ce*ca, d*ce*sa,d*se) GLU.gluSphere(quadric, .1, 10, 10) 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 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 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 render(self):
# create openGL list if render has not yet been called
if not self.has_rendered:
w = self.width
h = self.height
color1 = self.color1
color2 = self.color2
board_width = w * self.nrows
board_height = h * self.nrows
#gl.glDisable(gl.GL_LIGHTING)
self.glListIndex = gl.glGenLists(1)
gl.glNewList(self.glListIndex, gl.GL_COMPILE) # begin OpengGL list
try:
for x in range(0, self.nrows):
for y in range(0, self.nrows):
if (x + y) % 2 == 0:
gl.glColor3f(*color1)
else:
gl.glColor3f(*color2)
gl.glRectf(w*x, h*y, w*(x + 1), h*(y + 1))
if self.show_fixation_dot:
gl.glColor3f(*COLORS['red'])
gl.glTranslatef(board_width / 2.0, board_height / 2.0, 0)
glu.gluDisk(glu.gluNewQuadric(), 0, 0.005, 45, 1)
finally:
pass
#gl.glEnable(gl.GL_LIGHTING)
gl.glEndList() # end OpenGL list
self.has_rendered = True
# display checkerboard
gl.glDisable(gl.GL_LIGHTING)
gl.glCallList(self.glListIndex)
gl.glEnable(gl.GL_LIGHTING)
def render(self):
color1 = self.color1
color2 = self.color2
# create display lists if not yet done
if self.display_list_multi is None:
w = self.check_width
h = self.check_height
board_width = w * self.nrows
board_height = h * self.nrows
# get needed display list ints
if self.fixation_dot_color:
self.num_lists = 3 # include list for fixation dot
else:
self.num_lists = 2
self.display_list_multi = gl.glGenLists(self.num_lists)
# Create a display list for color 1
try:
gl.glNewList(self.display_list_multi, gl.GL_COMPILE)
# render the checkerboard's color1 checks
gl.glDisable(gl.GL_LIGHTING)
for x in range(0, self.nrows):
for y in range(0, self.nrows):
if (x + y) % 2 == 0:
gl.glRectf(w*x, h*y, w*(x + 1), h*(y + 1))
finally:
gl.glEnable(gl.GL_LIGHTING)
# End the display list
gl.glEndList()
# create a display list for color 2
try:
gl.glNewList(self.display_list_multi + 1, gl.GL_COMPILE)
# render the checkerboard's color2 checks
gl.glDisable(gl.GL_LIGHTING)
for x in range(0, self.nrows):
for y in range(0, self.nrows):
if (x + y) % 2 == 1:
gl.glRectf(w*x, h*y, w*(x + 1), h*(y + 1))
finally:
gl.glEnable(gl.GL_LIGHTING)
# End the display list
gl.glEndList()
# create list for fixation dot
if not self.fixation_dot_color is None:
gl.glNewList(self.display_list_multi + 2, gl.GL_COMPILE)
gl.glDisable(gl.GL_LIGHTING)
r, g, b = self.fixation_dot_color
gl.glColor3f(r, g, b)
gl.glTranslatef(board_width / 2.0, board_height / 2.0, 0)
glu.gluDisk(glu.gluNewQuadric(), 0, 0.005, 45, 1)
gl.glEnable(gl.GL_LIGHTING)
gl.glEndList()
self.show_display_lists(color1, color2)
else:
# render display lists
self.show_display_lists(color1, color2)
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 to_OpenGL(self, color=None, show_directions=False):
if not GL_enabled:
return
if not color is None:
GL.glColor4f(*color)
GL.glBegin(GL.GL_TRIANGLES)
# use normals to improve lighting (contributed by imyrek)
normal_t = self.normal
GL.glNormal3f(normal_t.x, normal_t.y, normal_t.z)
# The triangle's points are in clockwise order, but GL expects
# counter-clockwise sorting.
GL.glVertex3f(self.p1.x, self.p1.y, self.p1.z)
GL.glVertex3f(self.p3.x, self.p3.y, self.p3.z)
GL.glVertex3f(self.p2.x, self.p2.y, self.p2.z)
GL.glEnd()
if show_directions: # display surface normals
n = self.normal
c = self.center
d = 0.5
GL.glBegin(GL.GL_LINES)
GL.glVertex3f(c.x, c.y, c.z)
GL.glVertex3f(c.x+n.x*d, c.y+n.y*d, c.z+n.z*d)
GL.glEnd()
if False: # display bounding sphere
GL.glPushMatrix()
middle = self.middle
GL.glTranslate(middle.x, middle.y, middle.z)
if not hasattr(self, "_sphere"):
self._sphere = GLU.gluNewQuadric()
GLU.gluSphere(self._sphere, self.radius, 10, 10)
GL.glPopMatrix()
if pycam.Utils.log.is_debug(): # draw triangle id on triangle face
GL.glPushMatrix()
c = self.center
GL.glTranslate(c.x, c.y, c.z)
p12 = self.p1.add(self.p2).mul(0.5)
p3_12 = self.p3.sub(p12).normalized()
p2_1 = self.p1.sub(self.p2).normalized()
pn = p2_1.cross(p3_12)
GL.glMultMatrixf((p2_1.x, p2_1.y, p2_1.z, 0, p3_12.x, p3_12.y,
p3_12.z, 0, pn.x, pn.y, pn.z, 0, 0, 0, 0, 1))
n = self.normal.mul(0.01)
GL.glTranslatef(n.x, n.y, n.z)
maxdim = max((self.maxx - self.minx), (self.maxy - self.miny),
(self.maxz - self.minz))
factor = 0.001
GL.glScalef(factor * maxdim, factor * maxdim, factor * maxdim)
w = 0
id_string = "%s." % str(self.id)
for ch in id_string:
w += GLUT.glutStrokeWidth(GLUT.GLUT_STROKE_ROMAN, ord(ch))
GL.glTranslate(-w/2, 0, 0)
for ch in id_string:
GLUT.glutStrokeCharacter(GLUT.GLUT_STROKE_ROMAN, ord(ch))
GL.glPopMatrix()
if False: # draw point id on triangle face
c = self.center
p12 = self.p1.add(self.p2).mul(0.5)
p3_12 = self.p3.sub(p12).normalized()
p2_1 = self.p1.sub(self.p2).normalized()
pn = p2_1.cross(p3_12)
n = self.normal.mul(0.01)
for p in (self.p1, self.p2, self.p3):
GL.glPushMatrix()
pp = p.sub(p.sub(c).mul(0.3))
GL.glTranslate(pp.x, pp.y, pp.z)
GL.glMultMatrixf((p2_1.x, p2_1.y, p2_1.z, 0, p3_12.x, p3_12.y,
p3_12.z, 0, pn.x, pn.y, pn.z, 0, 0, 0, 0, 1))
GL.glTranslatef(n.x, n.y, n.z)
GL.glScalef(0.001, 0.001, 0.001)
w = 0
for ch in str(p.id):
w += GLUT.glutStrokeWidth(GLUT.GLUT_STROKE_ROMAN, ord(ch))
GL.glTranslate(-w/2, 0, 0)
for ch in str(p.id):
GLUT.glutStrokeCharacter(GLUT.GLUT_STROKE_ROMAN, ord(ch))
GL.glPopMatrix()
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 drawSphere(s,color=cyan,ndiv=8):
"""Draws a centered sphere with radius s in given color."""
quad = GLU.gluNewQuadric()
GLU.gluQuadricNormals(quad, GLU.GLU_SMOOTH)
GL.glColor(*color)
GLU.gluSphere(quad,s,ndiv,ndiv)
