581 lines
19 KiB
Python
581 lines
19 KiB
Python
# -*- coding: utf-8 -*-
|
|
if __name__ == '__main__':
|
|
import sys, os
|
|
md = os.path.dirname(os.path.abspath(__file__))
|
|
sys.path = [os.path.dirname(md), os.path.join(md, '..', '..', '..')] + sys.path
|
|
#print md
|
|
|
|
|
|
#from pyqtgraph.GraphicsView import GraphicsView
|
|
#import pyqtgraph.graphicsItems as graphicsItems
|
|
#from pyqtgraph.PlotWidget import PlotWidget
|
|
from pyqtgraph.Qt import QtGui, QtCore, USE_PYSIDE
|
|
from pyqtgraph.graphicsItems.ROI import ROI
|
|
from pyqtgraph.graphicsItems.ViewBox import ViewBox
|
|
from pyqtgraph.graphicsItems.GridItem import GridItem
|
|
|
|
if USE_PYSIDE:
|
|
from .CanvasTemplate_pyside import *
|
|
else:
|
|
from .CanvasTemplate_pyqt import *
|
|
|
|
#import DataManager
|
|
import numpy as np
|
|
from pyqtgraph import debug
|
|
#import pyqtgraph as pg
|
|
import weakref
|
|
from .CanvasManager import CanvasManager
|
|
#import items
|
|
from .CanvasItem import CanvasItem, GroupCanvasItem
|
|
|
|
class Canvas(QtGui.QWidget):
|
|
|
|
sigSelectionChanged = QtCore.Signal(object, object)
|
|
sigItemTransformChanged = QtCore.Signal(object, object)
|
|
sigItemTransformChangeFinished = QtCore.Signal(object, object)
|
|
|
|
def __init__(self, parent=None, allowTransforms=True, hideCtrl=False, name=None):
|
|
QtGui.QWidget.__init__(self, parent)
|
|
self.ui = Ui_Form()
|
|
self.ui.setupUi(self)
|
|
#self.view = self.ui.view
|
|
self.view = ViewBox()
|
|
self.ui.view.setCentralItem(self.view)
|
|
self.itemList = self.ui.itemList
|
|
self.itemList.setSelectionMode(self.itemList.ExtendedSelection)
|
|
self.allowTransforms = allowTransforms
|
|
self.multiSelectBox = SelectBox()
|
|
self.view.addItem(self.multiSelectBox)
|
|
self.multiSelectBox.hide()
|
|
self.multiSelectBox.setZValue(1e6)
|
|
self.ui.mirrorSelectionBtn.hide()
|
|
self.ui.reflectSelectionBtn.hide()
|
|
self.ui.resetTransformsBtn.hide()
|
|
|
|
self.redirect = None ## which canvas to redirect items to
|
|
self.items = []
|
|
|
|
#self.view.enableMouse()
|
|
self.view.setAspectLocked(True)
|
|
#self.view.invertY()
|
|
|
|
grid = GridItem()
|
|
self.grid = CanvasItem(grid, name='Grid', movable=False)
|
|
self.addItem(self.grid)
|
|
|
|
self.hideBtn = QtGui.QPushButton('>', self)
|
|
self.hideBtn.setFixedWidth(20)
|
|
self.hideBtn.setFixedHeight(20)
|
|
self.ctrlSize = 200
|
|
self.sizeApplied = False
|
|
self.hideBtn.clicked.connect(self.hideBtnClicked)
|
|
self.ui.splitter.splitterMoved.connect(self.splitterMoved)
|
|
|
|
self.ui.itemList.itemChanged.connect(self.treeItemChanged)
|
|
self.ui.itemList.sigItemMoved.connect(self.treeItemMoved)
|
|
self.ui.itemList.itemSelectionChanged.connect(self.treeItemSelected)
|
|
self.ui.autoRangeBtn.clicked.connect(self.autoRange)
|
|
self.ui.storeSvgBtn.clicked.connect(self.storeSvg)
|
|
self.ui.storePngBtn.clicked.connect(self.storePng)
|
|
self.ui.redirectCheck.toggled.connect(self.updateRedirect)
|
|
self.ui.redirectCombo.currentIndexChanged.connect(self.updateRedirect)
|
|
self.multiSelectBox.sigRegionChanged.connect(self.multiSelectBoxChanged)
|
|
self.multiSelectBox.sigRegionChangeFinished.connect(self.multiSelectBoxChangeFinished)
|
|
self.ui.mirrorSelectionBtn.clicked.connect(self.mirrorSelectionClicked)
|
|
self.ui.reflectSelectionBtn.clicked.connect(self.reflectSelectionClicked)
|
|
self.ui.resetTransformsBtn.clicked.connect(self.resetTransformsClicked)
|
|
|
|
self.resizeEvent()
|
|
if hideCtrl:
|
|
self.hideBtnClicked()
|
|
|
|
if name is not None:
|
|
self.registeredName = CanvasManager.instance().registerCanvas(self, name)
|
|
self.ui.redirectCombo.setHostName(self.registeredName)
|
|
|
|
def storeSvg(self):
|
|
self.ui.view.writeSvg()
|
|
|
|
def storePng(self):
|
|
self.ui.view.writeImage()
|
|
|
|
def splitterMoved(self):
|
|
self.resizeEvent()
|
|
|
|
def hideBtnClicked(self):
|
|
ctrlSize = self.ui.splitter.sizes()[1]
|
|
if ctrlSize == 0:
|
|
cs = self.ctrlSize
|
|
w = self.ui.splitter.size().width()
|
|
if cs > w:
|
|
cs = w - 20
|
|
self.ui.splitter.setSizes([w-cs, cs])
|
|
self.hideBtn.setText('>')
|
|
else:
|
|
self.ctrlSize = ctrlSize
|
|
self.ui.splitter.setSizes([100, 0])
|
|
self.hideBtn.setText('<')
|
|
self.resizeEvent()
|
|
|
|
def autoRange(self):
|
|
self.view.autoRange()
|
|
|
|
def resizeEvent(self, ev=None):
|
|
if ev is not None:
|
|
QtGui.QWidget.resizeEvent(self, ev)
|
|
self.hideBtn.move(self.ui.view.size().width() - self.hideBtn.width(), 0)
|
|
|
|
if not self.sizeApplied:
|
|
self.sizeApplied = True
|
|
s = min(self.width(), max(100, min(200, self.width()*0.25)))
|
|
s2 = self.width()-s
|
|
self.ui.splitter.setSizes([s2, s])
|
|
|
|
|
|
def updateRedirect(self, *args):
|
|
### Decide whether/where to redirect items and make it so
|
|
cname = str(self.ui.redirectCombo.currentText())
|
|
man = CanvasManager.instance()
|
|
if self.ui.redirectCheck.isChecked() and cname != '':
|
|
redirect = man.getCanvas(cname)
|
|
else:
|
|
redirect = None
|
|
|
|
if self.redirect is redirect:
|
|
return
|
|
|
|
self.redirect = redirect
|
|
if redirect is None:
|
|
self.reclaimItems()
|
|
else:
|
|
self.redirectItems(redirect)
|
|
|
|
|
|
def redirectItems(self, canvas):
|
|
for i in self.items:
|
|
if i is self.grid:
|
|
continue
|
|
li = i.listItem
|
|
parent = li.parent()
|
|
if parent is None:
|
|
tree = li.treeWidget()
|
|
if tree is None:
|
|
print("Skipping item", i, i.name)
|
|
continue
|
|
tree.removeTopLevelItem(li)
|
|
else:
|
|
parent.removeChild(li)
|
|
canvas.addItem(i)
|
|
|
|
|
|
def reclaimItems(self):
|
|
items = self.items
|
|
#self.items = {'Grid': items['Grid']}
|
|
#del items['Grid']
|
|
self.items = [self.grid]
|
|
items.remove(self.grid)
|
|
|
|
for i in items:
|
|
i.canvas.removeItem(i)
|
|
self.addItem(i)
|
|
|
|
def treeItemChanged(self, item, col):
|
|
#gi = self.items.get(item.name, None)
|
|
#if gi is None:
|
|
#return
|
|
try:
|
|
citem = item.canvasItem
|
|
except AttributeError:
|
|
return
|
|
if item.checkState(0) == QtCore.Qt.Checked:
|
|
for i in range(item.childCount()):
|
|
item.child(i).setCheckState(0, QtCore.Qt.Checked)
|
|
citem.show()
|
|
else:
|
|
for i in range(item.childCount()):
|
|
item.child(i).setCheckState(0, QtCore.Qt.Unchecked)
|
|
citem.hide()
|
|
|
|
def treeItemSelected(self):
|
|
sel = self.selectedItems()
|
|
#sel = []
|
|
#for listItem in self.itemList.selectedItems():
|
|
#if hasattr(listItem, 'canvasItem') and listItem.canvasItem is not None:
|
|
#sel.append(listItem.canvasItem)
|
|
#sel = [self.items[item.name] for item in sel]
|
|
|
|
if len(sel) == 0:
|
|
#self.selectWidget.hide()
|
|
return
|
|
|
|
multi = len(sel) > 1
|
|
for i in self.items:
|
|
#i.ctrlWidget().hide()
|
|
## updated the selected state of every item
|
|
i.selectionChanged(i in sel, multi)
|
|
|
|
if len(sel)==1:
|
|
#item = sel[0]
|
|
#item.ctrlWidget().show()
|
|
self.multiSelectBox.hide()
|
|
self.ui.mirrorSelectionBtn.hide()
|
|
self.ui.reflectSelectionBtn.hide()
|
|
self.ui.resetTransformsBtn.hide()
|
|
elif len(sel) > 1:
|
|
self.showMultiSelectBox()
|
|
|
|
#if item.isMovable():
|
|
#self.selectBox.setPos(item.item.pos())
|
|
#self.selectBox.setSize(item.item.sceneBoundingRect().size())
|
|
#self.selectBox.show()
|
|
#else:
|
|
#self.selectBox.hide()
|
|
|
|
#self.emit(QtCore.SIGNAL('itemSelected'), self, item)
|
|
self.sigSelectionChanged.emit(self, sel)
|
|
|
|
def selectedItems(self):
|
|
"""
|
|
Return list of all selected canvasItems
|
|
"""
|
|
return [item.canvasItem for item in self.itemList.selectedItems() if item.canvasItem is not None]
|
|
|
|
#def selectedItem(self):
|
|
#sel = self.itemList.selectedItems()
|
|
#if sel is None or len(sel) < 1:
|
|
#return
|
|
#return self.items.get(sel[0].name, None)
|
|
|
|
def selectItem(self, item):
|
|
li = item.listItem
|
|
#li = self.getListItem(item.name())
|
|
#print "select", li
|
|
self.itemList.setCurrentItem(li)
|
|
|
|
|
|
|
|
def showMultiSelectBox(self):
|
|
## Get list of selected canvas items
|
|
items = self.selectedItems()
|
|
|
|
rect = self.view.itemBoundingRect(items[0].graphicsItem())
|
|
for i in items:
|
|
if not i.isMovable(): ## all items in selection must be movable
|
|
return
|
|
br = self.view.itemBoundingRect(i.graphicsItem())
|
|
rect = rect|br
|
|
|
|
self.multiSelectBox.blockSignals(True)
|
|
self.multiSelectBox.setPos([rect.x(), rect.y()])
|
|
self.multiSelectBox.setSize(rect.size())
|
|
self.multiSelectBox.setAngle(0)
|
|
self.multiSelectBox.blockSignals(False)
|
|
|
|
self.multiSelectBox.show()
|
|
|
|
self.ui.mirrorSelectionBtn.show()
|
|
self.ui.reflectSelectionBtn.show()
|
|
self.ui.resetTransformsBtn.show()
|
|
#self.multiSelectBoxBase = self.multiSelectBox.getState().copy()
|
|
|
|
def mirrorSelectionClicked(self):
|
|
for ci in self.selectedItems():
|
|
ci.mirrorY()
|
|
self.showMultiSelectBox()
|
|
|
|
def reflectSelectionClicked(self):
|
|
for ci in self.selectedItems():
|
|
ci.mirrorXY()
|
|
self.showMultiSelectBox()
|
|
|
|
def resetTransformsClicked(self):
|
|
for i in self.selectedItems():
|
|
i.resetTransformClicked()
|
|
self.showMultiSelectBox()
|
|
|
|
def multiSelectBoxChanged(self):
|
|
self.multiSelectBoxMoved()
|
|
|
|
def multiSelectBoxChangeFinished(self):
|
|
for ci in self.selectedItems():
|
|
ci.applyTemporaryTransform()
|
|
ci.sigTransformChangeFinished.emit(ci)
|
|
|
|
def multiSelectBoxMoved(self):
|
|
transform = self.multiSelectBox.getGlobalTransform()
|
|
for ci in self.selectedItems():
|
|
ci.setTemporaryTransform(transform)
|
|
ci.sigTransformChanged.emit(ci)
|
|
|
|
|
|
def addGraphicsItem(self, item, **opts):
|
|
"""Add a new GraphicsItem to the scene at pos.
|
|
Common options are name, pos, scale, and z
|
|
"""
|
|
citem = CanvasItem(item, **opts)
|
|
item._canvasItem = citem
|
|
self.addItem(citem)
|
|
return citem
|
|
|
|
|
|
def addGroup(self, name, **kargs):
|
|
group = GroupCanvasItem(name=name)
|
|
self.addItem(group, **kargs)
|
|
return group
|
|
|
|
|
|
def addItem(self, citem):
|
|
"""
|
|
Add an item to the canvas.
|
|
"""
|
|
|
|
## Check for redirections
|
|
if self.redirect is not None:
|
|
name = self.redirect.addItem(citem)
|
|
self.items.append(citem)
|
|
return name
|
|
|
|
if not self.allowTransforms:
|
|
citem.setMovable(False)
|
|
|
|
citem.sigTransformChanged.connect(self.itemTransformChanged)
|
|
citem.sigTransformChangeFinished.connect(self.itemTransformChangeFinished)
|
|
citem.sigVisibilityChanged.connect(self.itemVisibilityChanged)
|
|
|
|
|
|
## Determine name to use in the item list
|
|
name = citem.opts['name']
|
|
if name is None:
|
|
name = 'item'
|
|
newname = name
|
|
|
|
## If name already exists, append a number to the end
|
|
## NAH. Let items have the same name if they really want.
|
|
#c=0
|
|
#while newname in self.items:
|
|
#c += 1
|
|
#newname = name + '_%03d' %c
|
|
#name = newname
|
|
|
|
## find parent and add item to tree
|
|
#currentNode = self.itemList.invisibleRootItem()
|
|
insertLocation = 0
|
|
#print "Inserting node:", name
|
|
|
|
|
|
## determine parent list item where this item should be inserted
|
|
parent = citem.parentItem()
|
|
if parent in (None, self.view.childGroup):
|
|
parent = self.itemList.invisibleRootItem()
|
|
else:
|
|
parent = parent.listItem
|
|
|
|
## set Z value above all other siblings if none was specified
|
|
siblings = [parent.child(i).canvasItem for i in range(parent.childCount())]
|
|
z = citem.zValue()
|
|
if z is None:
|
|
zvals = [i.zValue() for i in siblings]
|
|
if parent == self.itemList.invisibleRootItem():
|
|
if len(zvals) == 0:
|
|
z = 0
|
|
else:
|
|
z = max(zvals)+10
|
|
else:
|
|
if len(zvals) == 0:
|
|
z = parent.canvasItem.zValue()
|
|
else:
|
|
z = max(zvals)+1
|
|
citem.setZValue(z)
|
|
|
|
## determine location to insert item relative to its siblings
|
|
for i in range(parent.childCount()):
|
|
ch = parent.child(i)
|
|
zval = ch.canvasItem.graphicsItem().zValue() ## should we use CanvasItem.zValue here?
|
|
if zval < z:
|
|
insertLocation = i
|
|
break
|
|
else:
|
|
insertLocation = i+1
|
|
|
|
node = QtGui.QTreeWidgetItem([name])
|
|
flags = node.flags() | QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsDragEnabled
|
|
if not isinstance(citem, GroupCanvasItem):
|
|
flags = flags & ~QtCore.Qt.ItemIsDropEnabled
|
|
node.setFlags(flags)
|
|
if citem.opts['visible']:
|
|
node.setCheckState(0, QtCore.Qt.Checked)
|
|
else:
|
|
node.setCheckState(0, QtCore.Qt.Unchecked)
|
|
|
|
node.name = name
|
|
#if citem.opts['parent'] != None:
|
|
## insertLocation is incorrect in this case
|
|
parent.insertChild(insertLocation, node)
|
|
#else:
|
|
#root.insertChild(insertLocation, node)
|
|
|
|
citem.name = name
|
|
citem.listItem = node
|
|
node.canvasItem = citem
|
|
self.items.append(citem)
|
|
|
|
ctrl = citem.ctrlWidget()
|
|
ctrl.hide()
|
|
self.ui.ctrlLayout.addWidget(ctrl)
|
|
|
|
## inform the canvasItem that its parent canvas has changed
|
|
citem.setCanvas(self)
|
|
|
|
## Autoscale to fit the first item added (not including the grid).
|
|
if len(self.items) == 2:
|
|
self.autoRange()
|
|
|
|
|
|
#for n in name:
|
|
#nextnode = None
|
|
#for x in range(currentNode.childCount()):
|
|
#ch = currentNode.child(x)
|
|
#if hasattr(ch, 'name'): ## check Z-value of current item to determine insert location
|
|
#zval = ch.canvasItem.zValue()
|
|
#if zval > z:
|
|
###print " ->", x
|
|
#insertLocation = x+1
|
|
#if n == ch.text(0):
|
|
#nextnode = ch
|
|
#break
|
|
#if nextnode is None: ## If name doesn't exist, create it
|
|
#nextnode = QtGui.QTreeWidgetItem([n])
|
|
#nextnode.setFlags((nextnode.flags() | QtCore.Qt.ItemIsUserCheckable) & ~QtCore.Qt.ItemIsDropEnabled)
|
|
#nextnode.setCheckState(0, QtCore.Qt.Checked)
|
|
### Add node to correct position in list by Z-value
|
|
###print " ==>", insertLocation
|
|
#currentNode.insertChild(insertLocation, nextnode)
|
|
|
|
#if n == name[-1]: ## This is the leaf; add some extra properties.
|
|
#nextnode.name = name
|
|
|
|
#if n == name[0]: ## This is the root; make the item movable
|
|
#nextnode.setFlags(nextnode.flags() | QtCore.Qt.ItemIsDragEnabled)
|
|
#else:
|
|
#nextnode.setFlags(nextnode.flags() & ~QtCore.Qt.ItemIsDragEnabled)
|
|
|
|
#currentNode = nextnode
|
|
return citem
|
|
|
|
def treeItemMoved(self, item, parent, index):
|
|
##Item moved in tree; update Z values
|
|
if parent is self.itemList.invisibleRootItem():
|
|
item.canvasItem.setParentItem(self.view.childGroup)
|
|
else:
|
|
item.canvasItem.setParentItem(parent.canvasItem)
|
|
siblings = [parent.child(i).canvasItem for i in range(parent.childCount())]
|
|
|
|
zvals = [i.zValue() for i in siblings]
|
|
zvals.sort(reverse=True)
|
|
|
|
for i in range(len(siblings)):
|
|
item = siblings[i]
|
|
item.setZValue(zvals[i])
|
|
#item = self.itemList.topLevelItem(i)
|
|
|
|
##ci = self.items[item.name]
|
|
#ci = item.canvasItem
|
|
#if ci is None:
|
|
#continue
|
|
#if ci.zValue() != zvals[i]:
|
|
#ci.setZValue(zvals[i])
|
|
|
|
#if self.itemList.topLevelItemCount() < 2:
|
|
#return
|
|
#name = item.name
|
|
#gi = self.items[name]
|
|
#if index == 0:
|
|
#next = self.itemList.topLevelItem(1)
|
|
#z = self.items[next.name].zValue()+1
|
|
#else:
|
|
#prev = self.itemList.topLevelItem(index-1)
|
|
#z = self.items[prev.name].zValue()-1
|
|
#gi.setZValue(z)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def itemVisibilityChanged(self, item):
|
|
listItem = item.listItem
|
|
checked = listItem.checkState(0) == QtCore.Qt.Checked
|
|
vis = item.isVisible()
|
|
if vis != checked:
|
|
if vis:
|
|
listItem.setCheckState(0, QtCore.Qt.Checked)
|
|
else:
|
|
listItem.setCheckState(0, QtCore.Qt.Unchecked)
|
|
|
|
def removeItem(self, item):
|
|
if isinstance(item, CanvasItem):
|
|
item.setCanvas(None)
|
|
self.itemList.removeTopLevelItem(item.listItem)
|
|
self.items.remove(item)
|
|
else:
|
|
if hasattr(item, '_canvasItem'):
|
|
self.removeItem(item._canvasItem)
|
|
else:
|
|
self.view.removeItem(item)
|
|
|
|
## disconnect signals, remove from list, etc..
|
|
|
|
def clear(self):
|
|
while len(self.items) > 0:
|
|
self.removeItem(self.items[0])
|
|
|
|
|
|
def addToScene(self, item):
|
|
self.view.addItem(item)
|
|
|
|
def removeFromScene(self, item):
|
|
self.view.removeItem(item)
|
|
|
|
|
|
def listItems(self):
|
|
"""Return a dictionary of name:item pairs"""
|
|
return self.items
|
|
|
|
def getListItem(self, name):
|
|
return self.items[name]
|
|
|
|
#def scene(self):
|
|
#return self.view.scene()
|
|
|
|
def itemTransformChanged(self, item):
|
|
#self.emit(QtCore.SIGNAL('itemTransformChanged'), self, item)
|
|
self.sigItemTransformChanged.emit(self, item)
|
|
|
|
def itemTransformChangeFinished(self, item):
|
|
#self.emit(QtCore.SIGNAL('itemTransformChangeFinished'), self, item)
|
|
self.sigItemTransformChangeFinished.emit(self, item)
|
|
|
|
|
|
|
|
class SelectBox(ROI):
|
|
def __init__(self, scalable=False):
|
|
#QtGui.QGraphicsRectItem.__init__(self, 0, 0, size[0], size[1])
|
|
ROI.__init__(self, [0,0], [1,1])
|
|
center = [0.5, 0.5]
|
|
|
|
if scalable:
|
|
self.addScaleHandle([1, 1], center, lockAspect=True)
|
|
self.addScaleHandle([0, 0], center, lockAspect=True)
|
|
self.addRotateHandle([0, 1], center)
|
|
self.addRotateHandle([1, 0], center)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|