PYME-extra 1.0.4.post0__py3-none-any.whl

PYMEcs/experimental/splitRender.py

@@ -0,0 +1,246 @@
+from PYME.LMVis.renderers import TriangleRenderer, renderMetadataProviders
+from PYME.IO.image import GeneratedImage, ImageBounds
+# from PYME.LMVis import visHelpers
+from PYME.LMVis import statusLog
+# from PYME.IO import tabular
+
+from PYME.IO import MetaDataHandler
+import numpy as np
+
+from PYMEcs.misc.guiMsgBoxes import Warn
+
+from traits.api import HasTraits, Str, Int, CStr, List, Enum, Float, Bool
+from traitsui.api import View, Item, Group
+from traitsui.menu import OKButton, CancelButton, OKCancelButtons
+
+class TimeBlock(HasTraits):
+    TimeBlockSize = Int(100)   
+    Colour = Enum(values='clist')
+    PixelSize_in_nm = Float(5.0)
+    JitterFactor = Float(5.0)
+    SamplesToAverage = Int(40)
+    
+    clist = List([])
+
+    traits_view = View(Group(Item(name = 'TimeBlockSize'),
+                             Item(name = 'Colour'),
+                             Item(name = 'PixelSize_in_nm'),
+                             Item(name = 'JitterFactor'),
+                             Item(name = 'SamplesToAverage')),
+                       title = 'Select',
+                       buttons = OKCancelButtons
+    )
+
+    def add_keys(self,chans):
+        for chan in chans:
+            if chan not in self.clist:
+                self.clist.append(chan)
+
+
+class SplitRenderer(TriangleRenderer):
+    """A renderer that specialises the TriangleRenderer to generate two images
+       by splitting the events into two groups. It does not iterate over colour channels but rather will do 
+       a single colour which must be selected prior to calling this renderer.
+    """
+    
+    # def __init__(self, visFr, pipeline, mainWind = None, splitSettings = None):
+    #     super(SplitRenderer, self).__init__(visFr, pipeline, mainWind)
+    #     self.splitSettings = splitSettings
+        
+    def Generate(self, settings, splitSettings):
+        mdh = MetaDataHandler.NestedClassMDHandler()
+        mdh['Rendering.Method'] = self.name
+        if 'imageID' in self.pipeline.mdh.getEntryNames():
+            mdh['Rendering.SourceImageID'] = self.pipeline.mdh['imageID']
+        mdh['Rendering.SourceFilename'] = getattr(self.pipeline, 'filename', '')
+        mdh['Rendering.NEventsRendered'] = len(self.pipeline[self.pipeline.keys()[0]]) # in future good to use colourfilter for per channel info?
+        mdh.Source = MetaDataHandler.NestedClassMDHandler(self.pipeline.mdh)
+
+        if splitSettings is not None:
+            for key in splitSettings:
+                mdh['Rendering.SplitSettings.%s' % key] = splitSettings[key]
+            
+        for cb in renderMetadataProviders:
+            cb(mdh)
+
+        pixelSize = settings['pixelSize']
+
+        status = statusLog.StatusLogger('Generating %s Image ...' % self.name)
+        
+        imb = self._getImBounds(*settings.get('zBounds', [None, None]))
+
+        #record the pixel origin in nm from the corner of the camera for futrue overlays
+        if 'Source.Camera.ROIPosX' in mdh.getEntryNames():
+            #a rendered image with information about the source ROI
+            voxx, voxy = 1e3 * mdh['Source.voxelsize.x'], 1e3 * mdh['Source.voxelsize.y']
+
+            ox = (mdh['Source.Camera.ROIPosX'] - 1) * voxx + imb.x0
+            oy = (mdh['Source.Camera.ROIPosY'] - 1) * voxy + imb.y0
+            if 'Source.Positioning.PIFoc' in mdh.getEntryNames():
+                oz = mdh['Source.Positioning.PIFoc'] * 1e3
+            else:
+                oz = imb.z0
+        else:
+            ox = imb.x0
+            oy = imb.y0
+            oz = imb.z0
+
+        mdh['Origin.x'] = ox
+        mdh['Origin.y'] = oy
+        mdh['Origin.z'] = oz
+
+        colours = settings['colours']
+        curCol = self.colourFilter.currentColour
+        if curCol is None:
+            colnames = ['Everything_even','Everything_odd']
+        else:
+            colnames = ['%s_even' % curCol,'%s_odd' % curCol]
+
+        try:
+            oldBlock = self.pipeline.filterKeys['timeBlock']
+        except (KeyError, AttributeError):
+            oldBlock = None
+        
+        ims = []
+
+        for filter in [(-0.1,0.5),(0.5,1.5)]:
+            self.pipeline.filterKeys['timeBlock'] = filter
+            self.pipeline.Rebuild()
+            ims.append(np.atleast_3d(self.genIm(settings, imb, mdh)))
+        
+        # needs to reset timeBlock in some fashion
+        if oldBlock is None:
+            del self.pipeline.filterKeys['timeBlock']
+        else:
+            self.pipeline.filterKeys['timeBlock'] = oldBlock
+        self.pipeline.Rebuild()
+
+        return GeneratedImage(ims, imb, pixelSize, settings['zSliceThickness'], colnames, mdh=mdh)
+
+    def GenerateGUI(self, event=None, renderSettings=None, splitSettings=None):
+        import wx
+        from PYME.LMVis import genImageDialog
+        from PYME.DSView import ViewIm3D
+
+        if renderSettings is None:
+            jitVars = ['1.0']
+            jitVars += self.colourFilter.keys()
+
+            self.genMeas = self.pipeline.GeneratedMeasures.keys()
+            if not 'neighbourDistances' in self.genMeas:
+                self.genMeas.append('neighbourDistances')
+            
+            if not 'neighbourErrorMin' in self.genMeas:
+                self.genMeas.append('neighbourErrorMin')
+            
+            jitVars += self.genMeas
+        
+        
+            if 'z' in self.pipeline.keys():
+                zvals = self.pipeline['z']
+            else:
+                zvals = None
+
+            dlg = genImageDialog.GenImageDialog(self.mainWind, mode=self.mode,
+                                                defaultPixelSize=self._defaultPixelSize,
+                                                colours=self.colourFilter.getColourChans(),
+                                                zvals = zvals,
+                                                jitterVariables = jitVars,
+                                                jitterVarDefault=self._getDefaultJitVar(jitVars),
+                                                jitterVarDefaultZ=self._getDefaultZJitVar(jitVars))
+            ret = dlg.ShowModal()
+            generateSettings = dlg.get_settings()
+        else:
+            ret = wx.ID_OK
+            generateSettings = {
+                'pixelSize' : renderSettings['PixelSize'],
+                'jitterVariable' : 'neighbourDistances',
+                'jitterScale' : renderSettings['JitterFactor'],
+                'jitterVariableZ' : None,
+                'jitterScaleZ' : None,
+                'MCProbability' : 1.0,
+                'numSamples' : renderSettings['SamplesToAverage'],
+                'colours' : None,
+                'zBounds' : [None,None],
+                'zSliceThickness' : 200,
+                'softRender' : True
+            }
+        if ret == wx.ID_OK:
+            im = self.Generate(generateSettings,splitSettings=splitSettings)
+            imfc = ViewIm3D(im, mode='visGUI', title='Generated %s - %3.1fnm bins' % (self.name, im.pixelSize),
+                            glCanvas=self.visFr.glCanvas, parent=self.mainWind)
+        else:
+            imfc = None
+
+        dlg.Destroy()
+        return imfc
+
+class splitRenderPlugin:
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+        self.renderer = SplitRenderer(visFr, visFr.pipeline)
+        self.splitSettings = {
+            'BlockSize' : 100,
+            'Colour' : 'Everything',
+            'Mode' : 'TimeBlock'}
+        self.renderSettings = {
+            'PixelSize' : 5,
+            'JitterFactor' : 1.0,
+            'SamplesToAverage' : 40}
+
+        visFr.AddMenuItem('Experimental>Deprecated>Rendering',
+                          'Split Render by Time Blocks',
+                          self.deprecated, # self.OnSplitRender,
+                          helpText='this renders a 2 channel image with events split by time blocks that can be used to evaluate the FRC; for multi-colour images the correct colour needs to be selected')
+
+    def deprecated(self,event=None):
+        Warn(self.visFr, 'use Extras>Split by timeblocks for FRC instead',
+             caption = 'Function disabled!')
+
+    def addTimeBlock(self):
+        spSet = self.splitSettings
+        rSet = self.renderSettings
+        tb = TimeBlock(TimeBlockSize=spSet['BlockSize'],
+                       PixelSize_in_nm = rSet['PixelSize'],
+                       JitterFactor = rSet['JitterFactor'],
+                       SamplesToAverage = rSet['SamplesToAverage'])
+        tb.add_keys(['Everything']+self.pipeline.colourFilter.getColourChans())
+        tb.Colour = 'Everything'
+
+        if tb.configure_traits(kind='modal'):
+            psd = self.pipeline.selectedDataSource
+            blockSel = np.mod((psd['t']/tb.TimeBlockSize).astype('int'),2)
+            
+            spSet['BlockSize'] = tb.TimeBlockSize # remember choices
+            spSet['Colour'] = tb.Colour
+            rSet['PixelSize'] = tb.PixelSize_in_nm
+            rSet['JitterFactor'] = tb.JitterFactor
+            rSet['SamplesToAverage'] = tb.SamplesToAverage
+            self.pipeline.selectedDataSource.addColumn('timeBlock',blockSel)
+            self.pipeline.Rebuild()
+            return True
+        else:
+            return False
+
+    def OnSplitRender(self,event=None):
+        if not self.addTimeBlock():
+            return
+        oldCol = self.pipeline.colourFilter.currentColour
+        if self.splitSettings['Colour'] == 'Everything':
+            cChoice = None
+        else:
+            cChoice = self.splitSettings['Colour']
+
+        if oldCol != cChoice:
+            self.pipeline.colourFilter.setColour(cChoice)
+        self.renderer.GenerateGUI(renderSettings=self.renderSettings,
+                                  splitSettings=self.splitSettings)
+        if oldCol != cChoice:
+            self.pipeline.colourFilter.setColour(oldCol)
+            self.pipeline.Rebuild()
+
+def Plug(visFr):
+    '''Plugs this module into the gui'''
+    # disable this function for now
+    visFr.splitRender = splitRenderPlugin(visFr)

