Default setAxes method is now implemented in the GLObject class, and

default values given to xax/yax/zax in
GLObject.__init__. generateVertices method, used by image objects which
display a slice through image texture, is implemenmted in GLImageObject
class, purely to eliminate code duplication. gllabel_funcs module now
has an init function. Other cosmetic changes.

fsl/fslview/gl/gl21/gllabel_funcs.py

@@ -12,10 +12,10 @@ import OpenGL.raw.GL._types   as gltypes
 import fsl.fslview.gl.shaders as shaders
 import                           glvolume_funcs
 
-# TODO make an init() function
 def compileShaders(self):
 
-    self.vertexAttrBuffer = gl.glGenBuffers(1)
+    if self.shaders is not None:
+        gl.glDeleteProgram(self.shaders)
 
     vertShaderSrc = shaders.getVertexShader(  self,
                                               sw=self.display.softwareMode)
@@ -46,6 +46,16 @@ def compileShaders(self):
     self.outlineOffsetsPos = gl.glGetUniformLocation(self.shaders,
                                                      'outlineOffsets')
 
+
+def init(self):
+    self.shaders = None
+
+    compileShaders(   self)
+    updateShaderState(self)
+
+    self.vertexAttrBuffer = gl.glGenBuffers(1)
+    
+
 def destroy(self):
     gl.glDeleteBuffers(1, gltypes.GLuint(self.vertexAttrBuffer))
     gl.glDeleteProgram(self.shaders) 
@@ -53,8 +63,7 @@ def destroy(self):
 
 def updateShaderState(self):
 
-    display = self.display
-    opts    = self.displayOpts
+    opts = self.displayOpts
 
     gl.glUseProgram(self.shaders)
 

fsl/fslview/gl/gl21/glvolume_funcs.py

