def GenBlobFitPanel(self, _pnl):
item = afp.foldingPane(_pnl, -1, caption="Object Fitting", pinned=True)
# item = _pnl.AddFoldPanel("Object Fitting", collapsed=False,
# foldIcons=self.Images)
bFitObjects = wx.Button(item, -1, 'Fit')
bFitObjects.Bind(wx.EVT_BUTTON, self.OnFitObjects)
#_pnl.AddFoldPanelWindow(item, bFitObjects, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 10)
item.AddNewElement(bFitObjects)
pan = wx.Panel(item, -1)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Bead wxy:'), 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.tBeadWXY = wx.TextCtrl(pan, -1, value='125', size=(40, -1))
hsizer.Add(self.tBeadWXY, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
pan.SetSizer(hsizer)
hsizer.Fit(pan)
item.AddNewElement(pan)
bCalcShiftMap = wx.Button(item, -1, 'Shiftmap')
bCalcShiftMap.Bind(wx.EVT_BUTTON, self.OnCalcShiftmap)
#_pnl.AddFoldPanelWindow(item, bFitObjects, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 10)
item.AddNewElement(bCalcShiftMap)
_pnl.AddPane(item)
def GenPlayPanel(self, _pnl):
item = afp.foldingPane(_pnl, -1, caption="Playback", pinned=True)
self.playPan = PlayPanel(item, self.dsviewer)
item.AddNewElement(self.playPan)
_pnl.AddPane(item)
def GenTrackingPanel(self, _pnl):
item = afp.foldingPane(_pnl, -1, caption="Particle Tracking", pinned = True)
pan = self.edit_traits(parent=item, kind='panel')
item.AddNewElement(pan.control)
bTrack = wx.Button(item, -1, 'Track')
bTrack.Bind(wx.EVT_BUTTON, self.OnTrack)
item.AddNewElement(bTrack)
pan = wx.Panel(item, -1)
vsizer = wx.BoxSizer(wx.VERTICAL)
self.list = TrackList(pan)
self.list.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnSelectTrack)
vsizer.Add(self.list, 1, wx.EXPAND)
pan.SetSizer(vsizer)
vsizer.Fit(pan)
item.AddNewElement(pan)
bSave = wx.Button(item, -1, 'Save')
bSave.Bind(wx.EVT_BUTTON, self.SaveTracks)
item.AddNewElement(bSave)
_pnl.AddPane(item)
if not self.OnViewSelect in self.view.selectHandlers:
self.view.selectHandlers.append(self.OnViewSelect)
def GenQuadTreePanel(visgui, pnl, title='Points'):
"""Generate a ponts pane and insert into the given panel"""
item = afp.foldingPane(pnl, -1, caption=title, pinned=True)
pan = QuadTreeSettingsPanel(item, visgui.pipeline, visgui.quadTreeSettings)
item.AddNewElement(pan)
pnl.AddPane(item)
def GenViewClippingPanel(visgui, pnl, title='View Clipping'):
"""Generate a ponts pane and insert into the given panel"""
item = afp.foldingPane(pnl, -1, caption=title, pinned=False)
pan = ViewClippingPanel(item, visgui.glCanvas)
item.AddNewElement(pan)
pnl.AddPane(item)
def AddTool(self, pane, title, pinned=True, folded=True, panel=None):
"""Adds a pane to the tools section of the GUI
Parameters
----------
pane : an instance of a wx.Window derived class
The pane to add. Optionally, a list of panes
title : string
The caption for the panel.
"""
if panel is None:
panel = self.toolPanel
if isinstance(pane, afp.foldingPane):
pane.SetCaption(title).Pin(pinned).Fold(folded)
pane.Reparent(panel)
panel.AddPane(pane)
else:
# a normal wx.Panel / wx.Window
#print(panel, title, pinned, folded)
item = afp.foldingPane(panel, -1, caption=title, pinned=pinned, folded=folded)
pane.Reparent(item)
item.AddNewElement(pane, priority=1)
panel.AddPane(item)
def GenPointFindingPanel(self, _pnl):
item = afp.foldingPane(_pnl,
-1,
caption="Point Finding",
pinned=not (self.foldAnalPanes))
pan = wx.Panel(item, -1)
vsizer = wx.BoxSizer(wx.VERTICAL)
#load point finding settings
self._populateFindOptionsPanel(pan, vsizer)
if not self.lmanal is None:
hsizer = wx.BoxSizer(wx.HORIZONTAL)
#bTest = wx.Button(pan, -1, 'Test', style=wx.BU_EXACTFIT)
#bTest.Bind(wx.EVT_BUTTON, lambda e : self.lmanal.Test())
#hsizer.Add(bTest, 0,wx.LEFT|wx.ALIGN_CENTER_VERTICAL, 5)
bTestF = wx.Button(pan,
-1,
'Test This Frame',
style=wx.BU_EXACTFIT)
bTestF.Bind(wx.EVT_BUTTON, lambda e: self.lmanal.OnTestFrame(e))
hsizer.Add(bTestF, 0, wx.LEFT | wx.ALIGN_CENTER_VERTICAL, 5)
vsizer.Add(hsizer, 0, wx.BOTTOM | wx.EXPAND, 2)
pan.SetSizerAndFit(vsizer)
item.AddNewElement(pan)
_pnl.AddPane(item)
def GenFlowPanel(self, _pnl):
item = afp.foldingPane(_pnl, -1, caption="Flow Visualization", pinned = True)
pan = self.edit_traits(parent=item, kind='panel')
item.AddNewElement(pan.control)
_pnl.AddPane(item)
def GenViewClippingPanel(visgui, pnl, title='View Clipping'):
"""
Generate a folding pane that lets a user dynamically filter points
spatially by adjusting sliders.
"""
item = afp.foldingPane(pnl, -1, caption=title, pinned=False)
pan = ViewClippingPanel(item, visgui.glCanvas)
item.AddNewElement(pan)
pnl.AddPane(item)
def GenBlobPanel(visgui, pnl):
# item = self._pnl.AddFoldPanel("Objects", collapsed=False,
# foldIcons=self.Images)
item = afp.foldingPane(pnl, -1, caption="Objects", pinned=True)
pan = wx.BlobSettingsPanel(item, visgui.pipeline,
visgui.pipeline.blobSettings, visgui)
#self._pnl.AddFoldPanelWindow(item, pan, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 5)
item.AddNewElement(pan)
pnl.AddPane(item)
def GenFitStatusPanel(self, _pnl):
item = afp.foldingPane(_pnl, -1, caption="Fit Status", pinned=True)
pan = wx.Panel(item, -1) #, size = (160, 200))
vsizer = wx.BoxSizer(wx.VERTICAL)
self.progPan = progGraph.progPanel(pan,
self.fitResults,
size=(220, 100))
self.progPan.draw()
vsizer.Add(self.progPan, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL, 0)
pan.SetSizer(vsizer)
vsizer.Fit(pan)
#_pnl.AddFoldPanelWindow(item, pan, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 0)
item.AddNewElement(pan)
_pnl.AddPane(item)
def GenDataSourcePanel(self, pnl):
from PYME.recipes.vertical_recipe_display import RecipeDisplayPanel
print('Creating datasource panel')
item = afp.foldingPane(pnl, -1, caption="Data Pipeline", pinned=True)
pan = wx.Panel(item, -1)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'output:'), 0, wx.ALL, 2)
self.chSource = wx.Choice(pan, -1, choices=[])
hsizer.Add(self.chSource, 1, wx.ALL | wx.EXPAND, 2)
pan.SetSizerAndFit(hsizer)
self.update_datasource_panel()
self.chSource.Bind(wx.EVT_CHOICE, self.OnSourceChange)
self.pipeline.onRebuild.connect(self.update_datasource_panel)
item.AddNewElement(pan, foldable=False)
self.recipeView = RecipeDisplayPanel(item)
self.recipeView.SetRecipe(self.pipeline.recipe)
item.AddNewElement(self.recipeView, priority=20)
pnl.AddPane(item, 20)
def _layout(self, *args, **kwargs):
print('RecipeView._layout')
if self.fp:
self.fp.elements = []
self.fp.DestroyChildren()
self.fp = None
#print('destroyed fold panel children')
self.DestroyChildren()
#print('destroyed children')
from matplotlib import pyplot as plt
from .base import ModuleBase, OutputModule
import textwrap
#from PYME.ui import autoFoldPanel as afp
import PYME.ui.manualFoldPanel as afp
dg = self.recipe.dependancyGraph()
rdg = self.recipe.reverseDependancyGraph()
self.ordered, self.x0s = recipeLayout.layout_vertical(dg, rdg)
x_vals = -.1 * (1 + np.arange(len(self.ordered)))
self.input_target_panes = {}
self.output_source_panes = {}
self.data_panes = {}
#what data do we already have in the namespace?
self.input_datasources = list(self.recipe.namespace.keys())
for node in self.ordered:
if isinstance(node, ModuleBase):
for op in node.outputs:
try:
#this is obviously not an input - remove from list of input data
self.input_datasources.remove(op)
except ValueError:
pass
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.AddSpacer(20)
self.fp = afp.foldPanel(self)
hsizer.Add(self.fp, 1, wx.EXPAND, 0)
hsizer.AddSpacer(10)
for N, node in enumerate(self.ordered):
if isinstance(node, ModuleBase):
#This is a module - plot a box
s = node.__class__.__name__
item = afp.foldingPane(self.fp, -1, caption=s, pinned=False)
if getattr(node, '_has_buttons', False) or (getattr(
node, '_get_actions', None) is not None):
kind = 'panel'
else:
kind = 'subpanel'
pan = node.edit_traits(parent=item,
kind=kind,
view='pipeline_view_min')
pan.control.SetMinSize((150, -1))
item.AddNewElement(pan.control)
self.fp.AddPane(item)
#p = pan.control
#j += 1
#draw input lines
inputs = list(node.inputs)
ip_xs = [self._data_output_pos(ip)[0] for ip in inputs]
ip_ys = np.linspace(0, 1, 2 * len(inputs) + 1)[1::2]
ip_ys = ip_ys[np.argsort(ip_xs)[::-1]]
for ip_y, ip in zip(ip_ys, inputs):
self.input_target_panes[ip] = (item, ip_y)
#self.input_positions[ip] = lambda : (self.fp.panes[j].Position[0], self.fp.panes[j].Position[1] + ip_y*self.fp.panes[j].GetSize()[1])
#self.input_positions[ip] = lambda : _get_op(j)
#
# #draw the nodes outputs
outputs = list(node.outputs)[::-1]
if len(outputs) > 0:
op_y = np.linspace(0, 1, 2 * len(outputs) + 1)[1::2]
op_x = 5 * np.arange(len(outputs))[::-1]
for yp, xp, op in zip(op_y, op_x, outputs):
self.output_source_panes[op] = (item, xp, yp)
#self.output_positions[op] = lambda : (item.GetPosition()[0] + item.GetSize()[0] + 5 + xp, item.GetPosition()[1] + yp*item.GetSize()[1])
else:
# we must be an input - route back to LHS
try:
#only map back if we are going to be used.
if True: #rdg.get(node, False):
xi, yi = self._output_position(node)
x_0 = x_vals[self.x0s[node]]
#ax.plot([2, xi, xi, x_0], [yi, yi, y, y], '-', color=_col(node), lw=2)
#print('Adding static text')
item = afp.foldingPane(self.fp,
-1,
caption=None,
pinned=True,
folded=False,
padding=0,
style=0)
st = wx.StaticText(item, -1, node)
node_col = tuple(
[int(v) for v in (255 * self._col(node)[:3])])
evts = ''
data = self.recipe.namespace.get(node, None)
if isinstance(data, tabular.TabularBase):
evts = ' [%d evts]' % len(data)
st.SetLabelMarkup(
"<span foreground='#%02x%02x%02x'>%s%s</span>" %
(node_col + (node, evts)))
item.AddNewElement(st, foldable=False)
self.fp.AddPane(item)
self.data_panes[node] = (item, st)
#self.data_positions[node] = lambda : (item.GetPosition()[0] + x_0, item.GetPosition()[1] + 0.5 * item.GetSize()[1])
#self.data_positions_in[node] = lambda : (item.GetPosition()[0] + st.GetSize()[0], item.GetPosition()[1] + 0.5 * item.GetSize()[1])
except KeyError:
#dangling input
#print('dangling input')
x_0 = x_vals[self.x0s[node]]
item = afp.foldingPane(self.fp,
-1,
caption=None,
pinned=True,
folded=False,
padding=0,
style=0)
st = wx.StaticText(item, -1, node)
node_col = tuple(
[int(v) for v in (255 * self._col(node)[:3])])
bg = ''
evts = ''
if node in self.input_datasources:
bg = " background='#D0D0D0'"
data = self.recipe.namespace.get(node, None)
if isinstance(data, tabular.TabularBase):
evts = ' [%d evts]' % len(data)
st.SetLabelMarkup(
"<u><span foreground='#%02x%02x%02x' weight='bold'%s>%s%s</span></u>"
% (node_col + (bg, node, evts)))
item.AddNewElement(st, foldable=False)
self.fp.AddPane(item)
self.data_panes[node] = (item, st)
#self.data_positions[node] = lambda : (item.GetPosition()[0] + x_0, item.GetPosition()[1] + 0.5 * item.GetSize()[1])
print('Input datasources: ', self.input_datasources)
self.fp.fold_signal.connect(self._refr)
self.SetSizerAndFit(hsizer)
def GenPSFPanel(self, _pnl):
item = afp.foldingPane(_pnl, -1, caption="PSF Extraction", pinned=True)
pan = wx.Panel(item, -1)
vsizer = wx.BoxSizer(wx.VERTICAL)
#if self.multiChannel: #we have channels
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Channel:'), 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.chChannel = wx.Choice(pan, -1, choices=self.do.names)
hsizer.Add(self.chChannel, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
vsizer.Add(hsizer, 0, wx.EXPAND | wx.ALL, 0)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
#
# hsizer.Add(wx.StaticText(pan, -1, 'Threshold:'), 0,wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
# self.tThreshold = wx.TextCtrl(pan, -1, value='50', size=(40, -1))
#
bTagPSF = wx.Button(pan, -1, 'Tag', style=wx.BU_EXACTFIT)
bTagPSF.Bind(wx.EVT_BUTTON, self.OnTagPSF)
hsizer.Add(bTagPSF, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
bTagPoints = wx.Button(pan, -1, 'Tag Points', style=wx.BU_EXACTFIT)
bTagPoints.Bind(wx.EVT_BUTTON, self.OnTagPoints)
hsizer.Add(bTagPoints, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
bClearTagged = wx.Button(pan, -1, 'Clear', style=wx.BU_EXACTFIT)
bClearTagged.Bind(wx.EVT_BUTTON, self.OnClearTags)
hsizer.Add(bClearTagged, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
vsizer.Add(hsizer, 0, wx.ALL, 5)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'ROI Half Size:'), 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.tPSFROI = wx.TextCtrl(pan, -1, value='30,30,30', size=(40, -1))
hsizer.Add(self.tPSFROI, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.tPSFROI.Bind(wx.EVT_TEXT, self.OnPSFROI)
vsizer.Add(hsizer, 0, wx.EXPAND | wx.ALL, 0)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Blur:'), 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.tPSFBlur = wx.TextCtrl(pan, -1, value='.5,.5,1', size=(40, -1))
hsizer.Add(self.tPSFBlur, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
vsizer.Add(hsizer, 0, wx.EXPAND | wx.ALL, 0)
# hsizer = wx.BoxSizer(wx.HORIZONTAL)
# hsizer.Add(wx.StaticText(pan, -1, 'PSF Type:'), 0,wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
# self.chType = wx.Choice(pan, -1, choices=['Widefield', 'Confocal'], size=(40, -1))
# hsizer.Add(self.chType, 1,wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
# if 'Camera.IntegrationTime' in self.image.mdh.getEntryNames():
# #most likely widefield
# self.chType.SetSelection(0)
# else:
# #most likely confocal
# #confocal is a safe default as widefield just does some fancy extra
# #background correction
# self.chType.SetSelection(1)
# vsizer.Add(hsizer, 0,wx.EXPAND|wx.ALL|wx.ALIGN_CENTER_HORIZONTAL, 0)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Method:'), 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.chMethod = wx.Choice(
pan,
-1,
choices=['Standard', 'Split', 'Multi-channel'],
size=(40, -1))
hsizer.Add(self.chMethod, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.chMethod.SetSelection(
0
) # most common option - also a good default with a splitter assuming aberrations are not very different between channels.
if self.image.data.shape[3] == 4:
#most likely the high-throughput system, default to multi-view extraction
self.chMethod.SetSelection(0)
vsizer.Add(hsizer, 0, wx.EXPAND | wx.ALL, 0)
self.cbAlignZ = wx.CheckBox(pan, -1, 'Align Z')
self.cbAlignZ.SetValue(True)
vsizer.Add(self.cbAlignZ, 0, wx.ALL, 5)
self.cbBackgroundCorrect = wx.CheckBox(
pan, -1, 'Widefield background correction:')
self.cbBackgroundCorrect.SetValue(False)
vsizer.Add(self.cbBackgroundCorrect, 0, wx.ALL, 5)
self.cbExpandROI = wx.CheckBox(pan, -1, 'Expand z ROI')
self.cbExpandROI.SetValue(False)
vsizer.Add(self.cbExpandROI, 0, wx.ALL, 5)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
bExtract = wx.Button(pan, -1, 'Extract', style=wx.BU_EXACTFIT)
bExtract.Bind(wx.EVT_BUTTON, self.OnExtract)
hsizer.Add(bExtract, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
# bExtractSplit = wx.Button(pan, -1, 'Extract Split', style=wx.BU_EXACTFIT)
# bExtractSplit.Bind(wx.EVT_BUTTON, self.OnExtractSplitPSF)
# hsizer.Add(bExtractSplit, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
vsizer.Add(hsizer, 0, wx.ALL | wx.ALIGN_RIGHT, 5)
bAxialShift = wx.Button(pan,
-1,
'Estimate axial shift',
style=wx.BU_EXACTFIT)
bAxialShift.Bind(wx.EVT_BUTTON, self.OnCalcShift)
vsizer.Add(bAxialShift, 0, wx.ALL | wx.ALIGN_RIGHT, 5)
# bExtractMultColour = wx.Button(pan, -1, 'Extract Multi Colour', style=wx.BU_EXACTFIT)
# bExtractMultColour.Bind(wx.EVT_BUTTON, self.OnExtractMultiviewPSF)
# vsizer.Add(bExtractMultColour, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
#bCalibrateMultiview = wx.Button(pan, -1, 'Calibrate multiview astigmatism', style=wx.BU_EXACTFIT)
#bCalibrateMultiview.Bind(wx.EVT_BUTTON, self.OnCalibrateMultiview)
#vsizer.Add(bCalibrateMultiview, 0,wx.ALL|wx.ALIGN_RIGHT, 5)
pan.SetSizer(vsizer)
vsizer.Fit(pan)
#_pnl.AddFoldPanelWindow(item, pan, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 5)
item.AddNewElement(pan)
_pnl.AddPane(item)
def _init_ctrls(self, prnt):
# generated method, don't edit
#wx.Panel.__init__(self, id=-1, parent=prnt)#, size=wx.Size(442, 637))
self._init_utils()
#self.SetClientSize(wx.Size(434, 610))
#vsizer= wx.BoxSizer(wx.VERTICAL)
################ Splitter ######################
item = afp.foldingPane(self, -1, caption="Virtual Hardware", pinned=True)
#sbsizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Image splitting & PSF'),
# wx.VERTICAL)
pane = wx.Panel(item, -1)
sbsizer = wx.BoxSizer(wx.VERTICAL)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pane, -1, 'Number of detection channels: '), 0, wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 2)
self.cNumSplitterChans = wx.Choice(pane, -1, choices=['1 - Standard', '2 - Ratiometric/Biplane', '4 - HT / 4Pi-SMS'])
self.cNumSplitterChans.SetSelection(0)
self.cNumSplitterChans.Bind(wx.EVT_CHOICE, self.OnNumChannelsChanged)
hsizer.Add(self.cNumSplitterChans, 0, wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 10)
sbsizer.Add(hsizer, 0, wx.ALL | wx.EXPAND, 2)
self.gSplitter = wx.grid.Grid(pane, -1)
self.setupSplitterGrid()
self.OnNumChannelsChanged()
sbsizer.Add(self.gSplitter, 0, wx.RIGHT | wx.EXPAND, 2)
sbsizer.AddSpacer(8)
############## PSF Settings ################
hsizer = wx.BoxSizer(wx.HORIZONTAL)
self.st_psf = wx.StaticText(pane, -1, 'PSF: Default widefield')
hsizer.Add(self.st_psf, 0, wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 4)
hsizer.AddStretchSpacer()
self.bSetTPSF = wx.Button(pane, -1, 'Set Theoretical')
self.bSetTPSF.Bind(wx.EVT_BUTTON, self.OnBSetPSFModel)
hsizer.Add(self.bSetTPSF, 1, wx.RIGHT | wx.ALIGN_CENTER_VERTICAL, 2)
self.bSetPSF = wx.Button(pane, -1, 'Set Experimental')
self.bSetPSF.Bind(wx.EVT_BUTTON, self.OnBSetPSF)
hsizer.Add(self.bSetPSF, 1, wx.RIGHT | wx.ALIGN_CENTER_VERTICAL, 2)
self.bSavePSF = wx.Button(pane, -1, 'Save')
self.bSavePSF.Bind(wx.EVT_BUTTON, self.OnBSavePSF)
hsizer.Add(self.bSavePSF, 1, wx.RIGHT | wx.ALIGN_CENTER_VERTICAL, 2)
sbsizer.Add(hsizer, 0, wx.ALL, 2)
sbsizer.AddSpacer(8)
pane.SetSizerAndFit(sbsizer)
item.AddNewElement(pane)
self.AddPane(item)
#vsizer.Add(sbsizer, 0, wx.ALL | wx.EXPAND, 2)
########### Fluorophore Positions ############
#sbsizer=wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Fluorophore Postions'),
# wx.VERTICAL)
item = afp.foldingPane(self, -1, caption='Fluorophore Postions', pinned=True)
pane = wx.Panel(item, -1)
sbsizer = wx.BoxSizer(wx.VERTICAL)
hsizer=wx.BoxSizer(wx.HORIZONTAL)
self.tNumFluorophores = wx.TextCtrl(pane, -1, value='10000', size=(60, -1))
hsizer.Add(self.tNumFluorophores, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
hsizer.Add(wx.StaticText(pane,-1,'fluorophores distributed evenly along'),
0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
self.tKbp = wx.TextCtrl(pane, -1, size=(60, -1), value='200000')
hsizer.Add(self.tKbp, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
hsizer.Add(wx.StaticText(pane,-1,'nm'),
0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
hsizer.AddStretchSpacer()
self.bGenWormlike = wx.Button(pane, -1,'Generate')
self.bGenWormlike.Bind(wx.EVT_BUTTON, self.OnBGenWormlikeButton)
hsizer.Add(self.bGenWormlike, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
sbsizer.Add(hsizer, 0, wx.ALL|wx.EXPAND, 2)
hsizer=wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pane,-1,'Persistence length [nm]:'),
0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
self.tPersist = wx.TextCtrl(pane, -1, size=(60, -1), value='1500')
hsizer.Add(self.tPersist, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
hsizer.Add(wx.StaticText(pane,-1,'Z scale:'),
0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
self.tZScale = wx.TextCtrl(pane, -1, size=(60, -1), value='1.0')
hsizer.Add(self.tZScale, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
self.cbFlatten = wx.CheckBox(pane, -1, 'flatten (set z to 0)')
self.cbFlatten.SetValue(False)
hsizer.Add(self.cbFlatten, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
sbsizer.Add(hsizer, 0, wx.ALL | wx.EXPAND, 2)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
self.cbColour = wx.CheckBox(pane, -1, u'Colourful')
self.cbColour.SetValue(False)
hsizer.Add(self.cbColour, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
self.cbWrap = wx.CheckBox(pane, -1, u'Wrap at FOV edge')
self.cbWrap.SetValue(True)
hsizer.Add(self.cbWrap, 0, wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 2)
sbsizer.Add(hsizer, 0, wx.ALL|wx.EXPAND, 2)
hsizer=wx.BoxSizer(wx.HORIZONTAL)
self.stCurObjPoints = wx.StaticText(pane, -1, 'Current object has NO points')
self.stCurObjPoints.SetForegroundColour(wx.RED)
hsizer.Add(self.stCurObjPoints, 0, wx.ALL, 2)
hsizer.AddStretchSpacer()
self.bLoadPoints = wx.Button(pane, -1,'Load From File')
self.bLoadPoints.Bind(wx.EVT_BUTTON, self.OnBLoadPointsButton)
hsizer.Add(self.bLoadPoints, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
self.bSavePoints = wx.Button(pane, -1,'Save To File')
self.bSavePoints.Bind(wx.EVT_BUTTON, self.OnBSavePointsButton)
hsizer.Add(self.bSavePoints, 0, wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, 2)
sbsizer.Add(hsizer, 0, wx.ALL|wx.EXPAND, 2)
pane.SetSizerAndFit(sbsizer)
item.AddNewElement(pane)
self.AddPane(item)
#vsizer.Add(sbsizer, 0, wx.ALL|wx.EXPAND, 2)
################ Virtual Fluorophores ###########
#sbsizer=wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Generate Virtual Fluorophores'),
# wx.VERTICAL)
item = afp.foldingPane(self, -1, caption='Fluorophore switching model', pinned=True)
pane = wx.Panel(item, -1)
sbsizer = wx.BoxSizer(wx.VERTICAL)
self.nSimulationType = wx.Notebook(pane, -1)
######################## Based on first principles... #########
pFirstPrinciples = wx.Panel(self.nSimulationType, -1)
pFirstPrinciplesSizer = wx.BoxSizer(wx.VERTICAL)
sbsizer2 = wx.StaticBoxSizer(
wx.StaticBox(pFirstPrinciples, -1, 'Transition Tensor'),
wx.VERTICAL)
self.nTransitionTensor = wx.Notebook(pFirstPrinciples, -1)
# self.nTransitionTensor.SetLabel('Transition Probabilites')
#pFirstPrinciplesSizer.Add(wx.StaticText(pFirstPrinciples, -1, "A 4-state 1st order kinetic model, this allows simulation of all common modalities (PALM, STORM, PAINT, etc ...) with suitable parameter choices"), 0, wx.ALL, 2)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pFirstPrinciples, -1, 'Generate matrix for:'), 0, wx.ALL|wx.ALIGN_CENTRE_HORIZONTAL, 2)
self.cModelPresets = wx.Choice(pFirstPrinciples, -1, choices=['STORM', 'PALM', 'PAINT'])
self.cModelPresets.Bind(wx.EVT_CHOICE, self.OnModelPresets)
hsizer.Add(self.cModelPresets, 0, wx.ALL | wx.ALIGN_CENTRE_HORIZONTAL, 2)
sbsizer2.Add(hsizer, 0, wx.ALL, 2)
self.gSpontan = wx.grid.Grid(self.nTransitionTensor, -1)
self.gSwitch = wx.grid.Grid(self.nTransitionTensor, -1)
self.gProbe = wx.grid.Grid(self.nTransitionTensor, -1)
self._init_coll_nTransitionTensor_Pages(self.nTransitionTensor)
self.setupGrid(self.gSpontan, self.states, self.stateTypes)
self.setupGrid(self.gSwitch, self.states, self.stateTypes)
self.setupGrid(self.gProbe, self.states, self.stateTypes)
sbsizer2.Add(self.nTransitionTensor, 1, wx.EXPAND | wx.ALL, 2)
pFirstPrinciplesSizer.Add(sbsizer2, 1, wx.EXPAND | wx.ALL, 2)
sbsizer2 = wx.StaticBoxSizer(
wx.StaticBox(pFirstPrinciples, -1, 'Excitation Crossections (Fluorophore Brightness)'),
wx.HORIZONTAL)
sbsizer2.Add(wx.StaticText(pFirstPrinciples, -1, 'Switching Laser:'), 0,
wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 2)
self.tExSwitch = wx.TextCtrl(pFirstPrinciples, -1, value='1')
sbsizer2.Add(self.tExSwitch, 0, wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 2)
sbsizer2.Add(
wx.StaticText(pFirstPrinciples, -1, 'photons/mWs Probe Laser:'), 0,
wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 2)
self.tExProbe = wx.TextCtrl(pFirstPrinciples, -1, value='100')
sbsizer2.Add(self.tExProbe, 0, wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 2)
sbsizer2.Add(wx.StaticText(pFirstPrinciples, -1, 'photons/mWs'), 0,
wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 2)
self.sbsizer2 = sbsizer2
pFirstPrinciplesSizer.Add(sbsizer2, 0, wx.EXPAND | wx.ALL, 2)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
self.bGenFlours = wx.Button(pFirstPrinciples, -1, 'Go')
self.bGenFlours.Bind(wx.EVT_BUTTON, self.OnBGenFloursButton)
hsizer.Add(self.bGenFlours, 1, wx.RIGHT | wx.ALIGN_CENTER_VERTICAL, 2)
pFirstPrinciplesSizer.Add(hsizer, 0, wx.ALL | wx.ALIGN_RIGHT, 2)
pFirstPrinciples.SetSizer(pFirstPrinciplesSizer)
######################## Based on empirical data... #########
pEmpiricalModel = wx.Panel(self.nSimulationType, -1)
pEmpiricalModelSizer = wx.BoxSizer(wx.VERTICAL)
sbsizer2 = wx.StaticBoxSizer(wx.StaticBox(pEmpiricalModel, -1,
'Load Dye Kinetics Histogram (JSON)'),
wx.HORIZONTAL)
self.stEmpiricalHist = wx.StaticText(pEmpiricalModel, -1, 'File: ')
sbsizer2.Add(self.stEmpiricalHist, 0, wx.ALL, 2)
sbsizer2.AddStretchSpacer()
self.bLoadEmpiricalHist = wx.Button(pEmpiricalModel, -1, 'Load')
self.bLoadEmpiricalHist.Bind(wx.EVT_BUTTON, self.OnBLoadEmpiricalHistButton)
sbsizer2.Add(self.bLoadEmpiricalHist, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_RIGHT, 2)
pEmpiricalModelSizer.Add(sbsizer2, 0, wx.ALL | wx.EXPAND, 2)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
self.bGenEmpiricalHistFluors = wx.Button(pEmpiricalModel, -1, 'Go')
self.bGenEmpiricalHistFluors.Bind(wx.EVT_BUTTON, self.OnBGenEmpiricalHistFluorsButton)
hsizer.Add(self.bGenEmpiricalHistFluors, 1,
wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_RIGHT, 2)
pEmpiricalModelSizer.Add(hsizer, 0, wx.ALL | wx.ALIGN_RIGHT, 2)
pEmpiricalModel.SetSizer(pEmpiricalModelSizer)
self.pFirstPrinciples = pFirstPrinciples
self.pEmpericalModel = pEmpiricalModel
self.nSimulationType.AddPage(imageId=-1, page=pFirstPrinciples,
select=True,
text='Theoretical State Model')
self.nSimulationType.AddPage(imageId=-1, page=pEmpiricalModel,
select=False,
text='Data Based Empirical Model')
sbsizer.Add(self.nSimulationType, 0, wx.ALL | wx.EXPAND, 2)
#vsizer.Add(sbsizer, 0, wx.ALL | wx.EXPAND, 2)
pane.SetSizerAndFit(sbsizer)
item.AddNewElement(pane)
self.AddPane(item)
######## Status #########
#sbsizer=wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Status'),
# wx.VERTICAL)
item = afp.foldingPane(self, -1, caption='Status', pinned=True)
pane = wx.Panel(item, -1)
sbsizer = wx.BoxSizer(wx.VERTICAL)
self.stStatus = wx.StaticText(pane, -1,
label='hello\nworld\n\n\nfoo')
sbsizer.Add(self.stStatus, 0, wx.ALL|wx.EXPAND, 2)
self.bPause = wx.Button(pane, -1,'Pause')
self.bPause.Bind(wx.EVT_BUTTON, self.OnBPauseButton)
sbsizer.Add(self.bPause, 0, wx.ALL|wx.ALIGN_RIGHT, 2)
pane.SetSizerAndFit(sbsizer)
item.AddNewElement(pane)
self.AddPane(item)
def GenBlobFindingPanel(self, _pnl):
item = afp.foldingPane(_pnl, -1, caption="Object Finding", pinned=True)
pan = wx.Panel(item, -1)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Threshold:'), 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.tThreshold = wx.TextCtrl(pan, -1, value='50', size=(40, -1))
hsizer.Add(self.tThreshold, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
pan.SetSizer(hsizer)
hsizer.Fit(pan)
#_pnl.AddFoldPanelWindow(item, pan, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 5)
item.AddNewElement(pan)
pan = wx.Panel(item, -1)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
#hsizer.Add(wx.StaticText(pan, -1, 'Method:'), 0,wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
self.chMethod = wx.Choice(
pan,
-1,
choices=['Simple Threshold', 'SNR Threshold', 'Multi-threshold'])
self.chMethod.SetSelection(0)
self.chMethod.Bind(wx.EVT_CHOICE, self.OnChangeMethod)
hsizer.Add(self.chMethod, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
pan.SetSizer(hsizer)
hsizer.Fit(pan)
#_pnl.AddFoldPanelWindow(item, pan, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 5)
item.AddNewElement(pan)
pan = wx.Panel(item, -1)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Channel:'), 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.chChannel = wx.Choice(pan, -1, choices=self.do.names)
hsizer.Add(self.chChannel, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
pan.SetSizer(hsizer)
hsizer.Fit(pan)
item.AddNewElement(pan)
pan = wx.Panel(item, -1)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Blur size:'), 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
self.tBlurSize = wx.TextCtrl(pan, -1, value='1.5', size=(40, -1))
self.tBlurSize.Disable()
hsizer.Add(self.tBlurSize, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5)
pan.SetSizer(hsizer)
hsizer.Fit(pan)
#_pnl.AddFoldPanelWindow(item, pan, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 5)
item.AddNewElement(pan)
#self.cbSNThreshold = wx.CheckBox(item, -1, 'SNR Threshold')
#self.cbSNThreshold.SetValue(False)
#_pnl.AddFoldPanelWindow(item, self.cbSNThreshold, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 5)
#item.AddNewElement(self.cbSNThreshold)
#self.cbThresholdRange = wx.CheckBox(item, -1, 'Multi-thresholds')
#self.cbThresholdRange.SetValue(False)
#_pnl.AddFoldPanelWindow(item, self.cbSNThreshold, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 5)
#item.AddNewElement(self.cbThresholdRange)
bFindObjects = wx.Button(item, -1, 'Find')
bFindObjects.Bind(wx.EVT_BUTTON, self.OnFindObjects)
#_pnl.AddFoldPanelWindow(item, bFindObjects, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 10)
item.AddNewElement(bFindObjects)
_pnl.AddPane(item)
def GenAnalysisPanel(self, _pnl):
item = afp.foldingPane(_pnl,
-1,
caption="Analysis",
pinned=not (self.foldAnalPanes))
#############################
#std options
pan = wx.Panel(item, -1)
vsizer = wx.BoxSizer(wx.VERTICAL)
pan.SetSizer(vsizer)
self._populateStdOptionsPanel(pan, vsizer)
item.AddNewElement(pan)
#######################
#Fit factory selection
pan = wx.Panel(item, -1)
#find out what fit factories we have
self.fitFactories = PYME.localization.FitFactories.resFitFactories
print((self.fitFactories))
vsizer = wx.BoxSizer(wx.VERTICAL)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Type:'), 0,
wx.RIGHT | wx.ALIGN_CENTER_VERTICAL, 5)
self.cFitType = wx.Choice(
pan,
-1,
choices=[
'{:<35} \t- {:} '.format(
f, PYME.localization.FitFactories.useFor[f])
for f in self.fitFactories
],
size=(110, -1))
if 'Analysis.FitModule' in self.analysisMDH.getEntryNames():
#has already been analysed - most likely to want the same method again
try:
self.cFitType.SetSelection(
self.fitFactories.index(
self.analysisMDH['Analysis.FitModule']))
#self.tThreshold.SetValue('%s' % self.image.mdh.getOrDefault('Analysis.DetectionThreshold', 1))
except ValueError:
self.cFitType.SetSelection(
self.fitFactories.index('LatGaussFitFR'))
#elif 'Camera.ROIPosY' in self.image.mdh.getEntryNames() and (self.image.mdh.getEntry('Camera.ROIHeight') + 1 + 2*(self.image.mdh.getEntry('Camera.ROIPosY')-1)) == 512:
# #we have a symetrical ROI about the centre - most likely want to analyse using splitter
# self.cFitType.SetSelection(self.fitFactories.index('SplitterFitQR'))
# self.tThreshold.SetValue('0.5')
else:
self.cFitType.SetSelection(
self.fitFactories.index('LatGaussFitFR'))
self.analysisMDH['Analysis.FitModule'] = 'LatGaussFitFR'
self.cFitType.Bind(wx.EVT_CHOICE, self.OnFitModuleChanged)
hsizer.Add(self.cFitType, 1, wx.ALIGN_CENTER_VERTICAL, 0)
vsizer.Add(hsizer, 0, wx.BOTTOM | wx.EXPAND, 2)
pan.SetSizer(vsizer)
vsizer.Fit(pan)
item.AddNewElement(pan)
########################################
#custom (fit factory dependant) options
self.customOptionsPan = wx.Panel(item, -1)
self.customOptionsSizer = wx.BoxSizer(wx.VERTICAL)
self.customOptionsPan.SetSizer(self.customOptionsSizer)
self._populateCustomAnalysisPanel(self.customOptionsPan,
self.customOptionsSizer)
item.AddNewElement(self.customOptionsPan)
######################
#Go
if self.lmanal:
self.bGo = wx.Button(item, -1, 'Go')
self.bGo.Bind(wx.EVT_BUTTON, lambda e: self.lmanal.OnGo(e))
item.AddNewElement(self.bGo)
_pnl.AddPane(item)
self.analysisPanel = item
