python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/LMVis/layers/image_layer.py

@@ -0,0 +1,363 @@
+from .base import BaseEngine, EngineLayer
+from PYME.LMVis.shader_programs.DefaultShaderProgram import DefaultShaderProgram, ImageShaderProgram
+from PYME.LMVis.shader_programs.WireFrameShaderProgram import WireFrameShaderProgram
+from PYME.LMVis.shader_programs.GouraudShaderProgram import GouraudShaderProgram
+from PYME.LMVis.shader_programs.TesselShaderProgram import TesselShaderProgram
+
+from PYME.recipes.traits import CStr, Float, Enum, ListFloat, List, Int, observe
+# from pylab import cm
+from PYME.misc.colormaps import cm
+import numpy as np
+from PYME.contrib import dispatch
+
+from OpenGL.GL import *
+
+
+class ImageEngine(BaseEngine):
+    _outlines = True
+    def __init__(self):
+        BaseEngine.__init__(self)
+        self.set_shader_program(ImageShaderProgram)
+        
+        self._texture_id = None
+        self._lut_id = None
+        self._img = None
+        self._lut = None
+        
+    def set_texture(self, image):
+        if self._texture_id is None:
+            self._texture_id = glGenTextures(1)
+    
+        if image is None:
+            return
+        
+        if not image is self._img:
+            self._img = image
+    
+            image = image.T.reshape(*image.shape) #get our byte order right
+    
+            glActiveTexture(GL_TEXTURE0)
+            glBindTexture(GL_TEXTURE_2D, self._texture_id)
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+            #glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+            #glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+            #glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, image.shape[0], image.shape[1], 0, GL_RED, GL_FLOAT, image.astype('f4'))
+
+    def set_lut(self, lut):
+        if self._lut_id is None:
+            self._lut_id = glGenTextures(1)
+    
+        if lut is None:
+            return
+    
+        if not lut is self._lut:
+            self._lut = lut
+            
+            lut_array = lut(np.linspace(0, 1.0, 255))
+            
+            print(lut_array.shape, lut_array[-1])
+        
+            glActiveTexture(GL_TEXTURE1)
+            glBindTexture(GL_TEXTURE_1D, self._lut_id)
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+            glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+            #glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP)
+            #glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+            glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+            #glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+            glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+            #glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
+            glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, lut_array.shape[0], 0, GL_RGBA, GL_FLOAT,
+                         lut_array.astype('f4'))
+
+    
+    def render(self, gl_canvas, layer):
+        with self.get_shader_program(gl_canvas) as sp:
+            sp.set_clipping(gl_canvas.view.clipping.squeeze(), gl_canvas.view.clip_plane_matrix)
+            
+            if gl_canvas.core_profile:
+                sp.set_modelviewprojectionmatrix(gl_canvas.mvp)
+
+            self.set_lut(layer.colour_map)
+            glActiveTexture(GL_TEXTURE1)
+            glBindTexture(GL_TEXTURE_1D, self._lut_id) # bind to our texture, has id of 1 */
+            glUniform1i(sp.get_uniform_location("lut"), 1)
+            
+            self.set_texture(layer._im)
+            glUniform2f(sp.get_uniform_location("clim"), *layer.get_color_limit())
+            
+            if not gl_canvas.core_profile:
+                glEnable(GL_TEXTURE_2D) # enable texture mapping */
+
+            glActiveTexture(GL_TEXTURE0)
+            glBindTexture(GL_TEXTURE_2D, self._texture_id) # bind to our texture, has id of 1 */
+            glUniform1i(sp.get_uniform_location("im_sampler"), 0)
+            
+            x0, y0, x1, y1 = layer._bounds
+
+            if not gl_canvas.core_profile:
+                glDisable(GL_TEXTURE_GEN_S)
+                glDisable(GL_TEXTURE_GEN_T)
+                glDisable(GL_TEXTURE_GEN_R)
+
+            if gl_canvas.core_profile:
+                verts = self._gen_rect_triangles(x0, y0, x1-x0, y1-y0, z=layer.z_nm)
+                tex_coords = self._gen_rect_texture_coords()
+
+                vao = glGenVertexArrays(1)
+                vbo = glGenBuffers(2)
+                glBindVertexArray(vao)
+                glBindBuffer(GL_ARRAY_BUFFER, vbo[0])
+                glBufferData(GL_ARRAY_BUFFER, verts.nbytes, verts, GL_STATIC_DRAW)
+                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
+                glEnableVertexAttribArray(0)
+                glBindBuffer(GL_ARRAY_BUFFER, vbo[1])
+                glBufferData(GL_ARRAY_BUFFER, tex_coords.nbytes, tex_coords, GL_STATIC_DRAW)
+                glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, None)
+                glEnableVertexAttribArray(1)
+
+                glDrawArrays(GL_TRIANGLES, 0, len(verts))
+                glBindBuffer(GL_ARRAY_BUFFER, 0)
+                glBindVertexArray(0)
+                glDeleteVertexArrays(1, [vao, ])
+                glDeleteBuffers(2, vbo)
+
+            else:
+                #glColor3f(1.,0.,0.)
+                glColor4f(1., 1., 1., 1.)
+                glBegin(GL_QUADS)
+                glTexCoord2f(0., 0.) # lower left corner of image */
+                glVertex3f(x0, y0, layer.z_nm)
+                glTexCoord2f(1., 0.) # lower right corner of image */
+                glVertex3f(x1, y0, layer.z_nm)
+                glTexCoord2f(1.0, 1.0) # upper right corner of image */
+                glVertex3f(x1, y1, layer.z_nm)
+                glTexCoord2f(0.0, 1.0) # upper left corner of image */
+                glVertex3f(x0, y1, layer.z_nm)
+                glEnd()
+    
+            if not gl_canvas.core_profile:
+                glDisable(GL_TEXTURE_2D)
+                
+
+
+ENGINES = {
+    'image' : ImageEngine,
+}
+
+
+class ImageRenderLayer(EngineLayer):
+    """
+    Layer for viewing images.
+    """
+    # properties to show in the GUI. Note that we also inherit 'visible' from BaseLayer
+    cmap = Enum(*cm.cmapnames, default='gray', desc='Name of colourmap used to colour faces')
+    clim = ListFloat([0, 1], desc='How our data should be scaled prior to colour mapping')
+    alpha = Float(1.0, desc='Tranparency')
+    method = Enum(*ENGINES.keys(), desc='Method used to display image')
+    dsname = CStr('output', desc='Name of the datasource within the pipeline to use as an image')
+    channel = Int(0)
+    #slice = Int(0)
+    z_pos = Int(0)
+    t_pos = Int(0)
+    _datasource_choices = List()
+    _datasource_keys = List()
+
+    def __init__(self, pipeline, method='image', dsname='', display_opts=None, **kwargs):
+        EngineLayer.__init__(self, **kwargs)
+        self._pipeline = pipeline
+        self.engine = None
+        self.cmap = 'gray'
+
+        self._bbox = None
+        self._do = display_opts #a dh5view display_options instance - if provided, this over-rides the the clim, cmap properties
+        
+        self._im_key = None
+        self._zn_nm = 0
+
+        # define a signal so that people can be notified when we are updated (currently used to force a redraw when
+        # parameters change)
+        self.on_update = dispatch.Signal()
+
+        # define responses to changes in various traits
+        #self.on_trait_change(self._update, 'vertexColour')
+        self.on_trait_change(lambda: self.on_update.send(self), 'visible')
+        self.on_trait_change(self.update, 'cmap, clim, alpha, dsname, channel, z_pos, t_pos')
+        self.on_trait_change(self._set_method, 'method')
+
+        # update any of our traits which were passed as command line argumessssnts
+        self.trait_set(**kwargs)
+
+        # update datasource and method
+        self.dsname = dsname
+        if self.method == method:
+            #make sure we still call _set_method even if we start with the default method
+            self._set_method()
+        else:
+            self.method = method
+
+        # if we were given a pipeline, connect ourselves to the onRebuild signal so that we can automatically update
+        # ourselves
+        if (not self._pipeline is None) and hasattr(pipeline, 'onRebuild'):
+            self._pipeline.onRebuild.connect(self.update)
+
+        if self._do:
+            self.sync_to_display_opts()
+            self._do.WantChangeNotification.append(self.sync_to_display_opts)
+
+    @property
+    def datasource(self):
+        """
+        Return the datasource we are connected to (does not go through the pipeline for triangles_mesh).
+        """
+        try:
+            return self._pipeline.get_layer_data(self.dsname)
+        except AttributeError:
+            #fallback if pipeline is a dictionary
+            return self._pipeline[self.dsname]
+        #return self.datasource
+    
+    @property
+    def _ds_class(self):
+        # from PYME.experimental import triangle_mesh
+        from PYME.IO import image
+        return image.ImageStack
+
+    def _set_method(self):
+        self.engine = ENGINES[self.method]()
+        self.update()
+
+
+    # def _update(self, *args, **kwargs):
+    #     #pass
+    #     cdata = self._get_cdata()
+    #     self.clim = [float(cdata.min()), float(cdata.max())]
+    #     self.update(*args, **kwargs)
+
+    @observe('z_pos, t_pos')
+    def update(self, *args, **kwargs):
+        try:
+            self._datasource_choices = [k for k, v in self._pipeline.dataSources.items() if isinstance(v, self._ds_class)]
+        except AttributeError:
+            self._datasource_choices = [k for k, v in self._pipeline.items() if
+                                        isinstance(v, self._ds_class)]
+        
+        if not (self.engine is None or self.datasource is None):
+            print('lw update')
+            self.update_from_datasource(self.datasource)
+            self.on_update.send(self)
+
+    @property
+    def z_nm(self):
+        return self._z_nm
+
+    @property
+    def bbox(self):
+        return self._bbox
+    
+    def sync_to_display_opts(self, do=None):
+        if (do is None):
+            if not (self._do is None):
+                do = self._do
+            else:
+                return
+
+        o = do.Offs[self.channel]
+        g = do.Gains[self.channel]
+        clim = [o, o + 1.0 / g]
+
+        cmap = do.cmaps[self.channel].name
+        visible = do.show[self.channel]
+
+        self.trait_set(clim=clim, cmap=cmap, visible=visible, z_pos=do.zp, t_pos=do.tp)     
+        
+
+    def update_from_datasource(self, ds):
+        """
+
+        Parameters
+        ----------
+        ds :
+            PYME.IO.image.ImageStack object
+
+        Returns
+        -------
+        None
+        """
+
+        
+        #if self._do is not None:
+            # Let display options (if provied) over-ride our settings (TODO - is this the right way to do this?)
+        #    o = self._do.Offs[self.channel]
+        #    g = self._do.Gains[self.channel]
+        #    clim = [o, o + 1.0/g]
+            #self.clim = clim
+            
+        #    cmap = self._do.cmaps[self.channel]
+            #self.visible = self._do.show[self.channel]
+        #else:
+        
+        clim = self.clim
+        cmap = cm[self.cmap]
+            
+        alpha = float(self.alpha)
+        
+        c0, c1 = clim
+        
+        im_key = (self.dsname, self.z_pos, self.t_pos, self.channel)
+        
+        if not self._im_key == im_key:
+            self._im_key = im_key
+            self._im = ds.data_xyztc[:,:,self.z_pos, self.t_pos,self.channel].astype('f4').squeeze()# - c0)/(c1-c0)
+        
+            x0, y0, x1, y1, z0, z1 = ds.imgBounds.bounds
+
+            self._z_nm = z0 + self.z_pos*ds.voxelsize_nm.z 
+
+            self._bbox = np.array([x0, y0, z0, x1, y1, z1])
+        
+            self._bounds = [x0, y0, x1, y1]
+            
+        self._alpha = alpha
+        self._color_map = cmap
+        self._color_limit = clim
+
+        
+
+    def get_color_map(self):
+        return self._color_map
+
+    @property
+    def colour_map(self):
+        return self._color_map
+
+    def get_color_limit(self):
+        return self._color_limit
+    
+    def _get_cdata(self):
+        return self._im.ravel()[::20]
+
+    @property
+    def default_view(self):
+        from traitsui.api import View, Item, Group, InstanceEditor, EnumEditor
+        from PYME.ui.custom_traits_editors import HistLimitsEditor, CBEditor
+
+        return View([Group([Item('dsname', label='Data', editor=EnumEditor(name='_datasource_choices')), ]),
+                     #Item('method'),
+                     Group([Item('clim', editor=HistLimitsEditor(data=self._get_cdata), show_label=False), ]),
+                     Group([Item('cmap', label='LUT'),
+                            Item('z_pos', label='Z'),
+                            Item('t_pos', label='T'),
+                            Item('channel', label='Channel'),
+                            Item('alpha', visible_when='method in ["flat", "tessel"]')
+                            ])
+                     ], )
+        # buttons=['OK', 'Cancel'])
+
+    def default_traits_view(self):
+        return self.default_view

