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):
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 __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, 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, *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, 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, 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):
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,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 __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 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 __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):
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, 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, 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, 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 __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 initializeViewer(self):
fmt = QtOpenGL.QGLFormat()
fmt.setAlpha(True)
QtOpenGL.QGLFormat.setDefaultFormat(fmt)
self.rotor = self.buildRotor()
hints = coin.SoShapeHints()
hints.vertexOrdering = coin.SoShapeHints.COUNTERCLOCKWISE
hints.shapeType = coin.SoShapeHints.SOLID
hints.faceType = coin.SoShapeHints.CONVEX
self.root.addChild(self.rotor)
self.root.addChild(hints)
def __init__(self, parent):
super(GLWidget, self).__init__(qtgl.QGLFormat(qtgl.QGL.SampleBuffers),
parent)
self.listObj = []
self.colorRed = qt.QColor.fromCmykF(1, 0, 0, 0)
self.colorGreen = qt.QColor.fromCmykF(0, 1, 0, 0)
self.colorBlue = qt.QColor.fromCmykF(0, 0, 1, 0)
self.colorYellow = qt.QColor.fromCmykF(1, 1, 0, 0)
self.colorGrey = qt.QColor.fromCmykF(0.5, 0.5, 0.5, 0)
self.colorBlack = qt.QColor.fromCmykF(0, 0, 0, 0)
self.colorWhite = qt.QColor.fromCmykF(1.0, 1.0, 1.0, 0.0)
def __init__(self, parent=None):
QtOpenGL.QGLWidget.__init__(
self, QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent)
self.commands = []
self.quad = numpy.array(
[[-1., 1., 0], [1., 1., 0], [1., -1., 0], [-1., -1, 0]], dtype="f")
self.minx = self.miny = self.minz = 0
self.maxx = self.maxy = self.maxz = 0
self.b_box = [0, 0, 0], [0, 0, 0]
self.camera = numpy.array([0, 0, 0])
self.center = numpy.array([2, 0, 0])
def __init__(self, parent=None, **option):
fmt = QtOpenGL.QGLFormat()
fmt.setRgba(True)
fmt.setAlpha(True)
fmt.setDepth(True)
fmt.setDoubleBuffer(False)
if option.get('vsync', False):
fmt.setSwapInterval(1)
else:
fmt.setSwapInterval(0)
QtOpenGL.QGLWidget.__init__(self, fmt, parent,
GLWidget.getSharedWidget())
self.setFocusPolicy(QtCore.Qt.WheelFocus)
def __init__(self, parent=None):
QtOpenGL.QGLWidget.__init__(self, parent)
self.spw = self.parent().spykewindow
#self.setMouseTracking(True) # req'd for tooltips purely on mouse motion, slow
self.lastPos = QtCore.QPoint()
self.focus = np.float32([0, 0, 0]) # init camera focus
self.axes = 'both' # display both mini and focal xyz axes by default
self.selecting = None # True (selecting), False (deselecting), or None
self.collected_sids = []
self.update_sigmasqrtndims()
self.spw.ui.sigmaSpinBox.valueChanged.connect(self.update_focal_axes)
format = QtOpenGL.QGLFormat()
format.setDoubleBuffer(True) # req'd for picking
self.setFormat(format)
def __init__(self, parent=None):
super(GLWidget,
self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers),
parent)
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 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, parent, filename):
super(MeshWidget,
self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers),
parent)
self.setMinimumSize(640, 480)
self.count = 0
self.draw_bounding_box = self.draw_octree = False
self.draw_mesh = True
self.mesh = mesh.Mesh(3)
self.mesh.parse(filename)
self.setAutoBufferSwap(True)
self.initializeGL()
self.zoom = -self.mesh.bounding_box.minViewDistance()
self.enable_restrict = False
self.restricted = list(range(len(self.mesh.faces)))
self.point_draw = 1
def __init__(self, parent=None, fps=24, state=None):
"""
:param parent: parent Qt object
:param fps: frames per second (default 24)
:param state: GLState object (for shared states)
"""
self.camera = None
format = QtOpenGL.QGLFormat()
format.setDirectRendering(True)
format.setSampleBuffers(True)
self.state = state or GLState()
self.state.signal_state_change.connect(self.handle_state_change)
super(GLWidget, self).__init__(format, parent)
self.setAutoBufferSwap(True)
self.setMouseTracking(True)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setCursor(QtCore.Qt.OpenHandCursor)
# save the parent object
self._main = parent
# frames per second value
self.__time = 0
self.__frame = 0
self.__fps = fps
self.__playing = False
# various matrices and vectors
self.__bounds_default = imath.Box3d((-5, -5, -5), (5, 5, 5))
self.__bounds = None
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
# for animated scenes
self.timer = QtCore.QTimer(self)
# default camera
self.camera = GLCamera(self)
self.state.add_camera(self.camera)
self.frame()
