def run():
overlayList = fsloverlay.OverlayList()
displayCtx = dc.DisplayContext(overlayList)
lockGroup = dc.OverlayGroup(displayCtx, overlayList)
displayCtx.overlayGroups.append(lockGroup)
frame[0] = fslframe.FSLeyesFrame(None,
overlayList,
displayCtx)
app[0].SetOverlayListAndDisplayContext(overlayList, displayCtx)
app[0].SetTopWindow(frame[0])
frame[0].Show()
try:
if func is not None:
result[0] = func(frame[0],
overlayList,
displayCtx,
*args,
**kwargs)
except Exception as e:
traceback.print_exc()
raised[0] = e
finally:
wx.CallLater(finishingDelay, finish)
def run():
overlayList = fsloverlay.OverlayList()
displayCtx = dc.DisplayContext(overlayList)
state.frame = fslframe.FSLeyesFrame(None,
overlayList,
displayCtx)
state.app.SetOverlayListAndDisplayContext(overlayList, displayCtx)
state.app.SetTopWindow(state.frame)
state.frame.Show()
try:
if func is not None:
state.result = func(state.frame,
overlayList,
displayCtx,
*args,
**kwargs)
except Exception as e:
traceback.print_exc()
state.raised = e
finally:
wx.CallLater(finishingDelay, finish)
def makeDisplayContext(namespace, splash):
"""Creates the top-level *FSLeyes* :class:`.DisplayContext` and
:class:`.OverlayList` .
This function does the following:
1. Creates the :class:`.OverlayList` and the top level
:class:`.DisplayContext`.
2. Loads and configures all of the overlays which were passed in on the
command line.
:arg namesace: Parsed command line arguments (see :func:`parseArgs`).
:arg splash: The :class:`.FSLeyesSplash` frame, created in :func:`init`.
:returns: a tuple containing:
- the :class:`.OverlayList`
- the master :class:`.DisplayContext`
"""
import fsleyes_widgets.utils.status as status
import fsleyes.overlay as fsloverlay
import fsleyes.parseargs as parseargs
import fsleyes.displaycontext as displaycontext
# Splash status update must be
# performed on the main thread.
def splashStatus(msg):
wx.CallAfter(splash.SetStatus, msg)
# Redirect status updates
# to the splash frame
status.setTarget(splashStatus)
# Create the overlay list (only one of these
# ever exists) and the master DisplayContext.
# A new DisplayContext instance will be
# created for every new view that is opened
# in the FSLeyesFrame, but all child
# DisplayContext instances will be linked to
# this master one.
overlayList = fsloverlay.OverlayList()
displayCtx = displaycontext.DisplayContext(overlayList)
log.debug('Created overlay list and master DisplayContext ({})'.format(
id(displayCtx)))
# Load the images - the splash screen status will
# be updated with the currently loading overlay name.
parseargs.applyMainArgs(namespace, overlayList, displayCtx)
parseargs.applyOverlayArgs(namespace, overlayList, displayCtx)
return overlayList, displayCtx
def ready():
fslgl.bootstrap()
overlayList = fsloverlay.OverlayList()
displayCtx = fsldc.DisplayContext(overlayList)
frame = fslframe.FSLeyesFrame(
parent, overlayList, displayCtx, **kwargs)
if callback is not None:
callback(overlayList, displayCtx, frame)
def ready():
frame = None
fslgl.bootstrap()
overlayList = fsloverlay.OverlayList()
displayCtx = fsldc.DisplayContext(overlayList)
if make_fsleyesframe:
frame = fslframe.FSLeyesFrame(parent, overlayList, displayCtx,
**kwargs)
if ownapp:
app.SetOverlayListAndDisplayContext(overlayList, displayCtx)
# Keep a ref to prevent the app from being GC'd
if make_fsleyesframe:
frame._embed_app = app
called[0] = True
ret[0] = (overlayList, displayCtx, frame)
def makeDisplayContext(namespace):
"""Creates :class:`.OverlayList`, :class:`.DisplayContext``, and
:class:`.SceneOpts` instances which represent the scene to be rendered,
as described by the arguments in the given ``namespace`` object.
"""
# Create an overlay list and display context.
# The DisplayContext, Display and DisplayOpts
# classes are designed to be created in a
# parent-child hierarchy. So we need to create
# a 'dummy' master display context to make
# things work properly.
overlayList = fsloverlay.OverlayList()
masterDisplayCtx = displaycontext.DisplayContext(overlayList)
childDisplayCtx = displaycontext.DisplayContext(overlayList,
parent=masterDisplayCtx)
# We have to artificially create a ref to the
# master display context, otherwise it may get
# gc'd arbitrarily. The parent reference in the
# child creation above is ultimately stored as
# a weakref, so we need to create a real one.
childDisplayCtx.masterDisplayCtx = masterDisplayCtx
# The handleOverlayArgs function uses the
# fsleyes.overlay.loadOverlays function,
# which will call these functions as it
# goes through the list of overlay to be
# loaded.
def load(ovl):
log.info('Loading overlay {} ...'.format(ovl))
def error(ovl, error):
log.info('Error loading overlay {}: '.format(ovl, error))
# Load the overlays specified on the command
# line, and configure their display properties
parseargs.applyOverlayArgs(namespace,
overlayList,
masterDisplayCtx,
loadFunc=load,
errorFunc=error)
# Create a SceneOpts instance describing
# the scene to be rendered. The parseargs
# module assumes that GL canvases have
# already been created, so we use mock
# objects to trick it. The options applied
# to these mock objects are applied to the
# real canvases later on, in the render
# function below.
if namespace.scene == 'ortho':
sceneOpts = orthoopts.OrthoOpts(MockCanvasPanel(3))
elif namespace.scene == 'lightbox':
sceneOpts = lightboxopts.LightBoxOpts(MockCanvasPanel(1))
elif namespace.scene == '3d':
sceneOpts = scene3dopts.Scene3DOpts(MockCanvasPanel(1))
# 3D views default to
# world display space
if namespace.scene == '3d':
childDisplayCtx.displaySpace = 'world'
parseargs.applySceneArgs(namespace, overlayList, childDisplayCtx,
sceneOpts)
# Centre the location. The DisplayContext
# will typically centre its location on
# initialisation, but this may not work
# if any overlay arguments change the bounds
# of an overlay (e.g. mesh reference image)
if namespace.worldLoc is None and namespace.voxelLoc is None:
b = childDisplayCtx.bounds
childDisplayCtx.location = [
b.xlo + 0.5 * b.xlen, b.ylo + 0.5 * b.ylen, b.zlo + 0.5 * b.zlen
]
# This has to be applied after applySceneArgs,
# in case the user used the '-std'/'-std1mm'
# options.
if namespace.selectedOverlay is not None:
masterDisplayCtx.selectedOverlay = namespace.selectedOverlay
if len(overlayList) == 0:
raise RuntimeError('At least one overlay must be specified')
return overlayList, childDisplayCtx, sceneOpts
def makeDisplayContext(namespace, splash):
"""Creates the top-level *FSLeyes* :class:`.DisplayContext` and
:class:`.OverlayList` .
This function does the following:
1. Creates the :class:`.OverlayList` and the top level
:class:`.DisplayContext`.
2. Loads and configures all of the overlays which were passed in on the
command line.
:arg namesace: Parsed command line arguments (see :func:`parseArgs`).
:arg splash: The :class:`.FSLeyesSplash` frame, created in :func:`init`.
:returns: a tuple containing:
- the :class:`.OverlayList`
- the master :class:`.DisplayContext`
"""
import fsleyes_widgets.utils.status as status
import fsleyes.overlay as fsloverlay
import fsleyes.parseargs as parseargs
import fsleyes.displaycontext as displaycontext
# Splash status update must be
# performed on the main thread.
def splashStatus(msg):
wx.CallAfter(splash.SetStatus, msg)
# Redirect status updates
# to the splash frame
status.setTarget(splashStatus)
# Create the overlay list (only one of these
# ever exists) and the master DisplayContext.
# A new DisplayContext instance will be
# created for every new view that is opened
# in the FSLeyesFrame, but all child
# DisplayContext instances will be linked to
# this master one.
overlayList = fsloverlay.OverlayList()
displayCtx = displaycontext.DisplayContext(overlayList)
# While the DisplayContext may refer to
# multiple overlay groups, we are currently
# using just one, allowing the user to specify
# a set of overlays for which their display
# properties are 'locked'.
lockGroup = displaycontext.OverlayGroup(displayCtx, overlayList)
displayCtx.overlayGroups.append(lockGroup)
log.debug('Created overlay list and master DisplayContext ({})'.format(
id(displayCtx)))
# Load the images - the splash screen status will
# be updated with the currently loading overlay name.
#
# The applyOverlayArgs function gets called before
# the applySceneArgs function, so we'll manually
# apply some important settings to the DC here so
# they get used when any overlays are loaded.
if namespace.bigmem is not None:
displayCtx.loadInMemory = namespace.bigmem
if namespace.autoDisplay is not None:
displayCtx.autoDisplay = namespace.autoDisplay
parseargs.applyOverlayArgs(namespace, overlayList, displayCtx)
return overlayList, displayCtx
