def init_display(backend_str=None, size=(1000, 600)):
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args):
QtWidgets.QMainWindow.__init__(self, *args)
self.resize(size[0], size[1])
self.Viewer = qtViewer2(self)
self.setCentralWidget(self.Viewer)
self.centerOnScreen()
def centerOnScreen(self):
'''Centers the window on the screen.'''
resolution = QtWidgets.QDesktopWidget().screenGeometry()
self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
(resolution.height() / 2) - (self.frameSize().height() / 2))
# following couple of lines is a twek to enable ipython --gui='qt'
app = QtWidgets.QApplication.instance() # checks if QApplication already exists
if not app: # create QApplication if it doesnt exist
app = QtWidgets.QApplication(sys.argv)
win = MainWindow()
win.show()
win.Viewer.InitDriver()
display = win.Viewer._display
# background gradient
display.set_bg_gradient_color(206, 215, 222, 128, 128, 128)
# display black trihedron
display.display_trihedron()
def start_display():
win.raise_() # make the application float to the top
app.exec_()
win.display = display
win.show()
win.Viewer.init2()
# create and add shapes
box = BRepPrimAPI.BRepPrimAPI_MakeBox(60, 30, 10).Shape()
cyl = BRepPrimAPI.BRepPrimAPI_MakeCylinder(25, 40).Shape()
tr = gp.gp_Trsf()
tr.SetTranslation(gp.gp_Vec(0, 50, 0))
loc = TopLoc.TopLoc_Location(tr)
moved_box = box.Moved(loc)
# these shapes can be deleted by selecting them and pressing 'Del':
win.Viewer.doc_ctrl.add(box)
win.Viewer.doc_ctrl.add(cyl)
# this shape cannot be deleted in this implementation:
win.Viewer.doc_ctrl.add(moved_box)
win.Viewer.repaint(Update=False)
display.FitAll()
return display, start_display
from OCC import VERSION
from OCC.Display.backend import load_backend, get_qt_modules
from . import Topology
import matplotlib.pyplot as plt
import numpy as np
import itertools
log = logging.getLogger(__name__)
# Currently only trying qt
used_backend = load_backend()
log.info("GUI backend set to: {0}".format(used_backend))
from OCC.Display.qtDisplay import qtViewer3d
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
from matplotlib.backends.backend_qt4agg import (
FigureCanvasQTAgg as FigureCanvas)
from .matplotlib_radar import radar_factory, example_data
class Airconics_Viewgrid(QtWidgets.QWidget):
"""A simple grid containing both a 3d viewer and a range of performance
metrics for the geometry contained in the widget
Inputs
------
Topology - airconics.Toplogy (default None)
The Topology to display in this widget: see attributes. If no Topology
def init_display(backend_str=None, size=(1024, 768)):
used_backend = get_backend(backend_str)
log.info("GUI backend set to: {0}".format(used_backend))
# wxPython based simple GUI
if used_backend == 'wx':
import wx
from wxDisplay import wxViewer3d
class AppFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, "pythonOCC-%s 3d viewer ('wx' backend)" % VERSION,
style=wx.DEFAULT_FRAME_STYLE, size=size)
self.canva = wxViewer3d(self)
self.menuBar = wx.MenuBar()
self._menus = {}
self._menu_methods = {}
def add_menu(self, menu_name):
_menu = wx.Menu()
self.menuBar.Append(_menu, "&" + menu_name)
self.SetMenuBar(self.menuBar)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
# point on curve
_id = wx.NewId()
check_callable(_callable)
try:
self._menus[menu_name].Append(_id,
_callable.__name__.replace('_', ' ').lower())
except KeyError:
raise ValueError('the menu item %s does not exist' % menu_name)
self.Bind(wx.EVT_MENU, _callable, id=_id)
app = wx.PySimpleApp()
win = AppFrame(None)
win.Show(True)
wx.SafeYield()
win.canva.InitDriver()
app.SetTopWindow(win)
display = win.canva._display
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
app.MainLoop()
# Qt based simple GUI
elif 'qt' in used_backend:
from OCC.Display.qtDisplay import qtViewer3d
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args):
QtWidgets.QMainWindow.__init__(self, *args)
self.canva = qtViewer3d(self)
self.setWindowTitle("pythonOCC-%s 3d viewer ('%s' backend)" % (VERSION, used_backend))
self.resize(size[0], size[1])
self.setCentralWidget(self.canva)
if not sys.platform == 'darwin':
self.menu_bar = self.menuBar()
else:
# create a parentless menubar
# see: http://stackoverflow.com/questions/11375176/qmenubar-and-qmenu-doesnt-show-in-mac-os-x?lq=1
# noticeable is that the menu ( alas ) is created in the
# topleft of the screen, just
# next to the apple icon
# still does ugly things like showing the "Python" menu in
# bold
self.menu_bar = QtWidgets.QMenuBar()
self._menus = {}
self._menu_methods = {}
# place the window in the center of the screen, at half the
# screen size
self.centerOnScreen()
def centerOnScreen(self):
'''Centers the window on the screen.'''
resolution = QtWidgets.QDesktopWidget().screenGeometry()
self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
(resolution.height() / 2) - (self.frameSize().height() / 2))
def add_menu(self, menu_name):
_menu = self.menu_bar.addMenu("&" + menu_name)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
check_callable(_callable)
try:
_action = QtWidgets.QAction(_callable.__name__.replace('_', ' ').lower(), self)
# if not, the "exit" action is now shown...
_action.setMenuRole(QtWidgets.QAction.NoRole)
self.connect(_action, QtCore.SIGNAL("triggered()"), _callable)
self._menus[menu_name].addAction(_action)
except KeyError:
raise ValueError('the menu item %s does not exist' % menu_name)
# following couple of lines is a twek to enable ipython --gui='qt'
app = QtWidgets.QApplication.instance() # checks if QApplication already exists
if not app: # create QApplication if it doesnt exist
app = QtWidgets.QApplication(sys.argv)
win = MainWindow()
win.show()
win.canva.InitDriver()
display = win.canva._display
if sys.platform != "linux2":
display.EnableAntiAliasing()
# background gradient
display.set_bg_gradient_color(206, 215, 222, 128, 128, 128)
# display black trihedron
display.display_trihedron()
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
win.raise_() # make the application float to the top
app.exec_()
return display, start_display, add_menu, add_function_to_menu
##
##You should have received a copy of the GNU Lesser General Public License
##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>.
from __future__ import print_function
import logging
import sys
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
log = logging.getLogger(__name__)
from OCC.Display import OCCViewer
from OCC.Display.backend import get_qt_modules
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
class point(object):
def __init__(self, obj=None):
self.x = 0
self.y = 0
if obj is not None:
self.set(obj)
def set(self, obj):
self.x = obj.x()
self.y = obj.y()
class qtBaseViewer(QtOpenGL.QGLWidget):
def init_display(backend_str=None, size=(1024, 768)):
used_backend = get_backend(backend_str)
log.info("GUI backend set to: {0}".format(used_backend))
# wxPython based simple GUI
if used_backend == 'wx':
import wx
from wxDisplay import wxViewer3d
class AppFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, "pythonOCC-%s 3d viewer ('wx' backend)" % VERSION,
style=wx.DEFAULT_FRAME_STYLE, size=size)
self.canva = wxViewer3d(self)
self.menuBar = wx.MenuBar()
self._menus = {}
self._menu_methods = {}
def add_menu(self, menu_name):
_menu = wx.Menu()
self.menuBar.Append(_menu, "&" + menu_name)
self.SetMenuBar(self.menuBar)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
# point on curve
_id = wx.NewId()
check_callable(_callable)
try:
self._menus[menu_name].Append(_id,
_callable.__name__.replace('_', ' ').lower())
except KeyError:
raise ValueError('the menu item %s does not exist' % menu_name)
self.Bind(wx.EVT_MENU, _callable, id=_id)
app = wx.App(False)
win = AppFrame(None)
win.Show(True)
wx.SafeYield()
win.canva.InitDriver()
app.SetTopWindow(win)
display = win.canva._display
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
app.MainLoop()
# Qt based simple GUI
elif 'qt' in used_backend:
from OCC.Display.qtDisplay import qtViewer3d
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args):
QtWidgets.QMainWindow.__init__(self, *args)
self.canva = qtViewer3d(self)
self.setWindowTitle("pythonOCC-%s 3d viewer ('%s' backend)" % (VERSION, used_backend))
self.resize(size[0], size[1])
self.setCentralWidget(self.canva)
if not sys.platform == 'darwin':
self.menu_bar = self.menuBar()
else:
# create a parentless menubar
# see: http://stackoverflow.com/questions/11375176/qmenubar-and-qmenu-doesnt-show-in-mac-os-x?lq=1
# noticeable is that the menu ( alas ) is created in the
# topleft of the screen, just
# next to the apple icon
# still does ugly things like showing the "Python" menu in
# bold
self.menu_bar = QtWidgets.QMenuBar()
self._menus = {}
self._menu_methods = {}
# place the window in the center of the screen, at half the
# screen size
self.centerOnScreen()
def centerOnScreen(self):
'''Centers the window on the screen.'''
resolution = QtWidgets.QDesktopWidget().screenGeometry()
self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
(resolution.height() / 2) - (self.frameSize().height() / 2))
def add_menu(self, menu_name):
_menu = self.menu_bar.addMenu("&" + menu_name)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
check_callable(_callable)
try:
_action = QtWidgets.QAction(_callable.__name__.replace('_', ' ').lower(), self)
# if not, the "exit" action is now shown...
_action.setMenuRole(QtWidgets.QAction.NoRole)
_action.triggered.connect(_callable)
self._menus[menu_name].addAction(_action)
except KeyError:
raise ValueError('the menu item %s does not exist' % menu_name)
# following couple of lines is a twek to enable ipython --gui='qt'
app = QtWidgets.QApplication.instance() # checks if QApplication already exists
if not app: # create QApplication if it doesnt exist
app = QtWidgets.QApplication(sys.argv)
win = MainWindow()
win.show()
win.canva.InitDriver()
display = win.canva._display
if sys.platform != "linux2":
display.EnableAntiAliasing()
# background gradient
display.set_bg_gradient_color(206, 215, 222, 128, 128, 128)
# display black trihedron
display.display_trihedron()
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
win.raise_() # make the application float to the top
app.exec_()
return display, start_display, add_menu, add_function_to_menu
def init_display(backend_str=None, size=(1024, 768)):
""" This function loads and initialize a GUI using either wx, pyq4, pyqt5 or pyside.
If ever the environment variable PYTHONOCC_OFFSCREEN_RENDERER, then the GUI is simply
ignored and an offscreen renderer is returned.
init_display returns 4 objects :
* display : an instance of Viewer3d ;
* start_display : a function (the GUI mainloop) ;
* add_menu : a function that creates a menu in the GUI
* add_function_to_menu : adds a menu option
In case an offscreen renderer is returned, start_display and add_menu are ignored, i.e.
an empty function is returned (named do_nothing). add_function_to_menu just execute the
function taken as a paramter.
Note : the offscreen renderer is used on the travis side.
"""
if os.getenv("PYTHONOCC_OFFSCREEN_RENDERER") == "1":
# create the offscreen renderer
offscreen_renderer = OffscreenRenderer()
def do_nothing(*kargs, **kwargs):
""" takes as many parameters as you want,
ans does nothing
"""
pass
def call_function(s, func):
""" A function that calls another function.
Helpfull to bypass add_function_to_menu. s should be a string
"""
check_callable(func)
log.info("Execute %s :: %s menu fonction" % (s, func.__name__))
func()
log.info("done")
# returns empty classes and functions
return offscreen_renderer, do_nothing, do_nothing, call_function
used_backend = load_backend(backend_str)
log.info("GUI backend set to: %s", used_backend)
# wxPython based simple GUI
if used_backend == 'wx':
import wx
from wxDisplay import wxViewer3d
class AppFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self,
parent,
-1,
"pythonOCC-%s 3d viewer ('wx' backend)" %
VERSION,
style=wx.DEFAULT_FRAME_STYLE,
size=size)
self.canva = wxViewer3d(self)
self.menuBar = wx.MenuBar()
self._menus = {}
self._menu_methods = {}
def add_menu(self, menu_name):
_menu = wx.Menu()
self.menuBar.Append(_menu, "&" + menu_name)
self.SetMenuBar(self.menuBar)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
# point on curve
_id = wx.NewId()
check_callable(_callable)
try:
self._menus[menu_name].Append(
_id,
_callable.__name__.replace('_', ' ').lower())
except KeyError:
raise ValueError('the menu item %s does not exist' %
menu_name)
self.Bind(wx.EVT_MENU, _callable, id=_id)
app = wx.App(False)
win = AppFrame(None)
win.Show(True)
wx.SafeYield()
win.canva.InitDriver()
app.SetTopWindow(win)
display = win.canva._display
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
app.MainLoop()
# Qt based simple GUI
elif 'qt' in used_backend:
from OCC.Display.qtDisplay import qtViewer3d
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args):
QtWidgets.QMainWindow.__init__(self, *args)
self.canva = qtViewer3d(self)
self.setWindowTitle("pythonOCC-%s 3d viewer ('%s' backend)" %
(VERSION, used_backend))
self.setCentralWidget(self.canva)
if sys.platform != 'darwin':
self.menu_bar = self.menuBar()
else:
# create a parentless menubar
# see: http://stackoverflow.com/questions/11375176/qmenubar-and-qmenu-doesnt-show-in-mac-os-x?lq=1
# noticeable is that the menu ( alas ) is created in the
# topleft of the screen, just
# next to the apple icon
# still does ugly things like showing the "Python" menu in
# bold
self.menu_bar = QtWidgets.QMenuBar()
self._menus = {}
self._menu_methods = {}
# place the window in the center of the screen, at half the
# screen size
self.centerOnScreen()
def centerOnScreen(self):
'''Centers the window on the screen.'''
resolution = QtWidgets.QApplication.desktop().screenGeometry()
x = (resolution.width() - self.frameSize().width()) / 2
y = (resolution.height() - self.frameSize().height()) / 2
self.move(x, y)
def add_menu(self, menu_name):
_menu = self.menu_bar.addMenu("&" + menu_name)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
check_callable(_callable)
try:
_action = QtWidgets.QAction(
_callable.__name__.replace('_', ' ').lower(), self)
# if not, the "exit" action is now shown...
_action.setMenuRole(QtWidgets.QAction.NoRole)
_action.triggered.connect(_callable)
self._menus[menu_name].addAction(_action)
except KeyError:
raise ValueError('the menu item %s does not exist' %
menu_name)
# following couple of lines is a tweak to enable ipython --gui='qt'
app = QtWidgets.QApplication.instance(
) # checks if QApplication already exists
if not app: # create QApplication if it doesnt exist
app = QtWidgets.QApplication(sys.argv)
win = MainWindow()
win.show()
win.resize(size[0], size[1])
win.centerOnScreen()
win.canva.InitDriver()
win.canva.qApp = app
display = win.canva._display
# background gradient
display.set_bg_gradient_color(206, 215, 222, 128, 128, 128)
# display black trihedron
display.display_trihedron()
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
win.raise_() # make the application float to the top
app.exec_()
return display, start_display, add_menu, add_function_to_menu
def init_display(backend_str=None, size=(1024, 768)):
""" This function loads and initialize a GUI using either wx, pyq4, pyqt5 or pyside.
If ever the environment variable PYTHONOCC_SHUNT_GUI, then the GUI is simply ignored.
It can be useful to test some algorithms without being polluted by GUI statements.
This feature is used for running the examples suite as tests for
pythonocc-core development.
"""
if os.getenv("PYTHONOCC_SHUNT_GUI") == "1":
# define a dumb class and an empty method
from OCC.Display import OCCViewer
def do_nothing(*kargs, **kwargs):
""" A method that does nothing
"""
pass
def call_function(s, func):
""" A function that calls another function.
Helpfull to bypass add_function_to_menu. s should be a string
"""
check_callable(func)
print(s, func.__name__)
func()
class BlindViewer(OCCViewer.Viewer3d):
def __init__(self, *kargs):
self._window_handle = 0
self._inited = False
self._local_context_opened = False
self.Context_handle = Dumb()
self.Viewer_handle = Dumb()
self.View_handle = Dumb()
self.Context = Dumb()
self.Viewer = Dumb()
self.View = Dumb()
self.selected_shapes = []
self._select_callbacks = []
self._struc_mgr = Dumb()
def GetContext(self):
return Dumb()
def DisplayMessage(self, *kargs):
pass
class Dumb(object):
""" A class the does nothing whatever the method
or property is called
"""
def __getattr__(self, name):
if name in ['Context']:
return Dumb()
elif name in ['GetContext', 'GetObject']:
return Dumb
else:
return do_nothing
# returns empty classes and functions
return BlindViewer(), do_nothing, do_nothing, call_function
used_backend = load_backend(backend_str)
log.info("GUI backend set to: {0}".format(used_backend))
# wxPython based simple GUI
if used_backend == 'wx':
import wx
from wxDisplay import wxViewer3d
class AppFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, "pythonOCC-%s 3d viewer ('wx' backend)" % VERSION,
style=wx.DEFAULT_FRAME_STYLE, size=size)
self.canva = wxViewer3d(self)
self.menuBar = wx.MenuBar()
self._menus = {}
self._menu_methods = {}
def add_menu(self, menu_name):
_menu = wx.Menu()
self.menuBar.Append(_menu, "&" + menu_name)
self.SetMenuBar(self.menuBar)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
# point on curve
_id = wx.NewId()
check_callable(_callable)
try:
self._menus[menu_name].Append(_id,
_callable.__name__.replace('_', ' ').lower())
except KeyError:
raise ValueError('the menu item %s does not exist' % menu_name)
self.Bind(wx.EVT_MENU, _callable, id=_id)
app = wx.App(False)
win = AppFrame(None)
win.Show(True)
wx.SafeYield()
win.canva.InitDriver()
app.SetTopWindow(win)
display = win.canva._display
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
app.MainLoop()
# Qt based simple GUI
elif 'qt' in used_backend:
from OCC.Display.qtDisplay import qtViewer3d
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args):
QtWidgets.QMainWindow.__init__(self, *args)
self.canva = qtViewer3d(self)
self.setWindowTitle("pythonOCC-%s 3d viewer ('%s' backend)" % (VERSION, used_backend))
self.resize(size[0], size[1])
self.setCentralWidget(self.canva)
if not sys.platform == 'darwin':
self.menu_bar = self.menuBar()
else:
# create a parentless menubar
# see: http://stackoverflow.com/questions/11375176/qmenubar-and-qmenu-doesnt-show-in-mac-os-x?lq=1
# noticeable is that the menu ( alas ) is created in the
# topleft of the screen, just
# next to the apple icon
# still does ugly things like showing the "Python" menu in
# bold
self.menu_bar = QtWidgets.QMenuBar()
self._menus = {}
self._menu_methods = {}
# place the window in the center of the screen, at half the
# screen size
self.centerOnScreen()
def centerOnScreen(self):
'''Centers the window on the screen.'''
resolution = QtWidgets.QDesktopWidget().screenGeometry()
self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
(resolution.height() / 2) - (self.frameSize().height() / 2))
def add_menu(self, menu_name):
_menu = self.menu_bar.addMenu("&" + menu_name)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
check_callable(_callable)
try:
_action = QtWidgets.QAction(_callable.__name__.replace('_', ' ').lower(), self)
# if not, the "exit" action is now shown...
_action.setMenuRole(QtWidgets.QAction.NoRole)
_action.triggered.connect(_callable)
self._menus[menu_name].addAction(_action)
except KeyError:
raise ValueError('the menu item %s does not exist' % menu_name)
# following couple of lines is a twek to enable ipython --gui='qt'
app = QtWidgets.QApplication.instance() # checks if QApplication already exists
if not app: # create QApplication if it doesnt exist
app = QtWidgets.QApplication(sys.argv)
win = MainWindow()
win.show()
win.canva.InitDriver()
display = win.canva._display
if sys.platform != "linux2":
display.EnableAntiAliasing()
# background gradient
display.set_bg_gradient_color(206, 215, 222, 128, 128, 128)
# display black trihedron
display.display_trihedron()
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
win.raise_() # make the application float to the top
app.exec_()
return display, start_display, add_menu, add_function_to_menu
def init_display(backend_str=None, size=(1024, 768)):
""" This function loads and initialize a GUI using either wx, pyq4, pyqt5 or pyside.
If ever the environment variable PYTHONOCC_OFFSCREEN_RENDERER, then the GUI is simply
ignored and an offscreen renderer is returned.
init_display returns 4 objects :
* display : an instance of Viewer3d ;
* start_display : a function (the GUI mainloop) ;
* add_menu : a function that creates a menu in the GUI
* add_function_to_menu : adds a menu option
In case an offscreen renderer is returned, start_display and add_menu are ignored, i.e.
an empty function is returned (named do_nothing). add_function_to_menu just execute the
function taken as a paramter.
Note : the offscreen renderer is used on the travis side.
"""
if os.getenv("PYTHONOCC_OFFSCREEN_RENDERER") == "1":
# create the offscreen renderer
offscreen_renderer = OffscreenRenderer()
def do_nothing(*kargs, **kwargs):
""" takes as many parameters as you want,
ans does nothing
"""
pass
def call_function(s, func):
""" A function that calls another function.
Helpfull to bypass add_function_to_menu. s should be a string
"""
check_callable(func)
log.info("Execute %s :: %s menu fonction" % (s, func.__name__))
func()
log.info("done")
# returns empty classes and functions
return offscreen_renderer, do_nothing, do_nothing, call_function
used_backend = load_backend(backend_str)
log.info("GUI backend set to: %s", used_backend)
# wxPython based simple GUI
if used_backend == 'wx':
import wx
from wxDisplay import wxViewer3d
class AppFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, "pythonOCC-%s 3d viewer ('wx' backend)" % VERSION,
style=wx.DEFAULT_FRAME_STYLE, size=size)
self.canva = wxViewer3d(self)
self.menuBar = wx.MenuBar()
self._menus = {}
self._menu_methods = {}
def add_menu(self, menu_name):
_menu = wx.Menu()
self.menuBar.Append(_menu, "&" + menu_name)
self.SetMenuBar(self.menuBar)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
# point on curve
_id = wx.NewId()
check_callable(_callable)
try:
self._menus[menu_name].Append(_id,
_callable.__name__.replace('_', ' ').lower())
except KeyError:
raise ValueError('the menu item %s does not exist' % menu_name)
self.Bind(wx.EVT_MENU, _callable, id=_id)
app = wx.App(False)
win = AppFrame(None)
win.Show(True)
wx.SafeYield()
win.canva.InitDriver()
app.SetTopWindow(win)
display = win.canva._display
# background gradient
display.set_bg_gradient_color(206, 215, 222, 128, 128, 128)
# display black trihedron
display.display_trihedron()
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
app.MainLoop()
# Qt based simple GUI
elif 'qt' in used_backend:
from OCC.Display.qtDisplay import qtViewer3d
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args):
QtWidgets.QMainWindow.__init__(self, *args)
self.canva = qtViewer3d(self)
self.setWindowTitle("pythonOCC-%s 3d viewer ('%s' backend)" % (VERSION, used_backend))
self.setCentralWidget(self.canva)
if sys.platform != 'darwin':
self.menu_bar = self.menuBar()
else:
# create a parentless menubar
# see: http://stackoverflow.com/questions/11375176/qmenubar-and-qmenu-doesnt-show-in-mac-os-x?lq=1
# noticeable is that the menu ( alas ) is created in the
# topleft of the screen, just
# next to the apple icon
# still does ugly things like showing the "Python" menu in
# bold
self.menu_bar = QtWidgets.QMenuBar()
self._menus = {}
self._menu_methods = {}
# place the window in the center of the screen, at half the
# screen size
self.centerOnScreen()
def centerOnScreen(self):
'''Centers the window on the screen.'''
resolution = QtWidgets.QApplication.desktop().screenGeometry()
x = (resolution.width() - self.frameSize().width()) / 2
y = (resolution.height() - self.frameSize().height()) / 2
self.move(x, y)
def add_menu(self, menu_name):
_menu = self.menu_bar.addMenu("&" + menu_name)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
check_callable(_callable)
try:
_action = QtWidgets.QAction(_callable.__name__.replace('_', ' ').lower(), self)
# if not, the "exit" action is now shown...
_action.setMenuRole(QtWidgets.QAction.NoRole)
_action.triggered.connect(_callable)
self._menus[menu_name].addAction(_action)
except KeyError:
raise ValueError('the menu item %s does not exist' % menu_name)
# following couple of lines is a tweak to enable ipython --gui='qt'
app = QtWidgets.QApplication.instance() # checks if QApplication already exists
if not app: # create QApplication if it doesnt exist
app = QtWidgets.QApplication(sys.argv)
win = MainWindow()
win.show()
win.resize(size[0], size[1])
win.centerOnScreen()
win.canva.InitDriver()
win.canva.qApp = app
display = win.canva._display
# background gradient
display.set_bg_gradient_color(206, 215, 222, 128, 128, 128)
# display black trihedron
display.display_trihedron()
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
win.raise_() # make the application float to the top
app.exec_()
return display, start_display, add_menu, add_function_to_menu
def init_display(backend_str=None, size=(1024, 768)):
if os.getenv("PYTHONOCC_SHUNT_GUI") == "1":
# define a dumb class and an empty method
from OCC.Display import OCCViewer
def do_nothing(*kargs, **kwargs):
""" A method that does nothing
"""
pass
def call_function(s, func):
""" A function that calls another function.
Helpfull to bypass add_function_to_menu. s should be a string
"""
check_callable(func)
print(s, func.__name__)
func()
class BlindViewer(OCCViewer.Viewer3d):
def __init__(self, *kargs):
self._window_handle = 0
self._inited = False
self._local_context_opened = False
self.Context_handle = Dumb()
self.Viewer_handle = Dumb()
self.View_handle = Dumb()
self.Context = Dumb()
self.Viewer = Dumb()
self.View = Dumb()
self.selected_shapes = []
self._select_callbacks = []
self._struc_mgr = Dumb()
def GetContext(self):
return Dumb()
def DisplayMessage(self, *kargs):
pass
class Dumb(object):
""" A class the does nothing whatever the method
or property is called
"""
def __getattr__(self, name):
if name in ['Context']:
return Dumb()
elif name in ['GetContext', 'GetObject']:
return Dumb
else:
return do_nothing
return BlindViewer(), do_nothing, do_nothing, call_function
used_backend = load_backend(backend_str)
if used_backend == 'wx':
import wx
from wxDisplay import wxViewer3d
class AppFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self,
parent,
-1,
"pythonOCC-%s 3d viewer ('wx' backend)" %
VERSION,
style=wx.DEFAULT_FRAME_STYLE,
size=size)
self.canva = wxViewer3d(self)
self.menuBar = wx.MenuBar()
self._menus = {}
self._menu_methods = {}
def add_menu(self, menu_name):
_menu = wx.Menu()
self.menuBar.Append(_menu, "&" + menu_name)
self.SetMenuBar(self.menuBar)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
_id = wx.NewId()
check_callable(_callable)
try:
self._menus[menu_name].Append(
_id,
_callable.__name__.replace('_', ' ').lower())
except KeyError:
raise ValueError('the menu item %s does not exist' %
menu_name)
self.Bind(wx.EVT_MENU, _callable, id=_id)
app = wx.App(False)
win = AppFrame(None)
win.Show(True)
wx.SafeYield()
win.canva.InitDriver()
app.SetTopWindow(win)
display = win.canva._display
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
app.MainLoop()
elif 'qt' in used_backend:
from OCC.Display.qtDisplay import qtViewer3d
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args):
QtWidgets.QMainWindow.__init__(self, *args)
self.canva = qtViewer3d(self)
self.setWindowTitle("pythonOCC-%s 3d viewer ('%s' backend)" %
(VERSION, used_backend))
self.resize(size[0], size[1])
self.setCentralWidget(self.canva)
if sys.platform != 'darwin':
self.menu_bar = self.menuBar()
else:
self.menu_bar = QtWidgets.QMenuBar()
self._menus = {}
self._menu_methods = {}
self.centerOnScreen()
def centerOnScreen(self):
'''Centers the window on the screen.'''
resolution = QtWidgets.QDesktopWidget().screenGeometry()
self.move(
(resolution.width() / 2) - (self.frameSize().width() / 2),
(resolution.height() / 2) -
(self.frameSize().height() / 2))
def add_menu(self, menu_name):
_menu = self.menu_bar.addMenu("&" + menu_name)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name, _callable):
check_callable(_callable)
try:
_action = QtWidgets.QAction(
_callable.__name__.replace('_', ' ').lower(), self)
_action.setMenuRole(QtWidgets.QAction.NoRole)
_action.triggered.connect(_callable)
self._menus[menu_name].addAction(_action)
except KeyError:
raise ValueError('the menu item %s does not exist' %
menu_name)
app = QtWidgets.QApplication.instance()
if not app:
app = QtWidgets.QApplication(sys.argv)
win = MainWindow()
win.showMinimized()
win.close()
win.canva.InitDriver()
win.canva.qApp = app
display = win.canva._display
if sys.platform != "linux2":
display.EnableAntiAliasing()
display.set_bg_gradient_color([23, 1, 32], [23, 1, 32])
display.display_triedron()
def add_menu(*args, **kwargs):
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs):
win.add_function_to_menu(*args, **kwargs)
def start_display():
win.raise_()
app.exec_()
return display, start_display, add_menu, add_function_to_menu
