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,
viewport,
viewportMngr,
vpType,
prototypeMngr,
parent=None):
""" Initialization of the CompositionView class
Parameters:
viewportMngr - the manager of the viewports where the composition
view can reside in
prototypeMngr - the manager of the prototypes is used to obtain
the results of the solver
"""
QtWidgets.QDialog.__init__(self, parent)
self.prototypeManager = prototypeMngr
self.viewport = viewport
self.viewportManager = viewportMngr
self.settings = Settings()
self.setWindowFlags(QtCore.Qt.Window)
self.timer = QtCore.QObject()
# QtCore.qsrand(QtCore.QTime(0,0,0).secsTo(QtCore.QTime.currentTime()))
self.tree = Tree(None)
self.infoOverlay = CVInfoOverlay(self)
self.connections = []
self.ui = Ui_compositionView()
self.ui.setupUi(self)
self.ui.graphicsView.setupViewport(
QtOpenGL.QGLWidget(
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers
| QtOpenGL.QGL.DoubleBuffer)))
# self.ui.graphicsView.setViewport(QtGui.QWidget())
self.ui.graphicsView.setRenderHints(
QtGui.QPainter.Antialiasing | QtGui.QPainter.SmoothPixmapTransform)
self.collapsed = False
self.currentTool = None
self.viewportType = vpType
self.first = False
self.nodeId = 0
self.overConstrainedColor = QtGui.QColor(0, 0, 255)
self.underConstrainedColor = QtGui.QColor(255, 0, 0)
self.wellConstrainedColor = QtGui.QColor(0, 255, 0)
self.unsolvedColor = QtGui.QColor(125, 124, 255)
self.setScene()
self.createTriggers()
def __init__(self, parent):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSampleBuffers(True)
super().__init__(fmt, parent)
timer = QTimer(parent)
timer.timeout.connect(self.updateGL)
timer.start(0)
self.drawingElements = []
self.dt = 0.1
self.dx = 0
self.dy = 0
self.ds = 1
self.x = 0
self.y = 0
self.draw = True
self.camera = Camera()
self.isClick = False
def __init__(self, parent=None):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSampleBuffers(True)
self.timer = QtCore.QElapsedTimer()
super().__init__(fmt, parent=parent)
def __init__(self, parent):
QtWidgets.QGraphicsView.__init__(self, parent)
self.setObjectName("network_widget")
self.scene = NodeFlowScene(self)
self.setScene(self.scene)
self.setMouseTracking(True)
self.setInteractive(True)
## No need to see scroll bars in flow editor
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
format = QtOpenGL.QGLFormat.defaultFormat()
format.setSampleBuffers(True)
format.setSamples(16)
self.setViewport(
QtOpenGL.QGLWidget(format)) # Force OpenGL rendering mode.
self.setViewportUpdateMode(QtWidgets.QGraphicsView.FullViewportUpdate)
self.setDragMode(QtWidgets.QGraphicsView.RubberBandDrag)
## As a debug we always set new panel widget to "/"
self.setNetworkLevel("/img")
## Connect panel signals
self.parent().signals.copperNodeCreated[str].connect(
self.copperNodeCreated)
self.parent().signals.copperNodeSelected[str].connect(
self.copperNodeSelected)
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))
GLWidget.sharedWidget = hiddenWindow
hiddenWindow.makeCurrent()
return GLWidget.sharedWidget
def __init__(self,parent=None,shareWidget=None,flags=QtCore.Qt.WindowFlags(0)):
display_format = QtOpenGL.QGLFormat()
display_format.setVersion(3,3)
display_format.setProfile(QtOpenGL.QGLFormat.CoreProfile)
display_format.setAlpha(True)
display_format.setStencil(False)
display_format.setSampleBuffers(True)
display_format.setSamples(4)
super().__init__(display_format,parent,shareWidget,flags)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.model = None
self.animation = None
self.z_near = 25
self.z_far = 12800
self.fov = 22.5
self.view_position = numpy.array([0,0,1000],numpy.float32)
self.view_rotation = Quarternion(1,0,0,0)
self.movement_speed = 10
self.rotation_speed = 1
self.fps = 30
self.z_near_changed.connect(self.on_z_near_changed)
self.z_far_changed.connect(self.on_z_far_changed)
self.fov_changed.connect(self.on_fov_changed)
self.animation_timer = QtCore.QTimer(self)
self.animation_timer.timeout.connect(self.on_animation_timer_timeout)
self.pressed_keys = set()
QtWidgets.qApp.aboutToQuit.connect(self.on_application_aboutToQuit)
def __init__(self, parent=None):
#-------------------------------
if ChartWidget == QtOpenGL.QGLWidget:
QtOpenGL.QGLWidget.__init__(
self, QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent)
else:
QtWidgets.QWidget.__init__(self, parent)
self.setPalette(
QtGui.QPalette(QtGui.QColor('black'), QtGui.QColor('white')))
self.setMouseTracking(True)
self._id = None
self._plots = {} # id --> index in plotlist
self._plotlist = [] # [id, visible, plot] triples as a list
self._timezoom = 1.0
self._markers = [] # List of [xpos, time] pairs
self._marker = -1 # Index of marker being dragged
self._selectstart = None
self._selectend = None
self._selecting = False
self._selectmove = None
self._mousebutton = None
self._annotations = collections.OrderedDict(
) # id --> to tuple(start, end, text, tags, editable)
self._annrects = [] # List of tuple(rect, id)
self.semantic_tags = {}
def make_qt_format(cls, vsync=True):
"""
Initializes the Qt OpenGL format.
:param vsync: If True, use VSYNC, otherwise update as fast as possible
"""
# create format with default settings
format = QtOpenGL.QGLFormat()
# use OpenGL 3.3
format.setVersion(3, 3)
format.setProfile(QtOpenGL.QGLFormat.CoreProfile)
# use VSYNC
if vsync:
format.setSwapInterval(1)
else:
format.setSwapInterval(0)
# TODO: determine what these lines do and whether they are necessary
format.setSampleBuffers(True)
format.setDepthBufferSize(24)
# needed to enable transparency
format.setAlpha(True)
return format
def __init__(self, size, title):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(
3, 3
) # Минимальная версия OpenGL. Берем 3.3 так как ничего сложного не делаем.
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSwapInterval(
1) # Синхронизировать смену кадра с разверткой монитора
fmt.setSampleBuffers(
True
) # Использовать мальтисемплинг для сглаживания границ обьектов.
fmt.setDepthBufferSize(
24
) # Не важно, буфеп глубины для двумерной графики вообще не нужен
super(ExampleWindow, self).__init__(fmt, None)
self.resize(size[0], size[1])
self.move(QtWidgets.QDesktopWidget().rect().center() -
self.rect().center())
self.setWindowTitle(title)
self.start_time = time.clock()
self.example = lambda: None
self.ex = None
self.wnd = WindowInfo()
self.time_mark = time.time()
def __init__(self):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
super().__init__(fmt, None)
pts = np.random.rand(2, 100000).astype(np.float32) * 20 - 10
self.x, self.y = pts
def __init__(self, parent, color):
super(GLWidget,
self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers),
parent)
self.parent = parent
self.color = np.array(color) #MFC,MTD
self.scalexy = 0.010
self.scalez = 0.010
self.show = [True, True, False, False, False, False,
True] #MFC, MTD, DAT, DEP, CLIP, APART, BACK
self.depth = [0.0, 0.0, 1 / 40.0] #start, stop, step
self.data = None
self.tools = []
self.rotation = [-45, -45, 0] #X,Y,Z
self.data_idx = 0
idxs = []
for i in range(DISP_LEN - 1):
for j in range(W_INTERP):
idxs.append((i * W_INTERP + j, i * W_INTERP + j + W_INTERP))
idxs.append((i * W_INTERP, i * W_INTERP + W_INTERP))
self.idxs = np.array(idxs).reshape(
2 * (W_INTERP + 1) *
(DISP_LEN - 1)) #glDrawElements(vector indices)
z = np.linspace(DISP_LEN / 2, -DISP_LEN / 2.0, DISP_LEN)
self.verts_z = np.repeat(z, W_INTERP).reshape(
DISP_LEN * W_INTERP, 1) #glDrawElements(vector(x,y,Z))
def __init__(self, size, title, args):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSwapInterval(1)
fmt.setSampleBuffers(True)
fmt.setDepthBufferSize(24)
super(GLWindow, self).__init__(fmt, None)
self.setFixedSize(size[0], size[1])
self.move(QtWidgets.QDesktopWidget().rect().center() -
self.rect().center())
self.setWindowTitle(title)
self.start_time = time.clock()
self.example = lambda: None
self.ex = None
self.wnd = WindowInfo()
self.wnd.viewport = (0, 0) + (size[0] * self.devicePixelRatio(),
size[1] * self.devicePixelRatio())
self.wnd.ratio = size[0] / size[1]
self.wnd.size = size
self.args = args
def __init__(self):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSampleBuffers(True)
self.timer = QtCore.QElapsedTimer()
super(QGLControllerWidget, self).__init__(fmt, None)
def __init__(self,
render_class,
off_file,
size=(512, 512),
title="off_render"):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSwapInterval(1)
fmt.setSampleBuffers(True)
fmt.setDepthBufferSize(24)
super(RenderWindow, self).__init__(fmt, None)
self.setFixedSize(size[0], size[1])
self.move(QtWidgets.QDesktopWidget().rect().center() -
self.rect().center())
self.setWindowTitle(title)
self.model = ol.load_off(off_file)
self.start_time = time.time()
self.render_class = render_class
self.render = None
self.wnd = WindowInfo()
self.wnd.viewport = (0, 0) + size
self.wnd.ratio = size[0] / size[1]
self.wnd.size = size
def __init__(self, parent=None):
# Говорим Qt выбрать OpenGL 3.3 core
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSampleBuffers(True)
super().__init__(fmt, parent)
self.setMouseTracking(True)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.camera = Camera()
self.light = Light(pr.Vector3([0.0, 0.0, -10.0]),
pr.Vector3([1.0, 1.0, 1.0]))
self.reflectivity: float = 0.5
self.colorFactor: float = 1.0 # Общий коофицент цвета
self.figure = None
# Обьект, отвечающий за автоматические операции над кубиком
self.figureAlgorithms = CubeAlgorithms()
# Харакетеристики мыши
self.previousMousePos = [0, 0]
self.mouseButtons = {}
# Функция, вызываемая при смене позиции камеры, тк в основном окне есть соответствующие слайдеры
self.cameraCallback = lambda x, y: None
# Время последнего обновления (отрисовки)
self.lastTime = time.time()
def _shader_from_file(self, fname_vert, fname_frag):
shader = QtOpenGL.QGLShaderProgram()
shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, fname_vert)
shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Fragment, fname_frag)
shader.link()
shader.bind()
logger.debug("GLSL program log:%s", shader.log())
return shader
def __init__(self):
super(moView, self).__init__()
self.move(20, 20)
self.resize(930, 600)
self.setMinimumSize(930, 500)
self.setWindowTitle("color manager")
sc = moScene()
self.setScene(sc)
self.scene().setSceneRect(0, 0, 930, 600)
widget = QtOpenGL.QGLWidget(
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers | QtOpenGL.QGL.Rgba))
widget.makeCurrent()
self.setViewport(widget)
self.setViewportUpdateMode(QtWidgets.QGraphicsView.FullViewportUpdate)
self.setFrameStyle(QtWidgets.QFrame.NoFrame)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
def __init__(self, major=4, minor=4):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(major, minor)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSampleBuffers(True)
self.timer = QtCore.QElapsedTimer()
super(_window, self).__init__(fmt, None)
self.paintGL = None
def __init__(self, parent, controller):
qglFormat = QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers)
#qglFormat.setVersion(3, 3)
#qglFormat.setVersion(3, 2)
#qglFormat.setVersion(3, 1)
qglFormat.setVersion(4, 0)
qglFormat.setProfile(QtOpenGL.QGLFormat.CoreProfile)
QtOpenGL.QGLWidget.__init__(self, qglFormat, parent)
self.controller = controller
def __init__(self):
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
super().__init__(fmt, None)
self.mouse = (0,0)
self.mouseDrag = False
self.eye = (20,0,20)
self.ctx = None
def __init__(self, sex, parent=None):
self.Gender = sex
self.lastPos = QPoint()
fmt = QtOpenGL.QGLFormat()
fmt.setVersion(4, 3)
fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
fmt.setSampleBuffers(True)
super(GLWidget, self).__init__(fmt, parent)
def changeViewport(self, viewportName):
if self.name == viewportName:
return
else:
tool = self.glViewport.currentTool
self.glViewport.close()
if viewportName == "Top":
self.glViewport = GLViewport(
self, ViewportType.TOP, None,
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))
elif viewportName == "Side":
self.glViewport = GLViewport(
self, ViewportType.SIDE, None,
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))
elif viewportName == "Front":
self.glViewport = GLViewport(
self, ViewportType.FRONT, None,
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))
elif viewportName == "Perspective":
self.glViewport = GLViewport(
self, ViewportType.PERSPECTIVE, None,
QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))
elif viewportName == "Decomposition":
self.glViewport = CompositionView(
self, self.viewportManager, ViewportType.DECOMPOSITION,
PrototypeManager(
)) # self.getMainWindow().compositionView #
elif viewportName == "Solution":
self.solutionView = SolutionView(self.getMainWindow(),
self.viewportManager,
ViewportType.SOLUTION,
PrototypeManager(), True)
self.glViewport = self.solutionView.solutionWidget
self.setActions()
for action in self.editGroup.actions():
action.setChecked(False)
self.splitterVertical.addWidget(self.glViewport)
self.setName(self.glViewport.viewportType)
self.glViewport.currentTool = tool
if self.glViewport.viewportType != ViewportType.DECOMPOSITION:
self.glViewport.makeCurrent()
def __init__(self, parent, app):
self.app = app
self.blockRedraw = False
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 = None): super(GLCanvas, self).__init__(parent) fmt = QtOpenGL.QGLFormat() fmt.setVersion(4, 3) fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile) fmt.setSampleBuffers(True) self.setFixedSize(context['width'], context['height']) self.widget = QGLControllerWidget(fmt) self.setCentralWidget(self.widget) self.show()
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):
super(TestWindow, self).__init__(parent)
glformat = QtOpenGL.QGLFormat()
glformat.setVersion(4, 5)
glformat.setProfile(QtOpenGL.QGLFormat.CoreProfile)
glformat.setSampleBuffers(True)
self.widget = GLPlotWidget(glformat)
self.setGeometry(100, 100, self.widget.width, self.widget.height)
self.setCentralWidget(self.widget)
self.setWindowTitle('sb02a')
self.show()
def __init__(self, window):
self.activeViewport = None
self.mainWindow = window
self.viewportList = []
self.viewport = None
self.splitterVertical = QtWidgets.QSplitter()
self.frmt = QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers)
# self.frmt.setDoubleBuffer(True)
# self.frmt.setOverlay(True)
self.displayViewport = DisplayViewport.ALL
self.mouseActiveAction = None
def set_configuration(config):
global __glformat__
# WARNING: does not work on osx
# http://stackoverflow.com/questions/...
# ...7868882/enabling-opengl-core-profile-in-qt4-on-os-x
__glformat__ = QtOpenGL.QGLFormat()
__glformat__.setSwapInterval(0)
__glformat__.setRedBufferSize(config.red_size)
__glformat__.setGreenBufferSize(config.green_size)
__glformat__.setBlueBufferSize(config.blue_size)
__glformat__.setAlphaBufferSize(config.alpha_size)
__glformat__.setAccum(False)
__glformat__.setRgba(True)
if config.double_buffer:
__glformat__.setDoubleBuffer(True)
else:
__glformat__.setDoubleBuffer(False)
if config.depth_size:
__glformat__.setDepth(True)
__glformat__.setDepthBufferSize(config.depth_size)
else:
__glformat__.setDepth(False)
__glformat__.setDepthBufferSize(0)
if config.stencil_size:
__glformat__.setStencil(True)
__glformat__.setStencilBufferSize(config.stencil_size)
else:
__glformat__.setStencil(False)
__glformat__.setStencilBufferSize(0)
if config.samples:
__glformat__.setSampleBuffers(True)
__glformat__.setSamples(config.samples)
else:
__glformat__.setSampleBuffers(False)
__glformat__.setSamples(0)
__glformat__.setStereo(config.stereo)
__glformat__.setVersion(config.major_version, config.minor_version)
if config.major_version >= 3 and config.profile == "core":
__glformat__.setProfile(__glformat__.CoreProfile)
elif config.major_version >= 3 and config.profile == "compatibility":
__glformat__.setProfile(__glformat__.CompatibilityProfile)
else:
__glformat__.setProfile(__glformat__.NoProfile)
def __init__(self, world, camera):
"""
Main Class for managing the Visualization / OpenGL Programs / Visualization data
:param world: the world class
:param camera: a camera for the visualization
"""
self.fmt = QtOpenGL.QGLFormat()
self.fmt.setVersion(3, 3)
self.fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile)
self.fmt.setSampleBuffers(True)
self.fmt.setSamples(4)
super(OGLWidget, self).__init__(self.fmt)
self.info_frame = MatterInfoFrame()
self.info_frame.setParent(self)
self.info_frame.hide()
self.world = world
self.setMouseTracking(True)
self.drag_state = False
self.show_center = world.config_data.show_center
self.show_focus = world.config_data.show_focus
self.keyPressEventHandler = None
self.ctrl = False
self._show_info_frame = True
self._enable_cursor = True
self.last_position = []
self.mouse_pos = [0, 0]
self.drag_sensitivity = 1000
self.rotation_sensitivity = 5
self.zoom_sensitivity = 100
self.cursor_zoom_sensitivity = 200
self.cursor_type = MatterType.ITEM
self.added_matter_color = (1.0, 0.0, 0.0, 1.0)
self.camera = camera
# on init the background will be set from this variable, later on only by the setter
self.background = world.config_data.background_color
# programs, program flags and dynamic data
self.programs = {}
self.agent_offset_data = {}
self.agent_update_flag = False
self.item_offset_data = {}
self.item_update_flag = False
self.location_offset_data = {}
self.location_update_flag = False
