예제 #1
0
 def IsUsable(self):
     """ Returns whether the program is usable. In other words, whether
     the OpenGl driver supports GLSL.
     """ 
     if self._usable is None: # Not True nor False
         usable = getOpenGlCapable('2.0',
             'anti-aliasing, the clim property, colormaps and 3D rendering')
         self._usable = bool(usable) # Make very sure its not None
     return self._usable
예제 #2
0
 def IsUsable(self):
     """ Returns whether the program is usable. In other words, whether
     the OpenGl driver supports GLSL.
     """
     if self._usable is None:  # Not True nor False
         usable = getOpenGlCapable(
             '2.0',
             'anti-aliasing, the clim property, colormaps and 3D rendering')
         self._usable = bool(usable)  # Make very sure its not None
     return self._usable
예제 #3
0
    def _DrawLines(self):

        # set stipple style
        if not self.ls in lineStyles:
            stipple = False
        else:
            stipple = lineStyles[self.ls]
        #
        if stipple and self.lw:
            gl.glEnable(gl.GL_LINE_STIPPLE)
            gl.glLineStipple(int(round(self.lw)), stipple)
        else:
            gl.glDisable(gl.GL_LINE_STIPPLE)

        # init vertex array
        gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
        gl.glVertexPointerf(self._points.data)

        # linepieces drawn on top of other should draw just fine. See issue #95
        gl.glDepthFunc(gl.GL_LEQUAL)

        # init blending. Only use constant blendfactor when alpha<1
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        if self._alpha1 < 1:
            #if len(self._points) < 1000:
            if getOpenGlCapable('1.4', 'transparant points and lines'):
                gl.glBlendFunc(gl.GL_CONSTANT_ALPHA,
                               gl.GL_ONE_MINUS_CONSTANT_ALPHA)
                gl.glBlendColor(0.0, 0.0, 0.0, self._alpha1)
            gl.glDisable(gl.GL_DEPTH_TEST)

        # get color
        clr = getColor(self.lc)

        if clr and self._alpha1 > 0:

            # set width and color
            gl.glLineWidth(self.lw)
            gl.glColor3f(clr[0], clr[1], clr[2])

            # draw
            method = gl.GL_LINE_STRIP
            if self.ls == '+':
                method = gl.GL_LINES
            gl.glDrawArrays(method, 0, len(self._points))
            # flush!
            gl.glFlush()

        # clean up
        gl.glDisable(gl.GL_LINE_STIPPLE)
        gl.glLineStipple(int(round(self.lw)), int('1111111111111111', 2))
        gl.glEnable(gl.GL_DEPTH_TEST)
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
        gl.glDepthFunc(gl.GL_LESS)
예제 #4
0
 def __init__(self):
     # ids
     self._programId = 0
     self._shaderIds = []
     
     # code for the shaders        
     self._fragmentCode = ''
     self._vertexCode = ''
     
     # is usable?
     self._usable = True
     if not getOpenGlCapable('2.0',
         'anti-aliasing, the clim property, colormaps and 3D rendering'):
         self._usable = False
예제 #5
0
    def _DrawLines(self):

        # set stipple style
        if not self.ls in lineStyles:
            stipple = False
        else:
            stipple = lineStyles[self.ls]
        #
        if stipple and self.lw:
            gl.glEnable(gl.GL_LINE_STIPPLE)
            gl.glLineStipple(int(round(self.lw)), stipple)
        else:
            gl.glDisable(gl.GL_LINE_STIPPLE)

        # init vertex array
        gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
        gl.glVertexPointerf(self._points.data)

        # init blending. Only use constant blendfactor when alpha<1
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        if self._alpha1<1:
            if getOpenGlCapable('1.4','transparant points and lines'):
                gl.glBlendFunc(gl.GL_CONSTANT_ALPHA,
                    gl.GL_ONE_MINUS_CONSTANT_ALPHA)
                gl.glBlendColor(0.0,0.0,0.0, self._alpha1)
            gl.glDisable(gl.GL_DEPTH_TEST)

        # get color
        clr = getColor( self.lc )

        if clr and self._alpha1>0:

            # set width and color
            gl.glLineWidth(self.lw)
            gl.glColor3f(clr[0], clr[1], clr[2])

            # draw
            method = gl.GL_LINE_STRIP
            if self.ls == '+':
                method = gl.GL_LINES
            gl.glDrawArrays(method, 0, len(self._points))
            # flush!
            gl.glFlush()

        # clean up
        gl.glDisable(gl.GL_LINE_STIPPLE)
        gl.glLineStipple(int(round(self.lw)), int('1111111111111111',2))
        gl.glEnable(gl.GL_DEPTH_TEST)
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
예제 #6
0
    def __init__(self):
        # ids
        self._programId = 0
        self._shaderIds = []

        # code for the shaders
        self._fragmentCode = ''
        self._vertexCode = ''

        # is usable?
        self._usable = True
        if not getOpenGlCapable(
                '2.0',
                'anti-aliasing, the clim property, colormaps and 3D rendering'
        ):
            self._usable = False
