python-microscopy 25.11.20__cp310-cp310-win_amd64.whl

PYME/DSView/modules/pupilTools.py

@@ -0,0 +1,204 @@
+#!/usr/bin/python
+##################
+# coloc.py
+#
+# Copyright David Baddeley, 2011
+# d.baddeley@auckland.ac.nz
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+#import numpy
+import wx
+import wx.grid
+#import pylab
+#from PYME.IO.image import ImageStack
+from six.moves import xrange
+
+from PYME.recipes.traits import HasTraits, Float, Int, CStr, Bool
+
+class ZernikeView(wx.ScrolledWindow):
+    def __init__(self, dsviewer):
+        from PYME.misc import zernike
+        import numpy as np
+        
+        self.dsviewer = dsviewer
+        mag = np.abs(dsviewer.image.data[:,:])
+        phase = np.angle(dsviewer.image.data[:,:])
+        
+        xm = np.where(mag.max(1) > 0)[0]
+        ym = np.where(mag.max(0) > 0)[0]
+        
+        print((xm, ym, mag.shape))
+
+        mag = mag[xm[0]:(xm[-1]+1), ym[0]:(ym[-1]+1)]        
+        phase = phase[xm[0]:(xm[-1]+1), ym[0]:(ym[-1]+1)]
+        
+        #im = mag*np.exp(1j*phase)
+        
+        coeffs, res, im = zernike.calcCoeffs(phase, 25, mag)
+        
+        #s = ''
+        dsviewer.zernModes = {i : c for i, c in enumerate(coeffs)}
+        #for i, c, r, in zip(xrange(25), coeffs, res):
+        #    s += '%d\t%s%3.3f\tresidual=%3.2f\n' % (i, zernike.NameByNumber[i].ljust(30), c, r)
+        
+        wx.ScrolledWindow.__init__(self, dsviewer)
+        
+        vsizer = wx.BoxSizer(wx.VERTICAL)
+        
+        self.gZern = wx.grid.Grid(self, -1)
+        self.gZern.CreateGrid(len(coeffs), 3)
+        self.gZern.EnableEditing(0)
+        
+        self.gZern.SetColLabelValue(0, "Name")
+        self.gZern.SetColLabelValue(1, "Coefficient")
+        self.gZern.SetColLabelValue(2, "Residual")
+        
+        for i, c, r, in zip(xrange(len(coeffs)), coeffs, res):
+            self.gZern.SetRowLabelValue(i, '%d' %i)
+            self.gZern.SetCellValue(i, 0, zernike.NameByNumber[i])
+            self.gZern.SetCellValue(i, 1, '%3.3g' % c)
+            self.gZern.SetCellValue(i, 2, '%3.3g' % r)
+            
+            cv = 255 - 125*(abs(c))
+            col = (255, cv, cv)
+            
+            self.gZern.SetCellBackgroundColour(i, 0, col)
+            self.gZern.SetCellBackgroundColour(i, 1, col)
+            self.gZern.SetCellBackgroundColour(i, 2, col)
+            
+        self.gZern.AutoSizeColumns()
+        self.gZern.SetRowLabelSize(wx.grid.GRID_AUTOSIZE)
+        
+        vsizer.Add(self.gZern, 1, wx.EXPAND|wx.ALL, 5)
+        
+        #vsizer.Add(wx.StaticText(self, -1, s), 1, wx.EXPAND)
+        
+        self.SetSizer(vsizer)
+        self.SetScrollRate(0, 10)
+        
+        
+
+class PupilTools(HasTraits):
+    wavelength = Float(700)
+    NA = Float(1.49)
+    sizeX = Int(61)
+    sizeZ = Int(61)
+    zSpacing = Float(50) 
+    apodization = CStr('sine')
+    vectorial = Bool(False)
+    
+
+    def default_traits_view( self ):
+        from traitsui.api import View, Item
+        from traitsui.menu import OKButton
+        
+        view = View(Item('wavelength'),
+                    Item('NA'),
+                    Item('zSpacing'),
+                    Item('sizeZ'),
+                    Item('sizeX'),
+                    Item('apodization'),
+                    Item('vectorial'),
+                    buttons=[OKButton])
+        
+        return view
+
+    def __init__(self, dsviewer):
+        self.dsviewer = dsviewer
+        self.do = dsviewer.do
+
+        self.image = dsviewer.image
+        
+        dsviewer.AddMenuItem('Processing', "Generate PSF from pupil", self.OnPSFFromPupil)
+        dsviewer.AddMenuItem('Processing', "Generate PSF from Zernike modes", self.OnPSFFromZernikeModes)
+
+    def OnPSFFromPupil(self, event):
+        import numpy as np
+        #import pylab
+        from PYME.Analysis.PSFGen import fourierHNA
+        
+        from PYME.IO.image import ImageStack
+        from PYME.DSView import ViewIm3D
+        
+        self.configure_traits(kind='modal')
+
+        z_ = np.arange(self.sizeZ)*float(self.zSpacing)
+        z_ -= z_.mean()        
+        
+        if self.vectorial:
+            ps = fourierHNA.PsfFromPupilVect(self.image.data[:,:], z_, self.image.voxelsize_nm.x, lamb=self.wavelength, apodization=self.apodization, NA=self.NA)#, shape = [self.sizeX, self.sizeX])
+            #ps = abs(ps*np.conj(ps))
+        else:
+            ps = fourierHNA.PsfFromPupil(self.image.data[:,:], z_, self.image.voxelsize_nm.x, lamb=self.wavelength, apodization=self.apodization, NA=self.NA)#, shape = [self.sizeX, self.sizeX])
+        
+        #ps = ps/ps[:,:,self.sizeZ/2].sum()
+        
+        ps = ps/ps.max()
+        
+        im = ImageStack(ps, titleStub = 'Generated PSF')
+        im.mdh.copyEntriesFrom(self.image.mdh)
+        im.mdh['Parent'] = self.image.filename
+        #im.mdh['Processing.CropROI'] = roi
+        mode = 'psf'
+
+        dv = ViewIm3D(im, mode=mode, glCanvas=self.dsviewer.glCanvas, parent=wx.GetTopLevelParent(self.dsviewer))
+
+    def OnPSFFromZernikeModes(self, event):
+        import numpy as np
+        #import pylab
+        from PYME.Analysis.PSFGen import fourierHNA
+        
+        from PYME.IO.image import ImageStack
+        from PYME.DSView import ViewIm3D
+        
+        self.configure_traits(kind='modal')
+
+        z_ = np.arange(self.sizeZ)*float(self.zSpacing)
+        z_ -= z_.mean()        
+        
+        #if self.vectorial:
+        #    ps = fourierHNA.PsfFromPupilVect(self.image.data[:,:], z_, self.image.mdh['voxelsize.x']*1e3, self.wavelength, apodization=self.apodization, NA=self.NA)#, shape = [self.sizeX, self.sizeX])
+        #    #ps = abs(ps*np.conj(ps))
+        #else:
+        #    ps = fourierHNA.PsfFromPupil(self.image.data[:,:], z_, self.image.mdh['voxelsize.x']*1e3, self.wavelength, apodization=self.apodization, NA=self.NA)#, shape = [self.sizeX, self.sizeX])
+        
+        ps = fourierHNA.GenZernikeDPSF(z_, dx = self.image.voxelsize_nm.x,
+                                       zernikeCoeffs = self.dsviewer.zernModes, lamb=self.wavelength, 
+                                       n=1.51, NA = self.NA, ns=1.51, beadsize=0, 
+                                       vect=self.vectorial, apodization=self.apodization)
+        #ps = ps/ps[:,:,self.sizeZ/2].sum()
+        
+        ps = ps/ps.max()
+        
+        im = ImageStack(ps, titleStub = 'Generated PSF')
+        im.mdh.copyEntriesFrom(self.image.mdh)
+        im.mdh['Parent'] = self.image.filename
+        #im.mdh['Processing.CropROI'] = roi
+        mode = 'psf'
+
+        dv = ViewIm3D(im, mode=mode, glCanvas=self.dsviewer.glCanvas, parent=wx.GetTopLevelParent(self.dsviewer))     
+
+    
+
+
+
+def Plug(dsviewer):
+    dsviewer.PupilTools = PupilTools(dsviewer)
+    dsviewer.zern = ZernikeView(dsviewer)
+    dsviewer.AddPage(dsviewer.zern, False, 'Zernike Moments')
+
+
+