PYMEcs/experimental/testChannelByName.py

@@ -0,0 +1,36 @@
+import logging
+logger = logging.getLogger(__file__)
+import wx
+
+from PYMEcs.recipes.base import ExtractChannelByName
+
+def Msg(parent, message, caption = 'Message'):
+    dlg = wx.MessageDialog(parent, message, caption, wx.OK)
+    dlg.ShowModal()
+    dlg.Destroy()
+
+class TestChannelByName:
+    """
+
+    """
+    def __init__(self, dsviewer):
+        self.dsviewer = dsviewer
+        self.ec = ExtractChannelByName()
+        dsviewer.AddMenuItem('Experimental>Misc',
+                          'Test Channel Name Matching by RegEx',
+                          self.OnMatch,
+                          helpText='test the regex matching of the ExtracChannelByName module')
+
+        
+    def OnMatch(self, event=None):        
+        if not self.ec.configure_traits(kind='modal'):
+            return
+        mdh = self.dsviewer.image.mdh
+        channelNames = mdh.getOrDefault('ChannelNames',[])
+        matches = self.ec._matchChannels(channelNames)
+        Msg(None,"ChannelNames: \n\t%s\n\nMatches :\n \t%s" % (channelNames, [channelNames[i] for i in matches]))
+
+        
+def Plug(dsviewer):
+    """Plugs this module into the gui"""
+    dsviewer.tChanByName = TestChannelByName(dsviewer)

