diff --git a/fsl/fslview/gl/gl14/gllinevector_funcs.py b/fsl/fslview/gl/gl14/gllinevector_funcs.py
index 7204194878c9f619544fca69763d09bf0086c7de..eadb1a0431d07868c20180e0413611fc86abce4a 100644
--- a/fsl/fslview/gl/gl14/gllinevector_funcs.py
+++ b/fsl/fslview/gl/gl14/gllinevector_funcs.py
@@ -36,23 +36,22 @@ def init(self):
     updateShaderState(self)
     updateVertices(   self)
 
-    display = self.display
-    opts    = self.opts
+    opts = self.displayOpts
 
     def vertexUpdate(*a):
         updateVertices(self)
         self.onUpdate()
 
-    display.addListener('resolution', self.name, vertexUpdate)
-    opts   .addListener('directed',   self.name, vertexUpdate)
+    opts.addListener('resolution', self.name, vertexUpdate)
+    opts.addListener('directed',   self.name, vertexUpdate)
 
 
 def destroy(self):
     arbvp.glDeleteProgramsARB(1, gltypes.GLuint(self.vertexProgram))
     arbfp.glDeleteProgramsARB(1, gltypes.GLuint(self.fragmentProgram))
 
-    self.display.removeListener('resolution', self.name)
-    self.opts   .removeListener('directed',   self.name)
+    self.displayOpts.removeListener('resolution', self.name)
+    self.displayOpts.removeListener('directed',   self.name)
 
     glresources.delete(self._vertexResourceName)
 
@@ -80,17 +79,16 @@ def compileShaders(self):
 
 def updateVertices(self):
     
-    image   = self.image
-    display = self.display
-    opts    = self.opts
+    image = self.image
+    opts  = self.displayOpts
 
     if self.lineVertices is None:
         self.lineVertices = glresources.get(
             self._vertexResourceName, gllinevector.GLLineVertices, self) 
 
-    newHash = (hash(display.transform)    ^
-               hash(display.resolution)   ^
-               hash(opts   .directed))
+    newHash = (hash(opts.transform)  ^
+               hash(opts.resolution) ^
+               hash(opts.directed))
 
     if hash(self.lineVertices) != newHash:
 
@@ -161,7 +159,7 @@ def draw(self, zpos, xform=None):
         gl.glTexCoordPointer(3, gl.GL_FLOAT, 0, texCoords)
 
     vertices = vertices.ravel('C')
-    v2d      = self.display.getTransform('voxel', 'display')
+    v2d      = opts.getTransform('voxel', 'display')
 
     if xform is None: xform = v2d
     else:             xform = transform.concat(v2d, xform)
diff --git a/fsl/fslview/gl/gl21/gllinevector_funcs.py b/fsl/fslview/gl/gl21/gllinevector_funcs.py
index b0967f35cf79212e171a8b00b4de0b740d39c92a..da977d8980c57caf14bdbee0925ffadfb9a8dc18 100644
--- a/fsl/fslview/gl/gl21/gllinevector_funcs.py
+++ b/fsl/fslview/gl/gl21/gllinevector_funcs.py
@@ -31,9 +31,8 @@ def init(self):
 
     self._vertexResourceName = '{}_{}_vertices'.format(
         type(self).__name__, id(self.image))
-    
-    display = self.display
-    opts    = self.opts
+
+    opts = self.displayOpts
 
     def vertexUpdate(*a):
         
@@ -41,9 +40,9 @@ def init(self):
         self.updateShaderState()
         self.onUpdate()
 
-    display.addListener('transform',  self.name, vertexUpdate)
-    display.addListener('resolution', self.name, vertexUpdate)
-    opts   .addListener('directed',   self.name, vertexUpdate)
+    opts.addListener('transform',  self.name, vertexUpdate)
+    opts.addListener('resolution', self.name, vertexUpdate)
+    opts.addListener('directed',   self.name, vertexUpdate)
 
     compileShaders(   self)
     updateShaderState(self)