예제 #7
0
 def Enable(self, texUnit=0):
     """ Enable(texUnit)
     
     Enable the texture, using the given texture unit (max 9).
     If necessary, will upload/update the texture in OpenGl memory now.
     
     If texUnit is -1, will not bind the texture.
     
     """ 
     
     # Did we fail uploading texture last time?
     troubleLastTime = (self._uploadFlag==0)
     
     # If texture invalid, tell to upload, but only if we have a chance
     if self._texId == 0 or not gl.glIsTexture(self._texId):
         if not troubleLastTime:
             # Only if not in failure mode
             self._uploadFlag = abs(self._uploadFlag)
     
     # Store texture-Unit-id, and activate. Do before calling _setDataNow!
     if texUnit >= 0:
         self._texUnit = texUnit
         self._useTexUnit = getOpenGlCapable('1.3')        
         if self._useTexUnit:
             gl.glActiveTexture( gl.GL_TEXTURE0 + texUnit )   # Opengl v1.3
     
     # If we should upload/update, do that now. (SetData also sets the flag)
     if self._uploadFlag > 0:
         self._SetDataNow()
     
     # check if ok now
     if not gl.glIsTexture(self._texId):
         if not troubleLastTime:
             tmp = " (Hiding message for future draws.)"
             print "Warning enabling texture, the texture is not valid."+tmp
         return
     
     # Enable texturing, and bind to texture
     if texUnit >= 0:
         gl.glEnable(self._texType)
         gl.glBindTexture(self._texType, self._texId)
예제 #8
0
    def Enable(self, texUnit=0):
        """ Enable(texUnit)
        
        Enable the texture, using the given texture unit (max 9).
        If necessary, will upload/update the texture in OpenGl memory now.
        
        If texUnit is -1, will not bind the texture.
        
        """

        # Did we fail uploading texture last time?
        troubleLastTime = (self._uploadFlag == 0)

        # If texture invalid, tell to upload, but only if we have a chance
        if self._texId == 0 or not gl.glIsTexture(self._texId):
            if not troubleLastTime:
                # Only if not in failure mode
                self._uploadFlag = abs(self._uploadFlag)

        # Store texture-Unit-id, and activate. Do before calling _setDataNow!
        if texUnit >= 0:
            self._texUnit = texUnit
            self._useTexUnit = getOpenGlCapable('1.3')
            if self._useTexUnit:
                gl.glActiveTexture(gl.GL_TEXTURE0 + texUnit)  # Opengl v1.3

        # If we should upload/update, do that now. (SetData also sets the flag)
        if self._uploadFlag > 0:
            self._SetDataNow()

        # check if ok now
        if not gl.glIsTexture(self._texId):
            if not troubleLastTime:
                tmp = " (Hiding message for future draws.)"
                print "Warning enabling texture, the texture is not valid." + tmp
            return

        # Enable texturing, and bind to texture
        if texUnit >= 0:
            gl.glEnable(self._texType)
            gl.glBindTexture(self._texType, self._texId)