PYME/DSView/modules/pupilView.py

@@ -0,0 +1,139 @@
+#!/usr/bin/python
+##################
+# graphViewPanel.py
+#
+# Copyright David Baddeley, 2011
+# d.baddeley@auckland.ac.nz
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+import wx
+import wx.lib.agw.aui as aui
+import numpy as np
+
+import matplotlib
+matplotlib.use('WXAgg')
+
+from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
+from matplotlib.backends.backend_wx import _load_bitmap, error_msg_wx, cursord
+#from matplotlib.backends.backend_wxagg import NavigationToolbar2WxAgg
+#from matplotlib.backend_bases import NavigationToolbar2
+from PYME.DSView.modules.graphViewPanel import MyNavigationToolbar
+from matplotlib.figure import Figure
+
+from PYME.DSView.displayOptions import DisplayOpts
+
+
+class GraphViewPanel(wx.Panel):
+    def __init__(self, parent, dstack = None, do = None, xvals=None, xlabel=''):
+        wx.Panel.__init__(self, parent)
+
+        if (dstack is None and do is None):
+            dstack = scipy.zeros((10,10))
+
+        if do is None:
+            self.do = DisplayOpts(dstack)
+            self.do.Optimise()
+        else:
+            self.do = do
+
+        self.do.WantChangeNotification.append(self.draw)
+
+        self.xvals = xvals
+        self.xlabel = xlabel
+            
+        sizer1 = wx.BoxSizer(wx.VERTICAL)
+
+        self.figure = Figure()
+        self.axes = self.figure.add_subplot(111)
+        self.canvas = FigureCanvas(self, -1, self.figure)
+
+        sizer1.Add(self.canvas, 1, wx.TOP | wx.LEFT | wx.EXPAND)
+
+        #self.toolbar = NavigationToolbar2WxAgg(self.canvas)
+        #self.toolbar = MyNavigationToolbar(self.canvas, self)
+        #self.toolbar.Realize()
+
+#        if wx.Platform == '__WXMAC__':
+#            # Mac platform (OSX 10.3, MacPython) does not seem to cope with
+#            # having a toolbar in a sizer. This work-around gets the buttons
+#            # back, but at the expense of having the toolbar at the top
+#            self.SetToolBar(self.toolbar)
+#        else:
+#            # On Windows platform, default window size is incorrect, so set
+#            # toolbar width to figure width.
+#            tw, th = self.toolbar.GetSizeTuple()
+#            fw, fh = self.canvas.GetSizeTuple()
+#            # By adding toolbar in sizer, we are able to put it at the bottom
+#            # of the frame - so appearance is closer to GTK version.
+#            # As noted above, doesn't work for Mac.
+#            self.toolbar.SetSize(wx.Size(fw, th))
+#            
+#            sizer1.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
+
+        self.Bind(wx.EVT_SIZE, self._onSize)
+
+        #self.toolbar.update()
+        self.SetSizer(sizer1)
+        self.draw()
+
+    def draw(self, event=None):
+        self.axes.cla()
+
+        if self.xvals is None:
+            xvals = np.arange(self.do.ds.shape[0])
+        else:
+            xvals = self.xvals
+
+        for i in range(self.do.ds.shape[4]):
+            self.axes.plot(xvals, self.do.ds[:,self.do.yp, self.do.zp, 0, i].squeeze(), label=self.do.names[i])
+
+        if self.do.ds.shape[3] > 1:
+            self.axes.legend()
+        self.axes.set_xlabel(self.xlabel)
+
+        self.canvas.draw()
+
+    def _onSize( self, event ):
+        #self._resizeflag = True
+        self._SetSize()
+
+
+    def _SetSize( self ):
+        pixels = tuple( self.GetClientSize() )
+        self.SetSize( pixels )
+        self.canvas.SetSize( pixels )
+        self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(),
+                                     float( pixels[1] )/self.figure.get_dpi() )
+
+def Plug(dsviewer):
+    #if dsviewer.image.mdh and 'xvalues' in dsviewer.image.mdh.getEntryNames():
+    #    xvals = dsviewer.image.mdh.getEntry('xvalues')
+    #    xlabel = dsviewer.image.mdh.getEntry('xlabel')
+
+    if 'xvals' in dir(dsviewer.image):
+        xvals = dsviewer.image.xvals
+        xlabel = dsviewer.image.xlabel
+
+    else:
+        xvals = None
+        xlabel = ''
+        
+    dsviewer.gv = GraphViewPanel(dsviewer, do=dsviewer.do, xvals=xvals, xlabel=xlabel)
+    dsviewer.AddPage(dsviewer.gv, True, 'Graph View')
+    
+    dsviewer.gv.toolbar = MyNavigationToolbar(dsviewer.gv.canvas, dsviewer)
+    dsviewer._mgr.AddPane(dsviewer.gv.toolbar, aui.AuiPaneInfo().Name("MPLTools").Caption("Matplotlib Tools").CloseButton(False).
+                      ToolbarPane().Right().GripperTop())