@@ -108,8 +108,7 @@ def updateShaderState(self):
     current display properties.
     """
 
-    display = self.display
-    opts    = self.displayOpts
+    opts = self.displayOpts
 
     gl.glUseProgram(self.shaders)
     
@@ -124,10 +123,10 @@ def updateShaderState(self):
     # range, but the shader needs them to be in image
     # texture value range (0.0 - 1.0). So let's scale 
     # them.
-    clipLow = opts.clippingRange[0]           * \
+    clipLow = opts.clippingRange[0]            * \
         self.imageTexture.invVoxValXform[0, 0] + \
         self.imageTexture.invVoxValXform[3, 0]
-    clipHigh = opts.clippingRange[1]          * \
+    clipHigh = opts.clippingRange[1]           * \
         self.imageTexture.invVoxValXform[0, 0] + \
         self.imageTexture.invVoxValXform[3, 0] 
 

fsl/fslview/gl/gllabel.py

 #!/usr/bin/env python
 #
-# gllabel.py -
+# gllabel.py - OpenGL representation for label/atlas images.
 #
 # Author: Paul McCarthy <pauldmccarthy@gmail.com>
 #
 
-import OpenGL.GL           as gl
+import OpenGL.GL      as gl
 
-import fsl.utils.transform as transform
-import fsl.fslview.gl      as fslgl
-import resources           as glresources
-import routines            as glroutines
-import                        globject
-import                        textures
+import fsl.fslview.gl as fslgl
+import resources      as glresources
+import                   globject
+import                   textures
 
 
 class GLLabel(globject.GLImageObject):
@@ -32,14 +30,21 @@ class GLLabel(globject.GLImageObject):
             imageTexName,
             image,
             display)
-
         
-        fslgl.gllabel_funcs.compileShaders(self)
+        fslgl.gllabel_funcs.init(self)
 
         self.refreshLutTexture()
-
         self.addListeners()
 
+        
+    def destroy(self):
+
+        glresources.delete(self.imageTexture.getTextureName())
+        self.lutTexture.destroy()
+
+        self.removeListeners()
+        fslgl.gllabel_funcs.destroy(self)
+
 
     def addListeners(self):
 
@@ -68,6 +73,10 @@ class GLLabel(globject.GLImageObject):
 
         self.__lut = opts.lut
 
+        # TODO If you add a software shader, you will
+        #      need to call gllabel_funcs.compileShaders
+        #      when display.softwareMode changes
+
         opts    .addListener('outline',       self.name, shaderUpdate)
         opts    .addListener('outlineWidth',  self.name, shaderUpdate)
         opts    .addListener('lut',           self.name, lutChanged)
@@ -75,7 +84,6 @@ class GLLabel(globject.GLImageObject):
         display .addListener('alpha',         self.name, lutUpdate)
         display .addListener('brightness',    self.name, lutUpdate)
         display .addListener('contrast',      self.name, lutUpdate)
-        
 
 
     def removeListeners(self):
@@ -89,40 +97,11 @@ class GLLabel(globject.GLImageObject):
         display.removeListener('brightness',    self.name)
         display.removeListener('contrast',      self.name)
 
-    
-    def destroy(self):
-
-        glresources.delete(self.imageTexture.getTextureName())
-        self.lutTexture.destroy()
-
-        self.removeListeners()
-        fslgl.gllabel_funcs.destroy(self)
-
         
     def setAxes(self, xax, yax):
-        """This method should be called when the image display axes change."""
-        
-        self.xax = xax
-        self.yax = yax
-        self.zax = 3 - xax - yax
-
+        globject.GLImageObject.setAxes(self, xax, yax)
         fslgl.gllabel_funcs.updateShaderState(self)
 
-        
-    def generateVertices(self, zpos, xform):
-        vertices, voxCoords, texCoords = glroutines.slice2D(
-            self.image.shape[:3],
-            self.xax,
-            self.yax,
-            zpos, 
-            self.displayOpts.getTransform('voxel',   'display'),
-            self.displayOpts.getTransform('display', 'voxel'))
-
-        if xform is not None: 
-            vertices = transform.transform(vertices, xform)
-
-        return vertices, voxCoords, texCoords 
-
 
     def refreshLutTexture(self, *a):
 

fsl/fslview/gl/glmodel.py

@@ -104,10 +104,7 @@ class GLModel(globject.GLObject):
         
     
     def setAxes(self, xax, yax):
-        self.xax = xax
-        self.yax = yax
-        self.zax = 3 - xax - yax
-
+        globject.GLObject.setAxes(self, xax, yax)
         self._renderTexture.setAxes(xax, yax)
  
 

fsl/fslview/gl/globject.py

@@ -15,6 +15,9 @@ representation.
 
 import numpy as np
 
+import routines            as glroutines
+import fsl.utils.transform as transform
+
 
 def createGLObject(overlay, display):
     """Create :class:`GLObject` instance for the given overlay, as specified
@@ -34,21 +37,43 @@ def createGLObject(overlay, display):
 class GLObject(object):
     """The :class:`GLObject` class is a superclass for all 2D OpenGL
     objects.
+
+    The following attributes will always be available on ``GLObject``
+    instances:
+
+      - ``name``: A unique name for this ``GLObject`` instance.
+
+      - ``xax``:  Index of the display coordinate system axis that
+                  corresponds to the horizontal screen axis.
+    
+      - ``yax``:  Index of the display coordinate system axis that 
+                  corresponds to the vertical screen axis.
+    
+      - ``zax``:  Index of the display coordinate system axis that 
+                  corresponds to the depth screen axis. 
     """
 
+    
     def __init__(self):