@@ -55,9 +54,9 @@ def destroy(self):
     gl.glDeleteBuffers(1, gltypes.GLuint(self.texCoordBuffer))
     gl.glDeleteProgram(self.shaders)
 
-    self.display.removeListener('transform',  self.name)
-    self.display.removeListener('resolution', self.name)
-    self.opts   .removeListener('directed',   self.name)
+    self.displayOpts.removeListener('transform',  self.name)
+    self.displayOpts.removeListener('resolution', self.name)
+    self.displayOpts.removeListener('directed',   self.name)
 
     if self.display.softwareMode:
         glresources.delete(self._vertexResourceName)
@@ -149,8 +148,8 @@ def updateShaderState(self):
         
         directed  = opts.directed
         imageDims = self.image.pixdim[:3]
-        d2vMat    = display.getTransform('display', 'voxel')
-        v2dMat    = display.getTransform('voxel',   'display')
+        d2vMat    = opts.getTransform('display', 'voxel')
+        v2dMat    = opts.getTransform('voxel',   'display')
 
         imageDims = np.array(imageDims, dtype=np.float32)
         d2vMat    = np.array(d2vMat,    dtype=np.float32).ravel('C')
@@ -169,7 +168,7 @@ def updateVertices(self):
 
     image   = self.image
     display = self.display
-    opts    = self.opts
+    opts    = self.displayOpts
 
     if not display.softwareMode:
 
@@ -184,9 +183,9 @@ def updateVertices(self):
         self.lineVertices = glresources.get(
             self._vertexResourceName, gllinevector.GLLineVertices, self)
     
-    newHash = (hash(display.transform)  ^
-               hash(display.resolution) ^
-               hash(opts   .directed))
+    newHash = (hash(opts.transform)  ^
+               hash(opts.resolution) ^
+               hash(opts.directed))
 
     if hash(self.lineVertices) != newHash:
 
@@ -217,7 +216,7 @@ def softwareDraw(self, zpos, xform=None):
     vertices  = vertices .ravel('C')
     texCoords = texCoords.ravel('C')
 
-    v2d = self.display.getTransform('voxel', 'display')
+    v2d = opts.getTransform('voxel', 'display')
 
     if xform is None: xform = v2d
     else:             xform = transform.concat(v2d, xform)
@@ -252,14 +251,13 @@ def softwareDraw(self, zpos, xform=None):
 def hardwareDraw(self, zpos, xform=None):
 
     image      = self.image
-    display    = self.display
     opts       = self.displayOpts
-    v2dMat     = self.display.getTransform('voxel', 'display')
-    resolution = np.array([display.resolution] * 3)
+    v2dMat     = opts.getTransform('voxel', 'display')
+    resolution = np.array([opts.resolution] * 3)
 
-    if display.transform == 'id':
+    if opts.transform == 'id':
         resolution = resolution / min(image.pixdim[:3])