PYMEcs/experimental/timedSpecies.py

@@ -0,0 +1,28 @@
+class TimedSpecies:
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+        
+        visFr.AddMenuItem('Experimental>Deprecated', "Sequential Imaging - Timed species assignment",self.OnTimedSpecies)
+
+    def OnTimedSpecies(self,event):
+        from PYMEcs.recipes import localisations
+        recipe = self.pipeline.recipe
+        tsm = localisations.TimedSpecies(recipe,
+                                         inputName=self.pipeline.selectedDataSourceKey,
+                                         outputName='timedSpecies')
+        # configure first as subsequent reconfigs could be slow due to
+        # recalculations happening as you type
+        # if you cancel at this stage you will abort this recipe being
+        # inserted and executed
+        if not tsm.configure_traits(kind='modal'):
+            return
+        recipe.add_module(tsm)
+        recipe.execute()
+
+        self.pipeline.selectDataSource('timedSpecies')
+        self.pipeline.Rebuild()
+ 
+def Plug(visFr):
+    '''Plugs this module into the gui'''
+    visFr.timedSpecies = TimedSpecies(visFr)

PYMEcs/experimental/utils.py

@@ -0,0 +1,31 @@
+import logging
+logger = logging.getLogger(__file__)
+import wx
+
+class dsviewerUtils:
+    def __init__(self, dsviewer):
+        self.dsviewer = dsviewer
+        dsviewer.AddMenuItem('Experimental>Utils',
+                             'Save recipe from metadata',
+                             self.OnSaveRecipeFromMDH,
+                             helpText='try to save a recipe as yaml from image metadata')
+
+    def OnSaveRecipeFromMDH(self, event=None):
+        with wx.FileDialog(self.dsviewer, "Choose recipe file name", wildcard='YAML (*.yaml)|*.yaml',
+                           style=wx.FD_SAVE) as dialog:
+
+            if dialog.ShowModal() == wx.ID_CANCEL:
+                return
+
+            filename = dialog.GetPath()
+
+        from PYMEcs.misc.utils import recipe_from_mdh
+        recipe = recipe_from_mdh(self.dsviewer.image.mdh)
+        if recipe is not None:
+            with open(filename,"w") as fi:
+                print(recipe,file=fi)
+
+
+def Plug(dsviewer):
+    """Plugs this module into the gui"""
+    dsviewerUtils(dsviewer)

