def launch_viewer_frame (self) :
if (self.viewer is None) :
self.viewer = XrayFrame(
parent=self,
title="Image viewer")
self.viewer.Show()
self.Bind(wx.EVT_CLOSE, self.OnCloseViewer, self.viewer)
def run(self):
"""The run() function defines the frame and starts the main loop.
self._init_lock is released only when all initialisation is done.
Whatever thread is the current one when wxWindows is initialised
is what it will consider the "main thread." For wxPython 2.4 that
happens when wxPython.wx is imported the first time. For 2.5 it
will be when the wx.App object is created.
"""
import wx
from wxtbx import bitmaps
app = wx.App(0)
self._bitmap_pause = bitmaps.fetch_icon_bitmap('actions', 'stop')
self._bitmap_run = bitmaps.fetch_icon_bitmap('actions', 'runit')
self._frame = XrayFrame(None,
-1,
"X-ray image display",
size=(800, 720))
self._frame.Bind(wx.EVT_IDLE, self.OnIdle)
self.setup_toolbar(self._frame.toolbar)
self._frame.Show()
self._init_lock.release()
app.MainLoop()
# Avoid deadlock where the send_data() function is waiting for the
# semaphore after the frame has closed.
self._next_semaphore.release()
def setup_toolbar(self):
XFBaseClass.setup_toolbar(self)
btn = self.toolbar.AddLabelTool(id=wx.ID_SAVEAS,
label="Save As...",
bitmap=bitmaps.fetch_icon_bitmap("actions","save_all", 32),
shortHelp="Save As...",
kind=wx.ITEM_NORMAL)
self.Bind(wx.EVT_MENU, self.OnSaveAs, btn)
def display(self,path):
import wx
from rstbx.viewer.frame import XrayFrame
app = wx.App(0)
frame = XrayFrame(None, -1, "X-ray image display", size=(1200,1080))
frame.SetSize((1024,780))
frame.load_image(path)
frame.Show()
app.MainLoop()
def run_one_index(path, *arguments, **kwargs):
assert arguments[0].find("target=")==0
target = arguments[0].split("=")[1]
from xfel.phil_preferences import load_cxi_phil
if "--nodisplay" in arguments[1:]:
display = False
arguments = list(arguments)
arguments.remove("--nodisplay")
else:
display = True
args = ["indexing.data=%s"%path,
"beam_search_scope=0.5",
"lepage_max_delta = 3.0",
"spots_pickle = None",
"subgroups_pickle = None",
"refinements_pickle = None",
"rmsd_tolerance = 5.0",
"mosflm_rmsd_tolerance = 5.0",
"difflimit_sigma_cutoff=2.0",
#"indexing.verbose_cv=True",
"indexing.open_wx_viewer=%s"%display
] + list(arguments[1:])
horizons_phil = load_cxi_phil(target, args)
info = run_one_index_core(horizons_phil)
info.Files = info.organizer.Files
info.phil_params = info.horizons_phil
# The spotfinder view within cxi.index is an anachronism; no useful purpose anymore
# therefore remove this option within cxi.index:
return
work = wrapper_of_callback(info)
if kwargs.get("display",False):
import wx
from rstbx.viewer import display
from rstbx.viewer.frame import XrayFrame
display.user_callback = work.user_callback
app = wx.App(0)
frame = XrayFrame(None, -1, "X-ray image display", size=(1200,1080))
frame.SetSize((1024,780))
frame.load_image(path)
frame.Show()
app.MainLoop()
def run(args):
app = wx.App(0)
wx.SystemOptions.SetOption("osx.openfiledialog.always-show-types", "1")
frame = XrayFrame(None, -1, "X-ray image display", size=(800,720))
if (len(args) == 1 and os.path.basename(args[0]) == "DISTL_pickle"):
assert os.path.isfile(args[0])
frame.load_distl_output(args[0])
elif (len(args) > 0):
for file_name in args:
assert os.path.isfile(file_name)
frame.add_file_name_or_data(file_name)
frame.load_image(args[0])
frame.Show()
app.MainLoop()
def display(self,path):
import wx
from rstbx.viewer.frame import XrayFrame
app = wx.App(0)
frame = XrayFrame(None, -1, "X-ray image display", size=(1200,1080))
frame.SetSize((1024,780))
frame.load_image(path)
frame.Show()
app.MainLoop()
def run (args) :
app = wx.App(0)
wx.SystemOptions.SetOptionInt("osx.openfiledialog.always-show-types", 1)
frame = XrayFrame(None, -1, "X-ray image display", size=(800,720))
if (len(args) == 1 and os.path.basename(args[0]) == "DISTL_pickle") :
assert os.path.isfile(args[0])
frame.load_distl_output(args[0])
elif (len(args) > 0) :
for file_name in args:
assert os.path.isfile(file_name)
frame.add_file_name_or_data(file_name)
frame.load_image(args[0])
frame.Show()
app.MainLoop()
def run_one_index(path, *arguments, **kwargs):
assert arguments[0].find("target=") == 0
target = arguments[0].split("=")[1]
from xfel.phil_preferences import load_cxi_phil
if "--nodisplay" in arguments[1:]:
display = False
arguments = list(arguments)
arguments.remove("--nodisplay")
else:
display = True
args = [
"indexing.data=%s" % path,
"beam_search_scope=0.5",
"lepage_max_delta = 3.0",
"spots_pickle = None",
"subgroups_pickle = None",
"refinements_pickle = None",
"rmsd_tolerance = 5.0",
"mosflm_rmsd_tolerance = 5.0",
"difflimit_sigma_cutoff=2.0",
#"indexing.verbose_cv=True",
"indexing.open_wx_viewer=%s" % display
] + list(arguments[1:])
horizons_phil = load_cxi_phil(target, args)
info = run_one_index_core(horizons_phil)
info.Files = info.organizer.Files
info.phil_params = info.horizons_phil
# The spotfinder view within cxi.index is an anachronism; no useful purpose anymore
# therefore remove this option within cxi.index:
return
work = wrapper_of_callback(info)
if kwargs.get("display", False):
import wx
from rstbx.viewer import display
from rstbx.viewer.frame import XrayFrame
display.user_callback = work.user_callback
app = wx.App(0)
frame = XrayFrame(None, -1, "X-ray image display", size=(1200, 1080))
frame.SetSize((1024, 780))
frame.load_image(path)
frame.Show()
app.MainLoop()
def integrate_one_character(self,setting,integration_limit):
#from libtbx.development.timers import Profiler
#P = Profiler("Preliminary")
import copy
local = copy.deepcopy(self.process_dictionary)
local['cell']=cellstr(setting)
print("Cell in setting",setting["counter"],local["cell"])
frames = list(sorted(self.spotfinder_results.pd['osc_start'].keys()))
local['maxcel']='0'
local['xbeam']="%f"%setting['minimizer'].new['xbeam']
local['ybeam']="%f"%setting['minimizer'].new['ybeam']
local['distance']="%f"%setting['minimizer'].new['distance']
local["resolution"]= "%f"%integration_limit
from labelit.steps import primaries
local['spacegroup'] = primaries[setting['bravais']]
local['procstart'] = local['procend'] = "%d"%frames[0]
self.pixel_size = float(local['pixel_size'])
from labelit.dptbx import AutoIndexEngine, Parameters
ai = AutoIndexEngine(local['endstation'])
P = Parameters(xbeam=setting["refined x beam"],ybeam=setting["refined y beam"],
distance=setting["refined distance"],twotheta=float(local["twotheta"]))
ai.setBase(P)
ai.setWavelength(float(local['wavelength']))
ai.setMaxcell(float(local['ref_maxcel']))
print("Deltaphi is",float(local['deltaphi']))
ai.setDeltaphi(float(local['deltaphi'])*math.pi/180.)
ai.setMosaicity(setting["mosaicity"])
ai.setOrientation(setting["orient"])
refimage = self.files.images[0]
ai.set_active_areas(self.horizons_phil,
beam=(int(refimage.beamx/refimage.pixel_size),
int(refimage.beamy/refimage.pixel_size)))
image_centers = [(math.pi/180.)*float(x) for x in local["osc_start"].values()]
print("Limiting resolution",integration_limit)
local["results"] = []
for i in range(len(frames)):
print("---------BEGIN Integrate one frame %d %s" % \
(frames[i], os.path.split(self.files.filenames()[i])[-1]))
#P = Profiler("worker")
if self.horizons_phil.integration.combine_sym_constraints_and_3D_target and setting["counter"]>1:
from rstbx.apps.stills.dials_refinement_preceding_integration import integrate_one_frame
integrate_worker = integrate_one_frame(self.triclinic["integration"]["results"][0])
else:
from rstbx.apps.stills.deltapsi_refinement_preceding_integration import integrate_one_frame
integrate_worker = integrate_one_frame()
integrate_worker.inputai = ai
integrate_worker.inputpd = dict(masks=local["masks"],
size1=local["size1"],
size2=local["size2"],
symmetry=setting["best_subsym"])
# carefully select only the data items needed for integrate_worker
# avoid giving the whole process dictionary; reference to "local"
# is a circular reference creating memory leak, while copying the
# whole thing is a big performance hit.
integrate_worker.frame_numbers = frames
integrate_worker.imagefiles = self.files
integrate_worker.spotfinder = self.spotfinder_results
integrate_worker.image_centers = image_centers
integrate_worker.limiting_resolution = integration_limit
integrate_worker.setting_id = setting["counter"]
integrate_worker.pixel_size = self.pixel_size
integrate_worker.set_pixel_size(self.pixel_size)
integrate_worker.set_detector_size(int(local["size1"]),int(local["size2"]))
integrate_worker.set_detector_saturation(refimage.saturation)
integrate_worker.set_up_mask_focus()
integrate_worker.initialize_increments(i)
integrate_worker.horizons_phil = self.horizons_phil
if self.horizons_phil.indexing.verbose_cv:
print("EFFECTIVE TILING"," ".join(
["%d"%z for z in refimage.get_tile_manager(self.horizons_phil).effective_tiling_as_flex_int()]))
integrate_worker.integration_concept(image_number = i,
cb_op_to_primitive = setting["cb_op_inp_best"].inverse(),
verbose_cv = self.horizons_phil.indexing.verbose_cv,
background_factor = self.horizons_phil.integration.background_factor,
)
#P = Profiler("proper")
integrate_worker.integration_proper()
local["results"].append(integrate_worker)
local["r_xbeam"]=ai.xbeam()
local["r_ybeam"]=ai.ybeam()
local["r_distance"]=ai.distance()
local["r_wavelength"]=ai.wavelength
local["r_residual"]=integrate_worker.r_residual
local["r_mosaicity"]=setting["mosaicity"]
try:
local["ewald_proximal_volume"]=integrate_worker.ewald_proximal_volume
except Exception as e:
local["ewald_proximal_volume"]=None
if (self.horizons_phil.indexing.open_wx_viewer):
if True: #use updated slip viewer
try:
import wx
from rstbx.slip_viewer.frame import XrayFrame as SlipXrayFrame
from rstbx.command_line.slip_viewer import master_str as slip_params
from iotbx import phil
from spotfinder import phil_str
from spotfinder.command_line.signal_strength import additional_spotfinder_phil_defs
work_phil = phil.process_command_line("",master_string=slip_params + phil_str + additional_spotfinder_phil_defs)
work_params = work_phil.work.extract()
app = wx.App(0)
wx.SystemOptions.SetOption("osx.openfiledialog.always-show-types", "1")
frame = SlipXrayFrame(None, -1, "X-ray image display", size=(800,720))
frame.Show()
# Update initial settings with values from the command line. Needs
# to be done before image is loaded (but after the frame is
# instantiated).
frame.inherited_params = integrate_worker.horizons_phil
frame.params = work_params
if (frame.pyslip is None):
frame.init_pyslip()
if (frame.settings_frame is None):
frame.OnShowSettings(None)
frame.Layout()
frame.pyslip.tiles.user_requests_antialiasing = work_params.anti_aliasing
frame.settings_frame.panel.center_ctrl.SetValue(True)
frame.settings_frame.panel.integ_ctrl.SetValue(True)
frame.settings_frame.panel.spots_ctrl.SetValue(False)
frame.settings.show_effective_tiling = work_params.show_effective_tiling
frame.settings_frame.panel.collect_values()
paths = work_phil.remaining_args
frame.user_callback = integrate_worker.slip_callback
frame.load_image(self.files.filenames()[i])
app.MainLoop()
del app
except Exception:
pass # must use phenix.wxpython for wx display
elif False : #original wx viewer
try:
from rstbx.viewer.frame import XrayFrame
import wx
from rstbx.viewer import display
display.user_callback = integrate_worker.user_callback
app = wx.App(0)
frame = XrayFrame(None, -1, "X-ray image display", size=(1200,1080))
frame.settings.show_spotfinder_spots = False
frame.settings.show_integration = False
#frame.settings.enable_collect_values = False
frame.SetSize((1024,780))
frame.load_image(self.files.filenames()[i])
frame.Show()
app.MainLoop()
del app
except Exception:
pass # must use phenix.wxpython for wx display
# for the wx image viewer
filename = self.horizons_phil.indexing.indexing_pickle
if filename != None:
filename = "%s_%d_%d.pkl"%(filename,setting["counter"],keys[i])
SIO = StringIO()
table_raw = show_observations(integrate_worker.get_obs(
local["spacegroup"]),out=SIO)
limitobject = ResolutionAnalysisMetaClass(local, self.horizons_phil)
info = dict(table = SIO.getvalue(),
table_raw = table_raw,
xbeam = setting["refined x beam"],
ybeam = setting["refined y beam"],
distance = setting["refined distance"],
residual = integrate_worker.r_residual,
resolution = limitobject.value, # FIXME not reliable?
mosaicity = setting["mosaicity"],
pointgroup = local["spacegroup"],
hkllist = integrate_worker.hkllist,
predictions = (1./integrate_worker.pixel_size)*integrate_worker.predicted,
mapped_predictions = integrate_worker.detector_xy,
integration_masks_xy = integrate_worker.integration_masks_as_xy_tuples(),
background_masks_xy = integrate_worker.background_masks_as_xy_tuples()
)
assert info["predictions"].size() >= info["mapped_predictions"].size()
assert info["predictions"].size() == info["hkllist"].size()
G = open(filename,"wb")
pickle.dump(info,G,pickle.HIGHEST_PROTOCOL)
print("---------END Integrate one frame",frames[i])
return local
class ProcessingFrame(wx.Frame):
def __init__(self, *args, **kwds):
wx.Frame.__init__(self, *args, **kwds)
self.viewer = None
self.toolbar = self.CreateToolBar(style=wx.TB_3DBUTTONS | wx.TB_TEXT)
btn = self.toolbar.AddLabelTool(id=-1,
label="Image viewer",
bitmap=icons.hkl_file.GetBitmap(),
shortHelp="Image viewer",
kind=wx.ITEM_NORMAL)
self.Bind(wx.EVT_MENU, self.OnLaunchViewer, btn)
self.toolbar.Realize()
self.statusbar = self.CreateStatusBar()
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.SetSizer(self.sizer)
self.nb = fnb.FlatNotebook(self,
agwStyle=fnb.FNB_DEFAULT_STYLE
| fnb.FNB_NO_X_BUTTON)
self.sizer.Add(self.nb, 1, wx.EXPAND)
self.nb.SetMinSize((800, 40))
self.start_panel = StartPanel(self.nb)
self.nb.AddPage(self.start_panel, "Setup")
self.output_panel = LogViewer(self.nb)
self.nb.AddPage(self.output_panel, "Output")
try:
self.html_panel = wx.html2.WebView.New(self.nb)
except NotImplementedError:
self.html_panel = wx.html.HtmlWindow(self.nb)
self.nb.AddPage(self.html_panel, "Report")
#self.indexing_panel = indexing.IndexingPanel(self.nb)
#self.nb.AddPage(self.indexing_panel, "Indexing")
#self.integration_panel = integration.IntegrationPanel(self.nb)
#self.nb.AddPage(self.integration_panel, "Integration")
self.SetSize((800, 600))
self.event_dispatcher = process_control.event_agent(window=self,
project_id=0,
job_id=0)
self.was_aborted = False
#def LoadResults (self, dir_name) :
#self.result = results_base.result(dir_name)
#self.indexing_panel.SetIndexingResults(self.result.get_indexing())
#self.integration_panel.SetResults(self.result)
#self.nb.SetSelection(1)
def OnRunXia2(self, evt):
#thread = WorkerThread(0, self)
#thread.start()
#return
output_dir = self.start_panel.GetOutputDir()
result = self.run_xia2(imagesets=self.start_panel.GetImagesets(),
output_dir=output_dir)
def run_xia2(self, **kwds):
output_dir = kwds['output_dir']
imagesets = kwds['imagesets']
args = []
for imageset in imagesets:
scan = imageset.get_scan()
first, last = scan.get_image_range()
args.append('image=%s:%i:%i' % (imageset.paths()[0], first, last))
kwds = {}
self.nb.AdvanceSelection(forward=True)
thread = xia2Thread(self, output_dir, args)
thread.start()
return
def launch_viewer_frame(self):
if (self.viewer is None):
self.viewer = XrayFrame(parent=self, title="Image viewer")
self.viewer.Show()
self.Bind(wx.EVT_CLOSE, self.OnCloseViewer, self.viewer)
def get_viewer_frame(self):
self.launch_viewer_frame()
return self.viewer
def set_viewer_frame(self, frame):
assert (self.viewer is None)
self.viewer = frame
def OnCloseViewer(self, evt):
self.viewer.Destroy()
self.viewer = None
def OnLaunchViewer(self, evt):
self.launch_viewer_frame()
def callback_start(self, data):
self.event_dispatcher.callback_start(data)
def callback_stdout(self, data):
self.output_panel.AppendText(data)
self.event_dispatcher.callback_stdout(data)
def callback_other(self, data):
print 'other'
self.event_dispatcher.callback_other(data)
def callback_abort(self):
self.event_dispatcher.callback_abort()
self.close()
def callback_final(self, result):
if self.was_aborted: # XXX hack for jobs killed with 'qdel'
self.callback_abort()
return
import glob
html_files = glob.glob(
os.path.join(result.output_dir, 'LogFiles/*_report.html'))
print html_files
if html_files:
html_file = html_files[0]
try:
# wx.html.HtmlWindow
self.html_panel.LoadFile(html_file)
except AttributeError:
# wx.html2.WebView
self.html_panel.LoadURL(html_file)
self.nb.AdvanceSelection()
self.event_dispatcher.callback_final(result)
self.close()
def callback_error(self, error, traceback_info):
self.event_dispatcher.callback_error(error, traceback_info)
self.close()
def callback_pause(self):
self.event_dispatcher.callback_pause()
def callback_resume(self):
self.event_dispatcher.callback_resume()
def close(self):
pass
def OnLogEvent(self, event):
print event
class _XrayFrameThread(threading.Thread):
"""The _XrayFrameThread class allows MainLoop() to be run as a
thread, which is necessary because all calls to wxPython must be
made from the same thread that originally imported wxPython.
This is all based on "Running MainLoop in a separate thread",
http://wiki.wxpython.org/MainLoopAsThread.
"""
def __init__(self):
"""The thread is started automatically on initialisation.
self.run() will initialise self.frame and release self._init_lock.
"""
super(_XrayFrameThread, self).__init__()
self.setDaemon(1)
self._init_lock = threading.Lock()
self._next_semaphore = threading.Semaphore()
self._start_orig = self.start
self._frame = None
self.start = self._start_local
self._init_lock.acquire()
self.start()
def _start_local(self):
"""The _start_local() function calls the run() function through
self._start_orig, and exists only after self._init_lock has been
released. This eliminates a race condition which could cause
updates to be sent to a non-existent frame.
"""
self._start_orig()
self._init_lock.acquire()
def run(self):
"""The run() function defines the frame and starts the main loop.
self._init_lock is released only when all initialisation is done.
Whatever thread is the current one when wxWindows is initialised
is what it will consider the "main thread." For wxPython 2.4 that
happens when wxPython.wx is imported the first time. For 2.5 it
will be when the wx.App object is created.
"""
import wx
from wxtbx import bitmaps
app = wx.App(0)
self._bitmap_pause = bitmaps.fetch_icon_bitmap('actions', 'stop')
self._bitmap_run = bitmaps.fetch_icon_bitmap('actions', 'runit')
self._frame = XrayFrame(None,
-1,
"X-ray image display",
size=(800, 720))
self._frame.Bind(wx.EVT_IDLE, self.OnIdle)
self.setup_toolbar(self._frame.toolbar)
self._frame.Show()
self._init_lock.release()
app.MainLoop()
# Avoid deadlock where the send_data() function is waiting for the
# semaphore after the frame has closed.
self._next_semaphore.release()
def send_data(self, img, title):
"""The send_data() function updates the wxPython application with
@p img and @p title by sending it an ExternalUpdateEvent(). The
function blocks until the event is processed."""
from rstbx.viewer.frame import ExternalUpdateEvent
event = ExternalUpdateEvent()
event.img = img
event.title = title
if self.isAlive():
try:
# Saturating the event queue makes the whole caboodle
# uselessly unresponsive. Therefore, block until idle events
# are processed.
while self.isAlive() and not self._run_pause.IsToggled():
pass
self._frame.AddPendingEvent(event)
self._is_idle = False
while self.isAlive() and not self._is_idle:
pass
except Exception:
pass
def setup_toolbar(self, toolbar):
import wx
from wxtbx import icons
toolbar.ClearTools()
btn = toolbar.AddLabelTool(id=wx.ID_ANY,
label="Settings",
bitmap=icons.advancedsettings.GetBitmap(),
shortHelp="Settings",
kind=wx.ITEM_NORMAL)
self._frame.Bind(wx.EVT_MENU, self._frame.OnShowSettings, btn)
btn = toolbar.AddLabelTool(id=wx.ID_ANY,
label="Zoom",
bitmap=icons.search.GetBitmap(),
shortHelp="Zoom",
kind=wx.ITEM_NORMAL)
self._frame.Bind(wx.EVT_MENU, self._frame.OnZoom, btn)
# Reset the normal bitmap after the tool has been created, so that
# it will update on the next event. See also OnPauseRun()
self._run_pause = toolbar.AddCheckLabelTool(id=wx.ID_ANY,
label="Run/Pause",
bitmap=self._bitmap_run,
shortHelp="Run/Pause")
self._run_pause.SetNormalBitmap(self._bitmap_pause)
self._frame.Bind(wx.EVT_MENU, self.OnPauseRun, self._run_pause)
def OnIdle(self, event):
self._is_idle = True
event.RequestMore()
def OnPauseRun(self, event):
if self._run_pause.IsToggled():
self._run_pause.SetNormalBitmap(self._bitmap_run)
else:
self._run_pause.SetNormalBitmap(self._bitmap_pause)
def stop(self):
from wx import CloseEvent
self._frame.AddPendingEvent(CloseEvent())
class ProcessingFrame (wx.Frame) :
def __init__ (self, *args, **kwds) :
wx.Frame.__init__(self, *args, **kwds)
self.viewer = None
self.toolbar = self.CreateToolBar(style=wx.TB_3DBUTTONS|wx.TB_TEXT)
btn = self.toolbar.AddLabelTool(id=-1,
label="Image viewer",
bitmap=icons.hkl_file.GetBitmap(),
shortHelp="Image viewer",
kind=wx.ITEM_NORMAL)
self.Bind(wx.EVT_MENU, self.OnLaunchViewer, btn)
self.toolbar.Realize()
self.statusbar = self.CreateStatusBar()
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.SetSizer(self.sizer)
self.nb = wx.lib.agw.flatnotebook.FlatNotebook(self)
self.sizer.Add(self.nb, 1, wx.EXPAND)
self.nb.SetMinSize((800,40))
self.start_panel = StartPanel(self.nb)
self.nb.AddPage(self.start_panel, "Setup")
self.indexing_panel = indexing.IndexingPanel(self.nb)
self.nb.AddPage(self.indexing_panel, "Indexing")
self.integration_panel = integration.IntegrationPanel(self.nb)
self.nb.AddPage(self.integration_panel, "Integration")
self.SetSize((800,600))
def LoadResults (self, dir_name) :
self.result = results_base.result(dir_name)
self.indexing_panel.SetIndexingResults(self.result.get_indexing())
self.integration_panel.SetResults(self.result)
self.nb.SetSelection(1)
def OnRunIndexing (self, evt) :
dataset, frames = self.start_panel.GetDataset()
output_dir = self.start_panel.GetOutputDir()
result = self.run_indexing(
dataset=dataset,
frames=frames,
output_dir=output_dir)
self.LoadResults(output_dir)
def run_indexing (self, **kwds) :
from rstbx.viewer import drivers
run = drivers.run_indexing(**kwds)
indexing_result = process_control.run_function_as_process_in_dialog(
parent=self,
thread_function=run,
title="Running LABELIT",
message="Indexing images and performing simple test integration")
return indexing_result
def launch_viewer_frame (self) :
if (self.viewer is None) :
self.viewer = XrayFrame(
parent=self,
title="Image viewer")
self.viewer.Show()
self.Bind(wx.EVT_CLOSE, self.OnCloseViewer, self.viewer)
def get_viewer_frame (self) :
self.launch_viewer_frame()
return self.viewer
def set_viewer_frame (self, frame) :
assert (self.viewer is None)
self.viewer = frame
def OnCloseViewer (self, evt) :
self.viewer.Destroy()
self.viewer = None
def OnLaunchViewer (self, evt) :
self.launch_viewer_frame()