예제 #9
0
 def shader(self):
     if self._shader is None:
         if not getOpenGlCapable('2.0', 'Antialiased text'):
             self._shader = self
             self.Enable = lambda: None
             self.Disable = lambda: None
             global TEX_SCALE
             TEX_SCALE = 1.5 # Make text more blurry
         else:
             # Create shader
             self._shader = Shader()
             # Set fragment code, vertex code is empty
             self._shader.vertex.Clear()
             fragment = ShaderCodePart('textaa', '', FRAGMENT_SHADER)
             self._shader.fragment.AddPart(fragment)
             # Set uniform
             shape = self.atlas.data.shape[:2]
             uniform_shape = [float(s) for s in reversed(list(shape))]
             self.shader.SetStaticUniform('shape', uniform_shape)
     
     return self._shader
    def shader(self):
        if self._shader is None:
            if not getOpenGlCapable('2.0', 'Antialiased text'):
                self._shader = self
                self.Enable = lambda: None
                self.Disable = lambda: None
                global TEX_SCALE
                TEX_SCALE = 1.5  # Make text more blurry
            else:
                # Create shader
                self._shader = Shader()
                # Set fragment code, vertex code is empty
                self._shader.vertex.Clear()
                fragment = ShaderCodePart('textaa', '', FRAGMENT_SHADER)
                self._shader.fragment.AddPart(fragment)
                # Set uniform
                shape = self.atlas.data.shape[:2]
                uniform_shape = [float(s) for s in reversed(list(shape))]
                self.shader.SetStaticUniform('shape', uniform_shape)

        return self._shader
예제 #11
0
    def Create(self):
        """ Create an OpenGL texture from the data. """

        # detemine now if we can use point sprites
        self._canUse = getOpenGlCapable(
            '2.0', 'point sprites (for advanced markers)')
        if not self._canUse:
            return

        # gl.glEnable(gl.GL_TEXTURE_2D)

        # make texture
        self._texId = gl.glGenTextures(1)
        gl.glBindTexture(gl.GL_TEXTURE_2D, self._texId)

        # set interpolation and extrapolation parameters
        tmp = gl.GL_NEAREST  # gl.GL_NEAREST | gl.GL_LINEAR
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, tmp)
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, tmp)

        # upload data
        shape = self._data.shape
        gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_ALPHA, shape[0], shape[1],
                        0, gl.GL_ALPHA, gl.GL_UNSIGNED_BYTE, self._data)
예제 #12
0
파일: line.py 프로젝트: chiluf/visvis.dev
    def Create(self):
        """ Create an OpenGL texture from the data. """
        
        # detemine now if we can use point sprites
        self._canUse = getOpenGlCapable('2.0',
            'point sprites (for advanced markers)')
        if not self._canUse:
            return
        
        # gl.glEnable(gl.GL_TEXTURE_2D)
        
        # make texture
        self._texId = gl.glGenTextures(1)
        gl.glBindTexture(gl.GL_TEXTURE_2D, self._texId)
        
        # set interpolation and extrapolation parameters
        tmp = gl.GL_NEAREST # gl.GL_NEAREST | gl.GL_LINEAR
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, tmp)
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, tmp)

        # upload data
        shape = self._data.shape
        gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_ALPHA, shape[0], shape[1],
            0, gl.GL_ALPHA, gl.GL_UNSIGNED_BYTE, self._data)