PYME/LMVis/layers/labels.py

@@ -0,0 +1,186 @@
+"""
+A layer which draws text labels at the positions of the points in a tabular datasource.
+"""
+
+from PYME.LMVis.layers.base import SimpleLayer
+
+from PYME.recipes.traits import CStr, Float, Enum, ListFloat, List, Bool
+# from pylab import cm
+from PYME.misc.colormaps import cm
+import numpy as np
+import string
+from PYME.contrib import dispatch
+from .text import Text
+
+import logging
+logger = logging.getLogger(__name__)
+
+class LabelLayer(SimpleLayer):
+    """
+    A layer which draws text labels at the positions of the points in a tabular datasource.
+    """
+
+    dsname = CStr('output', desc='Name of the datasource within the pipeline to use as a source of points')
+    _datasource_keys = List()
+    _datasource_choices = List()
+
+    textColour = CStr('', desc='Name of variable used to colour our text')
+    font_size = Float(10, desc='font size in points')
+    cmap = Enum('SolidWhite', cm.cmapnames, desc='Name of colourmap used to colour text')
+    clim = ListFloat([0, 1], desc='How our variable should be scaled prior to colour mapping')
+
+    format_string = CStr('P{idx}', desc='Format string for the text labels. This should be a python format string which can take column names (and the special idx name which is the index in the table)')
+
+    def __init__(self, pipeline, **kwargs):
+        SimpleLayer.__init__(self, **kwargs)
+        self._pipeline = pipeline
+        
+        self.x_key = 'x' #TODO - make these traits?
+        self.y_key = 'y'
+        self.z_key = 'z'
+
+        self._bbox = None
+        self._text_objects = []
+    
+        # define a signal so that people can be notified when we are updated (currently used to force a redraw when
+        # parameters change)
+        self.on_update = dispatch.Signal()
+
+        # signal for when the data is updated (used to, e.g., refresh histograms)
+        self.data_updated = dispatch.Signal()
+
+        # define responses to changes in various traits
+        self.on_trait_change(self._update, 'textColour')
+        self.on_trait_change(lambda: self.on_update.send(self), 'visible')
+        self.on_trait_change(self.update, 'cmap, clim, dsname, font_size, format_string')
+
+        # update any of our traits which were passed as command line arguments
+        self.trait_set(**kwargs)
+
+        self.update()
+        
+        # if we were given a pipeline, connect ourselves to the onRebuild signal so that we can automatically update
+        # ourselves
+        if not self._pipeline is None:
+            self._pipeline.onRebuild.connect(self.update)
+
+    @property
+    def datasource(self):
+        """
+        Return the datasource we are connected to (through our dsname property).
+        """
+        return self._pipeline.get_layer_data(self.dsname)
+    
+    def _get_cdata(self):
+        try:
+            cdata = self.datasource[self.textColour]
+        except KeyError:
+            cdata = np.array([0, 1])
+    
+        return cdata
+    
+    def _update(self, *args, **kwargs):
+        cdata = self._get_cdata()
+        self.clim = [float(np.nanmin(cdata)), float(np.nanmax(cdata))+1e-9]
+        #self.update(*args, **kwargs)
+
+    def update(self, *args, **kwargs):
+        #print('lw update')
+        self._datasource_choices = self._pipeline.layer_data_source_names
+        if not self.datasource is None:
+            self._datasource_keys = sorted(self.datasource.keys())
+            
+            self.update_from_datasource(self.datasource)
+            self.on_update.send(self)
+            
+
+    @property
+    def bbox(self):
+        return self._bbox
+    
+    @property
+    def colour_map(self):
+        return cm[self.cmap]
+    
+    def update_from_datasource(self, ds):
+        print('labels.update_from_datasource() - dsname=%s' % self.dsname)
+        x, y = ds[self.x_key], ds[self.y_key]
+        try:
+            z = ds[self.z_key]
+        except (KeyError, ValueError):
+            z = 0*x
+        
+        if not self.textColour == '':
+            c = ds[self.textColour]
+        else:
+            c = 0*x
+
+        # find out what fields we need to format
+        format_field_names  = [f for _, f, _, _ in string.Formatter().parse(self.format_string) if f is not None]  
+        
+        data_columns = {k: ds[k] for k in format_field_names if not k == 'idx'}
+        data_columns['idx'] = np.arange(len(x))
+
+        labels = [self.format_string.format(**{k:v[i] for k, v in data_columns.items()}) for i in range(len(x))]
+
+        self.update_data(x, y, z, c, cmap=cm[self.cmap], clim=self.clim, labels=labels)
+
+        self.data_updated.send(self)
+    
+    
+    def update_data(self, x=None, y=None, z=None, colors=None, cmap=None, clim=None, labels=None, alpha=1.0):
+        self._text_objects = []
+        self._bbox = None
+
+        if clim is not None and colors is not None and clim is not None:
+            cs_ = ((colors - clim[0]) / (clim[1] - clim[0]))
+            cs = cmap(cs_)
+            cs[:, 3] = alpha
+            
+            cs = cs.ravel().reshape(len(colors), 4)
+        else:
+            if x is not None:
+                cs = np.ones((x.shape[0], 4), 'f')
+            else:
+                cs = None
+        
+        if x is not None and y is not None and z is not None and len(x) > 0:
+            self._text_objects = [Text(pos=(x[i], y[i], z[i]), text=labels[i], color=cs[i, :], font_size=self.font_size) for i in range(len(x))]
+            
+            self._bbox = np.array([x.min(), y.min(), z.min(), x.max(), y.max(), z.max()])
+        else:
+            
+            self._bbox = None
+
+    def render(self, gl_canvas):
+        if not self.visible:
+            return
+        
+        for to in self._text_objects:
+            to.render(gl_canvas)
+
+    @property
+    def default_view(self):
+        from traitsui.api import View, Item, Group, InstanceEditor, EnumEditor, TextEditor
+        from PYME.ui.custom_traits_editors import HistLimitsEditor, CBEditor
+
+        vis_when = 'cmap not in %s' % cm.solid_cmaps
+    
+        return View([Group([Item('dsname', label='Data', editor=EnumEditor(name='_datasource_choices')), ]),
+                     Item('textColour', editor=EnumEditor(name='_datasource_keys'), label='Colour', visible_when=vis_when),
+                     Group([Item('clim', editor=HistLimitsEditor(data=self._get_cdata, update_signal=self.data_updated), show_label=False), ], visible_when=vis_when),
+                     Group(Item('cmap', label='LUT'),
+                           #Item('alpha', visible_when="method in ['pointsprites', 'transparent_points']", editor=TextEditor(auto_set=False, enter_set=True, evaluate=float)),
+                           Item('font_size', label=u'Font\u00A0size', editor=TextEditor(auto_set=False, enter_set=True, evaluate=float)),
+                           Item('format_string', label='Format string', editor=TextEditor(auto_set=False, enter_set=True)),
+                           )])
+        #buttons=['OK', 'Cancel'])
+
+    def default_traits_view(self):
+        return self.default_view
+        
+        
+
+       
+    
+

