def __init__(self,
parent,
overlayList,
displayCtx,
title=None,
style=None):
"""Create an ``OrthoDialog``.
:arg parent: A :mod:`wx` parent object.
:arg overlayList: An :class:`.OverlayList` instance.
:arg displayCtx: A :class:`.DisplayContext` instance.
:arg title: Dialog title.
:arg style: Dialog style - defaults to
``wx.DEFAULT_DIALOG_STYLE``.
"""
if style is None:
style = wx.DEFAULT_DIALOG_STYLE
wx.Dialog.__init__(self, parent, title=title, style=style)
fslgl.getGLContext()
fslgl.bootstrap()
self.panel = OrthoPanel(self, overlayList, displayCtx, None)
self.Layout()
def fsleyes_embed(parent=None, make_fsleyesframe=True, **kwargs):
"""Initialise FSLeyes and create a :class:`.FSLeyesFrame`, when
running within another application.
.. note:: If a ``wx.App`` does not exist, one is created.
:arg parent: ``wx`` parent object
:arg make_fsleyesframe: bool, default is True to make a new :class:`.FSLeyesFrame`
:returns: A tuple containing:
- The :class:`.OverlayList`
- The master :class:`.DisplayContext`
- The :class:`.FSLeyesFrame` or None if make_fsleyesframe=False
All other arguments are passed to :meth:`.FSLeyesFrame.__init__`.
"""
import fsleyes_props as props
import fsleyes.gl as fslgl
import fsleyes.frame as fslframe
import fsleyes.overlay as fsloverlay
import fsleyes.displaycontext as fsldc
app = wx.GetApp()
ownapp = app is None
if ownapp:
app = FSLeyesApp()
fsleyes.initialise()
colourmaps.init()
props.initGUI()
called = [False]
ret = [None]
def until():
return called[0]
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)
fslgl.getGLContext(ready=ready, raiseErrors=True)
idle.block(10, until=until)
if ret[0] is None:
raise RuntimeError('Failed to start FSLeyes')
return ret[0]
def main(args=None):
"""Entry point for ``render``.
Creates and renders an OpenGL scene, and saves it to a file, according
to the specified command line arguments (which default to
``sys.argv[1:]``).
"""
if args is None:
args = sys.argv[1:]
# Initialise FSLeyes and implement hacks.
# This must come first as, amongst other
# things, it sets the fsleyes.assetDir.
fsleyes.initialise()
# Initialise colour maps module
fslcm.init()
# Create a GL context
fslgl.getGLContext(offscreen=True, createApp=True)
# Now that GL inititalisation is over,
# make sure that the idle loop executes
# all tasks synchronously, instead of
# trying to schedule them on the wx
# event loop. And make sure image textures
# don't use separate threads for data
# processing.
with idle.idleLoop.synchronous(), \
imagetexture.ImageTexture.enableThreading(False):
# Parse arguments, and
# configure logging/debugging
namespace = parseArgs(args)
fsleyes.configLogging(namespace.verbose, namespace.noisy)
# Initialise the fsleyes.gl modules
fslgl.bootstrap(namespace.glversion)
# Create a description of the scene
overlayList, displayCtx, sceneOpts = makeDisplayContext(namespace)
import matplotlib.image as mplimg
# Render that scene, and save it to file
bitmap, bg = render(namespace, overlayList, displayCtx, sceneOpts)
if namespace.crop is not None:
bitmap = autocrop(bitmap, bg, namespace.crop)
mplimg.imsave(namespace.outfile, bitmap)
def __init__(self, parent, overlayList, displayCtx, title=None):
"""Create an ``OrthoFrame``.
:arg parent: A :mod:`wx` parent object.
:arg overlayList: An :class:`.OverlayList` instance.
:arg displayCtx: A :class:`.DisplayContext` instance.
:arg title: Dialog title.
"""
wx.Frame.__init__(self, parent, title=title)
fslgl.getGLContext()
fslgl.bootstrap()
self.panel = OrthoPanel(self, overlayList, displayCtx, None)
self.Layout()
def main(args=None):
"""Entry point for ``render``.
Creates and renders an OpenGL scene, and saves it to a file, according
to the specified command line arguments (which default to
``sys.argv[1:]``).
"""
if args is None:
args = sys.argv[1:]
# Initialise FSLeyes and implement hacks.
# This must come first as, amongst other
# things, it sets the fsleyes.assetDir.
fsleyes.initialise()
# Initialise colour maps module
fslcm.init()
# Create a GL context
fslgl.getGLContext(offscreen=True, createApp=True)
# Parse arguments, and
# configure logging/debugging
namespace = parseArgs(args)
fsleyes.configLogging(namespace.verbose, namespace.noisy)
# Initialise the fsleyes.gl modules
fslgl.bootstrap(namespace.glversion)
# Create a description of the scene
overlayList, displayCtx, sceneOpts = makeDisplayContext(namespace)
import matplotlib.image as mplimg
# Render that scene, and save it to file
bitmap, bg = render(namespace, overlayList, displayCtx, sceneOpts)
if namespace.crop is not None:
bitmap = autocrop(bitmap, bg, namespace.crop)
mplimg.imsave(namespace.outfile, bitmap)
def main(args=None):
"""Entry point for ``render``.
Creates and renders an OpenGL scene, and saves it to a file, according
to the specified command line arguments (which default to
``sys.argv[1:]``).
"""
if args is None:
args = sys.argv[1:]
# Create a GL context
fslgl.getGLContext(offscreen=True, createApp=True)
# Initialise FSLeyes and implement hacks
fsleyes.initialise()
fsleyesmain.hacksAndWorkarounds()
# Initialise colour maps module
fslcm.init()
# Parse arguments, and
# configure logging/debugging
namespace = parseArgs(args)
fsleyes.configLogging(namespace)
# Initialise the fsleyes.gl modules
fslgl.bootstrap(namespace.glversion)
# Create a description of the scene
overlayList, displayCtx, sceneOpts = makeDisplayContext(namespace)
import matplotlib.image as mplimg
# Render that scene, and save it to file
bitmap = render(namespace, overlayList, displayCtx, sceneOpts)
mplimg.imsave(namespace.outfile, bitmap)
def embed(parent, callback=None, **kwargs):
"""Initialise FSLeyes and create a :class:`.FSLeyesFrame`, when
running within another application.
:arg parent: ``wx`` parent object
:arg callback: A function which will be called when FSLeyes
is ready. Must accept three positional arguments:
- The :class:`.OverlayList`
- The master :class:`.DisplayContext`
- The :class:`.FSLeyesFrame`
All other arguments are passed to :meth:`.FSLeyesFrame.__init__`.
"""
import fsleyes_props as props
import fsleyes.gl as fslgl
import fsleyes.frame as fslframe
import fsleyes.overlay as fsloverlay
import fsleyes.displaycontext as fsldc
fsleyes.initialise()
colourmaps.init()
props.initGUI()
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)
fslgl.getGLContext(parent=parent, ready=ready)
def initialise(splash, namespace, callback):
"""Called by :func:`main`. Bootstraps/Initialises various parts of
*FSLeyes*.
The ``callback`` function is asynchronously called when the initialisation
is complete.
:arg splash: The :class:`.FSLeyesSplash` screen.
:arg namespace: The ``argparse.Namespace`` object containing parsed
command line arguments.
:arg callback: Function which is called when initialisation is done.
"""
import fsl.utils.settings as fslsettings
import fsleyes_props as props
import fsleyes.gl as fslgl
props.initGUI()
# The save/load directory defaults
# to the current working directory.
curDir = op.normpath(os.getcwd())
# But if we are running as a frozen application, check to
# see if FSLeyes has been started by the system (e.g.
# double-clicking instead of being called from the CLI).
#
# If so, we set the save/load directory
# to the user's home directory instead.
if fwidgets.frozen():
fsleyesDir = op.dirname(__file__)
# If we're a frozen OSX application,
# we need to adjust the FSLeyes dir
# (which will be:
# [install_dir]/FSLeyes.app/Contents/MacOS/fsleyes/),
#
# Because the cwd will default to:
# [install_dir]/
if fslplatform.os == 'Darwin':
fsleyesDir = op.normpath(
op.join(fsleyesDir, '..', '..', '..', '..'))
# Similar adjustment for linux
elif fslplatform.os == 'Linux':
fsleyesDir = op.normpath(op.join(fsleyesDir, '..'))
if curDir == fsleyesDir:
curDir = op.expanduser('~')
fslsettings.write('loadSaveOverlayDir', curDir)
# Initialise silly things
if namespace.bumMode:
import fsleyes.icons as icons
icons.BUM_MODE = True
# Set notebook server port
fslsettings.write('fsleyes.notebook.port', namespace.notebookPort)
# This is called by fsleyes.gl.getGLContext
# when the GL context is ready to be used.
def realCallback():
fslgl.bootstrap(namespace.glversion)
callback()
try:
# Force the creation of a wx.glcanvas.GLContext object,
# and initialise OpenGL version-specific module loads.
fslgl.getGLContext(ready=realCallback)
except Exception:
log.error('Unable to initialise OpenGL!', exc_info=True)
splash.Destroy()
sys.exit(1)
def embed(mkFrame=True, **kwargs):
"""Initialise FSLeyes and create a :class:`.FSLeyesFrame`, when
running within another application.
.. note:: In most cases, this function must be called from the
``wx.MainLoop``.
:arg mkFrame: Defaults to ``True``. If ``False``, FSLeyes is
initialised, but a :class:`.FSLeyesFrame` is not created.
If you set this to ``False``, you must ensure that a
``wx.App`` object exists before calling this function.
:returns: A tuple containing:
- The :class:`.OverlayList`
- The master :class:`.DisplayContext`
- The :class:`.FSLeyesFrame` (or ``None``, if
``makeFrame is False``).
All other arguments are passed to :meth:`.FSLeyesFrame.__init__`.
"""
import fsleyes_props as props
import fsleyes.gl as fslgl
import fsleyes.frame as fslframe
import fsleyes.overlay as fsloverlay
import fsleyes.displaycontext as fsldc
# initialise must be called before
# a FSLeyesApp gets created, as it
# tries to access app_icon.png
fsleyes.initialise()
app = wx.GetApp()
ownapp = app is None
if ownapp and (mkFrame is False):
raise RuntimeError('If mkFrame is False, you '
'must create a wx.App before '
'calling fsleyes.main.embed')
if ownapp:
app = FSLeyesApp()
colourmaps.init()
props.initGUI()
called = [False]
ret = [None]
def until():
return called[0]
def ready():
fslgl.bootstrap()
overlayList = fsloverlay.OverlayList()
displayCtx = fsldc.DisplayContext(overlayList)
if mkFrame:
frame = fslframe.FSLeyesFrame(None, overlayList, displayCtx,
**kwargs)
else:
frame = None
if ownapp:
app.SetOverlayListAndDisplayContext(overlayList, displayCtx)
# Keep a ref to prevent the app from being GC'd
frame._embed_app = app
called[0] = True
ret[0] = (overlayList, displayCtx, frame)
fslgl.getGLContext(ready=ready, raiseErrors=True)
idle.block(10, until=until)
if ret[0] is None:
raise RuntimeError('Failed to start FSLeyes')
return ret[0]