-        """Create a :class:`GLObject`.  The constructor adds one attribute to
-        this instance, ``name``, which is simply a unique name for this
-        instance.
+        """Create a :class:`GLObject`.  The constructor adds one attribute
+        to this instance, ``name``, which is simply a unique name for this
+        instance, and gives default values to the ``xax``, ``yax``, and
+        ``zax`` attributes.
 
         Subclass implementations must call this method, and should also
         perform any necessary OpenGL initialisation, such as creating
         textures.
         """
 
+        # Give this instance a name, and set 
+        # initial values for the display axes
         self.name = '{}_{}'.format(type(self).__name__, id(self))
+        self.xax  = 0
+        self.yax  = 1
+        self.zax  = 2
+        
         self.__updateListeners = {}
-
+        
         
     def addUpdateListener(self, name, listener):
         """Adds a listener function which will be called whenever this
@@ -87,10 +112,15 @@ class GLObject(object):
     
     def setAxes(self, xax, yax):
         """This method is called when the display orientation for this
-        :class:`GLObject` changes. It should perform any necessary updates to
-        the GL data (e.g. regenerating/moving vertices).
+        :class:`GLObject` changes. It sets :attr:`xax`, :attr:`yax`,
+        and :attr:`zax` attributes on this ``GLObject`` instance.
+
+        Subclass implementations should call this method, or should set
+        the ``xax``, ``yax``, and ``zax`` attributes themselves.
         """
-        raise NotImplementedError()
+        self.xax = xax
+        self.yax = yax
+        self.zax = 3 - xax - yax
 
     
     def destroy(self):
@@ -131,7 +161,7 @@ class GLObject(object):
         ``xforms`` arrays.
 
         In some circumstances (hint: the :class:`.LightBoxCanvas`), better
-        performance may be achievbed in combining multiple renders, rather
+        performance may be achieved in combining multiple renders, rather
         than doing it with separate calls to :meth:`draw`.
 
         The default implementation does exactly this, so this method need only
@@ -160,27 +190,12 @@ class GLSimpleObject(GLObject):
 
     Subclasses should not assume that any of the other methods will ever
     be called.
-
-    On calls to :meth:`draw`, the following attributes will be available on
-    ``GLSimpleObject`` instances:
-
-      - ``xax``: Index of the display coordinate system axis that corresponds
-                 to the horizontal screen axis.
-    
-      - ``yax``: Index of the display coordinate system axis that corresponds
-                 to the vertical screen axis.
     """
 
     def __init__(self):
         GLObject.__init__(self)
 
-    def setAxes(self, xax, yax):
-        self.xax =  xax
-        self.yax =  yax
-        self.zax = 3 - xax - yax
-
-
-    def destroy(self): pass
+    def destroy( self): pass
     def preDraw( self): pass
     def postDraw(self): pass
 
@@ -234,6 +249,37 @@ class GLImageObject(GLObject):
             minres = int(round(((hi - lo) / res).min()))
             return [minres] * 3
 
+        
+    def generateVertices(self, zpos, xform):
+        """Generates vertex coordinates for a 2D slice through the given
+        ``zpos``, with the optional ``xform`` applied to the coordinates.
+        
+        This method is called by the :mod:`.gl14.glvolume_funcs` and
+        :mod:`.gl21.glvolume_funcs` modules.
+
+        A tuple of three values is returned, containing:
+        
+          - A ``6*3 numpy.float32`` array containing the vertex coordinates
+        
+          - A ``6*3 numpy.float32`` array containing the voxel coordinates
+            corresponding to each vertex
+        
+          - A ``6*3 numpy.float32`` array containing the texture coordinates
+            corresponding to each vertex
+        """ 
+        vertices, voxCoords, texCoords = glroutines.slice2D(
+            self.image.shape[:3],
+            self.xax,
+            self.yax,
+            zpos, 
+            self.displayOpts.getTransform('voxel',   'display'),
+            self.displayOpts.getTransform('display', 'voxel'))
+
+        if xform is not None: 
+            vertices = transform.transform(vertices, xform)
+
+        return vertices, voxCoords, texCoords 
+
 
 import glvolume
 import glmask

fsl/fslview/gl/glrgbvector.py

@@ -10,9 +10,7 @@ vector images in RGB mode.
 
 import numpy                   as np
 import fsl.fslview.gl          as fslgl
-import fsl.fslview.gl.routines as glroutines
 import fsl.fslview.gl.glvector as glvector
-import fsl.utils.transform     as transform
 
 
 class GLRGBVector(glvector.GLVector):
@@ -28,21 +26,6 @@ class GLRGBVector(glvector.GLVector):
         fslgl.glrgbvector_funcs.init(self)
 
 
-    def generateVertices(self, zpos, xform):
-        vertices, voxCoords, texCoords = glroutines.slice2D(
-            self.image.shape[:3],
-            self.xax,
-            self.yax,
-            zpos, 
-            self.displayOpts.getTransform('voxel',   'display'),
-            self.displayOpts.getTransform('display', 'voxel'))
-
-        if xform is not None: 
-            vertices = transform.transform(vertices, xform)
-
-        return vertices, voxCoords, texCoords 
-
-
     def compileShaders(self):
         fslgl.glrgbvector_funcs.compileShaders(self)
         

fsl/fslview/gl/glvector.py

@@ -276,14 +276,6 @@ class GLVector(globject.GLImageObject):
 
             texture.set(cmap=cmap, displayRange=drange)
         
-
-    def setAxes(self, xax, yax):
-        """Stores the new x/y/z axes."""
-
-        self.xax = xax
-        self.yax = yax
-        self.zax = 3 - xax - yax
-
         
     def preDraw(self):
         """Must be called by subclass implementations.

