def Draw(self):
centers = self.vertexSet.vertices.array
if len(centers) == 0:
return
faces = map(lambda x: [x], range(len(centers)))
if self.materials[GL.GL_FRONT] and \
not self.inheritMaterial:
fpProp = self.materials[GL.GL_FRONT].prop[:5]
fpBind = self.materials[GL.GL_FRONT].binding[:5]
else:
fpProp = None
fpBind = None
if self.materials[GL.GL_BACK] and \
not self.inheritMaterial:
bpProp = self.materials[GL.GL_BACK].prop[:5]
bpBind = self.materials[GL.GL_BACK].binding[:5]
else:
bpProp = None
bpBind = None
texCoords = None
if self.normals is None:
GL.glDisable(GL.GL_LIGHTING)
status = glDrawIndexedGeom(GL.GL_POINTS, self.vertexSet.vertices.array,
faces, self.normals, texCoords, fpProp,
bpProp, fpBind, bpBind, self.frontAndBack,
1)
return status
def Draw(self):
#print"Box.Draw"
self.oldFPM = self.frontPolyMode
if self.frontPolyMode == GL.GL_LINE:
GL.glDisable(GL.GL_LIGHTING)
#c is 8x3 array
c= self.vertexSet.vertices.array
#lines parallel to x-axis should be red, y->blue and z->green
col = ((1,0,0),(0,1,0),(0,0,1))
#these groups of 4 pairs of points define lines parallel to x, y, and z axes
alines=[[(c[0],c[1]),(c[2],c[3]),(c[4],c[5]),(c[6],c[7])],
[(c[0],c[3]),(c[1],c[2]),(c[4],c[7]),(c[5],c[6])],
[(c[0],c[4]),(c[1],c[5]),(c[3],c[7]),(c[2],c[6])]]
namectr=0
for i in range(3):
if not self.inheritMaterial:
GL.glColor3fv(col[i])
for vpairs in alines[i]:
GL.glPushName(namectr)
GL.glBegin(GL.GL_LINES)
GL.glVertex3dv(list(vpairs[0]))
GL.glVertex3dv(list(vpairs[1]))
GL.glEnd()
GL.glPopName()
namectr=namectr+1
self.viewer.enableOpenglLighting()
return 1
else:
return IndexedPolygons.Draw(self)
def Draw(self):
#print"Box.Draw"
self.oldFPM = self.frontPolyMode
if self.frontPolyMode == GL.GL_LINE:
GL.glDisable(GL.GL_LIGHTING)
#c is 8x3 array
c = self.vertexSet.vertices.array
#lines parallel to x-axis should be red, y->blue and z->green
col = ((1, 0, 0), (0, 1, 0), (0, 0, 1))
#these groups of 4 pairs of points define lines parallel to x, y, and z axes
alines = [[(c[0], c[1]), (c[2], c[3]), (c[4], c[5]), (c[6], c[7])],
[(c[0], c[3]), (c[1], c[2]), (c[4], c[7]), (c[5], c[6])],
[(c[0], c[4]), (c[1], c[5]), (c[3], c[7]), (c[2], c[6])]]
namectr = 0
for i in range(3):
if not self.inheritMaterial:
GL.glColor3fv(col[i])
for vpairs in alines[i]:
GL.glPushName(namectr)
GL.glBegin(GL.GL_LINES)
GL.glVertex3dv(list(vpairs[0]))
GL.glVertex3dv(list(vpairs[1]))
GL.glEnd()
GL.glPopName()
namectr = namectr + 1
self.viewer.enableOpenglLighting()
return 1
else:
return IndexedPolygons.Draw(self)
def Draw(self):
#print "StickerImage.Draw", self
if self.image is None:
return
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
Insert2d.Draw(self)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDisable(GL.GL_LIGHTING);
width = self.size[0]
height = self.size[1]
fullWidth = self.viewer.currentCamera.width
fullHeight = self.viewer.currentCamera.height
# we want the anchor of the image to be at the given position
posxFromLeft = self.position[0] * fullWidth - self.anchor[0] * width
posyFrombottom = (1.-self.position[1]) * fullHeight - (1.-self.anchor[1]) * height
#print "posxFromLeft, posyFrombottom", posxFromLeft, posyFrombottom
# used for picking
self.polygonContour = [ (posxFromLeft, posyFrombottom),
(posxFromLeft+width, posyFrombottom),
(posxFromLeft+width, posyFrombottom+height),
(posxFromLeft, posyFrombottom+height)
]
# this accept negative values were GL.glRasterPos2f(x,y) doesn't
GL.glRasterPos2f(0, 0)
_gllib.glBitmap(0, 0, 0, 0, posxFromLeft, posyFrombottom, 0)
GL.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1)
if self.image.mode == 'RGBA':
_gllib.glDrawPixels(self.image.size[0], self.image.size[1],
GL.GL_RGBA, GL.GL_UNSIGNED_BYTE,
self.image.tostring() )
elif self.image.mode == 'RGB':
_gllib.glDrawPixels(self.image.size[0], self.image.size[1],
GL.GL_RGB, GL.GL_UNSIGNED_BYTE,
self.image.tostring() )
elif self.image.mode == 'L':
_gllib.glDrawPixels(self.image.size[0], self.image.size[1],
GL.GL_LUMINANCE, GL.GL_UNSIGNED_BYTE,
self.image.tostring() )
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPopMatrix()
return 1
def SetupGL(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
"""Setup OpenGL rendering state for this object
"""
#print "SetupGL", self
if not self.inheritMaterial:
self.InitMaterial()
self.InitColor()
if self.GetLighting():
#glEnable(GL_LIGHTING)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
shading = self.GetShading()
if shading != GL.GL_NONE:
if self.normals is not None:
if (shading==GL.GL_SMOOTH and \
len(self.normals)!=len(self.vertexSet)) or \
(shading==GL.GL_FLAT and \
len(self.normals)!=len(self.faceSet)):
self.GetNormals()
self.viewer.objectsNeedingRedo[self] = None
GL.glShadeModel(shading)
else: # no lighting
GL.glDisable(GL.GL_LIGHTING)
if not self.inheritCulling:
if self.culling in (GL.GL_BACK, GL.GL_FRONT, GL.GL_FRONT_AND_BACK):
GL.glCullFace(self.culling)
GL.glEnable(GL.GL_CULL_FACE)
else:
GL.glDisable(GL.GL_CULL_FACE)
if not self.inheritFrontPolyMode:
mode = self.frontPolyMode
if self.frontPolyMode == viewerConst.OUTLINED:
mode = GL.GL_FILL
if self.frontAndBack:
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, mode)
else:
GL.glPolygonMode(GL.GL_FRONT, mode)
if not self.inheritBackPolyMode:
mode = self.backPolyMode
if self.backPolyMode == viewerConst.OUTLINED:
mode = GL.GL_FILL
GL.glPolygonMode(GL.GL_BACK, mode)
#self._AntiAliasing()
self._WidthAndStipple()
def SetupGL(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
"""Setup OpenGL rendering state for this object
"""
#print "SetupGL", self
if not self.inheritMaterial:
self.InitMaterial()
self.InitColor()
if self.GetLighting():
#glEnable(GL_LIGHTING)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
shading = self.GetShading()
if shading != GL.GL_NONE:
if self.normals is not None:
if (shading==GL.GL_SMOOTH and \
len(self.normals)!=len(self.vertexSet)) or \
(shading==GL.GL_FLAT and \
len(self.normals)!=len(self.faceSet)):
self.GetNormals()
self.viewer.objectsNeedingRedo[self] = None
GL.glShadeModel(shading)
else: # no lighting
GL.glDisable(GL.GL_LIGHTING)
if not self.inheritCulling:
if self.culling in (GL.GL_BACK, GL.GL_FRONT, GL.GL_FRONT_AND_BACK):
GL.glCullFace(self.culling)
GL.glEnable(GL.GL_CULL_FACE)
else: GL.glDisable(GL.GL_CULL_FACE)
if not self.inheritFrontPolyMode:
mode =self.frontPolyMode
if self.frontPolyMode==viewerConst.OUTLINED:
mode = GL.GL_FILL
if self.frontAndBack:
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, mode)
else:
GL.glPolygonMode(GL.GL_FRONT, mode)
if not self.inheritBackPolyMode:
mode = self.backPolyMode
if self.backPolyMode==viewerConst.OUTLINED:
mode = GL.GL_FILL
GL.glPolygonMode(GL.GL_BACK, mode)
#self._AntiAliasing()
self._WidthAndStipple()
def Draw(self):
#print "Sticker.Draw", self
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
Insert2d.Draw(self)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDisable(GL.GL_LIGHTING);
lLabelbounds = self.calculateSize()
width = self.size[0]
height = self.size[1]
fullWidth = self.viewer.currentCamera.width
fullHeight = self.viewer.currentCamera.height
# we want the anchor of the image to be at the given position
posxFromLeft = self.position[0] * fullWidth - self.anchor[0] * width
posyFrombottom = (1.-self.position[1]) * fullHeight - (1.-self.anchor[1]) * height
posxFromLeft = int(floor( posxFromLeft ) )
posyFrombottom = int(floor( posyFrombottom ) )
if (self.position[1] == 0.):
posyFrombottom -= 1
#print "posxFromLeft, posyFrombottom", posxFromLeft, posyFrombottom
# used for picking
self.polygonContour = [ (posxFromLeft, posyFrombottom),
(posxFromLeft+width, posyFrombottom),
(posxFromLeft+width, posyFrombottom+height),
(posxFromLeft, posyFrombottom+height)
]
GL.glTranslatef(float(posxFromLeft), float(posyFrombottom), 0)
self.drawSticker(lLabelbounds)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_LIGHTING);
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPopMatrix()
return 1
def Draw(self):
#print "Sticker.Draw", self
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
Insert2d.Draw(self)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDisable(GL.GL_LIGHTING)
lLabelbounds = self.calculateSize()
width = self.size[0]
height = self.size[1]
fullWidth = self.viewer.currentCamera.width
fullHeight = self.viewer.currentCamera.height
# we want the anchor of the image to be at the given position
posxFromLeft = self.position[0] * fullWidth - self.anchor[0] * width
posyFrombottom = (1. - self.position[1]) * fullHeight - (
1. - self.anchor[1]) * height
posxFromLeft = int(floor(posxFromLeft))
posyFrombottom = int(floor(posyFrombottom))
if (self.position[1] == 0.):
posyFrombottom -= 1
#print "posxFromLeft, posyFrombottom", posxFromLeft, posyFrombottom
# used for picking
self.polygonContour = [(posxFromLeft, posyFrombottom),
(posxFromLeft + width, posyFrombottom),
(posxFromLeft + width, posyFrombottom + height),
(posxFromLeft, posyFrombottom + height)]
GL.glTranslatef(float(posxFromLeft), float(posyFrombottom), 0)
self.drawSticker(lLabelbounds)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_LIGHTING)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPopMatrix()
return 1
def drawpolygons(self):
g = self.geom
vertices = g.getVertices()
faces = g.getFaces()
normals = g.getFNormals()
GL.glDisable(GL.GL_CULL_FACE)
for i,f in enumerate(faces):
GL.glBegin(GL.GL_POLYGON)
GL.glNormal3fv(normals[i])
for vi in f:
GL.glVertex3fv(vertices[vi])
GL.glEnd()
i+=1
def drawpolygons(self):
g = self.geom
vertices = g.getVertices()
faces = g.getFaces()
normals = g.getFNormals()
GL.glDisable(GL.GL_CULL_FACE)
for i, f in enumerate(faces):
GL.glBegin(GL.GL_POLYGON)
GL.glNormal3fv(normals[i])
for vi in f:
GL.glVertex3fv(vertices[vi])
GL.glEnd()
i += 1
def redraw(self):
""" redraw the Material editor opengl sphere that shows the effect
of the modifications
"""
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
self.tk.call(self._w, 'makecurrent')
GL.glClearColor(0, 0, 0, 0)
self.initProjection()
self.Configure()
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
""" draw the black background squares """
GL.glDisable(GL.GL_LIGHTING)
GL.glColor3f(0.1, 0.1, 0.1)
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f(-2, 0, 2)
GL.glVertex3f(-2, 2, 2)
GL.glVertex3f(0, 2, 2)
GL.glVertex3f(0, 0, 2)
GL.glEnd()
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f(0, -2, 2)
GL.glVertex3f(0, 0, 2)
GL.glVertex3f(2, 0, 2)
GL.glVertex3f(2, -2, 2)
GL.glEnd()
""" draw the grey background squares """
GL.glColor3f(0.3, 0.3, 0.3)
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f(-2, -2, 2)
GL.glVertex3f(-2, 0, 2)
GL.glVertex3f(0, 0, 2)
GL.glVertex3f(0, -2, 2)
GL.glEnd()
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f(0, 0, 2)
GL.glVertex3f(0, 2, 2)
GL.glVertex3f(2, 2, 2)
GL.glVertex3f(2, 0, 2)
GL.glEnd()
""" enable the sphere transparancy """
GL.glEnable(GL.GL_BLEND)
GL.glDepthMask(GL.GL_FALSE)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
""" draw the sphere """
#GL.glEnable(GL.GL_LIGHTING)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
self.setMaterial()
extractedGlutSolidSphere(1.6, 30, 30, 0)
def Draw(self):
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
Insert2d.Draw(self)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDisable(GL.GL_LIGHTING);
width = self.size[0]
height = self.size[1]
fullWidth = self.viewer.currentCamera.width
fullHeight = self.viewer.currentCamera.height
# we want the anchor of the image to be at the given position
posxFromLeft = self.position[0] * fullWidth - self.anchor[0] * width
posyFrombottom = (1.-self.position[1]) * fullHeight - (1.-self.anchor[1]) * height
#print "posxFromLeft, posyFrombottom", posxFromLeft, posyFrombottom
GL.glColor4fv(self.color)
xo, yo = self.position
dx, dy = self.size
GL.glBegin(GL.GL_QUADS);
GL.glVertex2f(xo, yo)
GL.glVertex2f(xo+dx, yo)
GL.glVertex2f(xo+dx, yo+dy)
GL.glVertex2f(xo, yo+dy)
GL.glEnd()
# used for picking
# self.polygonContour = [ (posxFromLeft, posyFrombottom),
# (posxFromLeft+width, posyFrombottom),
# (posxFromLeft+width, posyFrombottom+height),
# (posxFromLeft, posyFrombottom+height)
# ]
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_LIGHTING);
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPopMatrix()
return 1
def display(self):
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
# select white for all lines
GL.glColor3f(1.0, 1.0, 1.0)
# in 1st row, 3 lines, each with a different stipple
GL.glEnable(GL.GL_LINE_STIPPLE)
GL.glLineStipple(1, 0x0101) # dotted
self.drawOneLine(50.0, 125.0, 150.0, 125.0)
GL.glLineStipple(1, 0x00FF) # dashed
self.drawOneLine(150.0, 125.0, 250.0, 125.0)
GL.glLineStipple(1, 0x1C47) # dash/dot/dash
self.drawOneLine(250.0, 125.0, 350.0, 125.0)
# in 2nd row, 3 wide lines, each with different stipple
GL.glLineWidth(5.0)
GL.glLineStipple(1, 0x0101) # dotted
self.drawOneLine(50.0, 100.0, 150.0, 100.0)
GL.glLineStipple(1, 0x00FF) # dashed
self.drawOneLine(150.0, 100.0, 250.0, 100.0)
GL.glLineStipple(1, 0x1C47) # dash/dot/dash
self.drawOneLine(250.0, 100.0, 350.0, 100.0)
GL.glLineWidth(1.0)
# in 3rd row, 6 lines, with dash/dot/dash stipple
# as part of a single connected line strip
GL.glLineStipple(1, 0x1C47) # dash/dot/dash
GL.glBegin(GL.GL_LINE_STRIP)
try:
for i in range(0, 7):
GL.glVertex2f(50.0 + (i * 50.0), 75.0)
finally:
GL.glEnd()
# in 4th row, 6 independent lines with same stipple */
for i in range(0, 6):
self.drawOneLine(50.0 + (i * 50.0), 50.0, 50.0 + ((i + 1) * 50.0),
50.0)
# in 5th row, 1 line, with dash/dot/dash stipple
# and a stipple repeat factor of 5
GL.glLineStipple(5, 0x1C47) # dash/dot/dash
self.drawOneLine(50.0, 25.0, 350.0, 25.0)
GL.glDisable(GL.GL_LINE_STIPPLE)
GL.glFlush()
def Draw(self):
centers = self.getCoords(self.vertexSet.vertices.array)
if len(centers) == 0:
return
#faces = Numeric.zeros((0,3), 'i')
else:
faces = self.getFaces(len(self.vertexSet.vertices.array))
if self.materials[GL.GL_FRONT] and \
not self.inheritMaterial:
fpProp = self.materials[GL.GL_FRONT].prop[:5]
fpBind = self.materials[GL.GL_FRONT].binding[:5]
else:
fpProp = None
fpBind = None
if self.materials[GL.GL_BACK] and \
not self.inheritMaterial:
bpProp = self.materials[GL.GL_BACK].prop[:5]
bpBind = self.materials[GL.GL_BACK].binding[:5]
else:
bpProp = None
bpBind = None
texCoords = None
if self.lighting:
if (self.invertNormals) and (self.normals is not None):
norms = -self.normals
else:
norms = self.normals
else:
norms = None
#GL.glDisable(GL.GL_DEPTH_TEST)
if self.disableStencil is True:
GL.glDisable(GL.GL_STENCIL_TEST)
status = glDrawIndexedGeom(GL.GL_LINES, centers.astype('f'), faces,
norms, texCoords, fpProp, bpProp, fpBind,
bpBind, self.frontAndBack, 1)
if self.disableStencil is True:
GL.glEnable(GL.GL_STENCIL_TEST)
#GL.glEnable(GL.GL_DEPTH_TEST)
return status
def display(self):
GL.glClear( GL.GL_COLOR_BUFFER_BIT)
# select white for all lines
GL.glColor3f( 1.0, 1.0, 1.0)
# in 1st row, 3 lines, each with a different stipple
GL.glEnable( GL.GL_LINE_STIPPLE)
GL.glLineStipple( 1, 0x0101) # dotted
self.drawOneLine( 50.0, 125.0, 150.0, 125.0)
GL.glLineStipple( 1, 0x00FF) # dashed
self.drawOneLine( 150.0, 125.0, 250.0, 125.0);
GL.glLineStipple( 1, 0x1C47) # dash/dot/dash
self.drawOneLine( 250.0, 125.0, 350.0, 125.0)
# in 2nd row, 3 wide lines, each with different stipple
GL.glLineWidth( 5.0)
GL.glLineStipple( 1, 0x0101) # dotted
self.drawOneLine( 50.0, 100.0, 150.0, 100.0)
GL.glLineStipple( 1, 0x00FF) # dashed
self.drawOneLine( 150.0, 100.0, 250.0, 100.0)
GL.glLineStipple( 1, 0x1C47) # dash/dot/dash
self.drawOneLine( 250.0, 100.0, 350.0, 100.0)
GL.glLineWidth( 1.0)
# in 3rd row, 6 lines, with dash/dot/dash stipple
# as part of a single connected line strip
GL.glLineStipple( 1, 0x1C47) # dash/dot/dash
GL.glBegin( GL.GL_LINE_STRIP)
try:
for i in range( 0, 7):
GL.glVertex2f( 50.0 + (i * 50.0), 75.0)
finally:
GL.glEnd()
# in 4th row, 6 independent lines with same stipple */
for i in range( 0, 6):
self.drawOneLine( 50.0 + (i * 50.0), 50.0, 50.0 + ((i+1) * 50.0), 50.0)
# in 5th row, 1 line, with dash/dot/dash stipple
# and a stipple repeat factor of 5
GL.glLineStipple( 5, 0x1C47) # dash/dot/dash
self.drawOneLine( 50.0, 25.0, 350.0, 25.0)
GL.glDisable( GL.GL_LINE_STIPPLE)
GL.glFlush()
def redraw(self):
""" redraw the Material editor opengl sphere that shows the effect
of the modifications
"""
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
self.tk.call(self._w, 'makecurrent')
GL.glClearColor(0,0,0,0)
self.initProjection()
self.Configure()
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
""" draw the black background squares """
GL.glDisable( GL.GL_LIGHTING )
GL.glColor3f( 0.1, 0.1, 0.1 )
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f(-2, 0, 2); GL.glVertex3f(-2, 2, 2)
GL.glVertex3f( 0, 2, 2); GL.glVertex3f( 0, 0, 2)
GL.glEnd()
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f( 0,-2, 2); GL.glVertex3f( 0, 0, 2)
GL.glVertex3f( 2, 0, 2); GL.glVertex3f( 2,-2, 2)
GL.glEnd()
""" draw the grey background squares """
GL.glColor3f( 0.3, 0.3, 0.3 )
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f(-2,-2, 2); GL.glVertex3f(-2, 0, 2)
GL.glVertex3f( 0, 0, 2); GL.glVertex3f( 0,-2, 2)
GL.glEnd()
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f( 0, 0, 2); GL.glVertex3f( 0, 2, 2)
GL.glVertex3f( 2, 2, 2); GL.glVertex3f( 2, 0, 2)
GL.glEnd()
""" enable the sphere transparancy """
GL.glEnable(GL.GL_BLEND)
GL.glDepthMask(GL.GL_FALSE)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
""" draw the sphere """
#GL.glEnable(GL.GL_LIGHTING)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
self.setMaterial()
extractedGlutSolidSphere(1.6, 30, 30, 0)
def Draw(self):
GL.glEnable(GL.GL_DEPTH_TEST);
GL.glClear( GL.GL_STENCIL_BUFFER_BIT)
GL.glDisable(GL.GL_FOG)
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL)
OpenCSG.render(self.primitives, self.algo, self.depthalgo)
GL.glDepthFunc(GL.GL_EQUAL)
# FIXME should only enable fog if it is on in camera
GL.glEnable(GL.GL_FOG)
self.SetupGL()
for p in self.pyprimitives:
p.render()
GL.glDepthFunc(GL.GL_LESS);
def Draw(self):
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glClear(GL.GL_STENCIL_BUFFER_BIT)
GL.glDisable(GL.GL_FOG)
#GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL)
OpenCSG.render(self.primitives, self.algo, self.depthalgo)
GL.glDepthFunc(GL.GL_EQUAL)
# FIXME should only enable fog if it is on in camera
GL.glEnable(GL.GL_FOG)
self.SetupGL()
for p in self.pyprimitives:
p.render()
GL.glDepthFunc(GL.GL_LESS)
def Draw(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
GL.glEnable(GL.GL_AUTO_NORMAL)
GL.glEnable(GL.GL_NORMALIZE)
if self.theNurb is None:
self.theNurb = GLU.gluNewNurbsRenderer()
GLU.gluNurbsProperty(self.theNurb, GLU.GLU_SAMPLING_TOLERANCE,
25.0)
GLU.gluNurbsProperty(self.theNurb, GLU.GLU_DISPLAY_MODE,
GLU.GLU_OUTLINE_POLYGON)
GLU.gluNurbsCallback(self.theNurb, GLU.GLU_ERROR,
self.nurbsError)
GLU.gluBeginSurface(self.theNurb)
_glulib.gluNurbsSurface(self.theNurb, 8, self.knots, 8, self.knots,
4 * 3, 3, self.ctlpoints, 4, 4,
GL.GL_MAP2_VERTEX_3)
GLU.gluEndSurface(self.theNurb)
GL.glPointSize(5.0)
GL.glDisable(GL.GL_LIGHTING)
GL.glColor3f(1.0, 1.0, 0.0)
GL.glBegin(GL.GL_POINTS)
for i in range(4):
for j in range(4):
GL.glVertex3fv(self.ctlpoints[i][j])
GL.glEnd()
GL.glDisable(GL.GL_AUTO_NORMAL)
GL.glDisable(GL.GL_NORMALIZE)
def redraw(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
self.tk.call(self._w, 'makecurrent')
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDisable(GL.GL_LIGHTING)
#GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL)
GL.glBegin(GL.GL_QUADS)
GL.glColor3f(0., 0., 0.)
GL.glVertex2f(0., 1.)
GL.glVertex2f(0., 0.)
GL.glColor3f(float(self.rgbMax[0]), float(self.rgbMax[1]),
float(self.rgbMax[2]))
GL.glVertex2f(1., 0.)
GL.glVertex2f(1., 1.)
GL.glEnd()
GL.glEnable(GL.GL_COLOR_LOGIC_OP)
GL.glLogicOp(GL.GL_XOR)
GL.glLineWidth(2)
GL.glColor3f(.5, .5, .5)
GL.glBegin(GL.GL_LINES)
x1 = self.v - 0.01
x2 = self.v + 0.01
GL.glVertex2f(float(x1), 1.)
GL.glVertex2f(float(x1), 0.)
GL.glVertex2f(float(x2), 0.)
GL.glVertex2f(float(x2), 1.)
GL.glEnd()
GL.glDisable(GL.GL_COLOR_LOGIC_OP)
def redraw(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
self.tk.call(self._w, 'makecurrent')
GL.glDisable( GL.GL_DEPTH_TEST )
GL.glDisable( GL.GL_LIGHTING )
#GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL)
GL.glBegin(GL.GL_QUADS)
GL.glColor3f(0.,0.,0.)
GL.glVertex2f(0., 1.); GL.glVertex2f(0., 0.)
GL.glColor3f(float(self.rgbMax[0]),float(self.rgbMax[1]),float(self.rgbMax[2]))
GL.glVertex2f( 1., 0.); GL.glVertex2f( 1., 1.)
GL.glEnd()
GL.glEnable(GL.GL_COLOR_LOGIC_OP)
GL.glLogicOp(GL.GL_XOR)
GL.glLineWidth(2)
GL.glColor3f(.5,.5,.5)
GL.glBegin(GL.GL_LINES)
x1 = self.v-0.01
x2 = self.v+0.01
GL.glVertex2f(float(x1), 1.); GL.glVertex2f(float(x1), 0.)
GL.glVertex2f(float(x2), 0.); GL.glVertex2f(float(x2), 1.)
GL.glEnd()
GL.glDisable(GL.GL_COLOR_LOGIC_OP)
def redraw(self, event=None, filter=None):
if self.imarray is None:
return
if filter:
self.master.lift()
GL.glConvolutionFilter2D(GL.GL_CONVOLUTION_2D, GL.GL_LUMINANCE,
3, 3, GL.GL_LUMINANCE, GL.GL_FLOAT,
filter)
## GL.glConvolutionParameterfv(GL.GL_CONVOLUTION_2D,
## GL.GL_CONVOLUTION_FILTER_SCALE,
## (3., 3.,3.,3.))
## s= self.scale
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_RED_SCALE, s)
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_BLUE_SCALE, s)
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_GREEN_SCALE, s)
## s = self.bias
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_RED_BIAS, s)
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_BLUE_BIAS, s)
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_GREEN_BIAS, s)
## GL.GL_CONVOLUTION_FILTER_SCALE,
## (3., 3.,3.,3.))
## GL.glConvolutionParameteriv(GL.GL_CONVOLUTION_2D,
## GL.GL_CONVOLUTION_FILTER_BIAS,
## (1500, 1500, 1500, 1500))
GL.glEnable(GL.GL_CONVOLUTION_2D)
self.tk.call(self._w, 'makecurrent')
GL.glClearColor(0.0, 0.0, 0.0, 0.0)
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glRasterPos2i( 0, 0)
GL.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1)
if self.mode=='RGB':
_gllib.glDrawPixels( self.width, self.height,
GL.GL_RGB, GL.GL_UNSIGNED_BYTE, self.imarray)
elif self.mode in ['L','P']:
_gllib.glDrawPixels( self.width, self.height,
GL.GL_LUMINANCE, GL.GL_UNSIGNED_BYTE,
self.imarray)
GL.glDisable(GL.GL_CONVOLUTION_2D)
def redraw(self, event=None, filter=None):
if self.imarray is None:
return
if filter:
self.master.lift()
GL.glConvolutionFilter2D(GL.GL_CONVOLUTION_2D, GL.GL_LUMINANCE, 3,
3, GL.GL_LUMINANCE, GL.GL_FLOAT, filter)
## GL.glConvolutionParameterfv(GL.GL_CONVOLUTION_2D,
## GL.GL_CONVOLUTION_FILTER_SCALE,
## (3., 3.,3.,3.))
## s= self.scale
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_RED_SCALE, s)
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_BLUE_SCALE, s)
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_GREEN_SCALE, s)
## s = self.bias
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_RED_BIAS, s)
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_BLUE_BIAS, s)
## GL.glPixelTransferf(GL.GL_POST_CONVOLUTION_GREEN_BIAS, s)
## GL.GL_CONVOLUTION_FILTER_SCALE,
## (3., 3.,3.,3.))
## GL.glConvolutionParameteriv(GL.GL_CONVOLUTION_2D,
## GL.GL_CONVOLUTION_FILTER_BIAS,
## (1500, 1500, 1500, 1500))
GL.glEnable(GL.GL_CONVOLUTION_2D)
self.tk.call(self._w, 'makecurrent')
GL.glClearColor(0.0, 0.0, 0.0, 0.0)
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glRasterPos2i(0, 0)
GL.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1)
if self.mode == 'RGB':
_gllib.glDrawPixels(self.width, self.height, GL.GL_RGB,
GL.GL_UNSIGNED_BYTE, self.imarray)
elif self.mode in ['L', 'P']:
_gllib.glDrawPixels(self.width, self.height, GL.GL_LUMINANCE,
GL.GL_UNSIGNED_BYTE, self.imarray)
GL.glDisable(GL.GL_CONVOLUTION_2D)
def apply(self):
"""setup this light for current OpenGL context
"""
#print "Light.apply"
num = self.num
if self.ambient is not None:
GL.glLightfv(num, GL.GL_AMBIENT, self.ambient )
if self.diffuse is not None:
GL.glLightfv(num, GL.GL_DIFFUSE, self.diffuse )
if self.specular is not None:
GL.glLightfv(num, GL.GL_SPECULAR, self.specular )
if self.positional is False:
GL.glLightfv(num, GL.GL_POSITION, self.direction )
else:
GL.glLightfv(num, GL.GL_POSITION, self.position )
if self.spotFlag:
GL.glLightfv(num, GL.GL_SPOT_DIRECTION,
self.spotDirection[:3] )
GL.glLightfv(num, GL.GL_SPOT_EXPONENT, [self.spotExponent] )
GL.glLightfv(num, GL.GL_SPOT_CUTOFF, [self.spotCutoff] )
GL.glLightfv(num, GL.GL_CONSTANT_ATTENUATION,
[self.constantAttenuation] )
GL.glLightfv(num, GL.GL_LINEAR_ATTENUATION,
[self.linearAttenuation] )
GL.glLightfv(num, GL.GL_QUADRATIC_ATTENUATION,
[ self.quadraticAttenuation] )
if self.enabled is True:
GL.glEnable(num)
else:
GL.glDisable(num)
def extrude(self):
"""Extrude a cone with radii specified at each point
of the extrusion"""
assert len(self.radii)==len(self.trace3D)
from gle import glec
gle.gleSetJoinStyle ( self.joinStyle | self.normalStyle )
glec.gleFeedBack()
#DisplayFunction of the old GlePolyCylinder
GL.glColorMaterial (GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT)
GL.glEnable (GL.GL_COLOR_MATERIAL)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
colors = self.materials[GL.GL_FRONT].prop[0][:,:3]
gle.glePolyCone(self.trace3D, colors, self.radii)
GL.glDisable (GL.GL_COLOR_MATERIAL)
glec.gleTextureMode(0)
v,n,s = glec.gleGetTriangleMesh()
return v,n,s
def extrude(self):
"""Virtual Method to do the extrusion along a 3D path with a 2D shape
using the gle extrusion. We then get the geometry information
using the extrusion method in Feedback mode. This will then be
used to build a triangle strip."""
from gle import glec
gle.gleSetJoinStyle ( self.joinStyle | self.normalStyle )
glec.gleFeedBack()
#DisplayFunction of the old GlePolyCylinder
GL.glColorMaterial (GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT)
GL.glEnable (GL.GL_COLOR_MATERIAL)
#glEnable(GL_LIGHTING)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
colors = self.materials[GL.GL_FRONT].prop[0][:,:3]
gle.glePolyCylinder(self.trace3D, colors, self.radius)
GL.glDisable (GL.GL_COLOR_MATERIAL)
glec.gleTextureMode(0)
v,n,s = glec.gleGetTriangleMesh()
return v,n,s
def _WidthAndStipple(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
"""Set the line or points width
"""
#print "_WidthAndStipple", self.stippleLines , self.inheritStippleLines , self
GL.glPointSize(self.getPointWidth())
GL.glLineWidth(self.getLineWidth())
if self.getStippleLines() in (True, 1):
GL.glEnable(GL.GL_LINE_STIPPLE)
ls = self.linestipple
GL.glLineStipple(ls.factor, ls.pattern)
else:
GL.glDisable(GL.GL_LINE_STIPPLE)
if self.getStipplePolygons() in (True, 1):
GL.glEnable(GL.GL_POLYGON_STIPPLE)
ps = self.polygonstipple
GL.glPolygonStipple(self.polygonstipple.pattern)
else:
GL.glDisable(GL.GL_POLYGON_STIPPLE)
def _WidthAndStipple(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
"""Set the line or points width
"""
#print "_WidthAndStipple", self.stippleLines , self.inheritStippleLines , self
GL.glPointSize(self.getPointWidth())
GL.glLineWidth(self.getLineWidth())
if self.getStippleLines() in (True, 1):
GL.glEnable(GL.GL_LINE_STIPPLE)
ls = self.linestipple
GL.glLineStipple(ls.factor, ls.pattern)
else:
GL.glDisable(GL.GL_LINE_STIPPLE)
if self.getStipplePolygons() in (True, 1):
GL.glEnable(GL.GL_POLYGON_STIPPLE)
ps = self.polygonstipple
GL.glPolygonStipple(self.polygonstipple.pattern)
else:
GL.glDisable(GL.GL_POLYGON_STIPPLE)
def Draw(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
GL.glEnable(GL.GL_AUTO_NORMAL)
GL.glEnable(GL.GL_NORMALIZE)
if self.theNurb is None:
self.theNurb = GLU.gluNewNurbsRenderer()
GLU.gluNurbsProperty(self.theNurb, GLU.GLU_SAMPLING_TOLERANCE,
25.0)
GLU.gluNurbsProperty(self.theNurb, GLU.GLU_DISPLAY_MODE,
GLU.GLU_OUTLINE_POLYGON)
GLU.gluNurbsCallback(self.theNurb, GLU.GLU_ERROR, self.nurbsError)
GLU.gluBeginSurface(self.theNurb)
_glulib.gluNurbsSurface( self.theNurb,
8, self.knots,
8, self.knots,
4*3,
3,
self.ctlpoints,
4, 4,
GL.GL_MAP2_VERTEX_3)
GLU.gluEndSurface(self.theNurb)
GL.glPointSize(5.0)
GL.glDisable(GL.GL_LIGHTING)
GL.glColor3f(1.0, 1.0, 0.0)
GL.glBegin(GL.GL_POINTS)
for i in range(4):
for j in range(4):
GL.glVertex3fv(self.ctlpoints[i][j])
GL.glEnd()
GL.glDisable(GL.GL_AUTO_NORMAL)
GL.glDisable(GL.GL_NORMALIZE)
def Draw(self):
c = self.vertexSet.vertices.array
if len(c) == 0: return
GL.glDisable(GL.GL_LIGHTING)
if self.materials[GL.GL_FRONT]:
mat = self.materials[GL.GL_FRONT]
binding = self.materials[GL.GL_FRONT].binding[mat.diff]
else:
binding = viewerConst.OVERALL
if binding == viewerConst.INHERIT:
for i in xrange(c.shape[0]): #loop over lines
GL.glPushName(i)
GL.glBegin(self.primitiveType)
for v in c[i]:
#GL.glVertex3dv(v.tolist())
#gllib.glVertex3dv(v)
gllib.glVertex3fv(v)
GL.glEnd()
GL.glPopName()
elif binding == viewerConst.OVERALL:
if self.materials[GL.GL_FRONT]:
col = mat.prop[mat.diff][0]
GL.glColor4fv(col)
for i in xrange(c.shape[0]): #loop over lines
GL.glPushName(i)
GL.glBegin(self.primitiveType)
for v in c[i]:
#GL.glVertex3dv(v.tolist())
#gllib.glVertex3dv(v)
gllib.glVertex3fv(v)
GL.glEnd()
GL.glPopName()
elif binding == viewerConst.PER_VERTEX:
if self.materials[GL.GL_FRONT]:
col = mat.prop[mat.diff]
vi = 0
for i in xrange(c.shape[0]):
GL.glPushName(i)
GL.glBegin(self.primitiveType)
for v in c[i]:
GL.glColor4fv(col[vi])
vi = vi + 1
#GL.glVertex3dv(v.tolist())
#gllib.glVertex3dv(v)
gllib.glVertex3fv(v)
GL.glEnd()
GL.glPopName()
elif binding == viewerConst.PER_PART: # i.e. line
if self.materials[GL.GL_FRONT]:
col = mat.prop[mat.diff]
for i in xrange(c.shape[0]):
GL.glColor4fv(col[i])
GL.glPushName(i)
GL.glBegin(self.primitiveType)
for v in c[i]:
#GL.glVertex3dv(v.tolist())
#gllib.glVertex3dv(v)
gllib.glVertex3fv(v)
GL.glEnd()
GL.glPopName()
#glEnable(GL_LIGHTING)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
return True
def drawLegendOnly(
fullWidth,
fullHeight,
ramp,
verticalLegend=True,
roomLeftToLegend=0,
roomBelowLegend=50,
legendShortSide=10,
legendLongSide=150,
interpolate=True,
selected=False,
tile=None,
):
if ramp is None or len(ramp) == 0:
return
if tile is not None and selected is True:
selected = False
# deducted values
if verticalLegend is True:
lRoomToLegendCloseLongSide = roomLeftToLegend
lRoomToLegendCloseShortSide = roomBelowLegend
if legendShortSide < 1:
legendShortSide = 1
if legendLongSide < 1:
legendLongSide = 1
else:
lRoomToLegendCloseLongSide = roomBelowLegend
lRoomToLegendCloseShortSide = roomLeftToLegend
if legendShortSide < 1:
legendShortSide = 1
if legendLongSide < 1:
legendLongSide = 1
lRoomToLegendFarLongSide = lRoomToLegendCloseLongSide + legendShortSide
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
if tile is None:
GL.glOrtho(0, float(fullWidth), 0, float(fullHeight), -1, 1)
else:
GL.glOrtho(float(tile[0]), float(tile[1]), float(tile[2]), float(tile[3]), -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable( GL.GL_LIGHTING )
GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL)
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_FALSE)
if len(ramp[0]) == 4: # there are alpha values, draw checkered bg
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
#draw a bunch of quads as background
lCheckerSquareSize = legendShortSide * .5
if lCheckerSquareSize != 0:
nbquads = int(legendLongSide / lCheckerSquareSize)
else:
nbquads = 1
c1 = ( 0.1, 0.1, 0.1 )
c2 = ( 0.3, 0.3, 0.3 )
c = c1
x2 = None
for i in range(nbquads+1):
GL.glColor3fv(c)
if i==nbquads and nbquads != 0:
x1=x2
x2=legendLongSide
else:
x1 = i*lCheckerSquareSize
x2 = min (x1+lCheckerSquareSize, legendLongSide)
GL.glBegin(GL.GL_QUADS)
if verticalLegend is True:
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendCloseLongSide+lCheckerSquareSize),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendCloseLongSide+lCheckerSquareSize),
float(lRoomToLegendCloseShortSide + x2))
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + x2))
else:
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendCloseLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendCloseLongSide+lCheckerSquareSize))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendCloseLongSide+lCheckerSquareSize))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendCloseLongSide))
GL.glEnd()
if c==c1:
c=c2
else:
c=c1
GL.glColor3fv(c)
GL.glBegin(GL.GL_QUADS)
if verticalLegend is True:
GL.glVertex2f(float(lRoomToLegendCloseLongSide+lCheckerSquareSize),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + x2))
GL.glVertex2f(float(lRoomToLegendCloseLongSide+lCheckerSquareSize),
float(lRoomToLegendCloseShortSide + x2))
else:
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendCloseLongSide+lCheckerSquareSize))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendCloseLongSide+lCheckerSquareSize))
GL.glEnd()
#interp = False
if interpolate and (len(ramp) > 1): # we interpolate colors
# draw a quad strip for the color map
lDelta = legendLongSide/float(len(ramp)-1)
GL.glBegin(GL.GL_QUAD_STRIP)
for i in range(len(ramp)):
if selected is True:
c = deepcopy(ramp[i])
for j in range(3):
c[j] = .35 + c[j]*.3
else:
c = ramp[i]
if len(c)==3:
GL.glColor3fv(c)
elif len(c)==4:
GL.glColor4fv(c)
lStep = i*lDelta
if verticalLegend is True:
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + lStep))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + lStep))
else:
GL.glVertex2f(float(lRoomToLegendCloseShortSide + lStep),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + lStep),
float(lRoomToLegendCloseLongSide))
GL.glEnd()
else:
# we draw a quad for each color
lDelta = legendLongSide/float(len(ramp))
for i in range(len(ramp)):
if selected is True:
c = deepcopy(ramp[i])
for j in range(3):
c[j] = .35 + c[j]*.3
else:
c = ramp[i]
if len(c)==3:
GL.glColor3fv(c)
elif len(c)==4:
GL.glColor4fv(c)
x1 = i*lDelta
x2 = x1+lDelta
GL.glBegin(GL.GL_QUADS)
if verticalLegend is True:
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + x2))
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + x2))
else:
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendCloseLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendCloseLongSide))
GL.glEnd()
if len(ramp[0])==4:
GL.glDisable(GL.GL_BLEND)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_TRUE)
# GL.glEnable(GL.GL_LIGHTING)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
def drawLegendLabelName(
fullWidth,
fullHeight,
ramp,
mini,
maxi,
name='',
unit='',
labelValues=[],
verticalLegend=True,
leftOrBelowLabels=False,
roomLeftToLegend=0,
roomBelowLegend=50,
legendShortSide=10,
legendLongSide=150,
significantDigits=3,
backgroundColor=(0,0,0,.8),
labelColor=(1,1,1),
interpolate=True,
frame=True,
selected=False,
numOfLabels=None,
resizeSpotRadius=5,
fontScale=8,
glfFontID=0,
tile=None,
):
if ramp is None or len(ramp) == 0:
return
if tile is not None and selected is True:
selected = False
# some glf font initialisation
glf.glfSetCurrentFont(glfFontID)
glf.glfStringCentering(GL.GL_FALSE)
glf.glfStringDirection(glf.GLF_LEFT)
# calculate name and unit size
lNameMinAndMax = glf.glfGetStringBounds(name)
lNameMinAndMax = ( lNameMinAndMax[0]*fontScale,
lNameMinAndMax[1]*fontScale,
lNameMinAndMax[2]*fontScale,
lNameMinAndMax[3]*fontScale )
lNameWidth = lNameMinAndMax[2]-lNameMinAndMax[0]
lNameHeight = lNameMinAndMax[3]-lNameMinAndMax[1]
if lNameWidth == 0:
lNameWidth = fontScale
if unit is not None and (len(unit) > 0):
lUnitMinAndMax = glf.glfGetStringBounds(unit)
lUnitMinAndMax = ( lUnitMinAndMax[0]*fontScale,
lUnitMinAndMax[1]*fontScale,
lUnitMinAndMax[2]*fontScale,
lUnitMinAndMax[3]*fontScale )
lUnitWidth = lUnitMinAndMax[2]-lUnitMinAndMax[0]
lUnitHeight = lUnitMinAndMax[3]-lUnitMinAndMax[1]
else:
lUnitWidth = fontScale
lUnitHeight = 0
lMaxNameUnitHeight = max(lNameHeight, lUnitHeight)
lMaxNameUnitWidth = max(lNameWidth, lUnitWidth)
# deducted values
fontScaleHalf = fontScale/2
if verticalLegend is True:
lRoomToLegendCloseLongSide = roomLeftToLegend
lRoomToLegendCloseShortSide = roomBelowLegend
if legendShortSide < 1:
legendShortSide = 1
if legendLongSide < 1:
legendLongSide = 1
else:
lRoomToLegendCloseLongSide = roomBelowLegend
lRoomToLegendCloseShortSide = roomLeftToLegend
if legendShortSide < lMaxNameUnitHeight + fontScaleHalf:
legendShortSide = lMaxNameUnitHeight + fontScaleHalf
if legendLongSide < 1:
legendLongSide = 1
lRoomToLegendFarLongSide = lRoomToLegendCloseLongSide + legendShortSide
lRoomToLegendFarShortSide = lRoomToLegendCloseShortSide + legendLongSide
# prepare the legend labels
if len(labelValues) > 0:
lOnScreenLabelValues = labelValues
else:
if numOfLabels == None or numOfLabels < 0:
if verticalLegend is True:
numOfLabels = 6
else:
numOfLabels = 4
if ( numOfLabels == 0 ) or maxi is None or mini is None:
lOnScreenLabelValues = []
elif numOfLabels == 1:
lOnScreenLabelValues = [(mini+maxi)*0.5]
else:
delta = (maxi - mini) / float(numOfLabels-1)
lOnScreenLabelValues = []
for i in range(numOfLabels):
lOnScreenLabelValues.append(mini+i*delta)
lMaxLabelDigits = 0
for v in lOnScreenLabelValues:
lLabel = "%.*g" % (significantDigits,v)
if lMaxLabelDigits < len(lLabel):
lMaxLabelDigits = len(lLabel)
# calculate labels size
lLabelsMinAndMax = []
lLabelsWidth = []
lLabelsHeight = []
lMaxLabelsWidth = 0
lMaxLabelsHeight = 0
for v in lOnScreenLabelValues:
lLabel = "%.*g" % (significantDigits,v)
lLabelsMinAndMax.append( glf.glfGetStringBounds(lLabel) )
lLabelsMinAndMax[-1] = ( lLabelsMinAndMax[-1][0]*fontScale,
lLabelsMinAndMax[-1][1]*fontScale,
lLabelsMinAndMax[-1][2]*fontScale,
lLabelsMinAndMax[-1][3]*fontScale )
lLabelsWidth.append( lLabelsMinAndMax[-1][2]-lLabelsMinAndMax[-1][0] )
lLabelsHeight.append( lLabelsMinAndMax[-1][3]-lLabelsMinAndMax[-1][1] )
if lLabelsWidth[-1] > lMaxLabelsWidth:
lMaxLabelsWidth = lLabelsWidth[-1]
if lLabelsHeight[-1] > lMaxLabelsHeight:
lMaxLabelsHeight = lLabelsHeight[-1]
# calculate frame size
lMaxWidth = max(lMaxLabelsWidth + legendShortSide, lMaxNameUnitWidth)
lMaxNameUnitHeightHalf = lMaxNameUnitHeight/2
legendShortSideHalf = legendShortSide/2
if verticalLegend is True:
if leftOrBelowLabels is False:
lPt1 = (lRoomToLegendCloseLongSide,
-fontScale+lRoomToLegendCloseShortSide-lMaxLabelsHeight-lNameHeight,0)
lPt2 = (fontScale+lRoomToLegendCloseLongSide+lMaxWidth,
-fontScale+lRoomToLegendCloseShortSide-lMaxLabelsHeight-lNameHeight,0)
lPt3 = (fontScale+lRoomToLegendCloseLongSide+lMaxWidth,
fontScale+lRoomToLegendFarShortSide+lMaxLabelsHeight+lUnitHeight,0)
lPt4 = (lRoomToLegendCloseLongSide,
fontScale+lRoomToLegendFarShortSide+lMaxLabelsHeight+lUnitHeight,0)
else:
lPt1 = (-fontScale+lRoomToLegendFarLongSide-lMaxWidth,
-fontScale+lRoomToLegendCloseShortSide-lMaxLabelsHeight-lNameHeight,0)
lPt2 = (lRoomToLegendCloseLongSide+legendShortSide,
-fontScale+lRoomToLegendCloseShortSide-lMaxLabelsHeight-lNameHeight,0)
lPt3 = (lRoomToLegendCloseLongSide+legendShortSide,
fontScale+lRoomToLegendFarShortSide+lMaxLabelsHeight+lUnitHeight,0)
lPt4 = (-fontScale+lRoomToLegendFarLongSide-lMaxWidth,
fontScale+lRoomToLegendFarShortSide+lMaxLabelsHeight+lUnitHeight,0)
else:
if leftOrBelowLabels is False:
lPt1 = (-fontScale+lRoomToLegendCloseShortSide-lNameWidth,
lRoomToLegendCloseLongSide,0)
lPt2 = (fontScale+lRoomToLegendFarShortSide+lUnitWidth,
lRoomToLegendCloseLongSide,0)
lPt3 = (fontScale+lRoomToLegendFarShortSide+lUnitWidth,
fontScale+lRoomToLegendCloseLongSide \
+ legendShortSide \
+ lMaxLabelsHeight,
0)
lPt4 = (-fontScale+lRoomToLegendCloseShortSide-lNameWidth,
fontScale+lRoomToLegendCloseLongSide \
+ legendShortSide \
+ lMaxLabelsHeight,
0)
else:
lPt1 = (-fontScale+lRoomToLegendCloseShortSide-lNameWidth,
-fontScale+lRoomToLegendCloseLongSide-lMaxLabelsHeight,
0)
lPt2 = (fontScale+lRoomToLegendFarShortSide+lUnitWidth,
-fontScale+lRoomToLegendCloseLongSide-lMaxLabelsHeight,
0)
lPt3 = (fontScale+lRoomToLegendFarShortSide+lUnitWidth,
lRoomToLegendFarLongSide,0)
lPt4 = (-fontScale+lRoomToLegendCloseShortSide-lNameWidth,
lRoomToLegendFarLongSide,0)
if selected is True:
labelColor2 = (.5, .5, .5)
else:
labelColor2 = labelColor
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
if tile is None:
GL.glOrtho(0, float(fullWidth), 0, float(fullHeight), -1, 1)
else:
GL.glOrtho(float(tile[0]), float(tile[1]), float(tile[2]), float(tile[3]), -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable( GL.GL_LIGHTING )
GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL )
if len(backgroundColor) == 4:
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
#because of an unexplained bug on michel's laptop,
#we don't draw the background when there is no frame
#(so michel has a way to manage the legend)
if frame is True:
#draw transparent background
GL.glDepthMask(GL.GL_FALSE)
if len(backgroundColor) == 3:
GL.glColor3fv(backgroundColor)
else:
GL.glColor4fv(backgroundColor)
GL.glBegin(GL.GL_QUADS)
GL.glVertex3fv(lPt1)
GL.glVertex3fv(lPt2)
GL.glVertex3fv(lPt3)
GL.glVertex3fv(lPt4)
GL.glEnd()
GL.glDepthMask(GL.GL_TRUE)
#draw frame
if frame is True:
GL.glPolygonMode(GL.GL_FRONT, GL.GL_LINE )
GL.glLineWidth(1)
GL.glColor3fv(labelColor2)
GL.glBegin(GL.GL_QUADS)
GL.glVertex3fv(lPt1)
GL.glVertex3fv(lPt2)
GL.glVertex3fv(lPt3)
GL.glVertex3fv(lPt4)
GL.glEnd()
GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL)
if mini is not None and maxi is not None and maxi > mini:
lUnitStep = legendLongSide/float(maxi-mini)
else:
lUnitStep = legendLongSide
GL.glDisable( GL.GL_LIGHTING )
if verticalLegend is True:
if leftOrBelowLabels is True:
lRoomLeftToLabel = -fontScaleHalf + lRoomToLegendCloseLongSide
lRoomLeftToName = -fontScaleHalf + lRoomToLegendFarLongSide - lNameWidth
lRoomLeftToUnit = -fontScaleHalf + lRoomToLegendFarLongSide - lUnitWidth
lRoomBelowName = -fontScaleHalf + roomBelowLegend - lMaxLabelsHeight - lNameHeight
lRoomBelowUnit = fontScaleHalf + roomBelowLegend + legendLongSide + lMaxLabelsHeight
else:
lRoomLeftToLabel = fontScaleHalf + lRoomToLegendFarLongSide
lRoomLeftToName = fontScaleHalf + lRoomToLegendCloseLongSide
lRoomLeftToUnit = lRoomLeftToName
lRoomBelowName = -fontScaleHalf + roomBelowLegend - lMaxLabelsHeight - lNameHeight
lRoomBelowUnit = fontScaleHalf + roomBelowLegend + legendLongSide + lMaxLabelsHeight
else:
if leftOrBelowLabels is True:
lRoomBelowLabel = -fontScaleHalf + lRoomToLegendFarLongSide \
- legendShortSide - lMaxLabelsHeight
lRoomBelowName = lRoomToLegendCloseLongSide + legendShortSideHalf \
- lMaxNameUnitHeightHalf
else:
lRoomBelowLabel = fontScaleHalf + lRoomToLegendCloseLongSide \
+ legendShortSide
lRoomBelowName = lRoomToLegendCloseLongSide + legendShortSideHalf \
- lMaxNameUnitHeightHalf
lRoomBelowUnit = lRoomBelowName
lRoomLeftToName = -fontScaleHalf + lRoomToLegendCloseShortSide - lNameWidth
lRoomLeftToUnit = fontScaleHalf + lRoomToLegendFarShortSide
# set the color of the text
GL.glColor3fv(labelColor2)
# print the legend name
GL.glPushMatrix()
GL.glTranslatef(
float(lRoomLeftToName+fontScale),
float(lRoomBelowName-lNameMinAndMax[1]),
0)
GL.glScalef(float(fontScale), float(fontScale), 0);
glf.glfDrawSolidString(name)
GL.glPopMatrix()
if unit is not None and (len(unit) > 0):
GL.glPushMatrix()
GL.glTranslatef(
float(lRoomLeftToUnit+fontScale),
float(lRoomBelowUnit-lUnitMinAndMax[1]),
0)
GL.glScalef(float(fontScale), float(fontScale), 1);
glf.glfDrawSolidString(unit)
GL.glPopMatrix()
if mini is not None and maxi is not None:
i = 0
for v in lOnScreenLabelValues:
#calculate label position
lLabel = "%.*g" % (significantDigits,v)
lStep = (v - mini) * lUnitStep
GL.glPushMatrix()
if verticalLegend:
if leftOrBelowLabels:
GL.glTranslatef(
float(lRoomLeftToLabel+fontScale-lLabelsWidth[i]),
float(roomBelowLegend-(lLabelsHeight[i]/2+lLabelsMinAndMax[i][1])+lStep),
0)
else:
GL.glTranslatef(
float(lRoomLeftToLabel+fontScale),
float(roomBelowLegend-(lLabelsHeight[i]/2+lLabelsMinAndMax[i][1])+lStep),
0)
else:
GL.glTranslatef(
float(roomLeftToLegend-(lLabelsWidth[i]/2)+fontScale+lStep),
float(lRoomBelowLabel-lLabelsMinAndMax[i][1]),
0)
GL.glScalef(float(fontScale), float(fontScale), 1);
glf.glfDrawSolidString("%s" % lLabel)
GL.glPopMatrix()
i += 1
if len(backgroundColor) == 4:
GL.glDisable(GL.GL_BLEND)
# GL.glEnable(GL.GL_LIGHTING)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
drawLegendOnly(
fullWidth=fullWidth,
fullHeight=fullHeight,
ramp=ramp,
verticalLegend=verticalLegend,
roomLeftToLegend=roomLeftToLegend,
roomBelowLegend=roomBelowLegend,
legendShortSide=legendShortSide,
legendLongSide=legendLongSide,
interpolate=interpolate,
selected=selected,
tile=tile,
)
if selected is True:
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glOrtho(0, float(fullWidth), 0, float(fullHeight), -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable( GL.GL_LIGHTING )
GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL )
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_FALSE)
GL.glDisable(GL.GL_LIGHTING)
resizeSpot = []
if verticalLegend:
resizeSpot= [ roomLeftToLegend + legendShortSide,
roomBelowLegend + legendLongSide ]
else:
resizeSpot = [ roomLeftToLegend + legendLongSide,
roomBelowLegend + legendShortSide ]
GL.glColor3fv(labelColor)
GL.glBegin(GL.GL_QUADS)
GL.glVertex2f(float(resizeSpot[0]+resizeSpotRadius),float(resizeSpot[1]-resizeSpotRadius))
GL.glVertex2f(float(resizeSpot[0]+resizeSpotRadius),float(resizeSpot[1]+resizeSpotRadius))
GL.glVertex2f(float(resizeSpot[0]-resizeSpotRadius),float(resizeSpot[1]+resizeSpotRadius))
GL.glVertex2f(float(resizeSpot[0]-resizeSpotRadius),float(resizeSpot[1]-resizeSpotRadius))
GL.glEnd()
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_TRUE)
# GL.glEnable(GL.GL_LIGHTING)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
else:
resizeSpot = None
return [(lPt1[0], lPt1[1]),
(lPt2[0], lPt2[1]),
(lPt3[0], lPt3[1]),
(lPt4[0], lPt4[1]) ] , resizeSpot , verticalLegend
def Set(self, **kw):
""" set light values. For direction, position, and spot direction,
vals are given in absolute coordinates (independent of camera or
object). For these three values, the flag is set to 1 when they are
changed.
"""
#print "Light.Set"
self.hasBeenCurrent = True # remember the light has been changed
tagModified = True
val = getkw(kw, 'tagModified')
if val is not None:
tagModified = val
assert tagModified in [True, False]
self._modified = tagModified
self.viewer.currentCamera.Activate()
val = getkw(kw, 'ambient')
if not val is None:
#self.ambient = OneColor( val )
#GL.glLightfv(self.num, GL.GL_AMBIENT, self.ambient )
if len(val)==3 or len(val)==4:
self.ambient = OneColor( val )
GL.glLightModelfv(GL.GL_LIGHT_MODEL_AMBIENT, self.ambient)
GL.glLightfv(self.num, GL.GL_AMBIENT, self.ambient) # needed for mesa
else:
raise ValueError('length of new color must be 3 or 4')
val = getkw(kw, 'diffuse')
if not val is None:
self.diffuse = OneColor( val )
GL.glLightfv(self.num, GL.GL_DIFFUSE, self.diffuse )
val = getkw(kw, 'specular')
if not val is None:
self.specular = OneColor( val )
GL.glLightfv(self.num, GL.GL_SPECULAR, self.specular )
val = getkw(kw, 'direction')
if not val is None:
val = list(val)
if len(val)==3: val += [0.]
assert len(val)==4
self.direction = val
self.direction[3] = 0.0
self.dirFlag = 1 # tell the camera to redraw this light
self.positional = False
val = getkw(kw, 'position')
if not val is None:
val = list(val)
if len(val)==3: val += [1.]
assert len(val)==4
self.position = val
self.position[3] = 1.0
self.posFlag = 1 # tell the camera to redraw this light
self.positional = True
val = getkw(kw, 'spotDirection')
if not val is None:
val = list(val)
if len(val)==3: val += [0.]
assert len(val)==4
self.spotDirection = val
self.spotDirection[3] = 0.0
self.spotFlag = 1 # tell the camera to redraw this light
val = getkw(kw, 'spotExponent')
if not val is None:
self.spotExponent = float(val)
GL.glLightfv(self.num, GL.GL_SPOT_EXPONENT, [self.spotExponent])
val = getkw(kw, 'spotCutoff')
if not val is None:
if val > 180.:
raise ValueError("spotCutoff must be in [0., 90.] or 180.")
self.spotCutoff = float( val )
GL.glLightfv(self.num, GL.GL_SPOT_CUTOFF, [self.spotCutoff] )
val = getkw(kw, 'constantAttenuation')
if not val is None:
self.constantAttenuation = float( val )
if self.constantAttenuation < 0.0:
raise ValueError("constantAttenuation must be >= 0.0")
GL.glLightfv(self.num, GL.GL_CONSTANT_ATTENUATION,
[self.constantAttenuation] )
val = getkw(kw, 'linearAttenuation')
if not val is None:
self.linearAttenuation = float( val )
if self.linearAttenuation < 0.0:
raise ValueError("linearAttenuation must be >= 0.0")
GL.glLightfv(self.num, GL.GL_LINEAR_ATTENUATION,
[self.linearAttenuation] )
val = getkw(kw, 'quadraticAttenuation')
if not val is None:
self.quadraticAttenuation = float( val )
if self.quadraticAttenuation < 0.0:
raise ValueError("quadraticAttenuation must be >= 0.0")
GL.glLightfv(self.num, GL.GL_QUADRATIC_ATTENUATION,
[self.quadraticAttenuation] )
val = getkw(kw, 'positional')
if not val is None:
if val is True: self.position[3] = 1.0
elif val is False: self.position[3] = 0.0
else: raise AttributeError('positional can only be True or False')
self.positional = val
val = getkw(kw, 'enabled')
if not val is None:
if val in (True, 1): GL.glEnable(self.num)
elif val in (False, 0): GL.glDisable(self.num)
else: raise AttributeError('enabled can only be True or False')
self.enabled = val
val = getkw(kw, 'visible')
if not val is None:
if val in (True, False): self.visible = val
else: raise AttributeError('visible can only be True or False')
val = getkw(kw, 'lineWidth')
if not val is None:
if val >= 1:
self.lineWidth = int(val)
else: raise AttributeError('lineWidth has to be >= 1')
val = getkw(kw, 'length')
if not val is None:
if val > 0.0: self.length = float ( val )
else: raise AttributeError('length has to be > 0.0')
# val = getkw(kw, 'antialiased')
# if not val is None:
# if val in (True, False):
# self.antialiased = val
# else: raise ValueError ('antialiased can only be True or False')
val = getkw(kw, 'rotation')
if not val is None:
mat = Numeric.reshape(Numeric.array(val), (16,)).astype('f')
self.rotation = mat
val = getkw(kw, 'translation')
if not val is None:
mat = Numeric.reshape(Numeric.array(val), (3,)).astype('f')
self.translation = mat
val = getkw(kw, 'scale')
if not val is None:
mat = Numeric.reshape(Numeric.array(val), (3,)).astype('f')
self.scale = mat
val = getkw(kw, 'pivot')
if not val is None:
mat = Numeric.reshape(Numeric.array(val), (3,)).astype('f')
self.pivot = mat
if len(kw):
print 'WARNING9: Keyword(s) %s not used' % kw.keys()
#guillaume vareille 9/29/2005 :
# was c = self.viewer.cameras[0]
# was generating alternativly good and wrong rendering when 2 cameras
c = self.viewer.currentCamera
# force light to be update in viewer
c.Redraw()
# brodcast to other application that want to know about that light
# using aftere does not seem to make it better
#c.after_idle(self.broadcast)
self.broadcast()
def drawVertexArray(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
""" drawVertexArray
"""
#print "drawVertexArray", self.name
if hasattr(self, 'faceSet') and len(self.faceSet.faces.array) > 0:
# vertices
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
# normals
if len(self.vertexSet.normals.array) > 0:
GL.glEnableClientState(GL.GL_NORMAL_ARRAY)
# colors
if hasattr(self, 'colorPointerIsOn') and self.colorPointerIsOn is True:
GL.glEnableClientState(GL.GL_COLOR_ARRAY)
from DejaVu import preventIntelBug_WhiteTriangles
if preventIntelBug_WhiteTriangles:
GL.glColorMaterial(GL.GL_FRONT_AND_BACK, GL.GL_DIFFUSE)
else:
GL.glColorMaterial(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE)
GL.glEnable( GL.GL_COLOR_MATERIAL )
if DejaVu.enableVBO is True:
from opengltk.extent import _glextlib
# vertices
_glextlib.glBindBufferARB(_glextlib.GL_ARRAY_BUFFER_ARB,
int(self.vertexArrayFlagBufferList[0]))
_gllib.glVertexPointer(len(self.vertexSet.vertices.array[0]),
GL.GL_FLOAT, 0, 0)
# normals
if len(self.vertexSet.normals.array) > 0:
_glextlib.glBindBufferARB(_glextlib.GL_ARRAY_BUFFER_ARB,
int(self.vertexArrayFlagBufferList[1]))
_gllib.glNormalPointer(GL.GL_FLOAT, 0, 0)
# colors
if hasattr(self, 'colorPointerIsOn') and self.colorPointerIsOn is True:
_glextlib.glBindBufferARB(_glextlib.GL_ARRAY_BUFFER_ARB,
int(self.vertexArrayFlagBufferList[3]))
_gllib.glColorPointer(4, GL.GL_FLOAT, 0, 0)
else:
# vertices
_gllib.glVertexPointer(len(self.vertexSet.vertices.array[0]),
GL.GL_FLOAT, 0, self.vertexSet.vertices.array)
# normals
if len(self.vertexSet.normals.array) > 0:
_gllib.glNormalPointer(GL.GL_FLOAT, 0, self.vertexSet.normals.array)
# colors
if hasattr(self, 'colorPointerIsOn') and self.colorPointerIsOn is True:
_gllib.glColorPointer(4, GL.GL_FLOAT, 0, self.colorArray)
# Draw faces
if self.primitiveType == GL.GL_LINE_STRIP:
lPrimitiveType = GL.GL_LINES
elif self.primitiveType == GL.GL_TRIANGLES:
#print "triangles' length:", len(self.faceSet.faces.array[0])
lPrimitiveType = GL.GL_TRIANGLES
elif self.primitiveType == GL.GL_QUADS:
#print "quads' length:", len(self.faceSet.faces.array[0])
lPrimitiveType = GL.GL_QUADS
else:
#print "what's that ?" , self.primitiveType
lPrimitiveType = self.primitiveType
lNumOfNonHighlightedIndices = len(self.faceSet.faces.array) - self.numOfHighlightedIndex
if DejaVu.enableVBO is True:
_glextlib.glBindBufferARB(_glextlib.GL_ELEMENT_ARRAY_BUFFER,
int(self.vertexArrayFlagBufferList[2])) #this protect from unexplained segfault
if self.disableStencil is False and self.numOfHighlightedIndex > 0:
# highlighted
GL.glStencilFunc(GL.GL_ALWAYS, 1, 1)
_gllib.glDrawElements(lPrimitiveType,
self.numOfHighlightedIndex*len(self.faceSet.faces.array[0]),
GL.GL_UNSIGNED_INT,
0
)
GL.glStencilFunc(GL.GL_ALWAYS, 0, 1)
# non highlighted
_gllib.glDrawElements(lPrimitiveType,
lNumOfNonHighlightedIndices * len(self.faceSet.faces.array[0]),
GL.GL_UNSIGNED_INT,
self.numOfHighlightedIndex * len(self.faceSet.faces.array[0]) * 4
)
else:
_gllib.glDrawElements(lPrimitiveType,
len(self.faceSet.faces.array)*len(self.faceSet.faces.array[0]),
GL.GL_UNSIGNED_INT,
0
)
_glextlib.glBindBufferARB(_glextlib.GL_ELEMENT_ARRAY_BUFFER, 0 ) #this protect from unexplained segfault
else:
if self.disableStencil is False and self.numOfHighlightedIndex > 0:
# highlighted
GL.glStencilFunc(GL.GL_ALWAYS, 1, 1)
_gllib.glDrawElements(lPrimitiveType,
self.numOfHighlightedIndex*len(self.faceSet.faces.array[0]),
GL.GL_UNSIGNED_INT,
self.faceSet.faces.array
)
GL.glStencilFunc(GL.GL_ALWAYS, 0, 1)
# non highlighted
_gllib.glDrawElements(lPrimitiveType,
lNumOfNonHighlightedIndices * len(self.faceSet.faces.array[0]),
GL.GL_UNSIGNED_INT,
self.faceSet.faces.array[self.numOfHighlightedIndex: ]
)
else:
_gllib.glDrawElements(lPrimitiveType,
len(self.faceSet.faces.array)*len(self.faceSet.faces.array[0]),
GL.GL_UNSIGNED_INT,
self.faceSet.faces.array
)
if hasattr(self, 'colorPointerIsOn') and self.colorPointerIsOn is True:
GL.glDisable( GL.GL_COLOR_MATERIAL )
GL.glDisableClientState(GL.GL_COLOR_ARRAY)
if len(self.vertexSet.normals.array) > 0:
GL.glDisableClientState(GL.GL_NORMAL_ARRAY)
GL.glDisableClientState(GL.GL_VERTEX_ARRAY)
return 1
def DisplayFunction(self):
"""Draw a square with diagonals to represent the clipping plane
"""
#print "ClippingPlane.DisplayFunction"
#trans = self.eqn[3]*(self.eqn[:3]*self.n)
resetMaterialMemory()
trans = self.translation
GL.glPushMatrix()
#GL.glTranslatef(-trans[0],-trans[1],-trans[2])
GL.glTranslatef(float(trans[0]),
float(trans[1]),
float(trans[2]))
GL.glMultMatrixf(self.rotation)
GL.glScalef(float(self.scale[0]),
float(self.scale[1]),
float(self.scale[2]))
if self.polyMode == GL.GL_QUADS:
GL.glPushAttrib(GL.GL_CURRENT_BIT | GL.GL_LIGHTING_BIT |
GL.GL_POLYGON_BIT)
GL.glDisable(GL.GL_LIGHTING)
GL.glMaterialWithCheck(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT,
self.color)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL)
GL.glPushMatrix()
GL.glMultMatrixf(self.planeRot)
GL.glBegin (GL.GL_QUADS)
GL.glVertex3f (0.0, -5.0, -5.0)
GL.glVertex3f (0.0, -5.0, 5.0)
GL.glVertex3f (0.0, 5.0, 5.0)
GL.glVertex3f (0.0, 5.0, -5.0)
GL.glVertex3f (0.0, -5.0, -5.0)
GL.glEnd ()
GL.glPopMatrix()
GL.glPopAttrib()
else:
# MS disabling GL.GL_BLEND breaks display of transparent surfaces
## if self.antialiased==True:
## GL.glEnable(GL.GL_LINE_SMOOTH)
## GL.glEnable(GL.GL_BLEND)
## else:
## GL.glDisable(GL.GL_LINE_SMOOTH)
## GL.glDisable(GL.GL_BLEND)
GL.glColor4fv (self.color)
GL.glLineWidth(self.lineWidth)
GL.glPushMatrix()
GL.glMultMatrixf(self.planeRot)
# could and should be a display list made once for all planes
GL.glBegin (GL.GL_LINE_STRIP)
GL.glVertex3f (0.0, -5.0, -5.0)
GL.glVertex3f (0.0, -5.0, 5.0)
GL.glVertex3f (0.0, 5.0, 5.0)
GL.glVertex3f (0.0, 5.0, -5.0)
GL.glVertex3f (0.0, -5.0, -5.0)
GL.glVertex3f (0.0, 5.0, 5.0)
GL.glVertex3f (0.0, -5.0, 5.0)
GL.glVertex3f (0.0, 5.0, -5.0)
GL.glEnd ()
GL.glPopMatrix()
GL.glPopMatrix()
def DisplayFunction(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
"""display a set of indexed geometric primitives"""
if self.dpyList:
# print "DisplayFunction", self.dpyList, self.fullName
lDrawOutline = (self.getDrawOutlineMode('front'), self.getDrawOutlineMode('back'))
if (lDrawOutline[0] or lDrawOutline[1]) and self.viewer.hasOffsetExt:
outl = self.outline
if self.GetPolyMode('front') == GL.GL_FILL \
or self.GetPolyMode('back') == GL.GL_FILL:
mode = GL.GL_POLYGON_OFFSET_FILL
GL.glEnable(mode)
self.viewer.polyOffset( outl.factor, outl.unit)
Geom.DisplayFunction(self)
GL.glDisable(mode)
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE)
if not outl.colorAsMaterial:
if outl.lighting:
GL.glMaterialfv( GL.GL_FRONT_AND_BACK,
GL.GL_EMISSION,
outl.color )
else:
GL.glDisable(GL.GL_LIGHTING)
GL.glColor4fv (outl.color)
GL.glLineWidth(outl.lineWidth)
if lDrawOutline[0] is False or lDrawOutline[1] is False:
GL.glEnable(GL.GL_CULL_FACE)
if lDrawOutline[0]:
GL.glCullFace(GL.GL_BACK)
elif lDrawOutline[1]:
GL.glCullFace(GL.GL_FRONT)
else:
GL.glDisable(GL.GL_CULL_FACE)
if outl.dpyList:
currentcontext = self.viewer.currentCamera.tk.call(self.viewer.currentCamera._w, 'contexttag')
if currentcontext != outl.dpyList[1]:
warnings.warn("""DisplayFunction failed because the current context is the wrong one""")
#print "currentcontext != outl.dpyList[1]", currentcontext, outl.dpyList[1]
else:
#print '#%d'%outl.dpyList[0], currentcontext, "glCallList IndexedGeom"
GL.glCallList(outl.dpyList[0])
GL.glEnable(GL.GL_CULL_FACE)
GL.glEnable(GL.GL_LIGHTING)
else:
Geom.DisplayFunction(self)
else:
Geom.DisplayFunction(self)
def Draw(self):
if __debug__:
if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
""" draw geom
"""
#print "IndexedGeom.Draw", self.name
if self.vertexArrayFlag is True \
and DejaVu.enableVertexArray is True:
if not (hasattr(self.vertexSet, "texCoords") \
and self.vertexSet.texCoords.status >= viewerConst.COMPUTED):
return self.drawVertexArray()
if len(self.faceSet) and len(self.vertexSet):
if self.materials[GL.GL_FRONT] and \
not self.inheritMaterial:
mat = self.materials[GL.GL_FRONT]
fpProp = []
fpBind = []
for propInd in range(4):
b, p = mat.GetProperty(propInd)
fpProp.append(p)
fpBind.append(b)
fpProp.append(mat.prop[4])
fpBind.append(mat.binding[4])
else:
fpProp = None
fpBind = None
if self.materials[GL.GL_BACK] and \
not self.inheritMaterial:
mat = self.materials[GL.GL_BACK]
bpProp = []
bpBind = []
for propInd in range(4):
b, p = mat.GetProperty(propInd)
bpProp.append(p)
bpBind.append(b)
bpProp.append(mat.prop[4])
bpBind.append(mat.binding[4])
else:
bpProp = None
bpBind = None
texCoords = None
if hasattr(self.vertexSet, "texCoords"):
if self.vertexSet.texCoords.status >= viewerConst.COMPUTED:
texCoords = self.vertexSet.texCoords.array
if self.lighting and self.normals is not None:
if self.invertNormals:
norms = - self.normals
else:
norms = self.normals
else:
norms = None
from DejaVu import preventIntelBug_BlackTriangles
if preventIntelBug_BlackTriangles:
preventIntelBug = 1
else:
preventIntelBug = 0
lsharpColorBoundaries = self.getSharpColorBoundaries()
if self.disableStencil is True:
GL.glDisable(GL.GL_STENCIL_TEST)
status = glDrawIndexedGeom(
self.primitiveType,
self.vertexSet.vertices.array,
self.faceSet.faces.array,
norms,
texCoords,
fpProp, bpProp, fpBind, bpBind,
self.frontAndBack, 1,
lsharpColorBoundaries,
preventIntelBug,
highlight=self.highlight,
)
if self.disableStencil is True:
GL.glEnable(GL.GL_STENCIL_TEST)
return status
def _Disable(self):
"""Deactivate the clipping plane"""
GL.glDisable(self.clipPlaneNames[self.num])
def drawLegendLabelName(
fullWidth,
fullHeight,
ramp,
mini,
maxi,
name='',
unit='',
labelValues=[],
verticalLegend=True,
leftOrBelowLabels=False,
roomLeftToLegend=0,
roomBelowLegend=50,
legendShortSide=10,
legendLongSide=150,
significantDigits=3,
backgroundColor=(0, 0, 0, .8),
labelColor=(1, 1, 1),
interpolate=True,
frame=True,
selected=False,
numOfLabels=None,
resizeSpotRadius=5,
fontScale=8,
glfFontID=0,
tile=None,
):
if ramp is None or len(ramp) == 0:
return
if tile is not None and selected is True:
selected = False
# some glf font initialisation
glf.glfSetCurrentFont(glfFontID)
glf.glfStringCentering(GL.GL_FALSE)
glf.glfStringDirection(glf.GLF_LEFT)
# calculate name and unit size
lNameMinAndMax = glf.glfGetStringBounds(name)
lNameMinAndMax = (lNameMinAndMax[0] * fontScale,
lNameMinAndMax[1] * fontScale,
lNameMinAndMax[2] * fontScale,
lNameMinAndMax[3] * fontScale)
lNameWidth = lNameMinAndMax[2] - lNameMinAndMax[0]
lNameHeight = lNameMinAndMax[3] - lNameMinAndMax[1]
if lNameWidth == 0:
lNameWidth = fontScale
if unit is not None and (len(unit) > 0):
lUnitMinAndMax = glf.glfGetStringBounds(unit)
lUnitMinAndMax = (lUnitMinAndMax[0] * fontScale,
lUnitMinAndMax[1] * fontScale,
lUnitMinAndMax[2] * fontScale,
lUnitMinAndMax[3] * fontScale)
lUnitWidth = lUnitMinAndMax[2] - lUnitMinAndMax[0]
lUnitHeight = lUnitMinAndMax[3] - lUnitMinAndMax[1]
else:
lUnitWidth = fontScale
lUnitHeight = 0
lMaxNameUnitHeight = max(lNameHeight, lUnitHeight)
lMaxNameUnitWidth = max(lNameWidth, lUnitWidth)
# deducted values
fontScaleHalf = fontScale / 2
if verticalLegend is True:
lRoomToLegendCloseLongSide = roomLeftToLegend
lRoomToLegendCloseShortSide = roomBelowLegend
if legendShortSide < 1:
legendShortSide = 1
if legendLongSide < 1:
legendLongSide = 1
else:
lRoomToLegendCloseLongSide = roomBelowLegend
lRoomToLegendCloseShortSide = roomLeftToLegend
if legendShortSide < lMaxNameUnitHeight + fontScaleHalf:
legendShortSide = lMaxNameUnitHeight + fontScaleHalf
if legendLongSide < 1:
legendLongSide = 1
lRoomToLegendFarLongSide = lRoomToLegendCloseLongSide + legendShortSide
lRoomToLegendFarShortSide = lRoomToLegendCloseShortSide + legendLongSide
# prepare the legend labels
if len(labelValues) > 0:
lOnScreenLabelValues = labelValues
else:
if numOfLabels == None or numOfLabels < 0:
if verticalLegend is True:
numOfLabels = 6
else:
numOfLabels = 4
if (numOfLabels == 0) or maxi is None or mini is None:
lOnScreenLabelValues = []
elif numOfLabels == 1:
lOnScreenLabelValues = [(mini + maxi) * 0.5]
else:
delta = (maxi - mini) / float(numOfLabels - 1)
lOnScreenLabelValues = []
for i in range(numOfLabels):
lOnScreenLabelValues.append(mini + i * delta)
lMaxLabelDigits = 0
for v in lOnScreenLabelValues:
lLabel = "%.*g" % (significantDigits, v)
if lMaxLabelDigits < len(lLabel):
lMaxLabelDigits = len(lLabel)
# calculate labels size
lLabelsMinAndMax = []
lLabelsWidth = []
lLabelsHeight = []
lMaxLabelsWidth = 0
lMaxLabelsHeight = 0
for v in lOnScreenLabelValues:
lLabel = "%.*g" % (significantDigits, v)
lLabelsMinAndMax.append(glf.glfGetStringBounds(lLabel))
lLabelsMinAndMax[-1] = (lLabelsMinAndMax[-1][0] * fontScale,
lLabelsMinAndMax[-1][1] * fontScale,
lLabelsMinAndMax[-1][2] * fontScale,
lLabelsMinAndMax[-1][3] * fontScale)
lLabelsWidth.append(lLabelsMinAndMax[-1][2] - lLabelsMinAndMax[-1][0])
lLabelsHeight.append(lLabelsMinAndMax[-1][3] - lLabelsMinAndMax[-1][1])
if lLabelsWidth[-1] > lMaxLabelsWidth:
lMaxLabelsWidth = lLabelsWidth[-1]
if lLabelsHeight[-1] > lMaxLabelsHeight:
lMaxLabelsHeight = lLabelsHeight[-1]
# calculate frame size
lMaxWidth = max(lMaxLabelsWidth + legendShortSide, lMaxNameUnitWidth)
lMaxNameUnitHeightHalf = lMaxNameUnitHeight / 2
legendShortSideHalf = legendShortSide / 2
if verticalLegend is True:
if leftOrBelowLabels is False:
lPt1 = (lRoomToLegendCloseLongSide,
-fontScale + lRoomToLegendCloseShortSide -
lMaxLabelsHeight - lNameHeight, 0)
lPt2 = (fontScale + lRoomToLegendCloseLongSide + lMaxWidth,
-fontScale + lRoomToLegendCloseShortSide -
lMaxLabelsHeight - lNameHeight, 0)
lPt3 = (fontScale + lRoomToLegendCloseLongSide + lMaxWidth,
fontScale + lRoomToLegendFarShortSide + lMaxLabelsHeight +
lUnitHeight, 0)
lPt4 = (lRoomToLegendCloseLongSide, fontScale +
lRoomToLegendFarShortSide + lMaxLabelsHeight + lUnitHeight,
0)
else:
lPt1 = (-fontScale + lRoomToLegendFarLongSide - lMaxWidth,
-fontScale + lRoomToLegendCloseShortSide -
lMaxLabelsHeight - lNameHeight, 0)
lPt2 = (lRoomToLegendCloseLongSide + legendShortSide,
-fontScale + lRoomToLegendCloseShortSide -
lMaxLabelsHeight - lNameHeight, 0)
lPt3 = (lRoomToLegendCloseLongSide + legendShortSide, fontScale +
lRoomToLegendFarShortSide + lMaxLabelsHeight + lUnitHeight,
0)
lPt4 = (-fontScale + lRoomToLegendFarLongSide - lMaxWidth,
fontScale + lRoomToLegendFarShortSide + lMaxLabelsHeight +
lUnitHeight, 0)
else:
if leftOrBelowLabels is False:
lPt1 = (-fontScale + lRoomToLegendCloseShortSide - lNameWidth,
lRoomToLegendCloseLongSide, 0)
lPt2 = (fontScale + lRoomToLegendFarShortSide + lUnitWidth,
lRoomToLegendCloseLongSide, 0)
lPt3 = (fontScale+lRoomToLegendFarShortSide+lUnitWidth,
fontScale+lRoomToLegendCloseLongSide \
+ legendShortSide \
+ lMaxLabelsHeight,
0)
lPt4 = (-fontScale+lRoomToLegendCloseShortSide-lNameWidth,
fontScale+lRoomToLegendCloseLongSide \
+ legendShortSide \
+ lMaxLabelsHeight,
0)
else:
lPt1 = (-fontScale + lRoomToLegendCloseShortSide - lNameWidth,
-fontScale + lRoomToLegendCloseLongSide - lMaxLabelsHeight,
0)
lPt2 = (fontScale + lRoomToLegendFarShortSide + lUnitWidth,
-fontScale + lRoomToLegendCloseLongSide - lMaxLabelsHeight,
0)
lPt3 = (fontScale + lRoomToLegendFarShortSide + lUnitWidth,
lRoomToLegendFarLongSide, 0)
lPt4 = (-fontScale + lRoomToLegendCloseShortSide - lNameWidth,
lRoomToLegendFarLongSide, 0)
if selected is True:
labelColor2 = (.5, .5, .5)
else:
labelColor2 = labelColor
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
if tile is None:
GL.glOrtho(0, float(fullWidth), 0, float(fullHeight), -1, 1)
else:
GL.glOrtho(float(tile[0]), float(tile[1]), float(tile[2]),
float(tile[3]), -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable(GL.GL_LIGHTING)
GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL)
if len(backgroundColor) == 4:
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
#because of an unexplained bug on michel's laptop,
#we don't draw the background when there is no frame
#(so michel has a way to manage the legend)
if frame is True:
#draw transparent background
GL.glDepthMask(GL.GL_FALSE)
if len(backgroundColor) == 3:
GL.glColor3fv(backgroundColor)
else:
GL.glColor4fv(backgroundColor)
GL.glBegin(GL.GL_QUADS)
GL.glVertex3fv(lPt1)
GL.glVertex3fv(lPt2)
GL.glVertex3fv(lPt3)
GL.glVertex3fv(lPt4)
GL.glEnd()
GL.glDepthMask(GL.GL_TRUE)
#draw frame
if frame is True:
GL.glPolygonMode(GL.GL_FRONT, GL.GL_LINE)
GL.glLineWidth(1)
GL.glColor3fv(labelColor2)
GL.glBegin(GL.GL_QUADS)
GL.glVertex3fv(lPt1)
GL.glVertex3fv(lPt2)
GL.glVertex3fv(lPt3)
GL.glVertex3fv(lPt4)
GL.glEnd()
GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL)
if mini is not None and maxi is not None and maxi > mini:
lUnitStep = legendLongSide / float(maxi - mini)
else:
lUnitStep = legendLongSide
GL.glDisable(GL.GL_LIGHTING)
if verticalLegend is True:
if leftOrBelowLabels is True:
lRoomLeftToLabel = -fontScaleHalf + lRoomToLegendCloseLongSide
lRoomLeftToName = -fontScaleHalf + lRoomToLegendFarLongSide - lNameWidth
lRoomLeftToUnit = -fontScaleHalf + lRoomToLegendFarLongSide - lUnitWidth
lRoomBelowName = -fontScaleHalf + roomBelowLegend - lMaxLabelsHeight - lNameHeight
lRoomBelowUnit = fontScaleHalf + roomBelowLegend + legendLongSide + lMaxLabelsHeight
else:
lRoomLeftToLabel = fontScaleHalf + lRoomToLegendFarLongSide
lRoomLeftToName = fontScaleHalf + lRoomToLegendCloseLongSide
lRoomLeftToUnit = lRoomLeftToName
lRoomBelowName = -fontScaleHalf + roomBelowLegend - lMaxLabelsHeight - lNameHeight
lRoomBelowUnit = fontScaleHalf + roomBelowLegend + legendLongSide + lMaxLabelsHeight
else:
if leftOrBelowLabels is True:
lRoomBelowLabel = -fontScaleHalf + lRoomToLegendFarLongSide \
- legendShortSide - lMaxLabelsHeight
lRoomBelowName = lRoomToLegendCloseLongSide + legendShortSideHalf \
- lMaxNameUnitHeightHalf
else:
lRoomBelowLabel = fontScaleHalf + lRoomToLegendCloseLongSide \
+ legendShortSide
lRoomBelowName = lRoomToLegendCloseLongSide + legendShortSideHalf \
- lMaxNameUnitHeightHalf
lRoomBelowUnit = lRoomBelowName
lRoomLeftToName = -fontScaleHalf + lRoomToLegendCloseShortSide - lNameWidth
lRoomLeftToUnit = fontScaleHalf + lRoomToLegendFarShortSide
# set the color of the text
GL.glColor3fv(labelColor2)
# print the legend name
GL.glPushMatrix()
GL.glTranslatef(float(lRoomLeftToName + fontScale),
float(lRoomBelowName - lNameMinAndMax[1]), 0)
GL.glScalef(float(fontScale), float(fontScale), 0)
glf.glfDrawSolidString(name)
GL.glPopMatrix()
if unit is not None and (len(unit) > 0):
GL.glPushMatrix()
GL.glTranslatef(float(lRoomLeftToUnit + fontScale),
float(lRoomBelowUnit - lUnitMinAndMax[1]), 0)
GL.glScalef(float(fontScale), float(fontScale), 1)
glf.glfDrawSolidString(unit)
GL.glPopMatrix()
if mini is not None and maxi is not None:
i = 0
for v in lOnScreenLabelValues:
#calculate label position
lLabel = "%.*g" % (significantDigits, v)
lStep = (v - mini) * lUnitStep
GL.glPushMatrix()
if verticalLegend:
if leftOrBelowLabels:
GL.glTranslatef(
float(lRoomLeftToLabel + fontScale - lLabelsWidth[i]),
float(roomBelowLegend -
(lLabelsHeight[i] / 2 + lLabelsMinAndMax[i][1]) +
lStep), 0)
else:
GL.glTranslatef(
float(lRoomLeftToLabel + fontScale),
float(roomBelowLegend -
(lLabelsHeight[i] / 2 + lLabelsMinAndMax[i][1]) +
lStep), 0)
else:
GL.glTranslatef(
float(roomLeftToLegend - (lLabelsWidth[i] / 2) +
fontScale + lStep),
float(lRoomBelowLabel - lLabelsMinAndMax[i][1]), 0)
GL.glScalef(float(fontScale), float(fontScale), 1)
glf.glfDrawSolidString("%s" % lLabel)
GL.glPopMatrix()
i += 1
if len(backgroundColor) == 4:
GL.glDisable(GL.GL_BLEND)
# GL.glEnable(GL.GL_LIGHTING)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
drawLegendOnly(
fullWidth=fullWidth,
fullHeight=fullHeight,
ramp=ramp,
verticalLegend=verticalLegend,
roomLeftToLegend=roomLeftToLegend,
roomBelowLegend=roomBelowLegend,
legendShortSide=legendShortSide,
legendLongSide=legendLongSide,
interpolate=interpolate,
selected=selected,
tile=tile,
)
if selected is True:
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glOrtho(0, float(fullWidth), 0, float(fullHeight), -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable(GL.GL_LIGHTING)
GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL)
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_FALSE)
GL.glDisable(GL.GL_LIGHTING)
resizeSpot = []
if verticalLegend:
resizeSpot = [
roomLeftToLegend + legendShortSide,
roomBelowLegend + legendLongSide
]
else:
resizeSpot = [
roomLeftToLegend + legendLongSide,
roomBelowLegend + legendShortSide
]
GL.glColor3fv(labelColor)
GL.glBegin(GL.GL_QUADS)
GL.glVertex2f(float(resizeSpot[0] + resizeSpotRadius),
float(resizeSpot[1] - resizeSpotRadius))
GL.glVertex2f(float(resizeSpot[0] + resizeSpotRadius),
float(resizeSpot[1] + resizeSpotRadius))
GL.glVertex2f(float(resizeSpot[0] - resizeSpotRadius),
float(resizeSpot[1] + resizeSpotRadius))
GL.glVertex2f(float(resizeSpot[0] - resizeSpotRadius),
float(resizeSpot[1] - resizeSpotRadius))
GL.glEnd()
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_TRUE)
# GL.glEnable(GL.GL_LIGHTING)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
else:
resizeSpot = None
return [(lPt1[0], lPt1[1]), (lPt2[0], lPt2[1]), (lPt3[0], lPt3[1]),
(lPt4[0], lPt4[1])], resizeSpot, verticalLegend
def _Disable(self): """Deactivate the clipping plane""" GL.glDisable(self.clipPlaneNames[self.num])
def drawLegendOnly(
fullWidth,
fullHeight,
ramp,
verticalLegend=True,
roomLeftToLegend=0,
roomBelowLegend=50,
legendShortSide=10,
legendLongSide=150,
interpolate=True,
selected=False,
tile=None,
):
if ramp is None or len(ramp) == 0:
return
if tile is not None and selected is True:
selected = False
# deducted values
if verticalLegend is True:
lRoomToLegendCloseLongSide = roomLeftToLegend
lRoomToLegendCloseShortSide = roomBelowLegend
if legendShortSide < 1:
legendShortSide = 1
if legendLongSide < 1:
legendLongSide = 1
else:
lRoomToLegendCloseLongSide = roomBelowLegend
lRoomToLegendCloseShortSide = roomLeftToLegend
if legendShortSide < 1:
legendShortSide = 1
if legendLongSide < 1:
legendLongSide = 1
lRoomToLegendFarLongSide = lRoomToLegendCloseLongSide + legendShortSide
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
if tile is None:
GL.glOrtho(0, float(fullWidth), 0, float(fullHeight), -1, 1)
else:
GL.glOrtho(float(tile[0]), float(tile[1]), float(tile[2]),
float(tile[3]), -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glDisable(GL.GL_LIGHTING)
GL.glPolygonMode(GL.GL_FRONT, GL.GL_FILL)
GL.glDisable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_FALSE)
if len(ramp[0]) == 4: # there are alpha values, draw checkered bg
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
#draw a bunch of quads as background
lCheckerSquareSize = legendShortSide * .5
if lCheckerSquareSize != 0:
nbquads = int(legendLongSide / lCheckerSquareSize)
else:
nbquads = 1
c1 = (0.1, 0.1, 0.1)
c2 = (0.3, 0.3, 0.3)
c = c1
x2 = None
for i in range(nbquads + 1):
GL.glColor3fv(c)
if i == nbquads and nbquads != 0:
x1 = x2
x2 = legendLongSide
else:
x1 = i * lCheckerSquareSize
x2 = min(x1 + lCheckerSquareSize, legendLongSide)
GL.glBegin(GL.GL_QUADS)
if verticalLegend is True:
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(
float(lRoomToLegendCloseLongSide + lCheckerSquareSize),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(
float(lRoomToLegendCloseLongSide + lCheckerSquareSize),
float(lRoomToLegendCloseShortSide + x2))
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + x2))
else:
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendCloseLongSide))
GL.glVertex2f(
float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendCloseLongSide + lCheckerSquareSize))
GL.glVertex2f(
float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendCloseLongSide + lCheckerSquareSize))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendCloseLongSide))
GL.glEnd()
if c == c1:
c = c2
else:
c = c1
GL.glColor3fv(c)
GL.glBegin(GL.GL_QUADS)
if verticalLegend is True:
GL.glVertex2f(
float(lRoomToLegendCloseLongSide + lCheckerSquareSize),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + x2))
GL.glVertex2f(
float(lRoomToLegendCloseLongSide + lCheckerSquareSize),
float(lRoomToLegendCloseShortSide + x2))
else:
GL.glVertex2f(
float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendCloseLongSide + lCheckerSquareSize))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(
float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendCloseLongSide + lCheckerSquareSize))
GL.glEnd()
#interp = False
if interpolate and (len(ramp) > 1): # we interpolate colors
# draw a quad strip for the color map
lDelta = legendLongSide / float(len(ramp) - 1)
GL.glBegin(GL.GL_QUAD_STRIP)
for i in range(len(ramp)):
if selected is True:
c = deepcopy(ramp[i])
for j in range(3):
c[j] = .35 + c[j] * .3
else:
c = ramp[i]
if len(c) == 3:
GL.glColor3fv(c)
elif len(c) == 4:
GL.glColor4fv(c)
lStep = i * lDelta
if verticalLegend is True:
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + lStep))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + lStep))
else:
GL.glVertex2f(float(lRoomToLegendCloseShortSide + lStep),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + lStep),
float(lRoomToLegendCloseLongSide))
GL.glEnd()
else:
# we draw a quad for each color
lDelta = legendLongSide / float(len(ramp))
for i in range(len(ramp)):
if selected is True:
c = deepcopy(ramp[i])
for j in range(3):
c[j] = .35 + c[j] * .3
else:
c = ramp[i]
if len(c) == 3:
GL.glColor3fv(c)
elif len(c) == 4:
GL.glColor4fv(c)
x1 = i * lDelta
x2 = x1 + lDelta
GL.glBegin(GL.GL_QUADS)
if verticalLegend is True:
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + x1))
GL.glVertex2f(float(lRoomToLegendFarLongSide),
float(lRoomToLegendCloseShortSide + x2))
GL.glVertex2f(float(lRoomToLegendCloseLongSide),
float(lRoomToLegendCloseShortSide + x2))
else:
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendCloseLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x2),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendFarLongSide))
GL.glVertex2f(float(lRoomToLegendCloseShortSide + x1),
float(lRoomToLegendCloseLongSide))
GL.glEnd()
if len(ramp[0]) == 4:
GL.glDisable(GL.GL_BLEND)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_TRUE)
# GL.glEnable(GL.GL_LIGHTING)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPopMatrix()
GL.glMatrixMode(GL.GL_MODELVIEW)
def Draw(self):
c = self.vertexSet.vertices.array
if len(c)==0: return
GL.glDisable(GL.GL_LIGHTING)
if self.materials[GL.GL_FRONT]:
mat = self.materials[GL.GL_FRONT]
binding = self.materials[GL.GL_FRONT].binding[mat.diff]
else:
binding = viewerConst.OVERALL
if binding == viewerConst.INHERIT:
for i in xrange(c.shape[0]): #loop over lines
GL.glPushName(i)
GL.glBegin(self.primitiveType)
for v in c[i]:
#GL.glVertex3dv(v.tolist())
#gllib.glVertex3dv(v)
gllib.glVertex3fv(v)
GL.glEnd()
GL.glPopName()
elif binding == viewerConst.OVERALL:
if self.materials[GL.GL_FRONT]:
col = mat.prop[mat.diff][0]
GL.glColor4fv(col)
for i in xrange(c.shape[0]): #loop over lines
GL.glPushName(i)
GL.glBegin(self.primitiveType)
for v in c[i]:
#GL.glVertex3dv(v.tolist())
#gllib.glVertex3dv(v)
gllib.glVertex3fv(v)
GL.glEnd()
GL.glPopName()
elif binding == viewerConst.PER_VERTEX:
if self.materials[GL.GL_FRONT]:
col = mat.prop[mat.diff]
vi = 0
for i in xrange(c.shape[0]):
GL.glPushName(i)
GL.glBegin(self.primitiveType)
for v in c[i]:
GL.glColor4fv(col[vi])
vi = vi + 1
#GL.glVertex3dv(v.tolist())
#gllib.glVertex3dv(v)
gllib.glVertex3fv(v)
GL.glEnd()
GL.glPopName()
elif binding == viewerConst.PER_PART: # i.e. line
if self.materials[GL.GL_FRONT]:
col = mat.prop[mat.diff]
for i in xrange(c.shape[0]):
GL.glColor4fv(col[i])
GL.glPushName(i)
GL.glBegin(self.primitiveType)
for v in c[i]:
#GL.glVertex3dv(v.tolist())
#gllib.glVertex3dv(v)
gllib.glVertex3fv(v)
GL.glEnd()
GL.glPopName()
#glEnable(GL_LIGHTING)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
return True
def DisplayFunction(self):
"""Draw a square with diagonals to represent the clipping plane
"""
#print "ClippingPlane.DisplayFunction"
#trans = self.eqn[3]*(self.eqn[:3]*self.n)
resetMaterialMemory()
trans = self.translation
GL.glPushMatrix()
#GL.glTranslatef(-trans[0],-trans[1],-trans[2])
GL.glTranslatef(float(trans[0]), float(trans[1]), float(trans[2]))
GL.glMultMatrixf(self.rotation)
GL.glScalef(float(self.scale[0]), float(self.scale[1]),
float(self.scale[2]))
if self.polyMode == GL.GL_QUADS:
GL.glPushAttrib(GL.GL_CURRENT_BIT | GL.GL_LIGHTING_BIT
| GL.GL_POLYGON_BIT)
GL.glDisable(GL.GL_LIGHTING)
GL.glMaterialWithCheck(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT,
self.color)
if self.viewer is not None:
self.viewer.enableOpenglLighting()
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL)
GL.glPushMatrix()
GL.glMultMatrixf(self.planeRot)
GL.glBegin(GL.GL_QUADS)
GL.glVertex3f(0.0, -5.0, -5.0)
GL.glVertex3f(0.0, -5.0, 5.0)
GL.glVertex3f(0.0, 5.0, 5.0)
GL.glVertex3f(0.0, 5.0, -5.0)
GL.glVertex3f(0.0, -5.0, -5.0)
GL.glEnd()
GL.glPopMatrix()
GL.glPopAttrib()
else:
# MS disabling GL.GL_BLEND breaks display of transparent surfaces
## if self.antialiased==True:
## GL.glEnable(GL.GL_LINE_SMOOTH)
## GL.glEnable(GL.GL_BLEND)
## else:
## GL.glDisable(GL.GL_LINE_SMOOTH)
## GL.glDisable(GL.GL_BLEND)
GL.glColor4fv(self.color)
GL.glLineWidth(self.lineWidth)
GL.glPushMatrix()
GL.glMultMatrixf(self.planeRot)
# could and should be a display list made once for all planes
GL.glBegin(GL.GL_LINE_STRIP)
GL.glVertex3f(0.0, -5.0, -5.0)
GL.glVertex3f(0.0, -5.0, 5.0)
GL.glVertex3f(0.0, 5.0, 5.0)
GL.glVertex3f(0.0, 5.0, -5.0)
GL.glVertex3f(0.0, -5.0, -5.0)
GL.glVertex3f(0.0, 5.0, 5.0)
GL.glVertex3f(0.0, -5.0, 5.0)
GL.glVertex3f(0.0, 5.0, -5.0)
GL.glEnd()
GL.glPopMatrix()
GL.glPopMatrix()
def Setup(self):
"""Setup texture mapping"""
t = self
if not t.enabled:
GL.glDisable(t.dim)
return
t.MakeMatrix()
GL.glTexEnvf(GL.GL_TEXTURE_ENV,
GL.GL_TEXTURE_ENV_MODE, t.envMode)
if t.envMode==GL.GL_BLEND:
GL.glTexEnvf(GL.GL_TEXTURE_ENV,
GL.GL_TEXTURE_ENV_COLOR, t.envColor)
GL.glTexParameterf(t.dim, GL.GL_TEXTURE_WRAP_S, t.wrap[0])
GL.glTexParameterf(t.dim, GL.GL_TEXTURE_MAG_FILTER,
t.magFilter)
GL.glTexParameterf(t.dim, GL.GL_TEXTURE_MIN_FILTER,
t.minFilter)
if t.auto:
GL.glTexGeni(GL.GL_S, GL.GL_TEXTURE_GEN_MODE,
t.genMod[0])
GL.glTexGenfv(GL.GL_S, t.genPlane[0], t.plane[0])
GL.glEnable(GL.GL_TEXTURE_GEN_S)
else:
GL.glDisable(GL.GL_TEXTURE_GEN_S)
if t.dim==GL.GL_TEXTURE_1D:
from opengltk.extent import _gllib
_gllib.glTexImage1D(t.dim, t.level, t.format,
t.width, 0, t.format,
GL.GL_UNSIGNED_BYTE, t.image)
elif t.dim==GL.GL_TEXTURE_2D:
GL.glTexParameterf(t.dim, GL.GL_TEXTURE_WRAP_T, t.wrap[1])
from opengltk.extent import _gllib
# directly call the C function to not have to transform the
# t.image into a bufarray
#print "t.width, t.height", t.width, t.height
_gllib.glTexImage2D(t.dim, t.level, t.format,
t.width, t.height, t.border!=0, t.format,
GL.GL_UNSIGNED_BYTE, t.image)
## import bufarray
## bimage = bufarray.Bufarray(im, bufarray.ubyteCtype)
## GL.glTexImage2D(t.dim, t.level,GL.GL_UNSIGNED_BYTE,
## t.width, t.height, t.border!=0, t.format,
## bimage)
## GL.glTexImage2D(t.dim, t.level, t.format,
## t.width, t.height, t.border!=0, t.format,
## GL.GL_UNSIGNED_BYTE, t.image)
if t.auto:
GL.glTexGeni(GL.GL_T, GL.GL_TEXTURE_GEN_MODE,
t.genMod[1])
GL.glTexGenfv(GL.GL_T, t.genPlane[1], t.plane[1])
GL.glEnable(GL.GL_TEXTURE_GEN_T)
else:
GL.glDisable(GL.GL_TEXTURE_GEN_T)
GL.glEnable(t.dim)
