def __init__(self, backend_str=None, *args):
used_backend = load_backend(backend_str)
log.info("GUI backend set to: %s", used_backend)
from OCC.Display.qtDisplay import qtViewer3d, qtBaseViewer
# following couple of lines is a tweak to enable ipython --gui='qt'
# checks if QApplication already exists
self.app = QtWidgets.QApplication.instance()
if not self.app: # create QApplication if it doesnt exist
self.app = QtWidgets.QApplication(sys.argv)
QtWidgets.QMainWindow.__init__(self, *args)
self.canvas = qtViewer3d(self)
self.setWindowTitle("pythonOCC-%s 3d viewer ('%s' backend)" %
(VERSION, used_backend))
self.setCentralWidget(self.canvas)
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
# top-left 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()
# show time
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.time_draw)
self.timer.start(500) # msec
# @Last Modified time: 2016-10-07 15:05:47
import logging
import os
import sys
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
import sys
from PyQt4 import QtCore, QtGui
from OCC.Display.backend import load_backend
load_backend("qt-pyqt4") #here you need to tell OCC.Display to load qt4 backend
class AppGUI(QtGui.QMainWindow):
def __init__(self, *args):
QtGui.QMainWindow.__init__(self, *args)
# setup prefered interface
self.treeArea = QtGui.QTreeWidget()
self.textArea = QtGui.QTextEdit()
self.viewArea = QtGui.QTabWidget()
self.msgArea = QtGui.QTextBrowser()
# Add tabs
from OCC.Display import qtDisplay
self.modelTab = qtDisplay.qtViewer3d(self)
self.reportTab = QtGui.QTextBrowser()
self.viewArea.addTab(self.modelTab, "Model")
self.viewArea.addTab(self.reportTab, "Report")
# Window area splitters
self.vSplitter = QtGui.QSplitter(QtCore.Qt.Vertical)
self.vSplitter.addWidget(self.viewArea)
self.vSplitter.addWidget(self.msgArea)
self.hSplitter = QtGui.QSplitter(QtCore.Qt.Horizontal)
self.hSplitter.addWidget(self.treeArea)
self.hSplitter.addWidget(self.textArea)
self.hSplitter.addWidget(self.vSplitter)
# Assign mainwindow
self.setCentralWidget(self.hSplitter)
def init_display(
backend_str: Optional[str] = None,
size: Optional[Tuple[int, int]] = (1024, 768),
display_triedron: Optional[bool] = True,
background_gradient_color1: Optional[List[int]] = [206, 215, 222],
background_gradient_color2: Optional[List[int]] = [128, 128, 128]):
""" 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 size is None: # prevent size to being None (mypy)
raise AssertionError("window size cannot be None")
if os.getenv("PYTHONOCC_OFFSCREEN_RENDERER") == "1":
# create the offscreen renderer
offscreen_renderer = OffscreenRenderer()
def do_nothing(*kargs: Any, **kwargs: Any) -> None:
""" takes as many parameters as you want,
ans does nothing
"""
pass
def call_function(s, func: Callable) -> None:
""" 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 OCC.Display.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: str) -> None:
_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: str,
_callable: Callable) -> None:
# 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) -> None:
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs) -> None:
win.add_function_to_menu(*args, **kwargs)
def start_display() -> None:
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: Any) -> None:
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) -> None:
'''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: str) -> None:
_menu = self.menu_bar.addMenu("&" + menu_name)
self._menus[menu_name] = _menu
def add_function_to_menu(self, menu_name: str,
_callable: Callable) -> None:
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.resize(size[0] - 1, size[1] - 1)
win.show()
win.centerOnScreen()
win.canva.InitDriver()
win.resize(size[0], size[1])
win.canva.qApp = app
display = win.canva._display
def add_menu(*args, **kwargs) -> None:
win.add_menu(*args, **kwargs)
def add_function_to_menu(*args, **kwargs) -> None:
win.add_function_to_menu(*args, **kwargs)
def start_display() -> None:
win.raise_() # make the application float to the top
app.exec_()
if display_triedron:
display.display_triedron()
if background_gradient_color1 and background_gradient_color2:
# background gradient
display.set_bg_gradient_color(background_gradient_color1,
background_gradient_color2)
return display, start_display, add_menu, add_function_to_menu
""" 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
used_backend = load_backend(backend_str)
log.info("GUI backend set to: %s", used_backend)
#------------------------------------------------------------初始化结束
from OCC.Display.qtDisplay import qtViewer3d
import MainGui
from PyQt5.QtGui import QPixmap
QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
from OCC.Extend.DataExchange import read_step_file, write_step_file
from OCC.Core.TopoDS import TopoDS_Shape, TopoDS_Builder, TopoDS_Compound, topods_CompSolid
from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakePrism, BRepPrimAPI_MakeRevol
from OCC.Core.gp import gp_Pnt, gp_Vec, gp_Ax1, gp_Dir
from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_MakeEdge, BRepBuilderAPI_MakeWire, BRepBuilderAPI_MakeFace
from OCC.Core.BRepGProp import brepgprop_LinearProperties
from OCC.Core.GProp import GProp_GProps
from OCC.Core.TopoDS import topods_Edge, topods_Solid
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from spyder.widgets import internalshell
from OCC import VERSION
from OCC.Display.backend import load_backend, load_pyqt4, PYQT4
load_backend(PYQT4)
load_pyqt4()
from OCC.Display.qtDisplay import *
class ManiWindow(QMainWindow):
def __init__(self, parent=None):
super(ManiWindow, self).__init__(parent)
self.canvas = qtViewer3d(self)
self.setWindowTitle("pythonOCC-%s 3d viewer" % VERSION)
self.canvas.InitDriver()
self.display = self.canvas._display
bar = self.menuBar()
file = bar.addMenu("&File")
_new = QAction(QIcon('icons/exit.png'), '&New', self)
_new.setStatusTip("New application")
self.connect(_new, SIGNAL("triggered()"), self.my_process)
file.addAction(_new)
_exit = QAction(QIcon('icons/exit.png'), '&Exit', self)
_exit.setShortcut('Ctrl+Q')
_exit.setStatusTip('Exit application')
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
##Author github user @Tanneguydv, 2021
import os
import sys
from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakeBox
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QHBoxLayout, QGroupBox, QDialog, QVBoxLayout
from OCC.Display.backend import load_backend
load_backend('qt-pyqt5')
import OCC.Display.qtDisplay as qtDisplay
class App(QDialog):
def __init__(self):
super().__init__()
self.title = 'PyQt5 / pythonOCC'
self.left = 300
self.top = 300
self.width = 800
self.height = 300
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.createHorizontalLayout()
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.horizontalGroupBox)
# -*- coding: utf-8 -*-
from qtpy.QtWidgets import QApplication, QAction, qApp, QMainWindow
from qtpy.QtGui import QIcon
from OCC import VERSION
from OCC.Display.backend import load_backend, load_pyqt5, PYQT5
load_backend(PYQT5)
load_pyqt5()
from OCC.Display.qtDisplay import *
class ManiWindow(QMainWindow):
def __init__(self, parent=None):
super(ManiWindow, self).__init__(parent)
self.canvas = qtViewer3d(self)
# self.setWindowTitle("pythonOCC-%s 3d viewer" % VERSION)
self.canvas.InitDriver()
bar = self.menuBar()
file = bar.addMenu("&File")
_new = QAction(QIcon('icons/exit.png'), '&New', self)
_new.setStatusTip("New application")
_new.triggered.connect(self.my_process)
# self.connect(_new, SIGNAL("triggered()"), self.my_process)
file.addAction(_new)
_exit = QAction(QIcon('icons/exit.png'), '&Exit', self)
_exit.setShortcut('Ctrl+Q')
_exit.setStatusTip('Exit application')
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
import math
from OCC.Display.backend import load_backend
from OCC.gp import gp_Pnt
from PyQt5 import QtCore, QtGui
from PyQt5.QtGui import QOpenGLContext
from PyQt5.QtCore import QPointF
from PyQt5.QtGui import QTextItem
from geom import points_to_bezier_curve
from geom import points_to_bspline_curve
load_backend("qt-pyqt5")
#from OCC.Display.qtDisplay import qtViewer3d
from qt_display_opengl import qtViewer3d
from OpenGL.GL import *
class IfcViewerWidget(qtViewer3d):
def __init__(self, *kargs):
super(IfcViewerWidget, self).__init__(*kargs)
self._parent = kargs[0]
self._is_draw_path = False
self._path_pts = []
self._path_curve = [None, None]
self._preview_curve = [None, None]
self._path_height = None
self._is_draw_path_mark = False
def InitDriver(self):
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
#!/usr/bin/env python
"""
Embedded an IPythonConsole to interact with python-OCC
"""
from __future__ import print_function
from OCC.Display.backend import load_backend
load_backend('qt-pyside')
from OCC.Display.qtDisplay import qtViewer3d
from OCC import Quantity, Aspect
from inter_console import QIPythonWidget
try:
from PySide import QtGui, QtCore
except ImportError:
try:
from PyQt5 import QtCore, QtWidgets, QtGui
except ImportError:
print("Need to install PySide or PyQt5!\n")
class InteractOCC(QtGui.QMainWindow):
def __init__(self):
super(InteractOCC, self).__init__()
self.canvas = qtViewer3d()
self.setCentralWidget(self.canvas)
# add Ipython console as dockwidget
consoleDock = QtGui.QDockWidget("console", self)
consoleDock.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea |
QtCore.Qt.RightDockWidgetArea)
def remove(self, shape):
"""Remove a shape from the document"""
# get the label of the shape which should be removed
to_remove = self._shape_tool.FindShape(shape)
# find the shape that corresponds to the label and remove the
# associated component
for shape_label, comp_label in self._label_list:
if shape_label.IsEqual(to_remove):
self._shape_tool.RemoveComponent(comp_label)
self._shape_tool.RemoveShape(shape_label)
print("Removed shape", shape_label.Tag())
break
used_backend = load_backend(None)
log.info("GUI backend set to: {0}".format(used_backend))
from OCC.Display.qtDisplay import qtViewer3d
class qtViewer2(qtViewer3d):
keyPressed = QtCore.pyqtSignal()
def keyPressEvent(self, event):
print("Key pressed:", event.key())
print("========================================")
print("removing selected")
if event.key() == QtCore.Qt.Key_Delete:
shapes = self._display.GetSelectedShapes()
# print(shapes)
