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 __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 initializeGL(self): self.makeObject() glEnable(GL_DEPTH_TEST) glEnable(GL_CULL_FACE) vshader = QtOpenGL.QGLShader(QtOpenGL.QGLShader.Vertex, self) vshader.compileSourceCode(self.vsrc) fshader = QtOpenGL.QGLShader(QtOpenGL.QGLShader.Fragment, self) fshader.compileSourceCode(self.fsrc) self.program = QtOpenGL.QGLShaderProgram(self) self.program.addShader(vshader) self.program.addShader(fshader) self.program.bindAttributeLocation('vertex', self.PROGRAM_VERTEX_ATTRIBUTE) self.program.bindAttributeLocation('texCoord', self.PROGRAM_TEXCOORD_ATTRIBUTE) self.program.link() self.program.bind() self.program.setUniformValue('texture', 0) self.program.enableAttributeArray(self.PROGRAM_VERTEX_ATTRIBUTE) self.program.enableAttributeArray(self.PROGRAM_TEXCOORD_ATTRIBUTE) self.program.setAttributeArray(self.PROGRAM_VERTEX_ATTRIBUTE, self.vertices) self.program.setAttributeArray(self.PROGRAM_TEXCOORD_ATTRIBUTE, self.texCoords)
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 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, app=None): super(GAUDInspectView, self).__init__() self.app = app self.setWindowIcon(QtGui.QIcon(':/logo.png')) self.glcontext = QtOpenGL.QGLContext(QtOpenGL.QGLFormat(), None) self.setAcceptDrops(True) self.initUI() self.show()
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): 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 draw_callback(self): if not hasattr(self, '_edge_shader'): self._edge_shader = QtOpenGL.QGLShaderProgram() self._edge_shader.addShaderFromSourceFile( QtOpenGL.QGLShader.Vertex, os.path.join(os.path.dirname(__file__), 'edge.vs')) self._edge_shader.addShaderFromSourceFile( QtOpenGL.QGLShader.Fragment, os.path.join(os.path.dirname(__file__), 'edge.fs')) self._edge_shader.bindAttributeLocation('position', 0) if not self._edge_shader.link(): print('Failed to link edge shader!') self._node_shader = QtOpenGL.QGLShaderProgram() self._node_shader.addShaderFromSourceFile( QtOpenGL.QGLShader.Vertex, os.path.join(os.path.dirname(__file__), 'node.vs')) self._node_shader.addShaderFromSourceFile( QtOpenGL.QGLShader.Fragment, os.path.join(os.path.dirname(__file__), 'node.fs')) self._node_shader.bindAttributeLocation('position', 0) self._node_shader.bindAttributeLocation('offset', 1) self._node_shader.bindAttributeLocation('color', 2) self._node_shader.bindAttributeLocation('selected_marked', 3) if not self._node_shader.link(): print('Failed to link node shader!') self._edge_shader.bind() self._edge_shader.setUniformValue('projection', self.plot.projection) self._edge_shader.setUniformValue('model', self.plot.model) self._edge_shader.setUniformValue('view', self.plot.view) self._edge_shader.setUniformValue('translation', self.plot.plot_translation) self._edge_shader.setUniformValue('scale', self.plot.plot_scale) orangeqt.Canvas3D.draw_edges(self) self._edge_shader.release() self._node_shader.bind() self._node_shader.setUniformValue('projection', self.plot.projection) self._node_shader.setUniformValue('model', self.plot.model) self._node_shader.setUniformValue('view', self.plot.view) self._node_shader.setUniformValue('translation', self.plot.plot_translation) self._node_shader.setUniformValue('scale', self.plot.plot_scale) self._node_shader.setUniformValue('mode', 0.) orangeqt.Canvas3D.draw_nodes(self) self._node_shader.release()
def __init__(self,application=None,winid=None,parent=None): fmt=QtOpenGL.QGLFormat() fmt.setDoubleBuffer(True); EMGLWidget.__init__(self, parent=parent, winid=winid) self.setFormat(fmt) self.setWindowIcon(QtGui.QIcon(get_image_directory() +"plot.png")) self.axes={} self.pparm={} # nbins,color,histtype,orient,align,alpha,width,norm,cumul,logy,stacked self.inspector=None self.needupd=1 self.plotimg=None self.shapes={} self.bins = {} self.edges = None self.xlimits=None self.ylimits=None self.rmousedrag=None self.axisparms=(None,None,"linear","linear") self.selected=[] self.comments={} # IF reading from a file which contains per-point comments, this dictionary contains a list of comments for each point self.data={} # List of Lists to plot self.visibility = {} # Same entries as in self.data, but entries are true or False to indicate visibility self.glflags = EMOpenGLFlagsAndTools() # supplies power of two texturing flags self.tex_name = 0 self.main_display_list = 0 self.resize(640,480) self.nbins = 10 # start with 10. user can modify via inspector. self.stacked = False #self.inspector.stacked.isChecked() self.normed=False #self.inspector.normed.isChecked() self.histtype="bar" #histtypes[self.inspector.histtype.currentIndex()] self.orientation="vertical" #orientations[self.inspector.orient.currentIndex()] self.alignment="edge" #alignments[self.inspector.align.currentIndex()] self.cumulative = False #self.inspector.cumulative.isChecked() self.logy = False #self.inspector.logtogy.isChecked()
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, 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 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, parent=None): super(GLWidget, self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent) midnight = QtCore.QTime(0, 0, 0) random.seed(midnight.secsTo(QtCore.QTime.currentTime())) self.object = 0 self.xRot = 0 self.yRot = 0 self.zRot = 0 self.image = QtGui.QImage() self.bubbles = [] self.lastPos = QtCore.QPoint() self.trolltechGreen = QtGui.QColor.fromCmykF(0.40, 0.0, 1.0, 0.0) self.trolltechPurple = QtGui.QColor.fromCmykF(0.39, 0.39, 0.0, 0.0) self.animationTimer = QtCore.QTimer() self.animationTimer.setSingleShot(False) self.animationTimer.timeout.connect(self.animate) self.animationTimer.start(25) self.setAutoFillBackground(False) self.setMinimumSize(200, 200) self.setWindowTitle("Overpainting a Scene")
def __init__(self, parent=None): format = QtOpenGL.QGLFormat() format.setSampleBuffers(True) QtOpenGL.QGLWidget.__init__(self, format, parent) self.setCursor(QtCore.Qt.OpenHandCursor) self.setMouseTracking(True) self.modelview_matrix_ = [] self.translate_vector_ = [0.0, 0.0, 0.0] self.viewport_matrix_ = [] self.projection_matrix_ = [] self.near_ = 0.1 self.far_ = 100.0 self.fovy_ = 45.0 self.radius_ = 5.0 self.last_point_2D_ = QtCore.QPoint() self.last_point_ok_ = False self.last_point_3D_ = [1.0, 0.0, 0.0] self.isInRotation_ = False self.mesh = "" self.edges = 0 self.nrelements = [] #self.glshaders = GLshaders() #glUseProgram(self.glshaders.program) self.direction = [0.0, 2.0, -1.0, 1.0] # Direction of light #self.direction = [100,0,1] # Direction of light self.intensity = [0.7, 0.7, 0.7, 1.0] # Intensity of light self.ambient_intensity = [0.3, 0.3, 0.3, 1.0] # Intensity of ambient light self.components = {}
def __init__(self, parent=None): super(GLWidget, self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent) self.arrInstances = numpy.ones((1, 720, 576, 3), dtype=numpy.float16) self.instances = [] #cv2.imshow("hello",a[0]) #cv2.waitKey() self.setMouseTracking(True) self.xRot = 0 self.yRot = 0 self.zRot = 0 self.gear1Rot = 2 self.zCam = 2000.0 self.xCam = 0.0 self.yCam = 0.0 ############################### self.frame = 0 #self.timer = QtCore.QTimer(self) self.timer = QtCore.QTimer(self) self.timer.timeout.connect(self.play) self.curFrameNumber = 0 #global falloffValue self.expValue = 1.0 self.gamma = 2.2 self.first = 0 self.last = 1 self.lastPos = QtCore.QPoint()
def __init__(self, parent=None, filepath=None): format = QtOpenGL.QGLFormat() format.setSampleBuffers(True) QtOpenGL.QGLWidget.__init__(self, format, parent) # draw toggles self.__drawGrid = True self.__drawNormals = False self.__drawBounds = False self.__drawHUD = False # various matrices and vectors self.__matrix = [] self.__translate = [0.0, 0.0, 0.0] self.__center = [0.0, 0.0, 0.0] self.__near = 0.1 self.__far = 100000.0 self.__fovy = 45.0 self.__radius = 5.0 self.__last_pok = False self.__last_p2d = QtCore.QPoint() self.__last_p3d = [1.0, 0.0, 0.0] self.__rotating = False # alembic scene params self.archive = None self.scene = None self.setMouseTracking(True) self.setCursor(QtCore.Qt.OpenHandCursor) self.openScene(filepath)
def __init__(self, video_engine, parent=None): # Set up to sync with double-buffer, vertical refresh. Add Alpha and Depth buffers. fmt = QtOpenGL.QGLFormat() fmt.setSwapInterval(2) fmt.setDoubleBuffer(True) fmt.setAlpha(True) fmt.setDepth(True) QtOpenGL.QGLWidget.__init__(self, fmt, parent) # set application settings self.settings = LuxSettings() # create a mutex for the state self.lock = QtCore.QMutex() # height and width of viewport self.width = 512 self.height = 512 # set dirty state self.dirty = True # start up an update timer self.timerId = self.startTimer(30) # whether GL is initialized self.initialized = False # Start the simulator audio client. Connects to JACK server, # which must be running. self.makeCurrent() self.video_engine = video_engine
def __init__(self, screen): # Explicitly ask for legacy OpenGL version to keep maximum compatibility across different operating systems fmt = QtOpenGL.QGLFormat() fmt.setVersion(2, 1) fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile) fmt.setSampleBuffers(True) super(GLRenderArea, self).__init__(fmt, parent = screen) self.setAutoFillBackground(False) self.setFocusPolicy(QtCore.Qt.ClickFocus) self.xRot = 0.0 self.yRot = 0.0 self.zRot = 0.0 self.xTrans = 0.0 self.yTrans = 0.0 self.zTrans = 0.0 self.lastPos = QtCore.QPoint() self.mouseMoved = False self.mousePickRectStart = False self.ctrlPressed = False self.shiftPressed = False self.mouseRect = [] self.autoCam = False self.ortho = False self.camName = '' self.cameraPos = (0, 0, -1) self.targetPos = (0, 0, 0) self.testVertexBuffer = [] self.testColorBuffer = [] # self.vw = 0 # self.vh = 0 self.camera = Camera() self.screen = screen self.programCompiled = False self.currentFrame = 0 self.frameData = None self.groups = [] self.selectedMarkers = set([]) self.selectedGroups = set([]) self.maskDraw = set([]) self.maskTraj = set([]) self.maskTag = set([]) self.colorDict = {} self.timer = QtCore.QTimer(self) self.timer.setInterval(10) self.timer.timeout.connect(self.updateTimer) self.timer.start()
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, parent=None, image=None,application=None,winid=None): EMImage3DWidget.allim[self] = 0 EMGLWidget.__init__(self,parent) EMLightsDrawer.__init__(self) EMGLProjectionViewMatrices.__init__(self) fmt=QtOpenGL.QGLFormat() fmt.setDoubleBuffer(True) fmt.setDepth(True) fmt.setStencil(True) fmt.setSampleBuffers(True) self.setFormat(fmt) self.aspect=1.0 self.fov = 50 # field of view angle used by gluPerspective self.d = 0 self.zwidth = 0 self.yheight = None self.data = None # should eventually be an EMData object # self.cam = Camera() self.cam = Camera2(self) self.cam.cam_z = -250 self.resize(480,480) self.startz = 1 self.endz = 500 self.currentselection = -1 self.inspector = None self.viewables = [] self.num_iso = 0 self.num_vol = 0 self.num_sli = 0 self.num_sym = 0 self.vdtools = EMViewportDepthTools(self) self.last_window_width = -1 # used for automatic resizing from the desktop self.last_window_height = -1 # used for automatic resizing from the desktop self.file_name = None self.emit_events = False self.perspective = False if image != None: self.set_data(image) #From get_qt_widget... if isinstance(self.data,EMData): self.set_cam_z_from_fov_image(self.get_fov(),self.data) self.qt_parent.setWindowIcon(QtGui.QIcon(get_image_directory() +"single_image_3d.png")) #End from get_qt_widget self.updateGL() #Solves "error, OpenGL seems not to be initialized" message
def __init__(self, parent, app): self.app = app format = QtOpenGL.QGLFormat() format.setAlpha(True) format.setDepthBufferSize(24) format.setSampleBuffers(True) format.setSamples(4) super(Canvas, self).__init__(format, parent) self.create()
def __init__(self, parent): super(GLWidget, self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent) self.list_ = [] self.startTimer(40) self.setWindowTitle("Sample Buffers")
def __init__(self, parent, width, height): super(DisplayWindow, self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent) self.width = width self.height = height self.setAutoFillBackground(False) self.setMinimumSize(self.width, self.height)
def __init__(self, helper, parent): super(GLWidget, self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent) self.helper = helper self.elapsed = 0 self.setFixedSize(200, 200) self.setAutoFillBackground(False)
def __init__(self, parent): fmt = QtOpenGL.QGLFormat() fmt.setSampleBuffers(True) # antialiasing QtOpenGL.QGLWidget.__init__(self, fmt, parent) self.setFixedSize(300, 300) self.setAutoFillBackground(False) self.textPen = QtGui.QPen(QtCore.Qt.white) self.textFont = QtGui.QFont() self.textFont.setPixelSize(50)
def __init__(self, parent=None, format=None): if format == None: format = QtOpenGL.QGLFormat() format.setVersion(3, 3) format.setProfile(QtOpenGL.QGLFormat.CoreProfile) #glformat.setSampleBuffers( True ) super(Scene3DQT, self).__init__(format, parent) self.MakeCurrent() self.V = viewer.Viewer3D() self._needs_update = False
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 __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)