fsl/fslview/gl/glvolume.py

@@ -53,14 +53,12 @@ of the image bounds.
 import logging
 log = logging.getLogger(__name__)
 
-import OpenGL.GL                as gl
+import OpenGL.GL      as gl
 
-import fsl.utils.transform      as transform
-import fsl.fslview.gl           as fslgl
-import                             textures
-import                             globject
-import routines                 as glroutines
-import resources                as glresources
+import fsl.fslview.gl as fslgl
+import                   textures
+import                   globject
+import resources      as glresources
 
 
 class GLVolume(globject.GLImageObject):
@@ -106,14 +104,6 @@ class GLVolume(globject.GLImageObject):
         fslgl.glvolume_funcs.init(self)
 
 
-    def setAxes(self, xax, yax):
-        """This method should be called when the image display axes change."""
-        
-        self.xax = xax
-        self.yax = yax
-        self.zax = 3 - xax - yax
-
-
     def preDraw(self):
         """Sets up the GL state to draw a slice from this :class:`GLVolume`
         instance.
@@ -125,37 +115,6 @@ class GLVolume(globject.GLImageObject):
 
         fslgl.glvolume_funcs.preDraw(self)
 
-
-    def generateVertices(self, zpos, xform=None):
-        """Generates vertex coordinates for a 2D slice through the given
-        ``zpos``, with the optional ``xform`` applied to the coordinates.
-        
-        This method is called by the :mod:`.gl14.glvolume_funcs` and
-        :mod:`.gl21.glvolume_funcs` modules.
-
-        A tuple of three values is returned, containing:
-        
-          - A ``6*3 numpy.float32`` array containing the vertex coordinates
-        
-          - A ``6*3 numpy.float32`` array containing the voxel coordinates
-            corresponding to each vertex
-        
-          - A ``6*3 numpy.float32`` array containing the texture coordinates
-            corresponding to each vertex
-        """
-        vertices, voxCoords, texCoords = glroutines.slice2D(
-            self.image.shape[:3],
-            self.xax,
-            self.yax,
-            zpos, 
-            self.displayOpts.getTransform('voxel',   'display'),
-            self.displayOpts.getTransform('display', 'voxel'))
-
-        if xform is not None: 
-            vertices = transform.transform(vertices, xform)
-
-        return vertices, voxCoords, texCoords
-
         
     def draw(self, zpos, xform=None):
         """Draws a 2D slice of the image at the given real world Z location.