PYME/LMVis/layers/layer_defaults.py

@@ -0,0 +1,97 @@
+"""
+Default configurations for new layers
+=====================================
+
+To over-ride the defaults, place a file called ``layer_defaults.yaml`` in your ``~\.PYME`` directory. This should be a .yaml
+representation of a dictionary of default settings. An example file is shown below:
+
+.. code-block:: yaml
+
+    # the method/intent used to display all the localisations (default layer when opening PYMEVis)
+    points: 
+      method: spheres # change display mode to spheres
+      size: 50 # change size to 50
+      cmap: gist_rainbow # keep colourmap as gist_rainbow
+      vertexColour: ['z', 't'] # change to using z coloring by default (rather than  ['t', 'z'])
+      
+    # the method/intent used to display points from a single colour channel
+    points_channel: 
+      method: pointsprites # change display method to pointsprites
+      alpha: 0.2 # transparency
+      size: 20 # size
+      cmap: ['c', 'm', 'y', 'r', 'g', 'b'] # change order of colour selections (default = ['r', 'g', 'b', 'c', 'm', 'y'])
+
+
+**NOTE:** you must currently specify **all** setings for a layer - not just the ones you want to change/override as we
+we don't merge settings with the default settings.
+
+TODO - do a merge of the dictionaries so that we can just specify over-rides
+
+"""
+from PYME.misc.colormaps import cm
+from PYME import config
+import yaml
+
+_defaults = {
+    'points' : {  # single channel (or unseparated channels), PYMEVis default layer
+        'method' : 'points', # render as solid points
+        'cmap' : 'gist_rainbow',
+        'vertexColour' : ['t', 'z'],
+    },
+    'points_channel' : {
+        'method' : 'points', # render as solid points
+        'cmap' : list(cm.solid_cmaps),
+    },
+    'surface' :{
+        'cmap' : list(cm.solid_cmaps),
+    },
+    'image' :{
+        'cmap' : 'greys'
+    },
+    'image_channel' :{
+        'cmap' : ['r', 'g', 'b', 'c', 'y', 'm'],
+    },
+}
+
+defaults = config.load_config('layer_defaults.yaml', _defaults)
+
+def new_layer_settings(intent, layer_index=0, ds_keys=[], overrides={}):
+    """
+    Get the settings to use for a new channel based on intent. 
+    
+    To allow customisation with fallbacks, intent is split with an underscore into <base intent>_<specialisation>. Calling code should try to specify
+    a specialisation where appropriate, even if defaults for that specialisation do not exist.
+
+    Parameters
+    ==========
+
+    intent : str
+        the intent of this layer
+
+    layer_index : int, optional
+        the number of previously exisiting layers of this kind/intent (used for asigning sequential colourmaps to layers)
+
+    ds_keys : list, optional
+        the available data columns (usually data.keys()). Used to select which variable to colour points by.
+
+    """
+    try:
+        settings = defaults[intent].copy()
+    except KeyError:
+        settings = defaults[intent.split('_')[0]].copy()
+    
+    if isinstance(settings.get('cmap', None), list):
+        settings['cmap'] = settings['cmap'][layer_index%len(settings['cmap'])]
+
+    if isinstance(settings.get('vertexColour', None), list):
+        vcs = [vc for vc in settings['vertexColour'] if vc in ds_keys]
+        print('vcs: ', vcs)
+        if len(vcs) > 0:
+            settings['vertexColour'] = vcs[0]
+        else:
+            settings['vertexColour'] = ''
+
+    settings.update(overrides)
+    
+    return settings
+