def __init__(self, model, title = None):
super(GraphWidget, self).__init__()
self.timerId = 0
scene = QGraphicsScene(self)
scene.setItemIndexMethod(QtGui.QGraphicsScene.NoIndex)
scene.setSceneRect(-200, -200, 640, 400)
self.gscene = scene;
self.setScene(scene)
self.setCacheMode(QtGui.QGraphicsView.CacheBackground)
self.setViewportUpdateMode(QtGui.QGraphicsView.BoundingRectViewportUpdate)
self.setRenderHint(QtGui.QPainter.Antialiasing)
self.setTransformationAnchor(QtGui.QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QtGui.QGraphicsView.AnchorViewCenter)
self.model = model;
self.whitebrush = QBrush(Qt.white);
self.redbrush = QBrush(Qt.red)
self.drawNetwork(self.gscene, self.model);
#setttings of the window
self.scale(1.2,1.2);
self.setMinimumSize(640, 480);
if title == None:
self.setWindowTitle("Network Visualisation");
else:
self.setWindowTitle("Network Visualisation -" + title);
def __init__(self, tileSource, parent=None):
"""Constructor.
Args:
tileSource(MapTileSource): Source for loading the tiles.
parent(QObject): Parent object, default `None`
"""
QGraphicsScene.__init__(self)
self._zoom = 15
self._tileSource = tileSource
self._tileSource.setParent(self)
self._tileSource.tileReceived.connect(self.setTilePixmap)
tdim = self._tileSource.tileSize()
self._emptyTile = QPixmap(tdim, tdim)
self._emptyTile.fill(Qt.lightGray)
self._tilesRect = QRect()
self._tilePixmaps = {}
self._tileInDownload = list()
self.setSceneRect(0.0, 0.0, 400, 300)
self.sceneRectChanged.connect(self.onSceneRectChanged)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.scene = QGraphicsScene()
# Scene is the parent of the view in order to show the graphical items.
# the View must also be the parent of the scene in order to avoid
# bizarre segmentation faults with GTK
self.view = InteractiveView(self.scene)
self.scene.setParent(self.view)
self.setCentralWidget(self.view)
self.view.setSceneRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX)
self.view.centerOn(0, 0)
self.visualizer = Visualizer(self.scene)
self.visualizer.update_processes_data()
# Set a dark background color
back_color = QColor(25, 20, 45)
self.view.setBackgroundBrush(QBrush(back_color))
def keyPressEvent(self, event):
super(MainWindow, self).keyPressEvent(event)
# Quit via escape key.
if event.key() == Qt.Key_Escape:
self.close()
if event.key() == Qt.Key_R:
self.visualizer.showRootTasks = not self.visualizer.showRootTasks
class StartSelectView(QGraphicsView):
def __init__(self, *args):
QGraphicsView.__init__(self, *args)
self.move(2, 250)
self.btnSize = 28
self.setMaximumHeight(self.btnSize * 2)
self.setMaximumWidth(334)
self.setMinimumHeight(self.btnSize * 2)
self.setMinimumWidth(334)
self.adjustSize()
self.scene = QGraphicsScene(self)
self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;')
self.psButtons = QPixmap(os.getcwd() + '/../icons/controller-sprite.png')
self.select = self.psButtons.copy(696, 120, 45, 30)
self.select = self.select.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.selectItem = QGraphicsPixmapItem(self.select)
self.selectItem.setOffset(QPointF(0, 0))
self.scene.addItem(self.selectItem)
self.start = self.psButtons.copy(754, 120, 45, 30)
self.start = self.start.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.startItem = QGraphicsPixmapItem(self.start)
self.startItem.setOffset(QPointF(86, 0))
self.scene.addItem(self.startItem)
self.setScene(self.scene)
class Ventana(Ui_MainWindow, QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.actionOpenImgA.triggered.connect(self.cargarImgA)
self.actionOpenImgB.triggered.connect(self.cargarImgB)
self.actionOperate.triggered.connect(self.operar)
self.escenaA = QGraphicsScene()
self.imgA.setScene(self.escenaA)
self.escenaB = QGraphicsScene()
self.imgB.setScene(self.escenaB)
self.escenaC = QGraphicsScene()
self.imgC.setScene(self.escenaC)
self.operacion.addItem("suma")
self.operacion.addItem("multiplicacion")
self.operacion.addItem("promedio")
def cargarImgA(self):
self.imagenA = self.cargarImg(self.escenaA)
def cargarImgB(self):
self.imagenB = self.cargarImg(self.escenaB)
def cargarImg(self, escena):
ruta =QFileDialog.getOpenFileName(parent=self, caption="Archivo")
imagen = QImage()
imagen.load(ruta)
pixmap = QPixmap(imagen)
escena.addItem(QGraphicsPixmapItem(pixmap))
return imagen
def operar(self):
ancho = min(self.imagenA.width(), self.imagenB.width())
alto = min(self.imagenA.height(), self.imagenB.height())
oper = getattr(self,str(self.operacion.currentText()))
self.imagenC = QImage(ancho, alto, QImage.Format_RGB32 )
for i in range(ancho):
for j in range(alto):
pix = oper(self.imagenA.pixel(i,j), self.imagenB.pixel(i,j))
self.imagenC.setPixel(i, j, pix)
pixmap = QPixmap(self.imagenC)
self.escenaC.addItem(QGraphicsPixmapItem(pixmap))
def suma(self, pixA, pixB):
return pixA + pixB
def multiplicacion(self, pixA, pixB):
return pixA * pixB
def promedio(self, pixA, pixB):
return (pixA + pixB) / 2
def drawStationName(self):
"""Draw station name snippet to station_name_img"""
res = self.current_result
name = res.station.name
#self.station_name.setText('')
#self.station_name.clear()
#self.station_name.addItems(name.optional_values)
if not self.file_list.currentItem().station is None:
self.station_name.setText(self.file_list.currentItem().station)
else:
self.station_name.setText(name.value)
#font = QFont("Consolas", 11)
#self.station_name.lineEdit().setFont(font)
#self.setConfidenceColor(self.station_name, name)
img = self.cutImage(res.contrast_station_img, name)
if self.dark_theme:
img = 255 - img
processedimage = array2qimage(img)
pix = QPixmap()
pix.convertFromImage(processedimage)
if self.station_name_img.height() < pix.height():
pix = pix.scaled(self.station_name_img.size(),
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
scene = QGraphicsScene()
scene.addPixmap(pix)
self.station_name_img.setScene(scene)
self.station_name_img.show()
def tick_DC(self, u, i):
self.datau.pop(0)
self.datai.pop(0)
self.datau.append(u)
self.datai.append(i)
self.scene1 = QGraphicsScene()
self.scene2 = QGraphicsScene()
self.setup_scene(self.scene1)
self.setup_scene(self.scene2)
self.scene1.addSimpleText('[U/V]').moveBy(-39, 220-10)
self.scene2.addSimpleText('[I/mA]').moveBy(-39, 220-10)
self.scene1.addSimpleText('+4.0').moveBy(-40, 0-10)
self.scene1.addSimpleText('+2.0').moveBy(-40, 50-10)
self.scene1.addSimpleText(' 0.0').moveBy(-40, 100-10)
self.scene1.addSimpleText('-2.0').moveBy(-40, 150-10)
self.scene1.addSimpleText('-4.0').moveBy(-40, 200-10)
self.scene2.addSimpleText('+0.4').moveBy(-40, 0-10)
self.scene2.addSimpleText('+0.2').moveBy(-40, 50-10)
self.scene2.addSimpleText(' 0.0').moveBy(-40, 100-10)
self.scene2.addSimpleText('-0.2').moveBy(-40, 150-10)
self.scene2.addSimpleText('-0.4').moveBy(-40, 200-10)
path = QPainterPath()
path.moveTo(0,100-self.datau[0]*25)
for i in xrange(1,200):
path.lineTo(3*(i+1), 100-self.datau[i]*25)
self.scene1.addPath(path, QPen(QColor(0,0,255), 3))
path = QPainterPath()
path.moveTo(0,100-self.datai[0]*25)
for i in xrange(1,200):
path.lineTo(3*(i+1), 100-self.datai[i]*25)
self.scene2.addPath(path, QPen(QColor(0,0,255), 3))
self.ui.graph1.setScene(self.scene1)
self.ui.graph2.setScene(self.scene2)
def test_editlinksnode(self):
from ...registry.tests import small_testing_registry
reg = small_testing_registry()
file_desc = reg.widget("Orange.OrangeWidgets.Data.OWFile.OWFile")
bayes_desc = reg.widget("Orange.OrangeWidgets.Classify.OWNaiveBayes."
"OWNaiveBayes")
source_node = SchemeNode(file_desc, title="This is File")
sink_node = SchemeNode(bayes_desc)
scene = QGraphicsScene()
view = QGraphicsView(scene)
node = EditLinksNode(node=source_node)
scene.addItem(node)
node = EditLinksNode(direction=Qt.RightToLeft)
node.setSchemeNode(sink_node)
node.setPos(300, 0)
scene.addItem(node)
view.show()
view.resize(800, 300)
self.app.exec_()
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
screenPos = event.screenPos()
buttonDown = event.buttonDownScreenPos(Qt.LeftButton)
if (screenPos - buttonDown).manhattanLength() > 2.0:
self.updateSelectionRect(event)
QGraphicsScene.mouseMoveEvent(self, event)
def Paint(self):
scene = QGraphicsScene()
# Draw the graph
tt = self.ui.graphtype.currentIndex()
if tt == 0:
points = self.avgSpeed
elif tt == 1:
points = self.avgVolume
elif tt == 2:
points = self.avgCapacity
elif tt == 3:
points = self.avgRam
p0 = points[0]
for p in points[1:]:
scene.addLine(5 + p0[0] * 2, 205 - p0[1] * 2, 5 + p[0] * 2, 205 - p[1] * 2, QPen(self.settings["graph"]))
p0 = p
# Draw the axis
scene.addLine(5, 5, 5, 208, QPen(self.settings["axis"]))
scene.addLine(2, 205, self.time * 2 + 5, 205, QPen(self.settings["axis"]))
t = 0
while t <= self.time:
scene.addLine(5 + t * 2, 206, 5 + t * 2, 204, QPen(self.settings["axis"]))
font = QFont()
font.setPointSize(6)
capt = scene.addText(str(t), font)
capt.setPos(t * 2, 203)
t += 10
self.ui.graph.setScene(scene)
def search(self):
# first set/change the font of the serach box
font = self.dlg.search_lineEdit.font()
font.setItalic(False)
self.dlg.search_lineEdit.setFont(font)
# clear description and quicklook
self.dlg.textEdit.clear()
# make a new emptey scene to show
if not self.dlg.graphicsView is None:
scene = QGraphicsScene()
pic = QPixmap()
scene.addItem(QGraphicsPixmapItem(pic))
self.dlg.graphicsView.setScene(scene)
self.dlg.graphicsView.show()
# function the searches for a string in the datasets name, service type and otganization
text = self.dlg.search_lineEdit.text()
# convert to lower case and remove greek accents in case of Greek
text = text.lower()
text = self.removeGreekAccents(text)
foundDatasets = []
for dataset in self.datasets:
# use lowercase characters and remove greek accents , to make the comparison
name = self.removeGreekAccents(dataset.getName(self.language).lower())
source = self.removeGreekAccents(dataset.getSource(self.language).lower())
serviceType = self.removeGreekAccents(dataset.serviceType.lower())
if text in name or text in source or text in serviceType:
#QMessageBox.information(None, "DEBUG:", str(type(dataset.getName(self.language))))
foundDatasets.append(dataset)
#fill the table with the found datasets
self.fill_table(foundDatasets)
class Video(QWidget):
def __init__(self):
# init the widget
QWidget.__init__(self)
# set up the scene
self.scene=QGraphicsScene()
self.scene.setSceneRect(0,0,800,600)
# add a view of that scene
self.view = QGraphicsView()
self.view.setScene(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.setFixedSize(800,600)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# set the screen sync
val = "1"
# Set for nVidia linux
os.environ["__GL_SYNC_TO_VBLANK"] = val
# Set for recent linux Mesa DRI Radeon
os.environ["LIBGL_SYNC_REFRESH"] = val
qglf = QGLFormat()
qglf.setSampleBuffers(True)
#qglf.setSwapInterval(1)
self.glw = QGLWidget(qglf)
self.glw.setAutoBufferSwap(False)
self.view.setViewport(self.glw)
QTimer.singleShot(0,self.glw.swapBuffers)
def swapBuffers(self):
# first call the swap on the QGLWidget
self.glw.swapBuffers()
self.glw.makeCurrent()
# The following is taken from the PsychToolbox
# Draw a single pixel in left-top area of back-buffer.
# This will wait/stall the rendering pipeline
# until the buffer flip has happened, aka immediately after the VBL has started.
# We need the pixel as "synchronization token", so the following glFinish() really
# waits for VBL instead of just "falling through" due to the asynchronous nature of
# OpenGL:
glDrawBuffer(GL_BACK)
# We draw our single pixel with an alpha-value of zero - so effectively it doesn't
# change the color buffer - just the z-buffer if z-writes are enabled...
glColor4f(0.0,0.0,0.0,0.0)
glBegin(GL_POINTS)
glVertex2i(10,10)
glEnd()
# This glFinish() will wait until point drawing is finished, ergo backbuffer was ready
# for drawing, ergo buffer swap in sync with start of VBL has happened.
glFinish()
def show(self):
# shows the viewer widget
self.view.show()
def setPreviewImage(self, image):
"""Show image in self.preview."""
factor = self.factor.value()
pix = image.scaled(QSize(self.preview.size().width()*factor,self.preview.size().height()*factor), Qt.KeepAspectRatio, Qt.SmoothTransformation)
scene = QGraphicsScene()
scene.addPixmap(pix)
self.previewSetScene(scene)
class LiteBoxView(QGraphicsView):
ALPHA = QColor(0, 0, 0, 192)
closed_signal = QtCore.pyqtSignal()
def __init__(self, parent=None):
super(LiteBoxView, self).__init__(parent)
self.setWindowFlags(Qt.Window | Qt.WindowStaysOnTopHint)
#self.setAttribute(Qt.WA_DeleteOnClose)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
QtGui.QShortcut( Qt.Key_Escape, self, self.close )
self.desktopshot = None
# will propagate to children
self.setRenderHint(QPainter.Antialiasing)
self.setRenderHint(QPainter.TextAntialiasing)
self.scene = QGraphicsScene()
self.setScene(self.scene)
def close(self):
self.closed_signal.emit()
super(LiteBoxView, self).close()
def drawBackground(self, painter, rect):
if self.desktopshot is None:
self.desktopshot = get_desktop_pixmap()
painter.drawPixmap(self.mapToScene(0, 0), self.desktopshot)
painter.setBrush(LiteBoxView.ALPHA)
painter.drawRect(rect)
def show_fullscreen_svg(self, path):
""":param path: path to an svg file"""
from PyQt4 import QtSvg
item = QtSvg.QGraphicsSvgItem(path)
self.show_fullscreen_item(item)
def show_fullscreen_pixmap(self, pixmap):
""":param pixmap: a QPixmap"""
item = QGraphicsPixmapItem(pixmap)
self.show_fullscreen_item(item)
def show_fullscreen_image(self, image):
""":param image: a QImage"""
pixmap = QPixmap.fromImage(image)
self.show_fullscreen_pixmap( pixmap )
def show_fullscreen_item(self, item):
""":param item: a QGraphicsItem to be shown fullscreen"""
item.setFlag(QtGui.QGraphicsItem.ItemIsFocusable, True)
self.scene.clear()
self.scene.addItem(item)
CloseMark(parent=item)
self.showFullScreen()
self.setFocus()
def mouseReleaseEvent(self, mouseEvent):
if mouseEvent.button() == Qt.RightButton:
self.__kDummy.toggleEditMode()
self.update()
QGraphicsScene.mouseReleaseEvent(self, mouseEvent)
def mousePressEvent(self, mouseEvent):
QGraphicsScene.mousePressEvent(self, mouseEvent)
if self.__isControlModifier:
return
if mouseEvent.button() == Qt.RightButton:
self.__kDummy.toggleEditMode()
def __init__( self, navBar, parent = None ):
QGraphicsScene.__init__( self, parent )
CFSceneContextMenuMixin.__init__( self )
CFSceneMouseMixin.__init__( self )
CFSceneKeyboardMixin.__init__( self )
self.__navBar = navBar
self.selectionChanged.connect( self.selChanged )
return
def __init__(self, view=None, parent=None):
QGraphicsScene.__init__(self, parent)
if view is None:
raise AttributeError
self.__view = view
self.__create__()
class MyWidget(QGraphicsView):
def __init__(self):
super(MyWidget, self).__init__()
self.setFixedSize(300, 300)
self.setSceneRect(0, 0, 250, 250)
self.scene = QGraphicsScene()
self.setScene(self.scene)
self.scene.addItem(MyArrow())
def addItem(self, QGraphicsItem):
if self.__isNode(QGraphicsItem):
QGraphicsItem.setZValue(1.0)
QGraphicsItem.onPress.connect(self.__onNodePressed)
self.__nodes[QGraphicsItem.Id] = QGraphicsItem
QGraphicsScene.addItem(self, QGraphicsItem)
def __init__(self, parent=None):
"""Constructor
Args:
parent(QObject): Parent object, default None
"""
QGraphicsScene.__init__(self, parent=parent)
self._draggedLineItem = None
def drawSnippet(self, graphicsview, snippet):
"""Draw single result item to graphicsview"""
processedimage = array2qimage(snippet)
pix = QPixmap()
pix.convertFromImage(processedimage)
pix = pix.scaled(graphicsview.width(), graphicsview.height()-1, Qt.KeepAspectRatio, Qt.SmoothTransformation)
scene = QGraphicsScene()
scene.addPixmap(pix)
graphicsview.setScene(scene)
graphicsview.show()
def __init__(self, initial_width, initial_height, visible_meters, length, mass):
QGraphicsScene.__init__(self)
self.visible_meters = visible_meters
self.initial_width = initial_width
self.initial_height = initial_height
self.pend_radius = min(0.5 * mass, 0.2)
self.pole_length = length
self.unit = min(self.initial_width, self.initial_height) / self.visible_meters
self.__create_scene()
self.update_state(0.0, 0.0)
def mouseMoveEvent(self, mouseEvent):
"""Manage the mouse movement while it is pressed.
Args:
event(QMouseEvent): Mouse event.
"""
QGraphicsScene.mouseMoveEvent(self, mouseEvent)
if not mouseEvent.isAccepted() and mouseEvent.buttons() == Qt.LeftButton:
delta = mouseEvent.lastScreenPos() - mouseEvent.screenPos()
self.translate(delta.x(), delta.y())
def loadFileFromFile(self,path):
global image
image = QImage(path)
scene = QGraphicsScene()
scene.addPixmap(QPixmap(path))
self.graphicsView.setScene(scene)
print 'loading ' + path
def test(self):
if not self.winManager:
return
from PyQt4.QtGui import QGraphicsScene, QGraphicsItem, QGraphicsLineItem
from PyQt4.QtCore import QRectF, QLineF
w = self.winManager.newWindow()
scene = QGraphicsScene(w.graphicsView)
scene.addItem(Items.Grid())
scene.addItem(Items.Axes())
line = scene.addLine(QLineF(0, 0, 0, 0))
cross = Items.NodeCross(movable=True)
cross.addEdge(line, 1)
scene.addItem(cross)
help = scene.addText(QCoreApplication.translate('Graphics', 'Press "h" for help!'))
help.moveBy(-50, 80)
text = Items.NodeText(QCoreApplication.translate('Graphics', 'Drag Me!'))
text.setFlag(QGraphicsItem.ItemIsMovable, True)
text.setFlag(QGraphicsItem.ItemIsSelectable, True)
text.addEdge(line, 2)
scene.addItem(text)
w.graphicsView.setScene(scene)
def __init__(self, parent=None, back_image=None, width=100, heigth=100):
super(ToastWidget, self).__init__(parent)
self.setWindowFlags(Qt.SplashScreen)
self.scene = QGraphicsScene(self)
self.timer = QTimer(self)
self.setScene(self.scene)
self.set_image(back_image)
self.setGeometry(QRect(self.x(), self.y(), width, heigth))
self.show()
def drawPoints(self):
img = qrcode.make('TestCode 001',image_factory=qrcode.image.svg.SvgImage )
type(img)
gitem = QGraphicsScene()
self.graphicsView.setScene(gitem)
#gitem.addLine(0, 0, 2, 2)
qbrush = QBrush()
qbrush.setStyle(Qt.SolidPattern)
qbrush.setColor(Qt.black)
gitem.addRect(0, 0, 2, 2, brush=qbrush )
self.graphicsView.show()
def __init__(self):
QGraphicsScene.__init__(self)
self.__disableFocusRect = False
self._focusBoard = None
self.focusRect = QGraphicsRectItem()
pen = QPen(QColor(Qt.blue))
pen.setWidth(6)
self.focusRect.setPen(pen)
self.addItem(self.focusRect)
self.focusRect.setZValue(ZValues.marker)
self.focusRect.hide()
def test_graphicstextwidget(self):
scene = QGraphicsScene()
view = QGraphicsView(scene)
text = GraphicsTextWidget()
text.setHtml("<center><b>a text</b></center><p>paragraph</p>")
scene.addItem(text)
view.show()
view.resize(400, 300)
self.app.exec_()
def keyPressEvent(self, event):
""" Handles the key press event """
key = event.key()
modifiers = int(event.modifiers())
if modifiers in self.__hotKeys:
if key in self.__hotKeys[modifiers]:
self.__hotKeys[modifiers][key]()
event.accept()
return
QGraphicsScene.keyPressEvent(self, event)
return
def __init__(self, undo_stack, delete_act, sel_actions, *args):
"""
Constructor
"""
params = parameters.instance
QGraphicsScene.__init__(self, *args)
self.delete_act = delete_act
self.undo_stack = undo_stack
self.data_manager = None
self._mode = None
self.link = None
self.image_path = None
self.image_name = None
self.background_image = None
self.template = TemplateItem()
self.template.setPos(QPointF(0, 0))
self.template.setVisible(params.show_template)
self.show_template = False
self.points = {}
self.cells = {}
self._real_scene_rect = QRectF()
params.pointParameterChange.connect(self.updatePoints)
params.cellParameterChange.connect(self.updateCells)
params.searchParameterChange.connect(self.updateTemplate)
self.had_selection = None
self.selectionChanged.connect(self.updateSelectionActions)
self.current_data = None
self.back_matrix = QTransform()
self.invert_back_matrix = QTransform()
self.clear()
popup = QMenu("Scene menu")
validate_cell_act = popup.addAction("Validate cell", self.validateCell)
validate_cell_act.setVisible(False)
self._validate_cell_act = validate_cell_act
lifespan_act = popup.addAction("Change cell lifespan", self.changeLifespan)
lifespan_act.setVisible(False)
self.lifespan_act = lifespan_act
make_starshape_act = popup.addAction("Make cell star shaped", self.makeCellStarshaped)
make_starshape_act.setVisible(False)
self.make_starshape_act = make_starshape_act
sel = popup.addMenu("Selection")
for act in sel_actions:
if act == "-":
sel.addSeparator()
else:
sel.addAction(act)
popup.addAction(delete_act)
self._popup = popup
self._sel_rect = None
self._sel_first_pt = None
self._current_cell = None
self._first_point = None
self.mode = TrackingScene.Pan
def keyPressEvent(self, event):
""" Handles the key press event """
key = event.key()
modifiers = int(event.modifiers())
if modifiers in self.__hotKeys:
if key in self.__hotKeys[modifiers]:
self.__hotKeys[modifiers][key]()
event.accept()
return
QGraphicsScene.keyPressEvent(self, event)
return
def __init__(self, initial_width, initial_height, visible_meters, length,
mass):
QGraphicsScene.__init__(self)
self.visible_meters = visible_meters
self.initial_width = initial_width
self.initial_height = initial_height
self.pend_radius = min(0.5 * mass, 0.2)
self.pole_length = length
self.unit = min(self.initial_width,
self.initial_height) / self.visible_meters
self.__create_scene()
self.update_state(0.0, 0.0)
def __init__(self,
posModel,
along,
preemptive_fetch_number=5,
parent=None,
name="Unnamed Scene",
swapped_default=False):
"""
* preemptive_fetch_number -- number of prefetched slices; 0 turns the feature off
* swapped_default -- whether axes should be swapped by default.
"""
QGraphicsScene.__init__(self, parent=parent)
self._along = along
self._posModel = posModel
# QGraphicsItems can change this if they are in a state that should temporarily forbid brushing
# (For example, when the slice intersection marker is in 'draggable' state.)
self.allow_brushing = True
self._dataShape = (0, 0)
self._dataRect = None #A QGraphicsRectItem (or None)
self._offsetX = 0
self._offsetY = 0
self.name = name
self._stackedImageSources = StackedImageSources(LayerStackModel())
self._showTileOutlines = False
# FIXME: We don't show the red 'progress pies' because they look terrible.
# If we could fix their timing, maybe it would be worth it.
self._showTileProgress = False
self._tileProvider = None
self._dirtyIndicator = None
self._prefetching_enabled = False
self._swappedDefault = swapped_default
self.reset()
# BowWave preemptive caching
self.setPreemptiveFetchNumber(preemptive_fetch_number)
self._course = (1, 1) # (along, pos or neg direction)
self._time = self._posModel.time
self._channel = self._posModel.channel
self._posModel.timeChanged.connect(self._onTimeChanged)
self._posModel.channelChanged.connect(self._onChannelChanged)
self._posModel.slicingPositionChanged.connect(
self._onSlicingPositionChanged)
self._allTilesCompleteEvent = threading.Event()
self.dirty = False
def keyPressEvent(self, keyEvent):
QGraphicsScene.keyPressEvent(self, keyEvent)
if keyEvent.key() == Qt.Key_Control:
self.__view.setDragMode(QGraphicsView.ScrollHandDrag)
self.__isControlModifier = True
if keyEvent.key() == Qt.Key_Alt:
self.__isAltModifier = True
self.__previousSelectedNode = None
if keyEvent.key() == 88:
self.__kDummy.setSnapMode(True)
def keyReleaseEvent(self, keyEvent):
QGraphicsScene.keyReleaseEvent(self, keyEvent)
if keyEvent.key() == Qt.Key_Control:
self.__view.setDragMode(QGraphicsView.NoDrag)
self.__isControlModifier = False
if keyEvent.key() == Qt.Key_Alt:
self.__isAltModifier = False
self.__previousSelectedNode = None
if keyEvent.key() == 88:
self.__kDummy.setSnapMode(False)
def focusInEvent(self, event):
"""work around a qt bug. See https://bugreports.qt-project.org/browse/QTBUG-32890
This can be reproduced as follows:
./kajongg.py --game=whatever --autoplay=SomeRuleset
such that the human player is the first one to discard a tile.
wait until the main screen has been built
click with the mouse into the middle of that window
press left arrow key
this will violate the assertion in GraphicsTileItem.keyPressEvent """
prev = self.focusItem()
QGraphicsScene.focusInEvent(self, event)
if prev and bool(prev.flags() & QGraphicsItem.ItemIsFocusable) and prev != self.focusItem():
self.setFocusItem(prev)
def __init__ (self):
QMainWindow.__init__ (self)
self.controller = Controller ()
self.listener = LeapListener (self)
self.controller.add_listener (self.listener)
self.mode = "gallery"
self.scroll = False
self.direction = ""
self.direction_x = 0
self.scroll_velocity = 0
self.current_index = 0
# List containing images for the gallery
self.list_view = QListWidget ()
self.list_view.setFlow (0)
self.list_view.setHorizontalScrollMode (1)
self.list_view.setMouseTracking (True)
self.list_view.itemClicked.connect (self.show_image)
# Setting the style of the ListView, background, item selected, etc
self.list_view.setStyleSheet ("""
QListWidget::item:hover {background: transparent;}
QListWidget::item:disabled:hover {background: transparent;}
QListWidget::item:hover:!active {background: transparent;}
QListWidget::item:selected:active {background: transparent;}
QListWidget::item:selected:!active {background: transparent;}
QListWidget::item:selected:disabled {background: transparent;}
QListWidget::item:selected:!disabled {background: transparent;}
QListWidget {background: #2C3539}
""")
# Image viewer
self.scene = QGraphicsScene ()
self.viewer = QGraphicsView (self.scene)
self.stackedWidget = QStackedWidget ()
self.stackedWidget.addWidget (self.list_view)
self.stackedWidget.addWidget (self.viewer)
self.setCentralWidget (self.stackedWidget)
self.resize (500, 400)
self.showMaximized ()
scan = ScanLibrary ("/home/chris/Example")
threads.append (scan)
self.connect (scan, SIGNAL (scan.signal), self.add_images_to_list)
scan.start ()
self.connect (self, SIGNAL ("scrollChanged(bool)"), self.scroll_view)
def __init__(self, selfwindow):
QGraphicsView.__init__(self)
self.selfwindow = selfwindow
self.panSelect = False
self.zoomSelect = False
self.zoom_data = []
self.scene = QGraphicsScene()
self.setScene(self.scene)
self.setMouseTracking(False)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setDragMode(QGraphicsView.NoDrag)
def __init__(self, logger, opts):
QGraphicsScene.__init__(self)
self.logger, self.opts = logger, opts
self.pages = []
self.chapters = []
self.chapter_layout = None
self.current_screen = None
self.current_page = 0
self.link_map = {}
self.chapter_map = {}
self.history = History()
self.last_search = iter([])
if not opts.white_background:
self.setBackgroundBrush(QBrush(QColor(0xee, 0xee, 0xee)))
def drawOCRPreview(self):
if self.current_result is None:
self.setPreviewImage(self.preview_image)
return
factor = self.factor.value()
res = self.current_result
name = res.station
img = self.preview_image
old_h = img.height()
old_w = img.width()
pix = img.scaled(QSize(self.preview.size().width()*factor,self.preview.size().height()*factor), Qt.KeepAspectRatio, Qt.SmoothTransformation)
#pix = img.scaled(self.preview.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
new_h = pix.height()
new_w = pix.width()
ratio_h = old_h/float(new_h)
ratio_w = old_w/float(new_w)
self.scene = QGraphicsScene()
self.scene.addPixmap(pix)
#self.scene.addPixmap(img)
self.previewRects = []
pen = QPen(Qt.yellow)
redpen = QPen(Qt.red)
bluepen = QPen(Qt.blue)
greenpen = QPen(Qt.green)
rect = self.addRect(self.scene, name, ratio_w, ratio_h, greenpen)
counter = 0
for line in res.commodities:
if counter < self.OCRline:
rect = self.addRect(self.scene, line, ratio_w, ratio_h, greenpen)
elif counter == self.OCRline:
rect = self.addRect(self.scene, line, ratio_w, ratio_h, bluepen)
else:
if line.w < (0.02*old_w):
rect = self.addRect(self.scene, line, ratio_w, ratio_h, redpen)
else:
rect = self.addRect(self.scene, line, ratio_w, ratio_h, pen)
counter += 1
self.previewRects.append(rect)
self.previewSetScene(self.scene)
def drawSnippet(self, graphicsview, item):
"""Draw single result item to graphicsview"""
res = self.current_result
snippet = self.cutImage(res.contrast_commodities_img, item)
#cv2.imwrite('snippets/'+unicode(self.currentsnippet)+'.png',snippet)
#self.currentsnippet += 1
processedimage = array2qimage(snippet)
pix = QPixmap()
pix.convertFromImage(processedimage)
if graphicsview.height() < pix.height():
pix = pix.scaled(graphicsview.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
scene = QGraphicsScene()
scene.addPixmap(pix)
graphicsview.setScene(scene)
graphicsview.show()
def __init__(self):
super().__init__()
self.data = None
self.input_features = None
self.attrs = []
self.attr_box = gui.hBox(self.mainArea)
model = VariableListModel()
model.wrap(self.attrs)
self.attrXCombo = gui.comboBox(self.attr_box,
self,
value="attrX",
contentsLength=12,
callback=self.change_attr,
sendSelectedValue=True,
valueType=str)
self.attrXCombo.setModel(model)
gui.widgetLabel(self.attr_box, "\u2715").\
setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.attrYCombo = gui.comboBox(self.attr_box,
self,
value="attrY",
contentsLength=12,
callback=self.change_attr,
sendSelectedValue=True,
valueType=str)
self.attrYCombo.setModel(model)
self.canvas = QGraphicsScene()
self.canvasView = ViewWithPress(self.canvas,
self.mainArea,
handler=self.reset_selection)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
box = gui.hBox(self.mainArea)
gui.button(box,
None,
"&Save Graph",
callback=self.save_graph,
autoDefault=False)
gui.button(box,
None,
"&Report",
callback=self.show_report,
autoDefault=False)
def __init__(self, *args, **kwargs):
QGraphicsScene.__init__(self, *args, **kwargs)
self.scheme = None
self.registry = None
# All node items
self.__node_items = []
# Mapping from SchemeNodes to canvas items
self.__item_for_node = {}
# All link items
self.__link_items = []
# Mapping from SchemeLinks to canvas items.
self.__item_for_link = {}
# All annotation items
self.__annotation_items = []
# Mapping from SchemeAnnotations to canvas items.
self.__item_for_annotation = {}
# Is the scene editable
self.editable = True
# Anchor Layout
self.__anchor_layout = AnchorLayout()
self.addItem(self.__anchor_layout)
self.__channel_names_visible = True
self.__node_animation_enabled = True
self.user_interaction_handler = None
self.activated_mapper = NodeItemSignalMapper(self)
self.activated_mapper.pyMapped.connect(
self.node_item_activated
)
self.hovered_mapper = NodeItemSignalMapper(self)
self.hovered_mapper.pyMapped.connect(
self.node_item_hovered
)
self.position_change_mapper = NodeItemSignalMapper(self)
self.position_change_mapper.pyMapped.connect(
self._on_position_change
)
log.info("'%s' intitialized." % self)
def event(self, event):
# TODO: change the base class of Node/LinkItem to QGraphicsWidget.
# It already handles font changes.
if event.type() == QEvent.FontChange:
self.__update_font()
return QGraphicsScene.event(self, event)
def __init__( self, what, options, path = "", buf = "", parent = None ):
QDialog.__init__( self, parent )
self.__cancelRequest = False
self.__inProgress = False
self.__what = what
self.__options = options
self.__path = path # could be a dir or a file
self.__buf = buf # content in case of a modified file
# Working process data
self.__participantFiles = [] # Collected list of files
self.__projectImportDirs = []
self.__projectImportsCache = {} # utils.settings -> /full/path/to.py
self.__dirsToImportsCache = {} # /dir/path -> { my.mod: path.py, ... }
self.dataModel = ImportDiagramModel()
self.scene = QGraphicsScene()
# Avoid pylint complains
self.progressBar = None
self.infoLabel = None
self.__createLayout()
self.setWindowTitle( 'Imports/dependencies diagram generator' )
QTimer.singleShot( 0, self.__process )
return
def __init__(self, theCanvas, theLayer, selFeatureIds, parent=None):
super(CautionShowInfoDlg, self).__init__(parent)
self.setupUi(self)
self.mTheCanvas = theCanvas
self.mTheLayer = theLayer
self.mSelFeatureIds = selFeatureIds
self.mAllFeatureIds = []
self.highlightList = []
self.setWindowTitle("Caution")
self.labelOutlinkid.setText("Inlinkid:")
self.graphicsViewCaution.setScene(QGraphicsScene())
featureIter = self.mTheLayer.getFeatures(QgsFeatureRequest().setFlags(
QgsFeatureRequest.NoGeometry))
inti = 0
theFeature = QgsFeature()
while (featureIter.nextFeature(theFeature) and inti < 512):
inti += 1
self.mAllFeatureIds.append(theFeature.id())
self.spinBoxFeatureIndex.setValue(1)
self.spinBoxFeatureIndex.setMinimum(1)
self.spinBoxFeatureIndex.setMaximum(inti)
errMsg = ['']
self.initComboBoxOutlinkid()
self.comboBoxOutlinkid.setFocus()
self.selectFeatureById(errMsg,
self.mSelFeatureIds[0],
bZoomToSelected=False)
self.pushButtonPrev.clicked.connect(self.onPushButtonPrev)
self.pushButtonNext.clicked.connect(self.onPushButtonNext)
self.connect(self.comboBoxOutlinkid,
QtCore.SIGNAL('activated(QString)'),
self.comboBoxOutlinkidChanged)
def __init__(self, parent=None):
super(LiteBoxView, self).__init__(parent)
self.setWindowFlags(Qt.Window | Qt.WindowStaysOnTopHint)
#self.setAttribute(Qt.WA_DeleteOnClose)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
QtGui.QShortcut(Qt.Key_Escape, self, self.close)
self.desktopshot = None
# will propagate to children
self.setRenderHint(QPainter.Antialiasing)
self.setRenderHint(QPainter.TextAntialiasing)
self.scene = QGraphicsScene()
self.setScene(self.scene)
def setupUi(self, document):
super(NodeBoxDocumentBaseClass, self).setupUi(document)
superView = self.graphicsSuperView
self.BACKGROUND_COLOR = QColor(superView.palette().color(
QPalette.Window).name())
self.setupStyleSpecificUI()
self.verticalSplitter.setStyleSheet(superView.styleSheet())
self.graphicsView = graphicsView = self.app.newNodeBoxGraphicsView()
superView._scene = scene = QGraphicsScene()
scene.setItemIndexMethod(QGraphicsScene.NoIndex)
superView.setScene(scene)
scene.addItem(graphicsView)
graphicsView._scene = scene
graphicsView.superView = superView
graphicsView._viewPort = superView.viewport()
self._initSizeAndPosition()
self.horizontalSplitter.setSizes(split(self.width(), 0.466))
self.verticalSplitter.setSizes(split(self.height(), 0.767))
self.outputView.setFont(self.textView.font())
self.textView.setFocus()
if self.styleName not in ("windowsxp", "windowsvista", "mac"):
self.app.setPalette(self.app.style().standardPalette())
self.setPalette(self.style().standardPalette())
if sys.platform == "darwin":
self.setWindowIcon(QIcon())
def __init__(self, master, *args):
QGraphicsView.__init__(self, *args)
self.master = master
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setRenderHints(QPainter.Antialiasing)
scene = QGraphicsScene(self)
self.pixmapGraphicsItem = QGraphicsPixmapItem(None)
scene.addItem(self.pixmapGraphicsItem)
self.setScene(scene)
self.setMouseTracking(True)
self.viewport().setMouseTracking(True)
self.setFocusPolicy(Qt.WheelFocus)
def setupUi_custom(self, ):
self.scene = QGraphicsScene()
self.scene2 = QGraphicsScene()
self.pushButton.clicked.connect(self.selectFile)
self.horizontalSlider.valueChanged.connect(self.updateLCD)
self.pushButton_2.clicked.connect(self.disp_graph)
self.pushButton_3.clicked.connect(self.selectFile_from_folder)
self.stop_button.clicked.connect(self.set_stop)
#TODO [WEIRD PROBLEM] QPixmap needs to be called at least once with JPG image before tensorFlow, otherwise program crashes
self.scene.addPixmap(
QPixmap(os.getcwd() + "/images/demo.jpg").scaled(
self.graphicsView.size(), QtCore.Qt.KeepAspectRatio))
self.graphicsView.setScene(self.scene)
#Add blank canvas initially
fig1 = Figure()
self.addmpl(fig1)
def close(self):
#clear everything
self.init_table()
# clear description and quicklook
self.dlg.textEdit.clear()
# clear search box
#text = self.dlg.search_lineEdit.setText("")
self.init_searchBox()
# make a new emptey scene to show
if not self.dlg.graphicsView is None:
scene = QGraphicsScene()
pic = QPixmap()
scene.addItem(QGraphicsPixmapItem(pic))
self.dlg.graphicsView.setScene(scene)
self.dlg.graphicsView.show()
"""close the dialog"""
self.dlg.close()
def __init__(self,
posModel,
along,
preemptive_fetch_number=5,
parent=None,
name="Unnamed Scene",
swapped_default=False):
"""
* preemptive_fetch_number -- number of prefetched slices; 0 turns the feature off
* swapped_default -- whether axes should be swapped by default.
"""
QGraphicsScene.__init__(self, parent=parent)
self._along = along
self._posModel = posModel
self._dataShape = (0, 0)
self._dataRect = None #A QGraphicsRectItem (or None)
self._offsetX = 0
self._offsetY = 0
self.name = name
self._stackedImageSources = StackedImageSources(LayerStackModel())
self._showTileOutlines = False
self._showTileProgress = True
self._tileProvider = None
self._dirtyIndicator = None
self._prefetching_enabled = False
self._swappedDefault = swapped_default
self.reset()
# BowWave preemptive caching
self.setPreemptiveFetchNumber(preemptive_fetch_number)
self._course = (1, 1) # (along, pos or neg direction)
self._time = self._posModel.time
self._channel = self._posModel.channel
self._posModel.timeChanged.connect(self._onTimeChanged)
self._posModel.channelChanged.connect(self._onChannelChanged)
self._posModel.slicingPositionChanged.connect(
self._onSlicingPositionChanged)
self._allTilesCompleteEvent = threading.Event()
def drawSnippet(self, graphicsview, snippet):
"""Draw single result item to graphicsview"""
try:
h, w = snippet.shape
except:
h, w, c = snippet.shape
if h < 1 or w < 1:
return
processedimage = array2qimage(snippet)
pix = QPixmap()
pix.convertFromImage(processedimage)
pix = pix.scaled(graphicsview.width(),
graphicsview.height() - 1, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
scene = QGraphicsScene()
scene.addPixmap(pix)
graphicsview.setScene(scene)
graphicsview.show()
def __init__(self):
# pylint: disable=missing-docstring
super().__init__()
self.data = self.discrete_data = None
self.attrs = []
self.input_features = None
self.areas = []
self.selection = set()
self.attr_box = gui.hBox(self.mainArea)
model = VariableListModel()
model.wrap(self.attrs)
combo_args = dict(widget=self.attr_box,
master=self,
contentsLength=12,
callback=self.update_attr,
sendSelectedValue=True,
valueType=str,
model=model)
fixed_size = (QSizePolicy.Fixed, QSizePolicy.Fixed)
self.attrXCombo = gui.comboBox(value="attrX", **combo_args)
gui.widgetLabel(self.attr_box, "\u2715", sizePolicy=fixed_size)
self.attrYCombo = gui.comboBox(value="attrY", **combo_args)
self.vizrank = SieveRank(self)
self.vizrank_button = gui.button(self.attr_box,
self,
"Score Combinations",
sizePolicy=fixed_size,
callback=self.vizrank.reshow,
enabled=False)
self.vizrank.pairSelected.connect(self.set_attr)
self.canvas = QGraphicsScene()
self.canvasView = ViewWithPress(self.canvas,
self.mainArea,
handler=self.reset_selection)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
box = gui.hBox(self.mainArea)
box.layout().addWidget(self.graphButton)
box.layout().addWidget(self.report_button)
def updateDescAndQL(self):
# get the name of the selected dataset
dataset_name, dataset_serviceType = self.getSelectedNameAndType()
#custom web service object
dataset = self.selectdataSets(dataset_name, dataset_serviceType)
quicklook = os.path.join(self.quicklooks_dir, dataset.QLname + ".jpg")
desc = dataset.getDescription(self.language)
name = dataset.getName(self.language)
#update decription
self.dlg.textEdit.clear()
#creation and last update
if self.language == "EN":
crDate = "Creation date : " + dataset.creationDate
update = "Last update : " + dataset.lastUpdate
elif self.language == "GR":
crDate = unicode(
"Ημερομηνια δημιουργιας : " + dataset.creationDate, 'utf-8')
update = unicode("Τελευταία ενημέρωση : " + dataset.lastUpdate,
'utf-8')
cursor = QTextCursor(self.dlg.textEdit.document())
cursor.insertHtml("<h3> " + name + " <br><br></h3>")
cursor.insertHtml("<p> " + desc + " <br><br><br></p>")
cursor.insertHtml("<p><i> " + crDate + " <br></i></p>")
#cursor.insertHtml("<p><i> "+update+" <br></i></p>")
self.dlg.textEdit.setReadOnly(True)
#update quicklook
#GET DIMENSIONS OF THE IMAGE
img = Image.open(quicklook)
w, h = img.size
scene = QGraphicsScene()
pic = QPixmap(quicklook)
scene.addItem(QGraphicsPixmapItem(pic))
self.dlg.graphicsView.setScene(scene)
self.dlg.graphicsView.fitInView(QRectF(0, 0, w, h), Qt.KeepAspectRatio)
self.dlg.graphicsView.show()
def __initializeUi(self):
"""
Initializes the Widget ui.
"""
LOGGER.debug("> Initializing '{0}' ui.".format(self.__class__.__name__))
self.Previous_Image_pushButton.setIcon(QIcon(os.path.join(self.__uiResourcesDirectory, self.__uiPreviousImage)))
self.Next_Image_pushButton.setIcon(QIcon(os.path.join(self.__uiResourcesDirectory, self.__uiNextImage)))
self.Zoom_In_pushButton.setIcon(QIcon(os.path.join(self.__uiResourcesDirectory, self.__uiZoomInImage)))
self.Zoom_Out_pushButton.setIcon(QIcon(os.path.join(self.__uiResourcesDirectory, self.__uiZoomOutImage)))
len(self.__paths) <= 1 and self.Navigation_frame.hide()
LOGGER.debug("> Initializing graphics View.")
self.__graphicsView = QGraphicsView()
self.__graphicsView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.__graphicsView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.__graphicsView.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.__graphicsView.setDragMode(QGraphicsView.ScrollHandDrag)
# Reimplementing QGraphicsView wheelEvent method.
self.__graphicsView.wheelEvent = self.wheelEvent
LOGGER.debug("> Initializing graphics scene.")
self.__graphicsScene = QGraphicsScene(self.__graphicsView)
self.__graphicsScene.setItemIndexMethod(QGraphicsScene.NoIndex)
self.__graphicsScene.setSceneRect(-(float(self.__graphicsSceneWidth)) / 2,
- (float(self.__graphicsSceneHeight)) / 2,
float(self.__graphicsSceneWidth),
float(self.__graphicsSceneHeight))
self.__graphicsView.setScene(self.__graphicsScene)
self.__graphicsView.setBackgroundBrush(QBrush(self.__graphicsSceneBackgroundColor))
self.Images_Previewer_frame_gridLayout.addWidget(self.__graphicsView)
# Signals / Slots.
self.__container.engine.imagesCaches.QImage.contentAdded.connect(self.__engine_imagesCaches_QImage__contentAdded)
self.Previous_Image_pushButton.clicked.connect(self.__Previous_Image_pushButton__clicked)
self.Next_Image_pushButton.clicked.connect(self.__Next_Image_pushButton__clicked)
self.Zoom_Out_pushButton.clicked.connect(self.__Zoom_Out_pushButton__clicked)
self.Zoom_In_pushButton.clicked.connect(self.__Zoom_In_pushButton__clicked)
self.Zoom_Fit_pushButton.clicked.connect(self.__Zoom_Fit_pushButton__clicked)
def __init__(self, theCanvas, theLayer, selFeatureIds, parent=None):
super(NostraIllustCheckDlg, self).__init__(parent)
self.setupUi(self)
self.mTheCanvas = theCanvas
self.mTheLayer = theLayer
self.mSelFeatureIds = selFeatureIds
self.mAllFeatureIds = []
self.highlightList = []
uri = QgsDataSourceURI(self.mTheLayer.source())
self.conn = psycopg2.connect('''host='%s' dbname='%s' user='******' password='******' ''' %\
(uri.host(), uri.database(), uri.username(), uri.password()))
self.pg = self.conn.cursor()
# members shown in graphic view.
self.mScene = QGraphicsScene()
self.graphicsViewShowImage.setScene(self.mScene)
self.mPixmapList = []
featureIter = self.mTheLayer.getFeatures(QgsFeatureRequest().setFlags(
QgsFeatureRequest.NoGeometry))
inti = 0
theFeature = QgsFeature()
while (featureIter.nextFeature(theFeature)):
inti += 1
self.mAllFeatureIds.append(theFeature.id())
self.spinBoxFeatureIndex.setValue(1)
self.spinBoxFeatureIndex.setMinimum(1)
self.spinBoxFeatureIndex.setMaximum(inti)
errMsg = ['']
self.initComboBoxOutlinkid()
self.selectFeatureById(errMsg,
self.mSelFeatureIds[0],
bZoomToSelected=False)
self.comboBoxOutlinkid.setFocus()
self.pushButtonPrev.clicked.connect(self.onPushButtonPrev)
self.pushButtonNext.clicked.connect(self.onPushButtonNext)
self.connect(self.comboBoxOutlinkid,
QtCore.SIGNAL('activated(QString)'),
self.comboBoxOutlinkidChanged)
def mouseReleaseEvent(self, event):
items = self.getSelected()
if items:
starts = []
ends = []
moved_ids = []
data = self.current_data
#pt_scale = (self.scale[0]/self.img_scale[0], self.scale[1]/self.scale[1])
for item in items:
pos = item.pos()*self.min_scale
old_pos = data[item.pt_id]
if pos != old_pos:
moved_ids.append(item.pt_id)
starts.append(old_pos)
ends.append(pos)
if moved_ids:
self.planMovePoints(moved_ids, ends, starts)
elif self.mode == TrackingScene.AddCell:
QGraphicsScene.mouseReleaseEvent(self, event)
if event.isAccepted():
return
items = self.items(event.scenePos())
if items:
pt = items[0]
if isinstance(pt, PointItem):
pt_id = pt.pt_id
cells = self.current_data.cells
if self.has_current_cell:
cid = self.current_cell
cell_shape = list(cells[cid])
if pt_id in cell_shape:
cell_shape.remove(pt_id)
self.planChangeCell(cid, cell_shape)
else:
cell_shape.append(pt_id)
self.planChangeCell(cid, cell_shape)
else:
cid = self.current_cell
cell_shape = [pt_id]
self.planAddCell(cid, cell_shape)
return
QGraphicsScene.mouseReleaseEvent(self, event)