PYME/DSView/modules/recipes.py

@@ -0,0 +1,266 @@
+#!/usr/bin/python
+##################
+# coloc.py
+#
+# Copyright David Baddeley, 2011
+# d.baddeley@auckland.ac.nz
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+#import numpy as np
+#import wx
+from PYME.DSView.OverlaysPanel import OverlayPanel
+import wx.lib.agw.aui as aui
+import wx
+import numpy as np
+import six
+
+#from PYME.recipes import modules
+from PYME.recipes import recipeGui
+from PYME.IO.image import ImageStack
+from PYME.DSView import ViewIm3D
+from PYME.DSView import overlays
+from PYME.LMVis import pipeline
+
+import os
+
+from ._base import Plugin
+        
+
+class RecipePlugin(recipeGui.PipelineRecipeManager, Plugin):
+    def __init__(self, dsviewer):
+        Plugin.__init__(self, dsviewer)
+
+        if not 'pipeline' in dir(dsviewer):
+            dsviewer.pipeline = pipeline.Pipeline(execute_on_invalidation=False)
+        
+        recipeGui.PipelineRecipeManager.__init__(self, dsviewer.pipeline)
+        
+        self.cannedIDs = {}
+
+        dsviewer.AddMenuItem('Recipes', "Load Recipe", self.OnLoadRecipe)
+        self.mICurrent = dsviewer.AddMenuItem('Recipes', "Run Current Recipe\tF5", self.RunCurrentRecipe)
+        self.mITestCurrent = dsviewer.AddMenuItem('Recipes', "Test Current Recipe\tF7", self.TestCurrentRecipe)
+        self.mICurrent = dsviewer.AddMenuItem('Recipes', "Run Current Recipe and Save\tShift+F5", self.RunCurrentRecipeAndSave)
+        
+        #print CANNED_RECIPES
+        
+        if len(recipeGui.CANNED_RECIPES) > 0:
+            dsviewer.AddMenuItem('Recipes', '', itemType='separator')
+            #self.mRecipes.AppendSeparator()
+            
+            for r in recipeGui.CANNED_RECIPES:
+                #print r, 
+                ID = dsviewer.AddMenuItem('Recipes', os.path.split(r)[1], self.OnRunCanned).GetId()
+                #ID = wx.NewIdRef()
+                self.cannedIDs[ID] = r
+                #self.mRecipes.Append(ID, os.path.split(r)[1],"",  wx.ITEM_NORMAL)
+                #wx.EVT_MENU(dsviewer, ID, self.OnRunCanned)
+
+        # custom recipes - load only, do not execute
+        import PYME.config
+        customRecipes = PYME.config.get_custom_recipes()
+        if len(customRecipes) > 0:
+            dsviewer.AddMenuItem('Recipes', '', itemType='separator')
+            for r in customRecipes:
+                ID = dsviewer.AddMenuItem('Recipes', r, self.OnLoadCustom).GetId()
+                self.cannedIDs[ID] = customRecipes[r]
+
+        #dsviewer.menubar.Append(self.mRecipes, "Recipes")
+        dsviewer.AddMenuItem('Recipes', '', itemType='separator')
+        dsviewer.AddMenuItem('Recipes', "Save Results", self.OnSaveOutputs)
+        dsviewer.AddMenuItem('Recipes', "Save Results - Old Style", self.OnSaveOutputOld)
+        
+        #dsviewer.AddMenuItem('Recipes', '', itemType='separator')
+        dsviewer.AddMenuItem('Recipes', "Load Previous Results", self.OnLoadOutputs)
+            
+        self.recipeView = recipeGui.RecipeView(dsviewer, self)
+        dsviewer.AddPage(page=self.recipeView, select=False, caption='Recipe')
+        
+    def RunCurrentRecipeAndSave(self, event=None):
+        self.RunCurrentRecipe(saveResults=True)
+        
+    def RunCurrentRecipe(self, event=None, testMode=False, saveResults = False):
+        if self.activeRecipe:
+            if testMode:
+                #just run on current frame  # FIXME - this breaks SUPERTILE datasources and anything that needs to carry datasource attributes forward
+                self.outp = self.activeRecipe.execute(input=ImageStack([np.atleast_3d(self.image.data[:,:,self.do.zp, c]) for c in range(self.image.data.shape[3])], mdh=self.image.mdh))
+            else:
+                #run normally
+                self.outp = self.activeRecipe.execute(input=self.image)
+                
+                if saveResults:
+                    dir_dialog = wx.DirDialog(None, 'Set output directory', style=wx.FD_OPEN)
+                    succ = dir_dialog.ShowModal()
+                    if (succ == wx.ID_OK):
+                        output_dir = dir_dialog.GetPath()
+                        file_stub = os.path.splitext(os.path.split(self.image.filename)[-1])[0]
+                        self.activeRecipe.save({'output_dir': output_dir, 
+                                                'file_stub': file_stub})
+                    
+                    
+            def _display_output_image(outp):
+                if self.dsviewer.mode == 'visGUI':
+                    mode = 'visGUI'
+                elif 'out_tracks' in self.activeRecipe.namespace.keys():
+                    mode = 'tracking'
+                else:
+                    mode = 'default'
+    
+                dv = ViewIm3D(outp, mode=mode, glCanvas=self.dsviewer.glCanvas)
+    
+                if 'out_meas' in self.activeRecipe.namespace.keys():
+                    #have measurements as well - add to / overlay with output image
+                    if not 'pipeline' in dir(dv):
+                        dv.pipeline = pipeline.Pipeline()
+        
+                    from PYME.IO import tabular
+                    cache = tabular.CachingResultsFilter(self.activeRecipe.namespace['out_meas'])
+                    
+                    dv.pipeline.OpenFile(ds=cache) # TODO - is needed?
+                    dv.view.add_overlay(overlays.PointDisplayOverlay(filter=cache, display_name='out_meas'))
+                    
+                    #dv.view.filter = dv.pipeline
+    
+                #set scaling to (0,1)
+                for i in range(outp.data.shape[3]):
+                    dv.do.Gains[i] = 1.0
+    
+                if ('out_tracks' in self.activeRecipe.namespace.keys()) and 'tracker' in dir(dv):
+                    dv.tracker.SetTracks(self.activeRecipe.namespace['out_tracks'])
+                    
+            def _display_output_report(outp):
+                import wx.html2
+                html_view = wx.html2.WebView.New(self.dsviewer)
+                self.dsviewer.AddPage(html_view, True, 'Recipe Report')
+                html_view.SetPage(outp, 'Recipe Report')
+
+            if ('out_tracks' in self.activeRecipe.namespace.keys()) and 'tracker' in dir(self.dsviewer):
+                self.dsviewer.tracker.SetTracks(self.activeRecipe.namespace['out_tracks'])
+
+            #assume we made measurements - put in pipeline
+            #TODO - put an explict check in here
+
+            
+
+            if isinstance(self.outp, ImageStack):
+                _display_output_image(self.outp)
+            elif not self.outp is None:
+                #from PYME.IO import tabular
+                
+                
+                #cache = tabular.CachingResultsFilter(self.outp)
+                #self.dsviewer.pipeline.OpenFile(ds = cache, clobber_recipe=False)
+                #self.dsviewer.pipeline.filterKeys = {}
+                #self.dsviewer.pipeline.Rebuild()
+
+                if not hasattr(self, '_ovl'):
+                    self._ovl = overlays.PointDisplayOverlay(filter=self.dsviewer.pipeline, display_name='Recipe output')
+                    self.view.add_overlay(self.ovl)
+                    
+                
+            for out_ in self.activeRecipe.gather_outputs():
+                if isinstance(out_, ImageStack):
+                    _display_output_image(out_)
+                elif isinstance(out_, six.string_types):
+                    _display_output_report(out_)
+                    
+                
+
+                
+    def TestCurrentRecipe(self, event=None):
+        """run recipe on current frame only as an inexpensive form of testing"""
+        
+        self.RunCurrentRecipe(testMode=True)
+                
+    def OnRunCanned(self, event):
+        self.LoadRecipe(self.cannedIDs[event.GetId()])
+        self.RunCurrentRecipe()
+        
+    def OnLoadCustom(self, event):
+        self.LoadRecipe(self.cannedIDs[event.GetId()])
+
+    def OnSaveOutputs(self, event):
+        self.activeRecipe.save()
+        # from PYME.recipes import runRecipe
+        #
+        # filename = wx.FileSelector('Save results as ...',
+        #                            wildcard="CSV files (*.csv)|*.csv|Excell files (*.xlsx)|*.xlsx|HDF5 files (*.hdf)|*.hdf",
+        #                            flags = wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT)
+        #
+        # if not filename == '':
+        #     runRecipe.saveOutput(self.outp, filename)
+            
+        
+            
+        self.activeRecipe.save()
+
+    def OnSaveOutputOld(self, event):
+        from PYME.recipes import runRecipe
+        
+        filename = wx.FileSelector('Save results as ...',
+                                   wildcard="CSV files (*.csv)|*.csv|Excell files (*.xlsx)|*.xlsx|HDF5 files (*.hdf)|*.hdf",
+                                   flags = wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT)
+                                   
+        if not filename == '':
+            runRecipe.saveOutput(self.outp, filename)
+
+
+    def OnLoadOutputs(self, event):
+        import pandas
+        from PYME.IO import tabular
+        
+        filename = wx.FileSelector('Save results as ...', 
+                                   wildcard="CSV files (*.csv)|*.csv|Excell files (*.xlsx)|*.xlsx|HDF5 files (*.hdf)|*.hdf", 
+                                   flags = wx.FD_OPEN)
+                                   
+        if not filename == '':
+            if filename.endswith('.csv'):
+                data = pandas.read_csv(filename)
+            elif filename.endswith('.xlsx'):
+                data = pandas.read_excel(filename)
+            elif filename.endswith('.hdf'):
+                data = pandas.read_hdf(filename)
+                
+            
+            if not 'pipeline' in dir(self.dsviewer):
+                self.dsviewer.pipeline = pipeline.Pipeline()
+                
+            cache = tabular.CachingResultsFilter(data)
+            self.dsviewer.pipeline.OpenFile(ds = cache)
+
+            if not hasattr(self, '_ovl'):
+                self._ovl = overlays.PointDisplayOverlay(filter=self.dsviewer.pipeline, display_name=filename)
+                self.view.add_overlay(self.ovl)
+                
+                
+            
+        
+
+
+
+        
+
+
+
+
+def Plug(dsviewer):
+    # dsviewer.create_overlay_panel()
+    return RecipePlugin(dsviewer)
+    
+
+
+
+