예제 #13
0
 def _SetDataNow(self):
     """ Make sure the data in self._dataRef is uploaded to 
     OpenGl memory. If possible, update the data rather than 
     create a new texture object.
     """
     
     # Test whether padding to a factor of two is required
     needPadding = (abs(self._uploadFlag) == 2)
     needPadding = needPadding or not getOpenGlCapable('2.0')
     
     # Set flag in case of failure (set to success at the end)
     # If we tried without padding, we can still try with padding.
     # Note: In theory, getOpenGlCapable('2.0') should be enough to
     # determine if padding is required. However, bloody ATI drivers
     # sometimes need 2**n textures even if OpenGl > 2.0. (I've 
     # encountered this with someones PC and verified that the current
     # solution solves this.)
     if needPadding:
         self._uploadFlag = 0 # Give up
     else:
         self._uploadFlag = 2 # Try with padding next time
     
     # Get data. 
     if self._dataRef is None:
         return
     data = self._dataRef
     
     # older OpenGl versions do not know about 3D textures
     if self._ndim==3 and not getOpenGlCapable('1.2','3D textures'):
         return
     
     # Make singles if doubles (sadly opengl does not know about doubles)
     if data.dtype == np.float64:
         data = data.astype(np.float32)
     # dito for bools
     if data.dtype == np.bool:
         data = data.astype(np.uint8)
     
     # Determine type
     thetype = data.dtype.name
     if not thetype in dtypes:
         # this should not happen, since we concert incompatible types
         raise ValueError("Cannot convert datatype %s." % thetype)
     gltype = dtypes[thetype]
     
     # Determine format
     internalformat, format = self._GetFormat(data.shape)
     
     # Can we update or should we upload?        
     
     if (    gl.glIsTexture(self._texId) and 
             self._shape and (data.shape == self._shape) ):
         # We can update.
         
         # Bind to texture
         gl.glBindTexture(self._texType, self._texId)
         
         # update            
         self._UpdateTexture(data, internalformat, format, gltype)
     
     else:
         # We should upload.
         
         # Remove any old data. 
         self.DestroyGl()
         
         # Create texture object
         self._texId = gl.glGenTextures(1)
         
         # Bind to texture
         gl.glBindTexture(self._texType, self._texId)
         
         # Should we make the image a power of two?
         if needPadding:
             data2 = makePowerOfTwo(data, self._ndim)
             if data2 is not data:
                 data = data2
                 print "Warning: the data was padded to make it a power of two."
         
         # test whether it fits, downsample if necessary
         ok, count = False, 0
         while not ok and count<8:
             ok = self._TestUpload(data, internalformat,format,gltype)
             if not ok:
             #if count<2 and data.shape[0]<1000: # for testing
                 data = downSample(data, self._ndim)
                 count += 1
         
         # give warning or error
         if count and not ok:                
             raise MemoryError(  "Could not upload texture to OpenGL, " +
                                 "even after 8 times downsampling.")
         elif count:
             print(  "Warning: data was downscaled " + str(count) + 
                     " times to fit it in OpenGL memory." )
         
         # upload!
         self._UploadTexture(data, internalformat, format, gltype)
         
         # keep reference of data shape (as loaded to opengl)
         self._shape = data.shape
     
     # flag success
     if needPadding:
         self._uploadFlag = -2
     else:
         self._uploadFlag = -1
