def SetDisplayingItems(self, data, dataLen, colors):
self.data = data
self.colors = colors
self.xcount = len(unique(data[:, 0]))
self.ycount = len(unique(data[:, 1]))
workingData = self.data
workingColors = self.colors
self.dataNum = dataLen
self.colorsNum = self.dataNum
maxVals = amax(workingData, axis=0)
self.xMax = maxVals[0]
self.yMax = maxVals[1]
self.zMax = maxVals[2]
minVals = amin(workingData, axis=0)
self.xMin = minVals[0]
self.yMin = minVals[1]
self.zMin = minVals[2]
# print "Max before offset:", self.xMax, self.yMax, self.zMax
# print "Min before offset:", self.xMin, self.yMin, self.zMin
self.diffX = (self.xMax + self.xMin) / 2
self.diffY = (self.yMax + self.yMin) / 2
self.diffZ = (self.zMax + self.zMin) / 2
# print "Offset:", self.diffX, self.diffY, self.diffZ
workingData = subtract(workingData, array([self.diffX, self.diffY, self.diffZ], float32))
# recollect limitations
maxVals = amax(workingData, axis=0)
self.xMax = maxVals[0]
self.yMax = maxVals[1]
self.zMax = maxVals[2]
minVals = amin(workingData, axis=0)
self.xMin = minVals[0]
self.yMin = minVals[1]
self.zMin = minVals[2]
# print "Max:", self.xMax, self.yMax, self.zMax
# print "Min:", self.xMin, self.yMin, self.zMin
self.eyeDistance = 100 * max(abs(self.xMax), abs(self.xMin),
abs(self.yMax), abs(self.yMin),
abs(self.zMax), abs(self.zMin))
# print "eye distance:", self.eyeDistance
self.vertices_vbo = glGenBuffers(1)
glEnableClientState(GL_VERTEX_ARRAY)
glBindBuffer(GL_ARRAY_BUFFER, self.vertices_vbo)
glBufferData(GL_ARRAY_BUFFER, workingData.nbytes, workingData, GL_STATIC_DRAW)
glVertexPointer(3, GL_FLOAT, 0, None)
glBindBuffer(GL_ARRAY_BUFFER, 0)
self.colors_vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.colors_vbo)
glBufferData(GL_ARRAY_BUFFER, workingColors.nbytes, workingColors, GL_STATIC_DRAW)
glColorPointer(3, GL_FLOAT, 0, None)
glBindBuffer(GL_ARRAY_BUFFER, 0)
print "Points and color is ready"
def SetColors(self, colors):
if not iterable(colors):
return
if len(colors) < self.dataNum:
return
self.colors = colors
workingColors = self.colors
# workingData, self.dataNum, workingColors = self.GetWorkingSet(self.data, self.dataNum, self.colors)
self.colorsNum = len(workingColors)
self.colors_vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.colors_vbo)
glBufferData(GL_ARRAY_BUFFER, workingColors.nbytes, workingColors, GL_STATIC_DRAW)
glColorPointer(3, GL_FLOAT, 0, None)
glBindBuffer(GL_ARRAY_BUFFER, 0)
print "Color is ready"
def Draw(self, descriptor=[]):
"""Draws a map with all objects in the world,
according to the descriptor."""
GuiObject.Draw(self)
# TODO get rid of any frame mechanism parts here
frame = self._getFrameData()["frame"]
glTranslatef(frame, 2 * frame, 0.0)
# moving away from the frame
blockSize = (1 - 2 * frame) / self.worldLength
scaleFactor = blockSize
# data = narray(reduce(lambda a,b: a + b,
# map(self.__descToArray,
# descriptor)),
# "f");
if len(descriptor) > 0:
#valuesPerObject = len(self.__descToArray(descriptor[0]))
if self._vbo is None:
self._BuildData(descriptor)
for _id, obj in self._dirty_objects.items():
self._UpdateObject(_id, obj)
self._dirty_objects = {}
glTranslatef(frame, 2 * frame, 0.0)
# moving away from the frame
glScale(scaleFactor, scaleFactor, 1.0)
self._vbo.bind()
self._vbo.copy_data()
try:
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_COLOR_ARRAY)
# 2 coordinates with 4 color values with 4 bytes each in
# between
glVertexPointer(2, GL_FLOAT, 24, self._vbo)
# 4 color values with 2 coordinates with 4 bytes each in
# between
glColorPointer(4, GL_FLOAT, 24, self._vbo + 8)
glDrawArrays(GL_TRIANGLES, 0, 3 * 2 * (self._max_index + 1))
finally:
self._vbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_COLOR_ARRAY)
def Draw(self, descriptor=[]):
"""Draws a map with all objects in the world,
according to the descriptor."""
GuiObject.Draw(self)
# TODO get rid of any frame mechanism parts here
frame = self._getFrameData()["frame"]
glTranslatef(frame, 2 * frame, 0.0)
# moving away from the frame
blockSize = (1 - 2 * frame) / self.worldLength
scaleFactor = blockSize
# data = narray(reduce(lambda a,b: a + b,
# map(self.__descToArray,
# descriptor)),
# "f");
if len(descriptor) > 0:
# valuesPerObject = len(self.__descToArray(descriptor[0]))
if self._vbo is None:
self._BuildData(descriptor)
for _id, obj in self._dirty_objects.items():
self._UpdateObject(_id, obj)
self._dirty_objects = {}
glTranslatef(frame, 2 * frame, 0.0)
# moving away from the frame
glScale(scaleFactor, scaleFactor, 1.0)
self._vbo.bind()
self._vbo.copy_data()
try:
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_COLOR_ARRAY)
# 2 coordinates with 4 color values with 4 bytes each in
# between
glVertexPointer(2, GL_FLOAT, 24, self._vbo)
# 4 color values with 2 coordinates with 4 bytes each in
# between
glColorPointer(4, GL_FLOAT, 24, self._vbo + 8)
glDrawArrays(GL_TRIANGLES, 0, 3 * 2 * (self._max_index + 1))
finally:
self._vbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_COLOR_ARRAY)
def bind_colors(self, size, var_type, stride=0):
self.bind()
glColorPointer(size, var_type, stride, None)
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()
