def drawPoint(color, point, pointSize=3.0, isRound=True):
"""
Draw a point using GL_POINTS.
@param point: The x,y,z coordinate array/ vector of the point
@type point: A or V
@param pointSize: The point size to be used by glPointSize
@type pointSize: float
@param isRound: If True, the point will be drawn round otherwise square
@type isRound: boolean
"""
glDisable(GL_LIGHTING)
glColor3fv(color)
glPointSize(float(pointSize))
if isRound:
glEnable(GL_POINT_SMOOTH)
glBegin(GL_POINTS)
glVertex3fv(point)
glEnd()
if isRound:
glDisable(GL_POINT_SMOOTH)
glEnable(GL_LIGHTING)
if pointSize != 1.0:
glPointSize(1.0)
return
def drawPoint(color,
point,
pointSize = 3.0,
isRound = True):
"""
Draw a point using GL_POINTS.
@param point: The x,y,z coordinate array/ vector of the point
@type point: A or V
@param pointSize: The point size to be used by glPointSize
@type pointSize: float
@param isRound: If True, the point will be drawn round otherwise square
@type isRound: boolean
"""
glDisable(GL_LIGHTING)
glColor3fv(color)
glPointSize(float(pointSize))
if isRound:
glEnable(GL_POINT_SMOOTH)
glBegin(GL_POINTS)
glVertex3fv(point)
glEnd()
if isRound:
glDisable(GL_POINT_SMOOTH)
glEnable(GL_LIGHTING)
if pointSize != 1.0:
glPointSize(1.0)
return
def draw(self, i):
glPointSize(7.0)
glBegin(GL_POINTS)
glColor3f(self.particles[i].r, self.particles[i].g,
self.particles[i].b)
glVertex3f(self.particles[i].x, self.particles[i].y,
self.particles[i].z)
glEnd()
def draw_doms(self, size=3):
glPushMatrix()
glPointSize(size)
glColor3f(1.0, 1.0, 1.0)
glBegin(GL_POINTS)
for position in self.dom_positions:
glVertex3f(position[0], position[1], position[2])
glEnd()
glPopMatrix()
def display(self):
if self.world:
self.world.drawGL()
glPointSize(max(1, self.point_size))
for point_list in self.point_lists:
glCallList(point_list)
for xform in self.xforms:
gldraw.xform_widget(xform, 0.1, 0.01)
def dibujar_puntos(self, cuadrante: str):
for i in range(self.programa.lista_puntos.count()):
punto = self.programa.lista_puntos.itemWidget(
self.programa.lista_puntos.item(i))
if punto.render.isChecked() and punto.cuadrante == cuadrante:
glColor(punto.color)
glPointSize(punto.grosor)
glEnable(GL_POINT_SMOOTH)
glBegin(GL_POINTS)
glVertex(punto.x, punto.y, punto.z)
glEnd()
def paintLine(points, numsteps=None, **kwargs):
'''Paint a line with current brush
::
set_brush("mybrush.png", 10)
paintLine((0, 0, 20, 50))
paintLine((1, 2, 1, 5, 4, 6, 8, 7))
'''
if not __brush_texture:
pymt.pymt_logger.warning('Graphx: No brush set to paint line, abort')
return
if len(points) % 2 == 1:
raise Exception('Points list must be a pair length number (not impair)')
kwargs.setdefault('sfactor', GL_SRC_ALPHA)
kwargs.setdefault('dfactor', GL_ONE_MINUS_SRC_ALPHA)
blending = GlBlending(sfactor=kwargs.get('sfactor'),
dfactor=kwargs.get('dfactor'))
with DO(blending, gx_enable(GL_POINT_SPRITE_ARB),
gx_enable(__brush_texture.target)):
# prepare env
set_texture(__brush_texture.id, target=__brush_texture.target)
glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE)
glPointSize(__brush_size)
# initialize outputList
outputList = []
# extract 4 points each 2 points
for x1, y1, x2, y2 in zip(points[::2], points[1::2],
points[2::2], points[3::2]):
# calculate vector and distance
dx, dy = x2 - x1, y2 - y1
dist = sqrt(dx * dx + dy * dy)
# determine step
steps = numsteps
if steps is None:
steps = max(1, int(dist) / 4)
# construct pointList
for i in xrange(steps):
outputList.extend([x1 + dx * (float(i) / steps),
y1 + dy * (float(i) / steps)])
# draw !
if len(outputList) < 2:
return
with gx_begin(GL_POINTS):
for x, y in zip(outputList[::2], outputList[1::2]):
glVertex2f(x, y)
def draw_detector(self):
glUseProgram(self.shader)
try:
self.dom_positions_vbo.bind()
try:
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(self.dom_positions_vbo)
glPointSize(2)
glDrawArrays(GL_POINTS, 0, len(self.dom_positions)*3)
finally:
self.dom_positions_vbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY)
finally:
glUseProgram(0)
def plot():
glClear(GL_COLOR_BUFFER_BIT)
glPointSize(3.0)
glColor3f(1.0, 0.0, 0.0)
glBegin(GL_POINTS)
x_lst, y_lst = circle(0, 0, 1, 100)
for x, y in zip(x_lst, y_lst):
glVertex2f(x, y)
glEnd()
glFlush()
def _render_points(cls, point_list: List[Vector3], size: float, color: List[float]):
"""Draws a collection of points in the OpenGL 3D worldspace.
This function must be invoked inside the OpenGL render loop.
:param point_list: the points to render in the view context
:param size: the size in pixels of each point
:param color: the color to render the points
"""
glPointSize(size)
cls._set_color(color)
glBegin(GL_POINTS)
for point in point_list:
glVertex3f(point.x, point.y, point.z)
glEnd()
def draw_node(x, y, sizes, colors):
'''
Draw a node at the given position using max(len(sizes), len(colors))
points having the specified sizes and colors.
'''
if not len(sizes) == len(colors):
print "Size and colour count for node drawer not equal. Adjusting."
align_lists(sizes, colors)
for i, size in enumerate(sizes):
color = colors[i]
glPointSize(size)
glColor4f(color[0], color[1], color[2], color[3])
glBegin(GL_POINTS)
glVertex2f(x, y)
glEnd()
def Render(self, arrow_head_length=0.3):
from OpenGL.GL import glBegin, glEnd, glVertex2f, glColor3f, glPointSize, GL_POINTS
for edge in self.edge_list:
if edge[2] == PlanarGraphEdgeLabel.CUT:
glColor3f(0.0, 1.0, 0.0)
elif edge[2] == PlanarGraphEdgeLabel.REGION_BORDER:
glColor3f(0.6, 0.6, 0.6)
else:
glColor3f(1.0, 0.0, 0.0)
vector = self.EdgeVector(edge)
point = self.vertex_list[edge[0]]
vector.Render(point, arrow_head_length=arrow_head_length)
glPointSize(2.0)
glBegin(GL_POINTS)
try:
for point in self.vertex_list:
glColor3f(0.0, 0.0, 0.0)
glVertex2f(point.x, point.y)
finally:
glEnd()
def draw(self):
'''
Draw the point cloud.
'''
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glMultMatrixf(self._pose.T)
glDisable(GL_LIGHTING)
glPointSize(2)
if self._xyz_vbo:
# ref: http://stackoverflow.com/questions/16558819/vertex-buffer-objects-in-pyopengl-vertex-index-and-colour
with self._xyz_vbo:
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(self._xyz_vbo)
if self._rgb_vbo:
# check for dimension match to avoid segmentation faults
if len(self._rgb_vbo) != len(self._xyz_vbo):
raise RuntimeError(
'point cloud XYZ and RGB length mismatch: {} vs {}'
.format(len(self._xyz_vbo), len(self._rgb_vbo)))
with self._rgb_vbo:
# add color
glEnableClientState(GL_COLOR_ARRAY)
glColorPointerf(self._rgb_vbo)
glDrawArrays(GL_POINTS, 0, len(self._xyz_vbo))
else:
# draw without color
glDrawArrays(GL_POINTS, 0, len(self._xyz_vbo))
glDisableClientState(GL_COLOR_ARRAY)
glDisableClientState(GL_VERTEX_ARRAY)
glEnable(GL_LIGHTING)
glPopMatrix()
def draw_mesh(m, lighting_on):
# Supply vertices
glEnableClientState(GL_VERTEX_ARRAY)
m.vbo['v'].bind()
glVertexPointer(3, GL_FLOAT, 0, m.vbo['v'])
m.vbo['v'].unbind()
# Supply normals
if 'vn' in m.vbo.keys():
glEnableClientState(GL_NORMAL_ARRAY)
m.vbo['vn'].bind()
glNormalPointer(GL_FLOAT, 0, m.vbo['vn'])
m.vbo['vn'].unbind()
else:
glDisableClientState(GL_NORMAL_ARRAY)
# Supply colors
if 'vc' in m.vbo.keys():
glEnableClientState(GL_COLOR_ARRAY)
m.vbo['vc'].bind()
glColorPointer(3, GL_FLOAT, 0, m.vbo['vc'])
m.vbo['vc'].unbind()
else:
glDisableClientState(GL_COLOR_ARRAY)
if ('vt' in m.vbo.keys()) and hasattr(m, 'textureID'):
glEnable(GL_TEXTURE_2D)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
glBindTexture(GL_TEXTURE_2D, m.textureID)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
m.vbo['vt'].bind()
glTexCoordPointer(2, GL_FLOAT, 0, m.vbo['vt'])
m.vbo['vt'].unbind()
else:
glDisable(GL_TEXTURE_2D)
glDisableClientState(GL_TEXTURE_COORD_ARRAY)
# Draw
if len(m.f) > 0:
# ie if it is triangulated
if lighting_on:
glEnable(GL_LIGHTING)
else:
glDisable(GL_LIGHTING)
glDrawElementsui(GL_TRIANGLES, np.arange(m.f.size,
dtype=np.uint32))
else:
# not triangulated, so disable lighting
glDisable(GL_LIGHTING)
glPointSize(2)
glDrawElementsui(GL_POINTS, np.arange(len(m.v), dtype=np.uint32))
if hasattr(m, 'v_to_text'):
glEnable(GL_TEXTURE_2D)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
# glEnable(GL_TEXTURE_GEN_S)
# glEnable(GL_TEXTURE_GEN_T)
# glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR)
# glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR)
bgcolor = np.array(glGetDoublev(GL_COLOR_CLEAR_VALUE))
fgcolor = 1. - bgcolor
from .lines import Lines
sc = float(np.max(np.max(m.v, axis=0) - np.min(m.v, axis=0))) / 10.
cur_mtx = np.linalg.pinv(glGetFloatv(GL_MODELVIEW_MATRIX).T)
xdir = cur_mtx[:3, 0]
ydir = cur_mtx[:3, 1]
glEnable(GL_LINE_SMOOTH)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
for vidx, text in m.v_to_text.items():
pos0 = m.v[vidx].copy()
pos1 = m.v[vidx].copy()
if hasattr(m, 'vn'):
pos1 += m.vn[vidx] * sc
glLineWidth(5.0)
ln = Lines(v=np.vstack((pos0, pos1)), e=np.array([[0, 1]]))
glEnable(GL_LIGHTING)
glColor3f(1. - 0.8, 1. - 0.8, 1. - 1.00)
MeshViewerSingle.draw_lines(ln)
glDisable(GL_LIGHTING)
texture_id = get_textureid_with_text(text, bgcolor, fgcolor)
glBindTexture(GL_TEXTURE_2D, texture_id)
glPushMatrix()
glTranslatef(pos1[0], pos1[1], pos1[2])
dx = xdir * .10
dy = ydir * .10
if False:
glBegin(GL_QUADS)
glTexCoord2f(1., 0.)
glVertex3f(*(+dx + dy))
glTexCoord2f(1., 1.)
glVertex3f(*(+dx - dy))
glTexCoord2f(0., 1.)
glVertex3f(*(-dx - dy))
glTexCoord2f(0., 0.)
glVertex3f(*(-dx + dy))
# gluSphere(quadratic,0.05,32,32)
glEnd()
else:
glBegin(GL_POLYGON)
for r in np.arange(0, np.pi * 2., .01):
glTexCoord2f(np.cos(r) / 2. + .5, np.sin(r) / 2. + .5)
glVertex3f(*(dx * np.cos(r) + -dy * np.sin(r)))
glEnd()
glPopMatrix()
def display(self):
if self.knowledge_base:
# update the world
if self.knowledge_base.shelf_xform:
# load the shelf once a transform is available
if not self.shelf:
self.shelf = self.world.loadRigidObject("klampt_models/north_shelf/shelf_with_bins.obj")
logger.info("spawned shelf model")
self.shelf.setTransform(*self.knowledge_base.shelf_xform)
if self.knowledge_base.order_bin_xform:
# load the order bin once a transform is available
if not self.order_bin:
self.order_bin = self.world.loadRigidObject("klampt_models/apc_bin/apc_bin.obj")
logger.info("spawned order bin model")
self.order_bin.setTransform(*self.knowledge_base.order_bin_xform)
# spawn/update objects
for (name, xform) in self.knowledge_base.object_xforms.items():
# load the object once a transform is availale
if name not in self.objects:
body = self.world.loadRigidObject("klampt_models/items/{0}/{0}.obj".format(name))
logger.info("spawned {} model".format(name))
# load the point cloud
if name in self.knowledge_base.object_clouds:
self.n += 1
display_list = glGenLists(self.n)
# compile the display list
glNewList(display_list, GL_COMPILE)
glDisable(GL_LIGHTING)
glBegin(GL_POINTS)
points = self.knowledge_base.object_clouds[name]
for point in points:
if len(point) == 2:
xyz = point[0]
rgb = point[1]
else:
xyz = point[:3]
if len(point) == 4:
rgb = point[3]
elif len(point) > 3:
rgb = point[3:6]
else:
rgb = None
if rgb is not None:
glColor3f(*map(lambda x: x / 255.0, rgb))
else:
glColor3f(*colors[i % len(colors)])
glVertex3f(*xyz[:3])
glEnd()
glEndList()
logging.debug("compiled {} points for {}".format(len(points), name))
else:
display_list = None
self.objects[name] = {"body": body, "display_list": display_list}
# self.objects[name]['body'].setTransform(*xform)
# delete objects
for (name, props) in self.objects.items():
if name not in self.knowledge_base.object_xforms:
# remove the object
# XXX: cannot actually delete object... so move it far away... very far away
props["body"].setTransform(so3.identity(), [1e3, 1e3, 1e3])
del self.objects[name]
# update the robot state
if self.robot_state:
try:
self.robot.setConfig(self.robot_state.sensed_config)
except TypeError as e:
logger.error("error visualizing config: {}".format(self.robot_state.sensed_config))
logger.error(traceback.format_exc())
sys.exit(-1)
self.world.drawGL()
# draw commanded configurations
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, [0, 1, 0, 0.5])
if self.robot_state:
qi = self.robot.getConfig()
self.robot.setConfig(self.robot_state.commanded_config)
self.robot.drawGL(False)
self.robot.setConfig(qi)
glDisable(GL_BLEND)
# draw the point clouds
glPointSize(2)
for (name, props) in self.objects.items():
if "display_list" in props:
glCallList(props["display_list"])
# draw gripper link transforms
for name in ["left_gripper", "right_gripper"]:
gldraw.xform_widget(self.robot.getLink(name).getTransform(), 0.1, 0.01)
# draw axis-aligned axes for reference
gldraw.xform_widget((so3.identity(), [0, 0, 1]), 0.1, 0.01)
# draw local origins of objects
if self.knowledge_base:
for xform in self.knowledge_base.object_xforms.values():
gldraw.xform_widget(xform, 0.1, 0.01)
glDisableVertexAttribArray(0)
glDisableVertexAttribArray(1)
glutSwapBuffers()
def moveMouse(x, y, z, w):
pass
glutInit()
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH)
glutInitWindowSize(500, 500)
glutInitWindowPosition(100, 100)
wind = glutCreateWindow("OpenGL Window")
glPointSize(1)
vertshader = shaders.compileShader("""
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
out vec3 ourColor;
void main()
{
gl_Position = model * vec4(aPos, 1.0);
def main():
global width
global height
global camera
width = 1024
height = 1024
delta_time = 0.0
last_frame = 0.0
if not glfw.init():
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.RESIZABLE, GL_FALSE)
window = glfw.create_window(width, height, "opengl_lab1", None, None)
glfw.set_key_callback(window, key_callback)
glfw.set_cursor_pos_callback(window, mousemove_callback)
glfw.set_mouse_button_callback(window, mouseclick_callback)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
fun1 = lambda x, z: math.sin(x+z)
fun2 = lambda x, z: math.exp(-x*x - z*z)
fun3 = lambda x, z: (x**2 + z**2) / (x*z)
contour_plot = lambda x, z: 0.0
heightmap_dummy_fun = lambda x, z: 0.0
surface_size = 50
(fun_vao1, ind_fun1) = create_surface(100, 100, surface_size, fun1, False)
(fun_vao2, ind_fun2) = create_surface(100, 100, surface_size, fun2, False)
(fun_vao3, ind_fun3) = create_surface(100, 100, surface_size, fun3, False)
(grad_vao, grad_point_count) = create_grad(100, 100, surface_size)
(contour_plot_vao, ind_con, vec_lines, vector_line_indexes) = create_surface(100, 100, surface_size, 0, False, True)
(heightmap_vao, ind_hm) = create_surface(100,100, surface_size, heightmap_dummy_fun, True)
(sphere_vao, sphere_ind, normals_for_glyph) = uv_sphere(22, 11)
(torus_vao, torus_ind) = uv_torus(5, 10, 100, 100)
(cm_vao, ind_cm) = create_surface(100, 100, surface_size, heightmap_dummy_fun, True)
(cloud_vao, points_count) = read_ply()
(perlin_vao, ind_perlin) = create_surface(100, 100, surface_size, heightmap_dummy_fun, False)
(div_vao, ind_div) = create_surface(100, 100, surface_size, heightmap_dummy_fun, False)
(traj_vao, ind_traj) = simple_cube()
fun_shader_sources = [(GL_VERTEX_SHADER, "shaders/functions.vert"), (GL_FRAGMENT_SHADER, "shaders/functions.frag")]
fun_program = ShaderProgram(fun_shader_sources)
hm_shader_sources = [(GL_VERTEX_SHADER, "shaders/heightmap.vert"), (GL_FRAGMENT_SHADER, "shaders/heightmap.frag")]
hm_program = ShaderProgram(hm_shader_sources)
hm_texture = read_texture("1.jpg")
contour_plot_shader_sources = [(GL_VERTEX_SHADER, "shaders/contourplot.vert"), (GL_FRAGMENT_SHADER, "shaders/contourplot.frag")]
contour_plot_program = ShaderProgram(contour_plot_shader_sources)
sphere_shader_sources = [(GL_VERTEX_SHADER, "shaders/sphere.vert"), (GL_FRAGMENT_SHADER, "shaders/sphere.frag")]
sphere_program = ShaderProgram(sphere_shader_sources)
glyph_shader_sources = [(GL_VERTEX_SHADER, "shaders/glyph.vert"), (GL_GEOMETRY_SHADER, "shaders/glyph.geom"), (GL_FRAGMENT_SHADER, "shaders/glyph.frag")]
glyph_program = ShaderProgram(glyph_shader_sources)
grad_shader_sources = [(GL_VERTEX_SHADER, "shaders/grad.vert"), (GL_GEOMETRY_SHADER, "shaders/grad.geom"), (GL_FRAGMENT_SHADER, "shaders/grad.frag")]
grad_program = ShaderProgram(grad_shader_sources)
cm_shader_sources = [(GL_VERTEX_SHADER, "shaders/colormap.vert"), (GL_FRAGMENT_SHADER, "shaders/colormap.frag")]
cm_program = ShaderProgram( cm_shader_sources )
perlin_shader_sources = [(GL_VERTEX_SHADER, "shaders/perlin.vert"), (GL_FRAGMENT_SHADER, "shaders/perlin.frag")]
perlin_program = ShaderProgram(perlin_shader_sources)
cloud_shader_sources = [(GL_VERTEX_SHADER, "shaders/ply.vert"), (GL_FRAGMENT_SHADER, "shaders/ply.frag")]
cloud_program = ShaderProgram(cloud_shader_sources)
vf_shader_sources = [(GL_VERTEX_SHADER, "shaders/vector_field.vert"), (GL_FRAGMENT_SHADER, "shaders/vector_field.frag")]
vf_program = ShaderProgram(vf_shader_sources)
traj_shader_sources = [(GL_VERTEX_SHADER, "shaders/trajectory.vert"),
(GL_FRAGMENT_SHADER, "shaders/trajectory.frag")]
traj_program = ShaderProgram(traj_shader_sources)
check_gl_errors()
projection = projectionMatrixTransposed(60.0, float(width) / float(height), 1, 1000.0)
HDR_TEXTURES_AMOUNT = 33
cm_textures = read_cm_textures(HDR_TEXTURES_AMOUNT)
cm_texture_num = 0
cm_change_counter = 0
hdr_textures_speed = 6
perlin_time = 0.0
perlin_time_step = 0.03
cube_multiplier = 1.0
cube_center = [0.0, 0.0, 0.0]
traj_points_list = [ cube_center ]
cube_edge_length = 2.0 * cube_multiplier
offset = cube_edge_length / 10
left_cube_pos = -25 * cube_edge_length
cube_steps = -left_cube_pos / offset - 10
traj_points_count = int(cube_steps)
for i in range(traj_points_count):
traj_points_list.append( [0.5*cube_edge_length * i, 0.0, 0.0] )
traj_part_index = 0
while not glfw.window_should_close(window):
current_frame = glfw.get_time()
delta_time = current_frame - last_frame
last_frame = current_frame
glfw.poll_events()
doCameraMovement(camera, delta_time)
model = translateM4x4(np.array([0.0, 0.0, 0.0]))
view = camera.get_view_matrix()
glClearColor(0.5, 0.5, 0.5, 1.0)
glViewport(0, 0, width, height)
glEnable(GL_DEPTH_TEST)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
fun_program.bindProgram()
glUniform3fv(fun_program.uniformLocation("col"), 1 , [1.0, 0, 0] )
glUniformMatrix4fv(fun_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(fun_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(fun_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(fun_vao1)
glDrawElements(GL_TRIANGLE_STRIP, ind_fun1, GL_UNSIGNED_INT, None)
model = translateM4x4(np.array([-1.5*surface_size,0.0 ,0.0 ]))
glUniform3fv(fun_program.uniformLocation("col"), 1, [0.0, 1.0, 0])
glUniformMatrix4fv(fun_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glBindVertexArray(fun_vao2)
glDrawElements(GL_TRIANGLE_STRIP, ind_fun2, GL_UNSIGNED_INT, None)
model = translateM4x4(np.array([1.5 * surface_size, 0.0, 0.0]))
glUniform3fv(fun_program.uniformLocation("col"), 1, [0.0, 0.0, 1.0])
glUniformMatrix4fv(fun_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glBindVertexArray(fun_vao3)
glDrawElements(GL_TRIANGLE_STRIP, ind_fun3, GL_UNSIGNED_INT, None)
cloud_program.bindProgram()
translate_cloud = translateM4x4(np.array([-2.5*surface_size,0.0 ,0.0 ]))
# rotate_cloud = rotateYM4x4(math.radians(180))
model = translate_cloud
# glUniform3fv(fun_program.uniformLocation("col"), 1, [0.0, 1.0, 0])
glUniformMatrix4fv(cloud_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(cloud_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(cloud_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(cloud_vao)
glDrawArrays(GL_POINTS, 0, points_count)
sphere_program.bindProgram()
sph_scale = scaleM4x4(np.array([sphere_radius, sphere_radius, sphere_radius]))
sph_translate = translateM4x4(np.array([0.0, 0.0, 2.0 * surface_size]))
glUniformMatrix4fv(sphere_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(sph_translate + sph_scale).flatten())
glUniformMatrix4fv(sphere_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(sphere_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(sphere_vao)
glDrawElements(GL_TRIANGLES, sphere_ind, GL_UNSIGNED_INT, None)
torus_translate = translateM4x4(np.array([0.0, 0.0, 3.0 * surface_size]))
glUniformMatrix4fv(sphere_program.uniformLocation("model"), 1, GL_FALSE,
np.transpose(torus_translate + sph_scale).flatten())
glBindVertexArray(torus_vao)
glDrawElements(GL_TRIANGLES, torus_ind, GL_UNSIGNED_INT, None)
glyph_program.bindProgram()
sph_scale = scaleM4x4(np.array([sphere_radius, sphere_radius, sphere_radius]))
sph_translate = translateM4x4(np.array([0.0, 0.0, 2.0 * surface_size]))
glUniformMatrix4fv(glyph_program.uniformLocation("model"), 1, GL_FALSE,
np.transpose(sph_translate + sph_scale).flatten())
glUniformMatrix4fv(glyph_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(glyph_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
vao = glGenVertexArrays(1)
glBindVertexArray(vao)
vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(normals_for_glyph), normals_for_glyph.flatten(),
GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
glDrawArrays(GL_POINTS, 0, 10000)
glBindVertexArray(0)
contour_plot_program.bindProgram()
model = translateM4x4(np.array([-1.5 * surface_size, 0.0, -1.5 * surface_size]))
glUniformMatrix4fv(contour_plot_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(contour_plot_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(contour_plot_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(contour_plot_vao)
glDrawElements(GL_TRIANGLE_STRIP, ind_con, GL_UNSIGNED_INT, None)
fun_program.bindProgram()
lines_vao = glGenVertexArrays(1)
glBindVertexArray(lines_vao)
vbo_lines = glGenBuffers(1)
vbo_indices = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo_lines)
glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vec_lines), vec_lines.flatten(),
GL_STATIC_DRAW) #
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_indices)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vector_line_indexes), vector_line_indexes.flatten(),
GL_STATIC_DRAW)
glUniformMatrix4fv(fun_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(fun_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(fun_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(lines_vao)
glDrawElements(GL_LINES, vector_line_indexes.size, GL_UNSIGNED_INT, None)
hm_program.bindProgram()
model = translateM4x4(np.array([0.0, 0.0, -1.5 * surface_size]))
bindTexture(0, hm_texture)
glUniform1i(hm_program.uniformLocation("tex"), 0)
glUniformMatrix4fv(hm_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(hm_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(hm_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(heightmap_vao)
glDrawElements(GL_TRIANGLE_STRIP, ind_hm, GL_UNSIGNED_INT, None)
cm_program.bindProgram()
model = translateM4x4(np.array([1.5 * surface_size, 0.0, -1.5 * surface_size]))
cur_cm_texture = cm_textures[cm_texture_num % HDR_TEXTURES_AMOUNT]
bindTexture(1, cur_cm_texture)
if cm_change_counter % hdr_textures_speed == 0:
cm_texture_num += 1
cm_change_counter += 1
glUniform1i(cm_program.uniformLocation("cm_switch"), False)
glUniform1i(cm_program.uniformLocation("tex"), 1)
glUniformMatrix4fv(cm_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(cm_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(cm_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(cm_vao)
glDrawElements(GL_TRIANGLE_STRIP, ind_cm, GL_UNSIGNED_INT, None)
# draw second animated hdr on the same shader
model = translateM4x4(np.array([2.5 * surface_size, 0.0, -2.5 * surface_size]))
glUniformMatrix4fv(cm_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniform1i(cm_program.uniformLocation("cm_switch"), True)
glDrawElements(GL_TRIANGLE_STRIP, ind_cm, GL_UNSIGNED_INT, None)
perlin_program.bindProgram()
model = translateM4x4(np.array([0.0, 0.0, -3.5 * surface_size]))
glUniformMatrix4fv(perlin_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(perlin_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(perlin_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glUniform1f(perlin_program.uniformLocation("time"), perlin_time)
perlin_time += perlin_time_step
glBindVertexArray(perlin_vao)
glDrawElements(GL_TRIANGLE_STRIP, ind_perlin, GL_UNSIGNED_INT, None)
grad_program.bindProgram()
model = translateM4x4(np.array([-25.0, 0.0, -7.0 * surface_size]))
glUniformMatrix4fv(grad_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(grad_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(grad_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(grad_vao)
glDrawArrays(GL_LINES, 0, grad_point_count)
vf_program.bindProgram()
model = translateM4x4(np.array([0.0, 0.0, -5.5 * surface_size]))
glUniformMatrix4fv(vf_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glUniformMatrix4fv(vf_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(vf_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glUniform1i(vf_program.uniformLocation("cm_switch"), True)
glBindVertexArray(div_vao)
glDrawElements(GL_TRIANGLE_STRIP, ind_div, GL_UNSIGNED_INT, None)
glUniform1i(vf_program.uniformLocation("cm_switch"), False)
model = translateM4x4(np.array([1.0 * surface_size, 0.0, -6.5 * surface_size]))
glUniformMatrix4fv(vf_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
glDrawElements(GL_TRIANGLE_STRIP, ind_div, GL_UNSIGNED_INT, None)
traj_program.bindProgram()
l_traj_part =[]
r_traj_part =[]
if offset > 0:
traj_part_index = int(traj_points_count - cm_change_counter % cube_steps)
r_traj_part = traj_points_list[0:traj_part_index]
for traj_coords in r_traj_part:
l_traj_part.append( [-x for x in traj_coords] )
else:
traj_part_index = int(traj_points_count - cm_change_counter % cube_steps)
# traj_part_index = int(cm_change_counter % cube_steps)
l_traj_part = traj_points_list[0:traj_part_index]
for traj_coords in l_traj_part:
r_traj_part.append([-x for x in traj_coords])
l_traj_vec = np.array(l_traj_part, dtype=np.float32)
r_traj_vec = np.array(r_traj_part, dtype=np.float32)
indices_list = [i for i in range(len(r_traj_part))]
indices_vec = np.array(indices_list, dtype=np.uint32)
left_traj_vao = glGenVertexArrays(1)
right_traj_vao = glGenVertexArrays(1)
left_traj_vertices = glGenBuffers(1)
left_traj_indices = glGenBuffers(1)
right_traj_vertices = glGenBuffers(1)
right_traj_indices = glGenBuffers(1)
glBindVertexArray(left_traj_vao)
glPointSize( 3.0 )
glBindBuffer(GL_ARRAY_BUFFER, left_traj_vertices)
glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(l_traj_vec), l_traj_vec.flatten(),
GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, left_traj_indices)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(indices_vec), indices_vec.flatten(),
GL_STATIC_DRAW)
glBindVertexArray(right_traj_vao)
glBindBuffer(GL_ARRAY_BUFFER, right_traj_vertices)
glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(r_traj_vec), r_traj_vec.flatten(),
GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, right_traj_indices)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(indices_vec), indices_vec.flatten(),
GL_STATIC_DRAW)
glBindVertexArray(0)
cube_scale_ = scaleM4x4(np.array([1.0, 1.0, 1.0]))
left_cube_pos += offset
left_translation = translateM4x4(np.array([left_cube_pos, 0.0, -7.5 * surface_size]))
glUniformMatrix4fv(traj_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(left_translation).flatten())
glUniformMatrix4fv(traj_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
glUniformMatrix4fv(traj_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
glBindVertexArray(left_traj_vao)
glDrawElements(GL_LINE_STRIP, indices_vec.size, GL_UNSIGNED_INT, None)
glBindVertexArray(traj_vao)
glDrawElements(GL_TRIANGLE_STRIP, ind_traj, GL_UNSIGNED_INT, None)
right_translation = translateM4x4(np.array([-left_cube_pos, 0.0, -8.5 * surface_size]))
glUniformMatrix4fv(traj_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(right_translation).flatten())
glDrawElements(GL_TRIANGLE_STRIP, ind_traj, GL_UNSIGNED_INT, None)
glBindVertexArray(right_traj_vao)
glDrawElements(GL_LINE_STRIP, indices_vec.size, GL_UNSIGNED_INT, None)
if not cm_change_counter % cube_steps:
# left_cube_pos = left_cube_pos + offset * (cube_steps-1)
offset *= -1
# r_traj_part, l_traj_part = l_traj_part, r_traj_part
traj_program.unbindProgram()
glfw.swap_buffers(window)
glfw.terminate()
def landmark_visualizer(landmarks, cameras, left_landmarks, right_landmarks):
glLineWidth(1.5)
glBegin(GL_LINES)
glColor3f(0.0, 1.0, 0.0)
for landmark in landmarks:
glVertex3fv(cameras[0])
glVertex3fv(landmark)
glColor3f(0.0, 0.0, 1.0)
for landmark in landmarks:
glVertex3fv(cameras[1])
glVertex3fv(landmark)
glEnd()
glPointSize(3.0)
glBegin(GL_POINTS)
glColor3f(1.0, 0.0, 0.0)
for i in range(len(landmarks)):
glVertex3f(landmarks[i][0], landmarks[i][1], landmarks[i][2])
glEnd()
glPointSize(3.0)
glBegin(GL_POINTS)
glColor3f(1.0, 0.0, 0.0)
for i in range(len(cameras)):
glVertex3f(cameras[i][0], cameras[i][1], cameras[i][2])
glEnd()
glLineWidth(1.5)
glBegin(GL_LINES)
glColor3f(0.0, 1.0, 0.0)
for landmark in left_landmarks:
glVertex3fv(cameras[0])
glVertex3fv(landmark)
glColor3f(0.0, 0.0, 1.0)
for landmark in right_landmarks:
glVertex3fv(cameras[1])
glVertex3fv(landmark)
glEnd()
glPointSize(3.0)
glBegin(GL_POINTS)
glColor3f(1.0, 0.0, 0.0)
for i in range(len(left_landmarks)):
glVertex3f(left_landmarks[i][0], left_landmarks[i][1],
left_landmarks[i][2])
glEnd()
glPointSize(3.0)
glBegin(GL_POINTS)
glColor3f(1.0, 0.0, 0.0)
for i in range(len(right_landmarks)):
glVertex3f(right_landmarks[i][0], right_landmarks[i][1],
right_landmarks[i][2])
glEnd()
glPointSize(3.0)
glBegin(GL_POINTS)
glColor3f(1.0, 0.0, 0.0)
for i in range(len(cameras)):
glVertex3f(cameras[i][0], cameras[i][1], cameras[i][2])
glEnd()
def on_draw(self):
glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glTranslate(self.translatex, self.translatey, self.depth)
if self.autoRun:
glRotate(self.rotx, 0, 1, 0)
else:
# Perform arcball rotation.
glScale(1,-1,1)
glMultMatrixf(self.arcball.transform)
glScale(1,-1,1)
with displayListify("cubeTranslate") as shouldLeave:
if shouldLeave: raise LeaveWith
# Scale the co-ordinates so that they are correct
glScale(2/128, 2/128, 2/128)
glColor(0.25, 0.25, 0.25, 1)
glutWireCube(255)
glTranslate(-128, -128, -128)
with displayListify("allPoints") as shouldLeave:
if shouldLeave: raise LeaveWith
with SaveMatrix():
# Flip the co-ordinates and translate upwards
glScale(1,-1,1)
glColor(0.25, 0.25, 0.25, 0.5)
glTranslate(0,-255,0)
glPointSize(pointSize)
for dat in reversed(vLists):
glTranslate(0., 0., 1./nChunks*255)
dat.draw(GL_POINTS)
with displayListify("axisLabels") as shouldLeave:
if shouldLeave: raise LeaveWith
#if True:
with SaveMatrix():
glTranslate(128,0,0)
self.makeLabel("End").draw()
glTranslate(0,0,255)
self.makeLabel("Beginning").draw()
with SaveMatrix():
glTranslate(-128,128,0)
glRotate(90,0,0,1)
self.makeLabel("Byte 1").draw()
glTranslate(0,255,0)
self.makeLabel("Byte 2").draw()
with displayListify("fileName") as shouldLeave:
if shouldLeave: raise LeaveWith
glLoadIdentity()
with SaveMatrix():
glColor(1,0,0)
glTranslate(0,-2.2,-4)
glScale(1/64, 1/64, 1/64)
l = self.makeLabel(basename(currentInputFile))
l.color = (0, 128, 230, 255)
l.draw()
glTranslate(0,0,-1)
if self.autoRun:
if self.rotx > 360 - 45:
vlist = vertex_list(4, ('v2i', (-1, -1, 1, -1, 1, 1, -1, 1)))
glColor(0,0,0,(self.rotx-(360-45))/45)
vlist.draw(GL_QUADS)
if self.rotx < 45:
vlist = vertex_list(4, ('v2i', (-1, -1, 1, -1, 1, 1, -1, 1)))
glColor(0,0,0,1-(self.rotx/45))
vlist.draw(GL_QUADS)