PYMEcs/misc/ExtraCmaps.py

@@ -0,0 +1,177 @@
+import matplotlib.colors as mcol
+import matplotlib.pyplot as plt
+import numpy as np
+import pylab
+from PYME.misc.colormaps import cm
+
+
+def r(rgb):
+    return rgb[0]
+
+def g(rgb):
+    return rgb[1]
+
+def b(rgb):
+    return rgb[2]
+
+
+def hot_overflow(underflowcol = 'magenta', overflowcol = 'lime', percentage=5):
+    if percentage < 1:
+        percentage = 1
+    if percentage > 15:
+        percentage = 15
+
+    ucolrgb = mcol.hex2color(mcol.cnames[underflowcol])
+    ocolrgb = mcol.hex2color(mcol.cnames[overflowcol])
+    p = 0.01 * percentage
+    
+    # edited from hot_data in matplotlib
+    hot_data = {'red':   [(0, r(ucolrgb), r(ucolrgb)),
+                          (p, r(ucolrgb), 0.0416),
+                          (0.365079, 1.000000, 1.000000),
+                          (1.0-p, 1.0, r(ocolrgb)),
+                          (1.0, r(ocolrgb), r(ocolrgb))],
+                'green': [(0, g(ucolrgb), g(ucolrgb)),
+                          (p, g(ucolrgb), 0.),
+                          (0.365079, 0.000000, 0.000000),
+                          (0.746032, 1.000000, 1.000000),
+                          (1.0-p, 1.0, g(ocolrgb)),
+                          (1.0, g(ocolrgb), g(ocolrgb))],
+                'blue':  [(0, b(ucolrgb), b(ucolrgb)),
+                          (p, b(ucolrgb), 0.),
+                          (0.746032, 0.000000, 0.000000),
+                          (1.0-p, 1.0, b(ocolrgb)),
+                          (1.0, b(ocolrgb), b(ocolrgb))]}
+
+    cm_hot2 = mcol.LinearSegmentedColormap('hot_overflow', hot_data)
+    return cm_hot2
+
+
+def grey_overflow(underflowcol = 'magenta', overflowcol = 'lime', percentage=5, greystart=0.1):
+    if percentage < 1:
+        percentage = 1
+    if percentage > 15:
+        percentage = 15
+
+    ucolrgb = mcol.hex2color(mcol.cnames[underflowcol])
+    ocolrgb = mcol.hex2color(mcol.cnames[overflowcol])
+    p = 0.01 * percentage
+
+    grey_data = {'red':   [(0, r(ucolrgb), r(ucolrgb)),
+                          (p, r(ucolrgb), greystart),
+                          (1.0-p, 1.0, r(ocolrgb)),
+                          (1.0, r(ocolrgb), r(ocolrgb))],
+                'green': [(0, g(ucolrgb), g(ucolrgb)),
+                          (p, g(ucolrgb), greystart),
+                          (1.0-p, 1.0, g(ocolrgb)),
+                          (1.0, g(ocolrgb), g(ocolrgb))],
+                'blue':  [(0, b(ucolrgb), b(ucolrgb)),
+                          (p, b(ucolrgb), greystart),
+                          (1.0-p, 1.0, b(ocolrgb)),
+                          (1.0, b(ocolrgb), b(ocolrgb))]}
+
+    cm_grey2 = mcol.LinearSegmentedColormap('grey_overflow', grey_data)
+    return cm_grey2
+
+
+def grey_overflow2(underflowcol = 'magenta', overflowcol = 'lime', percentage=5):
+    if percentage < 1:
+        percentage = 1
+    if percentage > 30:
+        percentage = 30
+    clist = [(0,mcol.cnames[underflowcol]),
+             # (0.01*percentage,mcol.cnames['dimgrey']),
+             (0.01*percentage,(0.15,0.15,0.15)),
+             (1.0-0.01*percentage,mcol.cnames['white']),
+             (1.0,mcol.cnames[overflowcol])]
+
+    return mcol.LinearSegmentedColormap.from_list('grey_overflow2',clist)
+
+# this function needs some work
+def overflow_wrap(cmapname, underflowcol = 'magenta', overflowcol = 'lime', percentage=5):
+    cmap = pylab.get_cmap(cmapname)
+    if percentage < 0:
+        percentage = 0
+    if percentage > 10:
+        percentage = 10
+    p = 0.01*percentage
+    def mymap(c):
+        ret = cmap(c)
+        if c < p:
+            return colors.hex2color(colors.cnames[underflowcol])
+        elif c > 1.0-p:
+            return colors.hex2color(colors.cnames[overflowcol])
+        else:
+            return cmap(c/(1.0-2*p)+p)
+        
+    mymap.name = cmap.name + '_overflow'
+    return mymap
+
+# FIJI inspired colour maps
+
+# cyan hot (for pylab devide all values by 255.0)
+# red: 0 0, 170 0, 255 255
+# green: 0 0, 170 255, 255, 255
+# blue: 0 0, 85, 255, 255 255
+
+# cb_skyblue
+# red: 0 0, 255 85
+# green: 0 0, 255 180
+# blue: 0 0, 255 232
+
+# generate a 3-tupel for continuous colour and normalise to 0..1
+def contc(x,y):
+    return (x/255.0,y/255.0,y/255.0)
+
+cyan_hot_d = {
+    'red'   : [contc(0,0),contc(170,0),contc(255,255)],
+    'green' : [contc(0,0),contc(170,255),contc(255,255)],
+    'blue'  : [contc(0,0),contc(85,255),contc(255,255)]
+}
+
+cb_skyblue_d = {
+    'red'   : [contc(0,0),contc(255,85)],
+    'green' : [contc(0,0),contc(255,180)],
+    'blue'  : [contc(0,0),contc(255,232)]
+}
+
+cb_skyblue2_d = {
+    'red'   : [contc(0,0),contc(200,85),contc(255,255)],
+    'green' : [contc(0,0),contc(200,180),contc(255,255)],
+    'blue'  : [contc(0,0),contc(200,232),contc(255,255)]
+}
+
+cm_ch = mcol.LinearSegmentedColormap('cyan_hot',cyan_hot_d)
+cm_cbskb = mcol.LinearSegmentedColormap('cb_skyblue',cb_skyblue_d)
+cm_cbskb2 = mcol.LinearSegmentedColormap('cb_skyblue2',cb_skyblue2_d)
+
+cm.update({cmap.name: cmap for cmap in [cm_ch,cm_cbskb,cm_cbskb2,hot_overflow(overflowcol='cyan',percentage=2.5)]})
+
+
+############################
+### if colorcet is installed
+### register a few cms
+############################
+try:
+    import colorcet as cc
+    has_colorcet = True
+except ImportError:
+    has_colorcet = False
+
+if has_colorcet:
+    cm.update({'cet_fire':cc.m_fire,
+               'cet_coolwarm': cc.m_coolwarm,
+               'cet_bmw': cc.m_bmw,
+               'cet_bmy': cc.m_bmy})
+
+def main():
+    import numpy as np
+    a=np.outer(np.arange(0,1,0.01),np.ones(10))
+    # cm1 = grey_overflow()
+    # cm1 = grey_overflow2(percentage=2)
+    cm1 = hot_overflow(overflowcol='cyan')
+    # cm1 = overflow_wrap('jet')
+    plt.imshow(a,aspect='auto',cmap=cm1,origin="lower")
+
+if __name__ == "__main__":
+    main()

