def switchDisplaying(self):
self.__displayHelper += 1
if self.__displayHelper == 1:
self.__mapView.setViewport(QtOpenGL.QGLWidget(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers)))
if self.__displayHelper == 2:
self.__mapView.setViewport(QtOpenGL.QGLWidget(QtOpenGL.QGLFormat()))
if self.__displayHelper == 3:
self.__mapView.setViewport(QtGui.QWidget())
self.__displayHelper = 0
def __init__(self, graphics_view):
#print 'GUI IS SHUTDOWN??1', rospy.is_shutdown()
#add scene to QGraphicsView
scene = qtg.QGraphicsScene()
graphics_view.setViewport(qtl.QGLWidget())
#print 'GUI IS SHUTDOWN??11', rospy.is_shutdown()
self.drawing_widget = NodeBoxGUIHelper(graphics_view.viewport(), scene)
#print 'GUI IS SHUTDOWN??111', rospy.is_shutdown()
graphics_view.setScene(scene)
# TODO: graphics_view._scene = scene
#print 'GUI IS SHUTDOWN??112', rospy.is_shutdown()
scene.setItemIndexMethod(qtg.QGraphicsScene.NoIndex)
#print 'GUI IS SHUTDOWN??113', rospy.is_shutdown()
scene.addItem(self.drawing_widget)
#print 'GUI IS SHUTDOWN??2', rospy.is_shutdown()
#Add NB to scene
self.namespace = {}
self.canvas = graphics.Canvas()
#print 'text scale', QPixmap(1, 1).logicalDpiX() / 72.0
self.canvas._setTextScaleFactor(qtg.QPixmap(1, 1).logicalDpiX() / 72.0)
self.context = graphics.Context(self.canvas, self.namespace)
#Setup the scene
self.setup()
self.animationTimer = qtc.QTimer(self)
self.connect(self.animationTimer, qtc.SIGNAL("timeout()"), self._draw)
self.animationTimer.start(1000.0 / self.canvas.speed)
def __init__(self):
QtGui.QWidget.__init__(self)
# set up the scene
self.scene = QtGui.QGraphicsScene()
self.scene.setSceneRect(0, 0, 800, 600)
# add a view of that scene
self.view = QtGui.QGraphicsView()
self.view.setScene(self.scene)
self.view.setRenderHint(QtGui.QPainter.Antialiasing)
# make that view use OpenGL
qglf = QtOpenGL.QGLFormat()
qglf.setSampleBuffers(True)
self.glw = QtOpenGL.QGLWidget(qglf)
# turn off auto swapping of the buffer
self.glw.setAutoBufferSwap(False)
# use the GL widget for viewing
self.view.setViewport(self.glw)
# initialize the time
self.last_time = time.time()
# start some timers to draw things (it's frustrating we have
# to do this with timers)
QtCore.QTimer.singleShot(0, self.updateScreen)
QtCore.QTimer.singleShot(1000, self.jubba)
def set_graph(self, graph, relayout=True):
assert not graph or isinstance(graph, nx.Graph)
self.graph = graph
if not graph:
self.clear()
return
large_graph = IS_LARGE_GRAPH(graph)
very_large_graph = IS_VERY_LARGE_GRAPH(graph)
self.setViewport(
QtOpenGL.QGLWidget()
# FIXME: Try reenable the following test after Qt5 port
if large_graph and HAVE_OPENGL else QtGui.QWidget())
self.setRenderHints(QtGui.QPainter.RenderHint(
) if very_large_graph else (QtGui.QPainter.Antialiasing
| QtGui.QPainter.TextAntialiasing))
self.clear()
nodes = {}
for v in sorted(graph.nodes()):
node = Node(v, view=self)
self.addNode(node)
nodes[v] = node
for u, v in graph.edges():
self.addEdge(Edge(nodes[u], nodes[v], view=self))
self.selectionChanged.emit()
if relayout: self.relayout()
def set_gl(self, state):
if state == qc.Qt.Checked:
self.game.field.setViewport(QtOpenGL.QGLWidget())
self.game.config['gl'] = True
else:
self.game.field.setViewport(qg.QWidget())
self.game.config['gl'] = False
def __init__(self, *args):
QtGui.QGraphicsView.__init__(self, *args)
self.buffer_node = None
self.init_values()
if USE_GL:
print("USING GL")
F = QtOpenGL.QGLFormat()
F.setSampleBuffers(True)
print(F.sampleBuffers())
self.setViewport(QtOpenGL.QGLWidget(F))
self.setRenderHints(QtGui.QPainter.Antialiasing)
else:
self.setRenderHints(QtGui.QPainter.Antialiasing
or QtGui.QPainter.SmoothPixmapTransform)
self.setViewportUpdateMode(
QtGui.QGraphicsView.BoundingRectViewportUpdate)
self.setRenderHints(QtGui.QPainter.Antialiasing
or QtGui.QPainter.SmoothPixmapTransform)
#self.setViewportUpdateMode(QtGui.QGraphicsView.NoViewportUpdate)
self.setCacheMode(QtGui.QGraphicsView.CacheBackground)
self.setResizeAnchor(QtGui.QGraphicsView.AnchorUnderMouse)
#self.setOptimizationFlag (QtGui.QGraphicsView.DontAdjustForAntialiasing)
self.setOptimizationFlag(QtGui.QGraphicsView.DontSavePainterState)
def setRenderer(self, renderer):
self.renderer = renderer
if self.renderer == SvgView.OpenGL:
if QtOpenGL.QGLFormat.hasOpenGL():
self.setViewport(QtOpenGL.QGLWidget(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers)))
else:
self.setViewport(QtGui.QWidget())
def useOpenGL(self, b=True):
if b:
v = QtOpenGL.QGLWidget()
else:
v = QtGui.QWidget()
#v.setStyleSheet("background-color: #000000;")
self.setViewport(v)
def __init__(self):
BaseCam.__init__(self) #super(CudaGLCam, self).__init__()
#QT OpenGL widget, provides context through makeCurrent() calls (?)
self.glwidget = QtOpenGL.QGLWidget(
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))
#self.filters=[]
#QMutex protects raw_pbo
#self.raw_pbo_mutex=QtCore.QMutex()
#CAM params
#self.cam=CAMERA()
#self.raw_itemsize=self.cam.dtype(0).itemsize
self.raw_itemsize = self.dtype()(0).itemsize
self.tex_format = GL_RGB
self.tex_itemsize = 3
#initialize GL
#self.glwidget.makeCurrent()
self.glwidget.setAutoFillBackground(False)
#Texture Buffers
#siz=self.cam.w*self.cam.h*self.tex_itemsize
glcontext = self.glwidget.context()
[w, h] = self.shape()
siz = w * h * self.tex_itemsize
self.tex_pbo_idx = 0
self.tex_pbo = [PBO(siz, glcontext), PBO(siz, glcontext)]
self.tex_pbo_active = self.tex_pbo[self.tex_pbo_idx]
self.tex_pbo_inactive = self.tex_pbo[(self.tex_pbo_idx + 1) % 2]
#Data Buffers
self.siz = w * h * self.raw_itemsize
self.raw_pbo = PBO(self.siz, glcontext)
#siz=w*h*float32().itemsize
#self.preproc_pbo = PBO(siz, glcontext)
#Textures
self.glwidget.makeCurrent()
self.tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, self.tex)
#glTexImage2D(GL_TEXTURE_2D, 0, self.tex_format, self.cam.w, self.cam.h,
glTexImage2D(GL_TEXTURE_2D, 0, self.tex_format, w, h, 0,
self.tex_format, GL_UNSIGNED_BYTE, None)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glPixelStorei(
GL_UNPACK_ALIGNMENT,
1) #Word alignment (ask Lorenzo, CUDA or numpy compatibility?)
glBindTexture(GL_TEXTURE_2D, 0)
#OpenGL
glClearColor(0.0, 0.0, 0.0, 0.0)
glEnable(GL_TEXTURE_2D)
glEnable(GL_DEPTH_TEST)
def makeGLWidget(*args, **option):
fmt = QtOpenGL.QGLFormat()
fmt.setRgba(True)
fmt.setDepth(False)
fmt.setDoubleBuffer(True)
fmt.setSwapInterval(0)
fmt.setSampleBuffers(True)
viewport = QtOpenGL.QGLWidget(fmt)
return viewport
def __init__(self, env):
QtGui.QGraphicsView.__init__(self)
#super(WaveformView, self).__init__()
self.env = env
# Force OpenGL rendering! Super smooth scrolling for 50 plots with 1000
# bars each. Any kind of anti aliasing is useless because only
# right angles exist.
if not self.env.software_rendering:
self.opengl_widget = QtOpenGL.QGLWidget()
self.setViewport(self.opengl_widget)
def __init__(self, env):
QtGui.QGraphicsView.__init__(self)
#super(TimescaleView, self).__init__()
self.env = env
# Force OpenGL rendering! Super smooth scrolling for 50 plots with 1000
# bars each. Any kind of anti aliasing is useless because only
# right angles exist.
if not self.env.software_rendering:
self.opengl_widget = QtOpenGL.QGLWidget()
self.setViewport(self.opengl_widget)
# This is manually adjusted.
self.setMinimumHeight(62)
self.setMaximumHeight(64)
def main(argv):
app = QtGui.QApplication(argv)
view = QtDeclarative.QDeclarativeView()
app.setOverrideCursor( QtGui.QCursor( QtCore.Qt.BlankCursor ) )
view.setSource(QtCore.QUrl("qml/main2.qml"))
glw = QtOpenGL.QGLWidget()
view.setViewport(glw)
view.showFullScreen()
#view.resize(800, 600)
view.show()
app.exec_()
def getSharedWidget():
if not GLWidget.sharedWidget:
fmt = QtOpenGL.QGLFormat()
fmt.setRgba(True)
fmt.setAlpha(True)
fmt.setDepth(True)
fmt.setDoubleBuffer(True)
fmt.setSampleBuffers(True)
fmt.setSwapInterval(0)
QtOpenGL.QGLFormat.setDefaultFormat(fmt)
hiddenWindow = QtOpenGL.QGLWidget(QtOpenGL.QGLContext(fmt, None))
GLWidget.sharedWidget = hiddenWindow
hiddenWindow.makeCurrent()
return GLWidget.sharedWidget
def __init__(self):
#Test for OpenGL Version
gl2 = False
w = QtOpenGL.QGLWidget()
w.setVisible(False)
w.makeCurrent()
gl_version = glGetString(GL_VERSION)
if gl_version is None:
gl_version = '0'
allowChoosingOpenGL = False
if int(gl_version[0]) >= 2:
allowChoosingOpenGL = True
elif int(gl_version[0]) > 0:
allowChoosingOpenGL = False
else:
raise RuntimeError("Absolutely no OpenGL available")
super(RenderChoiceDialog, self).__init__()
layout = QtGui.QVBoxLayout(self)
choicesGroup = QtGui.QButtonGroup(self)
self.openglChoice = QtGui.QRadioButton("Open GL")
self.softwareChoice = QtGui.QRadioButton("Software + OpenGL")
okButton = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Ok,
QtCore.Qt.Vertical)
label = QtGui.QLabel("""<b>OpenGL + OpenGL Overview</b> allows
for fastest rendering if OpenGL is correctly installed.
<br> If visualization is slow or incomplete,
try the <b>Software + OpenGL</b> mode.""")
layout.addWidget(label)
layout.addWidget(self.openglChoice)
layout.addWidget(self.softwareChoice)
layout.addWidget(okButton)
self.setLayout(layout)
if platform.system() == 'Darwin':
allowChoosingOpenGL = False
if allowChoosingOpenGL:
self.openglChoice.setChecked(True)
else:
self.openglChoice.setEnabled(False)
self.softwareChoice.setChecked(True)
QtCore.QObject.connect(okButton, QtCore.SIGNAL("accepted()"), self,
QtCore.SLOT("accept()"))
def __init__(self, url, total_time):
QtGui.QMainWindow.__init__(self)
self.progress = 0
self.url = url
self.total_time = total_time
QtNetwork.QNetworkProxyFactory.setUseSystemConfiguration(True)
self.setGeometry(QtCore.QRect(200, 30, 1024, 700))
# Graphics view
self.view = QtGui.QGraphicsView()
self.view.setViewportUpdateMode(QtGui.QGraphicsView.MinimalViewportUpdate)
self.view.setOptimizationFlags(QtGui.QGraphicsView.DontSavePainterState)
self.view.setFrameShape(QtGui.QFrame.NoFrame)
self.view.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
self.view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.resize(800, 700)
self.scene_width = 1024
self.scene_height = 700
self.view.setSceneRect(QtCore.QRectF(0, 0, self.scene_width, self.scene_height))
self.view.setRenderHints(QtGui.QPainter.Antialiasing | QtGui.QPainter.SmoothPixmapTransform)
# Graphics scene
self.scene = QtGui.QGraphicsScene()
self.view.setScene(self.scene)
# Graphics web view
self.fast_view = QtWebKit.QGraphicsWebView()
#self.fast_view.page().setViewportSize(QtCore.QSize(600, 600))
self.fast_view.resize(1024, 768)
self.settings = self.fast_view.settings()
self.settings.setAttribute(QtWebKit.QWebSettings.AcceleratedCompositingEnabled, True)
#self.settings.setAttribute(QtWebKit.QWebSettings.WebGLEnabled, True)
#self.settings.setAttribute(QtWebKit.QWebSettings.PluginsEnabled, True)
# GL widget for QGraphicsView
self.qglwidget = QtOpenGL.QGLWidget()
self.view.setViewport(self.qglwidget)
self.scene.addItem(self.fast_view)
self.setCentralWidget(self.view)
self.fast_view.loadFinished.connect(self.finishLoading)
self.openInfographic()
def __init__(self, parent):
"""
Constructor
"""
self.is_live = False
if hasattr(parent, 'is_live') and parent.is_live:
self.is_live = True
if self.is_live:
self.parent = lambda: parent
super(Display, self).__init__()
self.controller = parent
self.screen = {}
# FIXME: On Mac OS X (tested on 10.7) the display screen is corrupt with
# OpenGL. Only white blank screen is shown on the 2nd monitor all the
# time. We need to investigate more how to use OpenGL properly on Mac OS
# X.
if not is_macosx():
self.setViewport(QtOpenGL.QGLWidget())
def setRenderingSystem(self):
if Colors.openGlRendering:
from PyQt4 import QtOpenGL
viewport = QtOpenGL.QGLWidget(
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))
if Colors.noScreenSync:
viewport.format().setSwapInterval(0)
viewport.setAutoFillBackground(False)
self.setCacheMode(QtGui.QGraphicsView.CacheNone)
Colors.debug("- using OpenGL")
else:
viewport = QtGui.QWidget()
self.setCacheMode(QtGui.QGraphicsView.CacheBackground)
Colors.debug("- using software rendering")
self.setViewport(viewport)
def detectSystemResources(cls):
try:
from PyQt4 import QtOpenGL
cls.openGlAvailable = True
except ImportError:
cls.openGlAvailable = False
if cls.openGlAvailable:
version_flags = QtOpenGL.QGLFormat.openGLVersionFlags()
if version_flags & QtOpenGL.QGLFormat.OpenGL_Version_2_0:
cls.glVersion = "2.0 or higher"
elif version_flags & QtOpenGL.QGLFormat.OpenGL_Version_1_5:
cls.glVersion = "1.5"
elif version_flags & QtOpenGL.QGLFormat.OpenGL_Version_1_4:
cls.glVersion = "1.4"
elif version_flags & QtOpenGL.QGLFormat.OpenGL_Version_1_3:
cls.glVersion = "1.3 or lower"
cls.debug("- OpenGL version:", cls.glVersion)
glw = QtOpenGL.QGLWidget()
if (not QtOpenGL.QGLFormat.hasOpenGL() or
not (version_flags & QtOpenGL.QGLFormat.OpenGL_Version_1_5) or
glw.depth() < 24):
cls.openGlAdequate = False
cls.debug("- OpenGL not recommended on this system")
else:
cls.openGlAdequate = False
cls.debug("- OpenGL not supported by current build of Qt")
# Check if X Render is present.
if hasattr(QtGui.QPixmap, 'x11PictureHandle'):
tmp = QtGui.QPixmap(1, 1)
if not tmp.x11PictureHandle():
cls.xRenderPresent = False
cls.debug("- X render not present")
w = QtGui.QWidget()
cls.debug("- Color depth: %d" % w.depth())
def __init__(self, *args):
super(SymbolView, self).__init__(*args)
from UIManager import UIManager
self.setScene(UIManager.instance().getSymbolScene())
self.setViewportUpdateMode(QtGui.QGraphicsView.FullViewportUpdate)
self.setCacheMode(QtGui.QGraphicsView.CacheNone)
#self.setDragMode(QtGui.QGraphicsView.RubberBandDrag)
self.setTransformationAnchor(QtGui.QGraphicsView.AnchorUnderMouse)
self.setMouseTracking(True)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setAcceptDrops(True)
self.setViewport(QtOpenGL.QGLWidget())
self.centerPnt = QtCore.QPointF()
self.scale(0.6, 0.6)
self.mousePressPnt = None
self.mouseCurPnt = None
self.isFrameSelectMode = False
def __init__(self):
QtGui.QWidget.__init__(self)
# This is always the same
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# set the icon
SetAppIcon(self)
#config
self.config = CreateOrLoadConfig()
print "C", self.config
# color for the solver
self.nextColor = 0
# shortcut for color choice
self.mNumColors = len(self.config["maze"]["solution_colors"])
# buld the scene which will hold my maze
self.scene = QtGui.QGraphicsScene()
self.ui.MazeView.setScene(self.scene)
# set the scene... height? what does it do
self.scene.setSceneRect(0, 0, 1024, 768)
# accelerate the viewport
self.ui.MazeView.setViewport(QtOpenGL.QGLWidget())
# set the scene background color
self.scene.setBackgroundBrush(
QtGui.QColor(self.config["maze"]["background_color"]))
#enable zoom
# self.ui.MazeView.setTransformationAnchor(QtGui.QGraphicsView.AnchorUnderMouse)
# maze information
self.maze = None
self.mazeLoaded = False
self.mazeLines = []
self.mazeScale = 20.0
self.mazeFile = None
# solver information
self.solver = None
self.solverRunning = False
self.solverIcon = None
self.solverPath = None
self.illustrateSolverPath = None
self.solverInteractive = False
# dialog remembers where it opened last file from
self.last_maze_dir = None
# timer for the solver
self.solverTimer = QtCore.QTimer()
self.solverTimer.timeout.connect(self.SolverStep)
# bind the menus
self.ui.actionExit.triggered.connect(QtGui.qApp.quit)
self.ui.actionOpenMaze.triggered.connect(self.LoadMazeFromFile)
self.ui.actionRunMaze.triggered.connect(self.StartManualRun)
self.ui.actionSolve_Maze.triggered.connect(self.StartAStarRun)
self.ui.actionNew_Maze.triggered.connect(self.newMaze)
self.ui.actionExport_to_Obj.triggered.connect(self.MazeToObj)
# create a maze dir
if not os.path.isdir(DEFAULT_MAZE_DIR):
os.mkdir(DEFAULT_MAZE_DIR)
def __init__(self, width, height):
super(Panel, self).__init__()
self.selectedX = 0
self.selectedY = 0
self.width = width
self.height = height
self.flipped = False
self.flipLeft = True
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setCacheMode(QtGui.QGraphicsView.CacheBackground)
self.setViewportUpdateMode(QtGui.QGraphicsView.FullViewportUpdate)
self.setRenderHints(QtGui.QPainter.Antialiasing
| QtGui.QPainter.SmoothPixmapTransform
| QtGui.QPainter.TextAntialiasing)
self.setBackgroundBrush(
QtGui.QBrush(QtGui.QPixmap('./images/blue_angle_swirl.jpg')))
if QtOpenGL.QGLFormat.hasOpenGL():
self.setViewport(
QtOpenGL.QGLWidget(
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers)))
self.setMinimumSize(50, 50)
self.selectionTimeLine = QtCore.QTimeLine(150, self)
self.flipTimeLine = QtCore.QTimeLine(500, self)
bounds = QtCore.QRectF((-width / 2.0) * 150, (-height / 2.0) * 150,
width * 150, height * 150)
self.scene = QtGui.QGraphicsScene(bounds, self)
self.setScene(self.scene)
self.baseItem = RoundRectItem(bounds, QtGui.QColor(226, 255, 92, 64))
self.scene.addItem(self.baseItem)
embed = QtGui.QWidget()
self.ui = Ui_BackSide()
self.ui.setupUi(embed)
self.ui.hostName.setFocus()
self.backItem = RoundRectItem(bounds, embed.palette().window(), embed)
self.backItem.setTransform(QtGui.QTransform().rotate(
180, QtCore.Qt.YAxis))
self.backItem.setParentItem(self.baseItem)
self.selectionItem = RoundRectItem(QtCore.QRectF(-60, -60, 120, 120),
QtCore.Qt.gray)
self.selectionItem.setParentItem(self.baseItem)
self.selectionItem.setZValue(-1)
self.selectionItem.setPos(self.posForLocation(0, 0))
self.startPos = self.selectionItem.pos()
self.endPos = QtCore.QPointF()
self.grid = []
for y in range(height):
self.grid.append([])
for x in range(width):
item = RoundRectItem(QtCore.QRectF(-54, -54, 108, 108),
QtGui.QColor(214, 240, 110, 128))
item.setPos(self.posForLocation(x, y))
item.setParentItem(self.baseItem)
item.setFlag(QtGui.QGraphicsItem.ItemIsFocusable)
self.grid[y].append(item)
rand = QtCore.qrand() % 9
if rand == 0:
item.setPixmap(
QtGui.QPixmap(':/images/kontact_contacts.png'))
elif rand == 1:
item.setPixmap(
QtGui.QPixmap(':/images/kontact_journal.png'))
elif rand == 2:
item.setPixmap(QtGui.QPixmap(':/images/kontact_notes.png'))
elif rand == 3:
item.setPixmap(
QtGui.QPixmap(':/images/kopeteavailable.png'))
elif rand == 4:
item.setPixmap(
QtGui.QPixmap(':/images/metacontact_online.png'))
elif rand == 5:
item.setPixmap(QtGui.QPixmap(':/images/minitools.png'))
elif rand == 6:
item.setPixmap(
QtGui.QPixmap(':/images/kontact_journal.png'))
elif rand == 7:
item.setPixmap(
QtGui.QPixmap(':/images/kontact_contacts.png'))
elif rand == 8:
item.setPixmap(
QtGui.QPixmap(':/images/kopeteavailable.png'))
else:
pass
item.qobject.activated.connect(self.flip)
self.grid[0][0].setFocus()
self.backItem.qobject.activated.connect(self.flip)
self.selectionTimeLine.valueChanged.connect(self.updateSelectionStep)
self.flipTimeLine.valueChanged.connect(self.updateFlipStep)
self.splash = SplashItem()
self.splash.setZValue(5)
self.splash.setPos(-self.splash.rect().width() / 2,
self.scene.sceneRect().top())
self.scene.addItem(self.splash)
self.splash.grabKeyboard()
self.updateSelectionStep(0)
self.setWindowTitle("Pad Navigator Example")
def makeSharedGLWidget(*args, **option):
sharedWidget = None
fmt = QtOpenGL.QGLFormat.defaultFormat()
sharedWidget = getSharedGLWidget()
return QtOpenGL.QGLWidget(fmt, None, sharedWidget)
def __init__(self, url):
super(MainWindow, self).__init__()
self.progress = 0
fd = QtCore.QFile(":/jquery.min.js")
if fd.open(QtCore.QIODevice.ReadOnly | QtCore.QFile.Text):
self.jQuery = QtCore.QTextStream(fd).readAll()
fd.close()
else:
self.jQuery = ''
QtNetwork.QNetworkProxyFactory.setUseSystemConfiguration(True)
self.setGeometry(QtCore.QRect(200, 50, 1024, 600))
# Graphics view
self.view = QtGui.QGraphicsView()
self.view.setViewportUpdateMode(
QtGui.QGraphicsView.MinimalViewportUpdate)
self.view.setOptimizationFlags(
QtGui.QGraphicsView.DontSavePainterState)
self.view.setFrameShape(QtGui.QFrame.NoFrame)
self.view.setSizePolicy(QtGui.QSizePolicy.Fixed,
QtGui.QSizePolicy.Fixed)
self.view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.resize(800, 600)
self.scene_width = 1024
self.scene_height = 600
self.view.setSceneRect(
QtCore.QRectF(0, 0, self.scene_width, self.scene_height))
#self.view.set
self.view.setRenderHints(QtGui.QPainter.Antialiasing
| QtGui.QPainter.SmoothPixmapTransform)
# Graphics scene
self.scene = QtGui.QGraphicsScene()
self.view.setScene(self.scene)
# Graphics web view
self.fast_view = QtWebKit.QGraphicsWebView()
#self.fast_view.page().setViewportSize(QtCore.QSize(600, 600))
self.fast_view.resize(1024, 768)
self.settings = self.fast_view.settings()
self.settings.setAttribute(
QtWebKit.QWebSettings.AcceleratedCompositingEnabled, True)
self.settings.setAttribute(QtWebKit.QWebSettings.WebGLEnabled, True)
self.settings.setAttribute(QtWebKit.QWebSettings.PluginsEnabled, True)
# GL widget for QGraphicsView
self.qglwidget = QtOpenGL.QGLWidget()
self.view.setViewport(self.qglwidget)
self.scene.addItem(self.fast_view)
# Connect progressions
self.fast_view.load(url)
self.fast_view.loadFinished.connect(self.adjustLocation)
self.fast_view.titleChanged.connect(self.adjustTitle)
self.fast_view.loadProgress.connect(self.setProgress)
self.fast_view.loadFinished.connect(self.finishLoading)
# Location
self.locationEdit = QtGui.QLineEdit(self)
self.locationEdit.setSizePolicy(
QtGui.QSizePolicy.Expanding,
self.locationEdit.sizePolicy().verticalPolicy())
self.locationEdit.returnPressed.connect(self.changeLocation)
# Toolbar
toolBar = self.addToolBar("Navigation")
toolBar.addAction(self.fast_view.pageAction(QtWebKit.QWebPage.Back))
toolBar.addAction(self.fast_view.pageAction(QtWebKit.QWebPage.Forward))
toolBar.addAction(self.fast_view.pageAction(QtWebKit.QWebPage.Reload))
toolBar.addAction(self.fast_view.pageAction(QtWebKit.QWebPage.Stop))
toolBar.addWidget(self.locationEdit)
# Menu bar
viewMenu = self.menuBar().addMenu("&View")
viewSourceAction = QtGui.QAction("Page Source", self)
viewSourceAction.triggered.connect(self.viewSource)
viewMenu.addAction(viewSourceAction)
# Button
buttonMenu = self.menuBar().addMenu("&Open Infographic")
openAction = QtGui.QAction("Open", self)
openAction.triggered.connect(self.openInfographic)
buttonMenu.addAction(openAction)
viewCaptureAction = QtGui.QAction("Capture", self)
viewCaptureAction.triggered.connect(self.initGrab)
buttonMenu.addAction(viewCaptureAction)
#
effectMenu = self.menuBar().addMenu("&Effect")
effectMenu.addAction("Highlight all links", self.highlightAllLinks)
self.rotateAction = QtGui.QAction(self.style().standardIcon(
QtGui.QStyle.SP_FileDialogDetailedView),
"Turn images upside down",
self,
checkable=True,
toggled=self.rotateImages)
effectMenu.addAction(self.rotateAction)
toolsMenu = self.menuBar().addMenu("&Tools")
toolsMenu.addAction("Remove GIF images", self.removeGifImages)
toolsMenu.addAction("Remove all inline frames",
self.removeInlineFrames)
toolsMenu.addAction("Remove all object elements",
self.removeObjectElements)
toolsMenu.addAction("Remove all embedded elements",
self.removeEmbeddedElements)
self.setCentralWidget(self.view)
self.setUnifiedTitleAndToolBarOnMac(True)
class MainWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self)
self.fullScreen = False
self.setGeometry(50, 50, 800, 600)
self.setWindowTitle("ilastik " + str(ILASTIK_VERSION))
self.setWindowIcon(QtGui.QIcon(ilastikIcons.Ilastik))
self.activeImageLock = threading.Semaphore(
1) #prevent chaning of _activeImageNumber during thread stuff
self.previousTabText = ""
self.labelWidget = None
self._activeImageNumber = 0
self._activeImage = None
self.createRibbons()
self.initImageWindows()
self.createFeatures()
self.classificationProcess = None
self.classificationOnline = None
self.featureCache = None
self.opengl = None
project = None
overlaysToLoad = []
try:
opts, args = getopt.getopt(sys.argv[1:], "", [
"help", "render=", "project=", "featureCache=",
"load-overlays="
])
for o, a in opts:
if o == "-v":
verbose = True
elif o in ("--help"):
print '%30s %s' % ("--help",
"print help on command line options")
print '%30s %s' % ("--render=[s,s_gl,gl_gl]",
"chose slice renderer:")
print '%30s %s' % ("s", "software without 3d overview")
print '%30s %s' % ("s_gl",
"software with opengl 3d overview")
print '%30s %s' % ("gl_gl",
"opengl with opengl 3d overview")
print '%30s %s' % ("--project=[filename]",
"open specified project file")
print '%30s %s' % (
"--featureCache=[filename]",
"use specified file for caching of features")
print '%30s %s' % (
"--load-overlays=[filename,filename...]",
"load additional overlays from these files")
elif o in ("--render"):
if a == 's':
self.opengl = False
self.openglOverview = False
elif a == 's_gl':
self.opengl = False
self.openglOverview = True
elif a == 'gl_gl':
self.opengl = True
self.openglOverview = True
else:
print "invalid --render option"
sys.exit()
elif o in ("--project"):
project = a
elif o in ("--featureCache"):
self.featureCache = h5py.File(a, 'w')
elif o in ("--load-overlays"):
keys = [x[0] for x in opts]
if not "--project" in keys:
raise RuntimeError(
"--load-overlays options is only allowed if --project is passed, too"
)
overlaysToLoad = a.split(',')
else:
assert False, "unhandled option"
except getopt.GetoptError, err:
# print help information and exit:
print str(
err) # will print something like "option -a not recognized"
if self.opengl == None: #no command line option for opengl was given, ask user interactively
dlg = RenderChoiceDialog()
dlg.exec_()
self.opengl = False
self.openglOverview = False
if dlg.openglChoice.isChecked():
self.opengl = True
self.openglOverview = True
elif dlg.softwareChoice.isChecked():
self.opengl = False
self.openglOverview = True
else:
raise RuntimeError("Unhandled choice in dialog")
print "* OpenGL:"
print " - Using OpenGL for slice views:", self.opengl
print " - Using OpenGL for 3D view: ", self.openglOverview
#if we have OpenGL, a shared QGLWidget is set up,
self.sharedOpenGLWidget = None
if self.opengl:
self.sharedOpenGLWidget = QtOpenGL.QGLWidget()
self.project = None
if project != None:
self.ribbon.getTab('Project').openProject(project)
#switch to the "classification" tab
self.ribbon.getTab(
'Classification').btnClassifierOptions.setEnabled(True)
self._activeImageNumber = 0
self.projectModified()
#in case the user has specified some additional overlays to load from a file, do that
for overlayFilename in overlaysToLoad:
print "loading overlay '%s'" % (overlayFilename)
dataItem = self.labelWidget.ilastik.project.dataMgr[
self.labelWidget.ilastik._activeImageNumber]
ov = DataImpex.importOverlay(dataItem, overlayFilename)
dataItem.overlayMgr[ov.key] = ov
self.shortcutSave = QtGui.QShortcut(QtGui.QKeySequence("Ctrl+S"), self,
self.saveProject, self.saveProject)
self.shortcutFullscreen = QtGui.QShortcut(
QtGui.QKeySequence("Ctrl+Shift+F"), self, self.showFullscreen,
self.showFullscreen)
self.tabChanged(0)
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(720, 720)
self.centralWidget = QtGui.QWidget(MainWindow)
self.centralWidget.setObjectName(_fromUtf8("centralWidget"))
#self.left_img = QtGui.QLabel(self.centralWidget)
#self.left_img.setGeometry(QtCore.QRect(20, 20, 320, 320))
#self.left_img.setText(_fromUtf8(""))
#self.left_img.setTextFormat(QtCore.Qt.AutoText)
#self.left_img.setObjectName(_fromUtf8("left_img"))
self.right_img = QtGui.QLabel(self.centralWidget)
self.right_img.setGeometry(QtCore.QRect(360, 20, 320, 320))
self.right_img.setText(_fromUtf8(""))
self.right_img.setTextFormat(QtCore.Qt.AutoText)
self.right_img.setObjectName(_fromUtf8("right_img"))
self.left_label = QtGui.QLabel(self.centralWidget)
self.left_label.setGeometry(QtCore.QRect(120, 350, 101, 31))
self.left_label.setObjectName(_fromUtf8("left_label"))
self.left_graphicsView = QtGui.QGraphicsView(self.centralWidget)
self.left_graphicsView.setGeometry(QtCore.QRect(20, 20, 320, 320))
self.left_graphicsView.setObjectName(_fromUtf8("left_graphicsView"))
self.left_graphicsView.setViewport(QtOpenGL.QGLWidget())
self.scene = QtGui.QGraphicsScene()
self.scene.setSceneRect(0, 0, 320, 320)
self.left_img = self.scene.addPixmap(QtGui.QPixmap(320, 320))
self.left_graphicsView.setScene(self.scene)
# self.left_img = GLWidget(self.centalWidget)
# self.left_img.setGeometry(QtCore.QRect(20, 20, 320, 320))
# self.left_img.setObjectName(_fromUft8("left_img"))
self.right_label = QtGui.QLabel(self.centralWidget)
self.right_label.setGeometry(QtCore.QRect(480, 350, 111, 31))
self.right_label.setObjectName(_fromUtf8("right_label"))
self.velocity_label = QtGui.QLabel(self.centralWidget)
self.velocity_label.setGeometry(QtCore.QRect(70, 440, 67, 17))
self.velocity_label.setObjectName(_fromUtf8("velocity_label"))
self.gear_label = QtGui.QLabel(self.centralWidget)
self.gear_label.setGeometry(QtCore.QRect(70, 520, 67, 17))
self.gear_label.setObjectName(_fromUtf8("gear_label"))
self.gear_textEdit = QtGui.QTextEdit(self.centralWidget)
self.gear_textEdit.setGeometry(QtCore.QRect(140, 520, 120, 31))
self.gear_textEdit.setReadOnly(True)
self.gear_textEdit.setObjectName(_fromUtf8("gear_textEdit"))
self.brake_label = QtGui.QLabel(self.centralWidget)
self.brake_label.setGeometry(QtCore.QRect(290, 440, 101, 17))
self.brake_label.setObjectName(_fromUtf8("brake_label"))
self.throttle_label = QtGui.QLabel(self.centralWidget)
self.throttle_label.setGeometry(QtCore.QRect(290, 480, 111, 17))
self.throttle_label.setObjectName(_fromUtf8("throttle_label"))
self.angle_label = QtGui.QLabel(self.centralWidget)
self.angle_label.setGeometry(QtCore.QRect(70, 480, 67, 17))
self.angle_label.setObjectName(_fromUtf8("angle_label"))
self.brake_textEdit = QtGui.QTextEdit(self.centralWidget)
self.brake_textEdit.setGeometry(QtCore.QRect(400, 430, 140, 31))
self.brake_textEdit.setReadOnly(True)
self.brake_textEdit.setObjectName(_fromUtf8("brake_textEdit"))
self.throttle_textEdit = QtGui.QTextEdit(self.centralWidget)
self.throttle_textEdit.setGeometry(QtCore.QRect(400, 470, 140, 31))
self.throttle_textEdit.setReadOnly(True)
self.throttle_textEdit.setObjectName(_fromUtf8("throttle_textEdit"))
self.angle_textEdit = QtGui.QTextEdit(self.centralWidget)
self.angle_textEdit.setGeometry(QtCore.QRect(140, 470, 140, 31))
self.angle_textEdit.setReadOnly(True)
self.angle_textEdit.setObjectName(_fromUtf8("angle_textEdit"))
self.velocity_textEdit = QtGui.QTextEdit(self.centralWidget)
self.velocity_textEdit.setGeometry(QtCore.QRect(140, 430, 140, 31))
self.velocity_textEdit.setReadOnly(True)
self.velocity_textEdit.setObjectName(_fromUtf8("velocity_textEdit"))
MainWindow.setCentralWidget(self.centralWidget)
self.menuBar = QtGui.QMenuBar(MainWindow)
self.menuBar.setGeometry(QtCore.QRect(0, 0, 720, 22))
self.menuBar.setObjectName(_fromUtf8("menuBar"))
MainWindow.setMenuBar(self.menuBar)
self.mainToolBar = QtGui.QToolBar(MainWindow)
self.mainToolBar.setObjectName(_fromUtf8("mainToolBar"))
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)
self.statusBar = QtGui.QStatusBar(MainWindow)
self.statusBar.setObjectName(_fromUtf8("statusBar"))
MainWindow.setStatusBar(self.statusBar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def __init__(self, parent=None, useOpenGL=True):
"""Re-implementation of QGraphicsView that removes scrollbars and allows unambiguous control of the
viewed coordinate range. Also automatically creates a QGraphicsScene and a central QGraphicsWidget
that is automatically scaled to the full view geometry.
By default, the view coordinate system matches the widget's pixel coordinates and
automatically updates when the view is resized. This can be overridden by setting
autoPixelRange=False. The exact visible range can be set with setRange().
The view can be panned using the middle mouse button and scaled using the right mouse button if
enabled via enableMouse()."""
self.closed = False
QtGui.QGraphicsView.__init__(self, parent)
if useOpenGL:
v = QtOpenGL.QGLWidget(
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))
else:
v = QtGui.QWidget()
self.setViewport(v)
# palette = QtGui.QPalette()
# brush = QtGui.QBrush(QtGui.QColor(0,0,0))
# brush.setStyle(QtCore.Qt.SolidPattern)
# palette.setBrush(QtGui.QPalette.Active,QtGui.QPalette.Base,brush)
# brush = QtGui.QBrush(QtGui.QColor(0,0,0))
# brush.setStyle(QtCore.Qt.SolidPattern)
# palette.setBrush(QtGui.QPalette.Inactive,QtGui.QPalette.Base,brush)
# brush = QtGui.QBrush(QtGui.QColor(244,244,244))
# brush.setStyle(QtCore.Qt.SolidPattern)
# palette.setBrush(QtGui.QPalette.Disabled,QtGui.QPalette.Base,brush)
# self.setPalette(palette)
self.setRenderHints(QtGui.QPainter.SmoothPixmapTransform
) # | QtGui.QPainter.Antialiasing)
self.setBackgroundBrush(QtGui.QBrush(QtGui.QColor('white')))
#self.setProperty("cursor",QtCore.QVariant(QtCore.Qt.ArrowCursor))
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setFrameShape(QtGui.QFrame.NoFrame)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setTransformationAnchor(QtGui.QGraphicsView.NoAnchor)
self.setResizeAnchor(QtGui.QGraphicsView.AnchorViewCenter)
#self.setResizeAnchor(QtGui.QGraphicsView.NoAnchor)
self.setViewportUpdateMode(QtGui.QGraphicsView.SmartViewportUpdate)
#self.setSceneRect(QtCore.QRectF(-1e10, -1e10, 2e10, 2e10))
self.setSceneRect(
1, 1, 0, 0
) ## Set an empty (but non-zero) scene rect so that the view doesn't try to automatically update for us.
#self.setInteractive(False)
self.lockedViewports = []
self.lastMousePos = None
#self.setMouseTracking(False)
self.aspectLocked = False
self.yInverted = True
self.range = QtCore.QRectF(0, 0, 1, 1)
self.autoPixelRange = False #True
self.currentItem = None
self.clearMouse()
self.updateMatrix()
self.sceneObj = QtGui.QGraphicsScene()
self.setScene(self.sceneObj)
## by default we set up a central widget with a grid layout.
## this can be replaced if needed.
self.centralWidget = None
self.setCentralItem(QtGui.QGraphicsWidget())
self.centralLayout = QtGui.QGraphicsGridLayout()
self.centralWidget.setLayout(self.centralLayout)
self.mouseEnabled = False
self.scaleCenter = False ## should scaling center around view center (True) or mouse click (False)
self.clickAccepted = False