PYME/DSView/modules/redimension.py

@@ -0,0 +1,75 @@
+import wx
+from ._base import Plugin
+
+class RedimensionDialog(wx.Dialog):
+    def __init__(self, parent, img):
+        wx.Dialog.__init__(self, parent, title='Redimension')
+        self._img = img
+        
+        _, _, sz, st, sc = img.data_xyztc.shape
+        
+        self._dim_prod = sz*st*sc
+        
+        vsizer = wx.BoxSizer(wx.VERTICAL)
+        gsizer = wx.GridSizer(2, gap=(5,5))
+        
+        gsizer.Add(wx.StaticText(self, -1, 'Input axis order:'))
+        self.cOrder = wx.Choice(self, -1, choices=['XYZTC', 'XYCZT', 'XYZCT', 'XYCTZ', 'XYTZC', 'XYTCZ'])
+        gsizer.Add(self.cOrder)
+        
+        gsizer.Add(wx.StaticText(self, -1, 'Size Z:'))
+        self.tSizeZ = wx.TextCtrl(self, -1, str(sz))
+        gsizer.Add(self.tSizeZ)
+
+        gsizer.Add(wx.StaticText(self, -1, 'Size T:'))
+        self.tSizeT = wx.TextCtrl(self, -1, str(st))
+        gsizer.Add(self.tSizeT)
+
+        gsizer.Add(wx.StaticText(self, -1, 'Size C:'))
+        self.tSizeC = wx.TextCtrl(self, -1, str(sc))
+        gsizer.Add(self.tSizeC)
+        
+        vsizer.Add(gsizer)
+        
+        self.stError = wx.StaticText(self, -1, '')
+        vsizer.Add(self.stError)
+        
+        bsizer = self.CreateButtonSizer(wx.OK|wx.CANCEL)
+        
+        vsizer.Add(bsizer)
+        
+        self.SetSizerAndFit(vsizer)
+        
+def redimension(parent, img):
+    with RedimensionDialog(parent, img) as dlg:
+        if dlg.ShowModal() == wx.ID_OK:
+            from PYME.IO.image import ImageStack
+            from PYME.DSView import ViewIm3D
+            from PYME.IO.DataSources.BaseDataSource import XYZTCWrapper
+
+            
+            
+            d = XYZTCWrapper(img.data_xyztc)
+            d.set_dim_order_and_size(dlg.cOrder.GetStringSelection(), size_z=int(dlg.tSizeZ.GetValue()),
+                                     size_t=int(dlg.tSizeT.GetValue()), size_c=int(dlg.tSizeC.GetValue()))
+            im = ImageStack(data=d, titleStub='Redimensioned')
+            
+            im.mdh.copyEntriesFrom(img.mdh)
+            im.mdh['Parent'] = img.filename
+            #im.mdh['Processing.CropROI'] = roi
+
+            # if self.dsviewer.mode == 'visGUI':
+            #     mode = 'visGUI'
+            # else:
+            #     mode = 'lite'
+
+            dv = ViewIm3D(im, mode=parent.mode, glCanvas=parent.glCanvas, parent=wx.GetTopLevelParent(parent))
+
+            #set scaling to (0,1)
+            for i in range(im.data.shape[3]):
+                dv.do.Gains[i] = 1.0
+            
+            
+            
+def Plug(dsviewer):
+    dsviewer.AddMenuItem('Processing', 'Redimension', lambda e : redimension(dsviewer, dsviewer.image))