예제 #14
0
    def _DrawPoints(self):

        # get colors (use color from edge or face if not present)
        clr1 = getColor(self.mc)
        clr2 = getColor(self.mec)

        # draw face or edge?
        drawFace = bool(self.mc)  # if not ms or mw we would not get here
        drawEdge = self.mec and self.mew
        if not drawFace and not drawEdge:
            return

        # get figure
        f = self.GetFigure()
        if not f:
            return

        # init blending. Only use constant blendfactor when alpha<1
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        if self._alpha1 < 1:
            if getOpenGlCapable('1.4', 'transparant points and lines'):
                gl.glBlendFunc(gl.GL_CONSTANT_ALPHA,
                               gl.GL_ONE_MINUS_CONSTANT_ALPHA)
                gl.glBlendColor(0.0, 0.0, 0.0, self._alpha1)
            gl.glDisable(gl.GL_DEPTH_TEST)

        # init vertex array
        gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
        gl.glVertexPointerf(self._points.data)

        # points drawn on top of points should draw (because we draw
        # the face and edge seperately)
        gl.glDepthFunc(gl.GL_LEQUAL)

        # Enable alpha test, such that fragments with 0 alpha
        # will not update the z-buffer.
        gl.glEnable(gl.GL_ALPHA_TEST)
        gl.glAlphaFunc(gl.GL_GREATER, 0.01)

        if self.ms in ['o', '.', 's'] and not drawEdge:
            # Use standard OpenGL points, faster and anti-aliased
            # Pure filled points or squares always work.

            # choose style
            if self.ms == 's':
                gl.glDisable(gl.GL_POINT_SMOOTH)
            else:
                gl.glEnable(gl.GL_POINT_SMOOTH)

            # draw faces only
            if drawFace:
                gl.glColor3f(clr1[0], clr1[1], clr1[2])
                gl.glPointSize(self.mw)
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))

        elif self.ms in ['o', '.', 's'] and drawFace and self.alpha == 1:
            # Use standard OpenGL points, faster and anti-aliased
            # If alpha=1 and we have a filled marker, we can draw in two steps.

            # choose style
            if self.ms == 's':
                gl.glDisable(gl.GL_POINT_SMOOTH)
            else:
                gl.glEnable(gl.GL_POINT_SMOOTH)

            # draw edges
            if drawEdge:
                gl.glColor3f(clr2[0], clr2[1], clr2[2])
                gl.glPointSize(self.mw + self.mew * 2)
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))
            # draw faces
            if drawFace:
                gl.glColor3f(clr1[0], clr1[1], clr1[2])
                gl.glPointSize(self.mw)
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))

        #elif self.alpha>0:
        else:
            # Use sprites

            # get sprites
            tmp = f._markerManager.GetSprites(self.ms, self.mw, self.mew)
            pSize, sprite1, sprite2 = tmp
            gl.glPointSize(pSize)

            # draw points for the edges
            if drawEdge:
                sprite2.Enable()
                gl.glColor3f(clr2[0], clr2[1], clr2[2])
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))
            # draw points for the faces
            if drawFace:
                sprite1.Enable()
                gl.glColor3f(clr1[0], clr1[1], clr1[2])
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))

            # disable sprites
            sprite1.Disable()  # Could as well have used sprite2

        # clean up
        gl.glDisable(gl.GL_ALPHA_TEST)
        gl.glEnable(gl.GL_DEPTH_TEST)
        gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
        gl.glDepthFunc(gl.GL_LESS)
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
예제 #15
0
    def _SetDataNow(self):
        """ Make sure the data in self._dataRef is uploaded to 
        OpenGl memory. If possible, update the data rather than 
        create a new texture object.
        """

        # Test whether padding to a factor of two is required
        needPadding = (abs(self._uploadFlag) == 2)
        needPadding = needPadding or not getOpenGlCapable('2.0')

        # Set flag in case of failure (set to success at the end)
        # If we tried without padding, we can still try with padding.
        # Note: In theory, getOpenGlCapable('2.0') should be enough to
        # determine if padding is required. However, bloody ATI drivers
        # sometimes need 2**n textures even if OpenGl > 2.0. (I've
        # encountered this with someones PC and verified that the current
        # solution solves this.)
        if needPadding:
            self._uploadFlag = 0  # Give up
        else:
            self._uploadFlag = 2  # Try with padding next time

        # Get data.
        if self._dataRef is None:
            return
        data = self._dataRef

        # older OpenGl versions do not know about 3D textures
        if self._ndim == 3 and not getOpenGlCapable('1.2', '3D textures'):
            return

        # Make singles if doubles (sadly opengl does not know about doubles)
        if data.dtype == np.float64:
            data = data.astype(np.float32)
        # dito for bools
        if data.dtype == np.bool:
            data = data.astype(np.uint8)

        # Determine type
        thetype = data.dtype.name
        if not thetype in dtypes:
            # this should not happen, since we concert incompatible types
            raise ValueError("Cannot convert datatype %s." % thetype)
        gltype = dtypes[thetype]

        # Determine format
        internalformat, format = self._GetFormat(data.shape)

        # Can we update or should we upload?

        if (gl.glIsTexture(self._texId) and self._shape
                and (data.shape == self._shape)):
            # We can update.

            # Bind to texture
            gl.glBindTexture(self._texType, self._texId)

            # update
            self._UpdateTexture(data, internalformat, format, gltype)

        else:
            # We should upload.

            # Remove any old data.
            self.DestroyGl()

            # Create texture object
            self._texId = gl.glGenTextures(1)

            # Bind to texture
            gl.glBindTexture(self._texType, self._texId)

            # Should we make the image a power of two?
            if needPadding:
                data2 = makePowerOfTwo(data, self._ndim)
                if data2 is not data:
                    data = data2
                    print "Warning: the data was padded to make it a power of two."

            # test whether it fits, downsample if necessary
            ok, count = False, 0
            while not ok and count < 8:
                ok = self._TestUpload(data, internalformat, format, gltype)
                if not ok:
                    #if count<2 and data.shape[0]<1000: # for testing
                    data = downSample(data, self._ndim)
                    count += 1

            # give warning or error
            if count and not ok:
                raise MemoryError("Could not upload texture to OpenGL, " +
                                  "even after 8 times downsampling.")
            elif count:
                print("Warning: data was downscaled " + str(count) +
                      " times to fit it in OpenGL memory.")

            # upload!
            self._UploadTexture(data, internalformat, format, gltype)

            # keep reference of data shape (as loaded to opengl)
            self._shape = data.shape

        # flag success
        if needPadding:
            self._uploadFlag = -2
        else:
            self._uploadFlag = -1