PYMEcs/misc/configUtils.py

@@ -0,0 +1,169 @@
+from PYME import config
+import os
+import logging
+
+DSVIEWER_PLUGINS = \
+'''
+PYMEcs.experimental.showErrsDh5view
+PYMEcs.experimental.mapTools
+PYMEcs.experimental.meas2DplotDh5view
+PYMEcs.experimental.testChannelByName
+PYMEcs.experimental.FRC
+PYMEcs.experimental.regExtraCmaps
+PYMEcs.experimental.procPoints
+PYMEcs.experimental.combine_maps
+PYMEcs.experimental.Sofi
+PYMEcs.experimental.CalcZfactor
+PYMEcs.experimental.ImageJROItools
+'''
+
+VISGUI_PLUGINS = \
+'''
+PYMEcs.experimental.clusterTrack
+PYMEcs.experimental.fiducials
+PYMEcs.experimental.fiducialsNew
+PYMEcs.experimental.qPAINT
+PYMEcs.experimental.showErrs
+PYMEcs.experimental.showShiftMap
+PYMEcs.experimental.binEventProperty
+PYMEcs.experimental.onTimes
+PYMEcs.experimental.snrEvents
+PYMEcs.experimental.randMap
+PYMEcs.experimental.mortensen
+PYMEcs.experimental.splitRender
+PYMEcs.experimental.timedSpecies
+PYMEcs.experimental.chaining
+PYMEcs.experimental.specLabeling
+PYMEcs.experimental.selectROIfilterTable
+PYMEcs.experimental.regExtraCmaps
+PYMEcs.experimental.pyme2caml
+PYMEcs.experimental.Simpler
+PYMEcs.experimental.MINFLUX
+PYMEcs.experimental.eventProcessing
+PYMEcs.experimental.NPCcalcLM
+'''
+
+RECIPES = \
+'''
+PYMEcs.recipes.processing
+PYMEcs.recipes.output
+PYMEcs.recipes.base
+PYMEcs.recipes.localisations
+PYMEcs.recipes.simpler
+'''
+
+def get_legacy_scripts_dir():
+    return os.path.join(os.path.dirname(config.__file__), 'Acquire/Scripts')
+
+# this tries to replicate what config.get_init_filename does
+#  if the config function were changed we would need to change this one as well
+def get_init_directories_to_search():
+    directories_to_search = [os.path.join(conf_dir, 'init_scripts') for conf_dir in config.config_dirs]
+    
+    extra_conf_dir = config.config.get('PYMEAcquire-extra_init_dir')
+    if not extra_conf_dir is None:
+        directories_to_search.insert(0, extra_conf_dir)
+
+    directories_to_search.insert(0,get_legacy_scripts_dir())
+    
+    return directories_to_search
+
+def list_config_dirs():
+    print('List of configuration directories:')
+    for dir in config.config_dirs:
+        print(dir)
+
+def install_plugins():
+    # options parsing
+    import argparse
+    from pathlib import Path
+
+    logging.basicConfig(level=logging.INFO)
+    op = argparse.ArgumentParser(description='install PYME-extra plugins')
+    op.add_argument('-u','--user', action='store_true',
+                    help='install plugin info to user config directory')
+    op.add_argument('--dry-run',action="store_true",
+                    help='just process options and merely show what would be done')
+
+    args = op.parse_args()
+    if args.user:
+        installdir = Path(config.user_config_dir)
+    else:
+        installdir = Path(config.dist_config_directory)
+
+    recfile = installdir / 'plugins' / 'recipes' / 'PYMEcsRecipePlugins.txt'
+    visguifile = installdir / 'plugins' / 'visgui' / 'PYMEcsVisguiPlugins.txt'
+    dsviewerfile = installdir / 'plugins' / 'dsviewer' / 'PYMEcsDsviewerPlugins.txt'
+
+    logging.info("will install recipes to\n\t%s" % recfile)
+    logging.info("will install visgui plugins to\n\t%s" % visguifile)
+    logging.info("will install dsviewer plugins to\n\t%s" % dsviewerfile)
+    
+    if args.dry_run:
+        logging.info("dry run, aborting...")
+        import sys
+        sys.exit(0)
+
+    recfile.write_text(RECIPES)
+    visguifile.write_text(VISGUI_PLUGINS)
+    dsviewerfile.write_text(DSVIEWER_PLUGINS)
+
+    logging.info("\nPYME-extra recipes and plugins have been registered...")
+
+def main():
+    import sys
+    import argparse
+    import pprint
+
+    # options parsing
+    op = argparse.ArgumentParser(description='inspect PYME config files and settings.')
+    op.add_argument('--initdirs', action='store_true',
+                    help='list directories searched for init files')
+    op.add_argument('-p','--parameters', action='store_true',
+                    help='print configuration parameters', dest='config_params')
+    op.add_argument('-d','--directories', action='store_true',
+                    help='print configuration directories')
+    op.add_argument('--protocols', action='store_true',
+                    help='print custom protols found')
+    op.add_argument('-i','--initfile', default=None,
+                    help='locate init file and if found print full path')
+
+    args = op.parse_args()
+
+    if args.initdirs:
+        print('List of directories searched for init scripts, legacy path included:')
+        for dir in get_init_directories_to_search():
+            print(dir)
+        sys.exit(0)
+
+    if args.directories:
+        list_config_dirs()
+        sys.exit(0)
+
+    if args.config_params:
+        print('List of configuration parameters:')
+        for par in config.config.keys():
+            print('%s : %s' % (par,config.config[par]))
+        sys.exit(0)
+
+    if args.protocols:
+        prots = config.get_custom_protocols()
+        print('Custom Protocols:')
+        pprint.pprint(prots)
+        sys.exit(0)
+
+    if args.initfile is not None:
+        inipath = config.get_init_filename(args.initfile, get_legacy_scripts_dir())
+        if inipath is None:
+            print("Initialisation file %s was not found" % args.initfile)
+        else:
+            print("Initialisation file %s was resolved as %s" %
+                  (args.initfile,os.path.abspath(inipath)))
+        sys.exit(0)
+
+
+    # if we got here carry out a default action
+    list_config_dirs()
+    
+if __name__ == "__main__":
+    main()