-    elif display.transform == 'pixdim':
+    elif opts.transform == 'pixdim':
         resolution = map(lambda r, p: max(r, p), resolution, image.pixdim[:3])
 
     vertices = glroutines.calculateSamplePoints(
diff --git a/fsl/fslview/gl/gllinevector.py b/fsl/fslview/gl/gllinevector.py
index 949a62b4869df4c10e0b9f295434b6317a036381..ad7882b79ed188a207839e6b183cb3672b2a7f5f 100644
--- a/fsl/fslview/gl/gllinevector.py
+++ b/fsl/fslview/gl/gllinevector.py
@@ -38,14 +38,13 @@ class GLLineVertices(object):
         
     def refresh(self, glvec):
 
-        display = glvec.display
-        opts    = glvec.opts
-        image   = glvec.image
+        opts  = glvec.displayOpts
+        image = glvec.image
 
         # Extract a sub-sample of the vector image
         # at the current display resolution
         data, starts, steps = glroutines.subsample(image.data,
-                                                   display.resolution,
+                                                   opts.resolution,
                                                    image.pixdim)
 
         # Pull out the xyz components of the 
@@ -105,18 +104,18 @@ class GLLineVertices(object):
         self.texCoords = texCoords
         self.starts    = starts
         self.steps     = steps
-        self.__hash    = (hash(display.transform)  ^
-                          hash(display.resolution) ^
-                          hash(opts   .directed))
+        self.__hash    = (hash(opts.transform)  ^
+                          hash(opts.resolution) ^
+                          hash(opts.directed))
  
 
     def getVertices(self, glvec, zpos):
 
-        display = glvec.display
-        image   = glvec.image
-        xax     = glvec.xax
-        yax     = glvec.yax
-        zax     = glvec.zax
+        opts  = glvec.displayOpts
+        image = glvec.image
+        xax   = glvec.xax
+        yax   = glvec.yax
+        zax   = glvec.zax
 
         vertices  = self.vertices
         texCoords = self.texCoords
@@ -126,10 +125,10 @@ class GLLineVertices(object):
         # If in id/pixdim space, the display
         # coordinate system axes are parallel
         # to the voxeld coordinate system axes
-        if display.transform in ('id', 'pixdim'):
+        if opts.transform in ('id', 'pixdim'):
 
             # Turn the z position into a voxel index
-            if display.transform == 'pixdim':
+            if opts.transform == 'pixdim':
                 zpos = zpos / image.pixdim[zax]
 
             zpos = round(zpos)
@@ -155,8 +154,8 @@ class GLLineVertices(object):
             # in the display coordinate system
             coords = glroutines.calculateSamplePoints(
                 image.shape[ :3],
-                [display.resolution] * 3,
-                display.getTransform('voxel', 'display'),
+                [opts.resolution] * 3,
+                opts.getTransform('voxel', 'display'),
                 xax,
                 yax)[0]
             
@@ -165,7 +164,7 @@ class GLLineVertices(object):
             # transform that plane of display
             # coordinates into voxel coordinates
             coords = transform.transform(
-                coords, display.getTransform('display', 'voxel'))
+                coords, opts.getTransform('display', 'voxel'))
 
             # The voxel vertex matrix may have
             # been sub-sampled (see the
@@ -196,21 +195,19 @@ class GLLineVector(glvector.GLVector):
         
         glvector.GLVector.__init__(self, image, display)
         
-        self.opts = display.getDisplayOpts()
-        
         fslgl.gllinevector_funcs.init(self)
 
         def update(*a):
             self.onUpdate()
 
-        self.opts.addListener('lineWidth', self.name, update)
+        self.displayOpts.addListener('lineWidth', self.name, update)
 
         
     def destroy(self):
         glvector.GLVector.destroy(self)
         fslgl.gllinevector_funcs.destroy(self)
         
-        self.opts.removeListener('lineWidth', self.name)
+        self.displayOpts.removeListener('lineWidth', self.name)
 
 
     def getDataResolution(self, xax, yax):
diff --git a/fsl/fslview/gl/glrgbvector.py b/fsl/fslview/gl/glrgbvector.py
index 6d78c29f045d1c86c501f9358432e680c1307427..d4c80c080950e3013ab5d1726707a2fee78acec8 100644
--- a/fsl/fslview/gl/glrgbvector.py
+++ b/fsl/fslview/gl/glrgbvector.py
@@ -34,8 +34,8 @@ class GLRGBVector(glvector.GLVector):
             self.xax,
             self.yax,
             zpos, 
-            self.display.getTransform('voxel',   'display'),
-            self.display.getTransform('display', 'voxel'))
+            self.displayOpts.getTransform('voxel',   'display'),
+            self.displayOpts.getTransform('display', 'voxel'))
 
         if xform is not None: 
             vertices = transform.transform(vertices, xform)