예제 #16
0
파일: line.py 프로젝트: chiluf/visvis.dev
    def _DrawPoints(self):

        # get colors (use color from edge or face if not present)
        clr1 = getColor(self.mc)
        clr2 = getColor(self.mec)

        # draw face or edge?
        drawFace = bool(self.mc) # if not ms or mw we would not get here
        drawEdge = self.mec and self.mew
        if not drawFace and not drawEdge:
            return

        # get figure
        f = self.GetFigure()
        if not f:
            return

        # init blending. Only use constant blendfactor when alpha<1
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        if self._alpha1<1:
            if getOpenGlCapable('1.4','transparant points and lines'):
                gl.glBlendFunc(gl.GL_CONSTANT_ALPHA,
                    gl.GL_ONE_MINUS_CONSTANT_ALPHA)
                gl.glBlendColor(0.0,0.0,0.0, self._alpha1)
            gl.glDisable(gl.GL_DEPTH_TEST)

        # init vertex array
        gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
        gl.glVertexPointerf(self._points.data)

        # points drawn on top of points should draw (because we draw
        # the face and edge seperately)
        gl.glDepthFunc(gl.GL_LEQUAL)

        # Enable alpha test, such that fragments with 0 alpha
        # will not update the z-buffer.
        gl.glEnable(gl.GL_ALPHA_TEST)
        gl.glAlphaFunc(gl.GL_GREATER, 0.01)

        if self.ms in ['o','.','s'] and not drawEdge:
            # Use standard OpenGL points, faster and anti-aliased
            # Pure filled points or squares always work.

            # choose style
            if self.ms == 's':
                gl.glDisable(gl.GL_POINT_SMOOTH)
            else:
                gl.glEnable(gl.GL_POINT_SMOOTH)

            # draw faces only
            if drawFace:
                gl.glColor3f(clr1[0],clr1[1],clr1[2])
                gl.glPointSize(self.mw)
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))

        elif self.ms in ['o','.','s'] and drawFace and self.alpha==1:
            # Use standard OpenGL points, faster and anti-aliased
            # If alpha=1 and we have a filled marker, we can draw in two steps.

            # choose style
            if self.ms == 's':
                gl.glDisable(gl.GL_POINT_SMOOTH)
            else:
                gl.glEnable(gl.GL_POINT_SMOOTH)

            # draw edges
            if drawEdge:
                gl.glColor3f(clr2[0],clr2[1],clr2[2])
                gl.glPointSize(self.mw+self.mew*2)
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))
            # draw faces
            if drawFace:
                gl.glColor3f(clr1[0],clr1[1],clr1[2])
                gl.glPointSize(self.mw)
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))

        #elif self.alpha>0:
        else:
            # Use sprites
            
            # get sprites
            tmp = f._markerManager.GetSprites(self.ms, self.mw, self.mew)
            pSize, sprite1, sprite2 = tmp
            gl.glPointSize(pSize)
            
            # draw points for the edges
            if drawEdge:
                sprite2.Enable()
                gl.glColor3f(clr2[0],clr2[1],clr2[2])
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))
            # draw points for the faces
            if drawFace:
                sprite1.Enable()
                gl.glColor3f(clr1[0],clr1[1],clr1[2])
                gl.glDrawArrays(gl.GL_POINTS, 0, len(self._points))
            
            # disable sprites
            sprite1.Disable() # Could as well have used sprite2
        
        # clean up
        gl.glDisable(gl.GL_ALPHA_TEST)
        gl.glEnable(gl.GL_DEPTH_TEST)
        gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
        gl.glDepthFunc(gl.GL_LESS)
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)