")
+ self.output.insertPlainText(strn)
+ #self.stdout.write(strn)
+
+ def displayException(self):
+ """
+ Display the current exception and stack.
+ """
+ tb = traceback.format_exc()
+ lines = []
+ indent = 4
+ prefix = ''
+ for l in tb.split('\n'):
+ lines.append(" "*indent + prefix + l)
+ self.write('\n'.join(lines))
+ self.exceptionHandler(*sys.exc_info())
+
+ def cmdSelected(self, item):
+ index = -(self.ui.historyList.row(item)+1)
+ self.input.setHistory(index)
+ self.input.setFocus()
+
+ def cmdDblClicked(self, item):
+ index = -(self.ui.historyList.row(item)+1)
+ self.input.setHistory(index)
+ self.input.execCmd()
+
+ def flush(self):
+ pass
+
+ def catchAllExceptions(self, catch=True):
+ """
+ If True, the console will catch all unhandled exceptions and display the stack
+ trace. Each exception caught clears the last.
+ """
+ self.ui.catchAllExceptionsBtn.setChecked(catch)
+ if catch:
+ self.ui.catchNextExceptionBtn.setChecked(False)
+ self.enableExceptionHandling()
+ self.ui.exceptionBtn.setChecked(True)
+ else:
+ self.disableExceptionHandling()
+
+ def catchNextException(self, catch=True):
+ """
+ If True, the console will catch the next unhandled exception and display the stack
+ trace.
+ """
+ self.ui.catchNextExceptionBtn.setChecked(catch)
+ if catch:
+ self.ui.catchAllExceptionsBtn.setChecked(False)
+ self.enableExceptionHandling()
+ self.ui.exceptionBtn.setChecked(True)
+ else:
+ self.disableExceptionHandling()
+
+ def enableExceptionHandling(self):
+ exceptionHandling.register(self.exceptionHandler)
+ self.updateSysTrace()
+
+ def disableExceptionHandling(self):
+ exceptionHandling.unregister(self.exceptionHandler)
+ self.updateSysTrace()
+
+ def clearExceptionClicked(self):
+ self.currentTraceback = None
+ self.ui.exceptionInfoLabel.setText("[No current exception]")
+ self.ui.exceptionStackList.clear()
+ self.ui.clearExceptionBtn.setEnabled(False)
+
+ def stackItemClicked(self, item):
+ pass
+
+ def stackItemDblClicked(self, item):
+ editor = self.editor
+ if editor is None:
+ editor = pg.getConfigOption('editorCommand')
+ if editor is None:
+ return
+ tb = self.currentFrame()
+ lineNum = tb.tb_lineno
+ fileName = tb.tb_frame.f_code.co_filename
+ subprocess.Popen(self.editor.format(fileName=fileName, lineNum=lineNum), shell=True)
+
+
+ #def allExceptionsHandler(self, *args):
+ #self.exceptionHandler(*args)
+
+ #def nextExceptionHandler(self, *args):
+ #self.ui.catchNextExceptionBtn.setChecked(False)
+ #self.exceptionHandler(*args)
+
+ def updateSysTrace(self):
+ ## Install or uninstall sys.settrace handler
+
+ if not self.ui.catchNextExceptionBtn.isChecked() and not self.ui.catchAllExceptionsBtn.isChecked():
+ if sys.gettrace() == self.systrace:
+ sys.settrace(None)
+ return
+
+ if self.ui.onlyUncaughtCheck.isChecked():
+ if sys.gettrace() == self.systrace:
+ sys.settrace(None)
+ else:
+ if sys.gettrace() is not None and sys.gettrace() != self.systrace:
+ self.ui.onlyUncaughtCheck.setChecked(False)
+ raise Exception("sys.settrace is in use; cannot monitor for caught exceptions.")
+ else:
+ sys.settrace(self.systrace)
+
+ def exceptionHandler(self, excType, exc, tb):
+ if self.ui.catchNextExceptionBtn.isChecked():
+ self.ui.catchNextExceptionBtn.setChecked(False)
+ elif not self.ui.catchAllExceptionsBtn.isChecked():
+ return
+
+ self.ui.clearExceptionBtn.setEnabled(True)
+ self.currentTraceback = tb
+
+ excMessage = ''.join(traceback.format_exception_only(excType, exc))
+ self.ui.exceptionInfoLabel.setText(excMessage)
+ self.ui.exceptionStackList.clear()
+ for index, line in enumerate(traceback.extract_tb(tb)):
+ self.ui.exceptionStackList.addItem('File "%s", line %s, in %s()\n %s' % line)
+
+ def systrace(self, frame, event, arg):
+ if event == 'exception' and self.checkException(*arg):
+ self.exceptionHandler(*arg)
+ return self.systrace
+
+ def checkException(self, excType, exc, tb):
+ ## Return True if the exception is interesting; False if it should be ignored.
+
+ filename = tb.tb_frame.f_code.co_filename
+ function = tb.tb_frame.f_code.co_name
+
+ ## Go through a list of common exception points we like to ignore:
+ if excType is GeneratorExit or excType is StopIteration:
+ return False
+ if excType is KeyError:
+ if filename.endswith('python2.7/weakref.py') and function in ('__contains__', 'get'):
+ return False
+ if filename.endswith('python2.7/copy.py') and function == '_keep_alive':
+ return False
+ if excType is AttributeError:
+ if filename.endswith('python2.7/collections.py') and function == '__init__':
+ return False
+ if filename.endswith('numpy/core/fromnumeric.py') and function in ('all', '_wrapit', 'transpose', 'sum'):
+ return False
+ if filename.endswith('numpy/core/arrayprint.py') and function in ('_array2string'):
+ return False
+ if filename.endswith('MetaArray.py') and function == '__getattr__':
+ for name in ('__array_interface__', '__array_struct__', '__array__'): ## numpy looks for these when converting objects to array
+ if name in exc:
+ return False
+ if filename.endswith('flowchart/eq.py'):
+ return False
+ if filename.endswith('pyqtgraph/functions.py') and function == 'makeQImage':
+ return False
+ if excType is TypeError:
+ if filename.endswith('numpy/lib/function_base.py') and function == 'iterable':
+ return False
+ if excType is ZeroDivisionError:
+ if filename.endswith('python2.7/traceback.py'):
+ return False
+
+ return True
+
\ No newline at end of file
diff --git a/pyqtgraph/console/__init__.py b/pyqtgraph/console/__init__.py
new file mode 100644
index 00000000..16436abd
--- /dev/null
+++ b/pyqtgraph/console/__init__.py
@@ -0,0 +1 @@
+from .Console import ConsoleWidget
\ No newline at end of file
diff --git a/pyqtgraph/console/template.ui b/pyqtgraph/console/template.ui
new file mode 100644
index 00000000..6e5c5be3
--- /dev/null
+++ b/pyqtgraph/console/template.ui
@@ -0,0 +1,184 @@
+
+
+ Form
+
+
+
+ 0
+ 0
+ 710
+ 497
+
+
+
+ Console
+
+
+
+ 0
+
+
+ 0
+
+ -
+
+
+ Qt::Vertical
+
+
+
+
-
+
+
+
+ Monospace
+
+
+
+ true
+
+
+
+ -
+
+
-
+
+
+ -
+
+
+ History..
+
+
+ true
+
+
+
+ -
+
+
+ Exceptions..
+
+
+ true
+
+
+
+
+
+
+
+
+
+
+ Monospace
+
+
+
+
+
+ Exception Handling
+
+
+
+ 0
+
+
+ 0
+
+
+ 0
+
+ -
+
+
+ Show All Exceptions
+
+
+ true
+
+
+
+ -
+
+
+ Show Next Exception
+
+
+ true
+
+
+
+ -
+
+
+ Only Uncaught Exceptions
+
+
+ true
+
+
+
+ -
+
+
+ true
+
+
+
+ -
+
+
+ Run commands in selected stack frame
+
+
+ true
+
+
+
+ -
+
+
+ Exception Info
+
+
+
+ -
+
+
+ false
+
+
+ Clear Exception
+
+
+
+ -
+
+
+ Qt::Horizontal
+
+
+
+ 40
+ 20
+
+
+
+
+
+
+
+
+
+
+
+
+ CmdInput
+ QLineEdit
+
+
+
+
+
+
diff --git a/pyqtgraph/console/template_pyqt.py b/pyqtgraph/console/template_pyqt.py
new file mode 100644
index 00000000..89ee6cff
--- /dev/null
+++ b/pyqtgraph/console/template_pyqt.py
@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file './console/template.ui'
+#
+# Created: Sun Sep 9 14:41:30 2012
+# by: PyQt4 UI code generator 4.9.1
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+ _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+ _fromUtf8 = lambda s: s
+
+class Ui_Form(object):
+ def setupUi(self, Form):
+ Form.setObjectName(_fromUtf8("Form"))
+ Form.resize(710, 497)
+ self.gridLayout = QtGui.QGridLayout(Form)
+ self.gridLayout.setMargin(0)
+ self.gridLayout.setSpacing(0)
+ self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
+ self.splitter = QtGui.QSplitter(Form)
+ self.splitter.setOrientation(QtCore.Qt.Vertical)
+ self.splitter.setObjectName(_fromUtf8("splitter"))
+ self.layoutWidget = QtGui.QWidget(self.splitter)
+ self.layoutWidget.setObjectName(_fromUtf8("layoutWidget"))
+ self.verticalLayout = QtGui.QVBoxLayout(self.layoutWidget)
+ self.verticalLayout.setMargin(0)
+ self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
+ self.output = QtGui.QPlainTextEdit(self.layoutWidget)
+ font = QtGui.QFont()
+ font.setFamily(_fromUtf8("Monospace"))
+ self.output.setFont(font)
+ self.output.setReadOnly(True)
+ self.output.setObjectName(_fromUtf8("output"))
+ self.verticalLayout.addWidget(self.output)
+ self.horizontalLayout = QtGui.QHBoxLayout()
+ self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
+ self.input = CmdInput(self.layoutWidget)
+ self.input.setObjectName(_fromUtf8("input"))
+ self.horizontalLayout.addWidget(self.input)
+ self.historyBtn = QtGui.QPushButton(self.layoutWidget)
+ self.historyBtn.setCheckable(True)
+ self.historyBtn.setObjectName(_fromUtf8("historyBtn"))
+ self.horizontalLayout.addWidget(self.historyBtn)
+ self.exceptionBtn = QtGui.QPushButton(self.layoutWidget)
+ self.exceptionBtn.setCheckable(True)
+ self.exceptionBtn.setObjectName(_fromUtf8("exceptionBtn"))
+ self.horizontalLayout.addWidget(self.exceptionBtn)
+ self.verticalLayout.addLayout(self.horizontalLayout)
+ self.historyList = QtGui.QListWidget(self.splitter)
+ font = QtGui.QFont()
+ font.setFamily(_fromUtf8("Monospace"))
+ self.historyList.setFont(font)
+ self.historyList.setObjectName(_fromUtf8("historyList"))
+ self.exceptionGroup = QtGui.QGroupBox(self.splitter)
+ self.exceptionGroup.setObjectName(_fromUtf8("exceptionGroup"))
+ self.gridLayout_2 = QtGui.QGridLayout(self.exceptionGroup)
+ self.gridLayout_2.setSpacing(0)
+ self.gridLayout_2.setContentsMargins(-1, 0, -1, 0)
+ self.gridLayout_2.setObjectName(_fromUtf8("gridLayout_2"))
+ self.catchAllExceptionsBtn = QtGui.QPushButton(self.exceptionGroup)
+ self.catchAllExceptionsBtn.setCheckable(True)
+ self.catchAllExceptionsBtn.setObjectName(_fromUtf8("catchAllExceptionsBtn"))
+ self.gridLayout_2.addWidget(self.catchAllExceptionsBtn, 0, 1, 1, 1)
+ self.catchNextExceptionBtn = QtGui.QPushButton(self.exceptionGroup)
+ self.catchNextExceptionBtn.setCheckable(True)
+ self.catchNextExceptionBtn.setObjectName(_fromUtf8("catchNextExceptionBtn"))
+ self.gridLayout_2.addWidget(self.catchNextExceptionBtn, 0, 0, 1, 1)
+ self.onlyUncaughtCheck = QtGui.QCheckBox(self.exceptionGroup)
+ self.onlyUncaughtCheck.setChecked(True)
+ self.onlyUncaughtCheck.setObjectName(_fromUtf8("onlyUncaughtCheck"))
+ self.gridLayout_2.addWidget(self.onlyUncaughtCheck, 0, 2, 1, 1)
+ self.exceptionStackList = QtGui.QListWidget(self.exceptionGroup)
+ self.exceptionStackList.setAlternatingRowColors(True)
+ self.exceptionStackList.setObjectName(_fromUtf8("exceptionStackList"))
+ self.gridLayout_2.addWidget(self.exceptionStackList, 2, 0, 1, 5)
+ self.runSelectedFrameCheck = QtGui.QCheckBox(self.exceptionGroup)
+ self.runSelectedFrameCheck.setChecked(True)
+ self.runSelectedFrameCheck.setObjectName(_fromUtf8("runSelectedFrameCheck"))
+ self.gridLayout_2.addWidget(self.runSelectedFrameCheck, 3, 0, 1, 5)
+ self.exceptionInfoLabel = QtGui.QLabel(self.exceptionGroup)
+ self.exceptionInfoLabel.setObjectName(_fromUtf8("exceptionInfoLabel"))
+ self.gridLayout_2.addWidget(self.exceptionInfoLabel, 1, 0, 1, 5)
+ self.clearExceptionBtn = QtGui.QPushButton(self.exceptionGroup)
+ self.clearExceptionBtn.setEnabled(False)
+ self.clearExceptionBtn.setObjectName(_fromUtf8("clearExceptionBtn"))
+ self.gridLayout_2.addWidget(self.clearExceptionBtn, 0, 4, 1, 1)
+ spacerItem = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
+ self.gridLayout_2.addItem(spacerItem, 0, 3, 1, 1)
+ self.gridLayout.addWidget(self.splitter, 0, 0, 1, 1)
+
+ self.retranslateUi(Form)
+ QtCore.QMetaObject.connectSlotsByName(Form)
+
+ def retranslateUi(self, Form):
+ Form.setWindowTitle(QtGui.QApplication.translate("Form", "Console", None, QtGui.QApplication.UnicodeUTF8))
+ self.historyBtn.setText(QtGui.QApplication.translate("Form", "History..", None, QtGui.QApplication.UnicodeUTF8))
+ self.exceptionBtn.setText(QtGui.QApplication.translate("Form", "Exceptions..", None, QtGui.QApplication.UnicodeUTF8))
+ self.exceptionGroup.setTitle(QtGui.QApplication.translate("Form", "Exception Handling", None, QtGui.QApplication.UnicodeUTF8))
+ self.catchAllExceptionsBtn.setText(QtGui.QApplication.translate("Form", "Show All Exceptions", None, QtGui.QApplication.UnicodeUTF8))
+ self.catchNextExceptionBtn.setText(QtGui.QApplication.translate("Form", "Show Next Exception", None, QtGui.QApplication.UnicodeUTF8))
+ self.onlyUncaughtCheck.setText(QtGui.QApplication.translate("Form", "Only Uncaught Exceptions", None, QtGui.QApplication.UnicodeUTF8))
+ self.runSelectedFrameCheck.setText(QtGui.QApplication.translate("Form", "Run commands in selected stack frame", None, QtGui.QApplication.UnicodeUTF8))
+ self.exceptionInfoLabel.setText(QtGui.QApplication.translate("Form", "Exception Info", None, QtGui.QApplication.UnicodeUTF8))
+ self.clearExceptionBtn.setText(QtGui.QApplication.translate("Form", "Clear Exception", None, QtGui.QApplication.UnicodeUTF8))
+
+from .CmdInput import CmdInput
diff --git a/pyqtgraph/console/template_pyside.py b/pyqtgraph/console/template_pyside.py
new file mode 100644
index 00000000..0493a0fe
--- /dev/null
+++ b/pyqtgraph/console/template_pyside.py
@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file './console/template.ui'
+#
+# Created: Sun Sep 9 14:41:30 2012
+# by: pyside-uic 0.2.13 running on PySide 1.1.0
+#
+# WARNING! All changes made in this file will be lost!
+
+from PySide import QtCore, QtGui
+
+class Ui_Form(object):
+ def setupUi(self, Form):
+ Form.setObjectName("Form")
+ Form.resize(710, 497)
+ self.gridLayout = QtGui.QGridLayout(Form)
+ self.gridLayout.setContentsMargins(0, 0, 0, 0)
+ self.gridLayout.setSpacing(0)
+ self.gridLayout.setObjectName("gridLayout")
+ self.splitter = QtGui.QSplitter(Form)
+ self.splitter.setOrientation(QtCore.Qt.Vertical)
+ self.splitter.setObjectName("splitter")
+ self.layoutWidget = QtGui.QWidget(self.splitter)
+ self.layoutWidget.setObjectName("layoutWidget")
+ self.verticalLayout = QtGui.QVBoxLayout(self.layoutWidget)
+ self.verticalLayout.setContentsMargins(0, 0, 0, 0)
+ self.verticalLayout.setObjectName("verticalLayout")
+ self.output = QtGui.QPlainTextEdit(self.layoutWidget)
+ font = QtGui.QFont()
+ font.setFamily("Monospace")
+ self.output.setFont(font)
+ self.output.setReadOnly(True)
+ self.output.setObjectName("output")
+ self.verticalLayout.addWidget(self.output)
+ self.horizontalLayout = QtGui.QHBoxLayout()
+ self.horizontalLayout.setObjectName("horizontalLayout")
+ self.input = CmdInput(self.layoutWidget)
+ self.input.setObjectName("input")
+ self.horizontalLayout.addWidget(self.input)
+ self.historyBtn = QtGui.QPushButton(self.layoutWidget)
+ self.historyBtn.setCheckable(True)
+ self.historyBtn.setObjectName("historyBtn")
+ self.horizontalLayout.addWidget(self.historyBtn)
+ self.exceptionBtn = QtGui.QPushButton(self.layoutWidget)
+ self.exceptionBtn.setCheckable(True)
+ self.exceptionBtn.setObjectName("exceptionBtn")
+ self.horizontalLayout.addWidget(self.exceptionBtn)
+ self.verticalLayout.addLayout(self.horizontalLayout)
+ self.historyList = QtGui.QListWidget(self.splitter)
+ font = QtGui.QFont()
+ font.setFamily("Monospace")
+ self.historyList.setFont(font)
+ self.historyList.setObjectName("historyList")
+ self.exceptionGroup = QtGui.QGroupBox(self.splitter)
+ self.exceptionGroup.setObjectName("exceptionGroup")
+ self.gridLayout_2 = QtGui.QGridLayout(self.exceptionGroup)
+ self.gridLayout_2.setSpacing(0)
+ self.gridLayout_2.setContentsMargins(-1, 0, -1, 0)
+ self.gridLayout_2.setObjectName("gridLayout_2")
+ self.catchAllExceptionsBtn = QtGui.QPushButton(self.exceptionGroup)
+ self.catchAllExceptionsBtn.setCheckable(True)
+ self.catchAllExceptionsBtn.setObjectName("catchAllExceptionsBtn")
+ self.gridLayout_2.addWidget(self.catchAllExceptionsBtn, 0, 1, 1, 1)
+ self.catchNextExceptionBtn = QtGui.QPushButton(self.exceptionGroup)
+ self.catchNextExceptionBtn.setCheckable(True)
+ self.catchNextExceptionBtn.setObjectName("catchNextExceptionBtn")
+ self.gridLayout_2.addWidget(self.catchNextExceptionBtn, 0, 0, 1, 1)
+ self.onlyUncaughtCheck = QtGui.QCheckBox(self.exceptionGroup)
+ self.onlyUncaughtCheck.setChecked(True)
+ self.onlyUncaughtCheck.setObjectName("onlyUncaughtCheck")
+ self.gridLayout_2.addWidget(self.onlyUncaughtCheck, 0, 2, 1, 1)
+ self.exceptionStackList = QtGui.QListWidget(self.exceptionGroup)
+ self.exceptionStackList.setAlternatingRowColors(True)
+ self.exceptionStackList.setObjectName("exceptionStackList")
+ self.gridLayout_2.addWidget(self.exceptionStackList, 2, 0, 1, 5)
+ self.runSelectedFrameCheck = QtGui.QCheckBox(self.exceptionGroup)
+ self.runSelectedFrameCheck.setChecked(True)
+ self.runSelectedFrameCheck.setObjectName("runSelectedFrameCheck")
+ self.gridLayout_2.addWidget(self.runSelectedFrameCheck, 3, 0, 1, 5)
+ self.exceptionInfoLabel = QtGui.QLabel(self.exceptionGroup)
+ self.exceptionInfoLabel.setObjectName("exceptionInfoLabel")
+ self.gridLayout_2.addWidget(self.exceptionInfoLabel, 1, 0, 1, 5)
+ self.clearExceptionBtn = QtGui.QPushButton(self.exceptionGroup)
+ self.clearExceptionBtn.setEnabled(False)
+ self.clearExceptionBtn.setObjectName("clearExceptionBtn")
+ self.gridLayout_2.addWidget(self.clearExceptionBtn, 0, 4, 1, 1)
+ spacerItem = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
+ self.gridLayout_2.addItem(spacerItem, 0, 3, 1, 1)
+ self.gridLayout.addWidget(self.splitter, 0, 0, 1, 1)
+
+ self.retranslateUi(Form)
+ QtCore.QMetaObject.connectSlotsByName(Form)
+
+ def retranslateUi(self, Form):
+ Form.setWindowTitle(QtGui.QApplication.translate("Form", "Console", None, QtGui.QApplication.UnicodeUTF8))
+ self.historyBtn.setText(QtGui.QApplication.translate("Form", "History..", None, QtGui.QApplication.UnicodeUTF8))
+ self.exceptionBtn.setText(QtGui.QApplication.translate("Form", "Exceptions..", None, QtGui.QApplication.UnicodeUTF8))
+ self.exceptionGroup.setTitle(QtGui.QApplication.translate("Form", "Exception Handling", None, QtGui.QApplication.UnicodeUTF8))
+ self.catchAllExceptionsBtn.setText(QtGui.QApplication.translate("Form", "Show All Exceptions", None, QtGui.QApplication.UnicodeUTF8))
+ self.catchNextExceptionBtn.setText(QtGui.QApplication.translate("Form", "Show Next Exception", None, QtGui.QApplication.UnicodeUTF8))
+ self.onlyUncaughtCheck.setText(QtGui.QApplication.translate("Form", "Only Uncaught Exceptions", None, QtGui.QApplication.UnicodeUTF8))
+ self.runSelectedFrameCheck.setText(QtGui.QApplication.translate("Form", "Run commands in selected stack frame", None, QtGui.QApplication.UnicodeUTF8))
+ self.exceptionInfoLabel.setText(QtGui.QApplication.translate("Form", "Exception Info", None, QtGui.QApplication.UnicodeUTF8))
+ self.clearExceptionBtn.setText(QtGui.QApplication.translate("Form", "Clear Exception", None, QtGui.QApplication.UnicodeUTF8))
+
+from .CmdInput import CmdInput
diff --git a/debug.py b/pyqtgraph/debug.py
similarity index 90%
rename from debug.py
rename to pyqtgraph/debug.py
index 2a2157db..ea9157aa 100644
--- a/debug.py
+++ b/pyqtgraph/debug.py
@@ -6,9 +6,9 @@ Distributed under MIT/X11 license. See license.txt for more infomation.
"""
import sys, traceback, time, gc, re, types, weakref, inspect, os, cProfile
-import ptime
+from . import ptime
from numpy import ndarray
-from PyQt4 import QtCore, QtGui
+from .Qt import QtCore, QtGui
__ftraceDepth = 0
def ftrace(func):
@@ -18,13 +18,13 @@ def ftrace(func):
def w(*args, **kargs):
global __ftraceDepth
pfx = " " * __ftraceDepth
- print pfx + func.__name__ + " start"
+ print(pfx + func.__name__ + " start")
__ftraceDepth += 1
try:
rv = func(*args, **kargs)
finally:
__ftraceDepth -= 1
- print pfx + func.__name__ + " done"
+ print(pfx + func.__name__ + " done")
return rv
return w
@@ -39,20 +39,20 @@ def printExc(msg='', indent=4, prefix='|'):
"""Print an error message followed by an indented exception backtrace
(This function is intended to be called within except: blocks)"""
exc = getExc(indent, prefix + ' ')
- print "[%s] %s\n" % (time.strftime("%H:%M:%S"), msg)
- print " "*indent + prefix + '='*30 + '>>'
- print exc
- print " "*indent + prefix + '='*30 + '<<'
+ print("[%s] %s\n" % (time.strftime("%H:%M:%S"), msg))
+ print(" "*indent + prefix + '='*30 + '>>')
+ print(exc)
+ print(" "*indent + prefix + '='*30 + '<<')
def printTrace(msg='', indent=4, prefix='|'):
"""Print an error message followed by an indented stack trace"""
trace = backtrace(1)
#exc = getExc(indent, prefix + ' ')
- print "[%s] %s\n" % (time.strftime("%H:%M:%S"), msg)
- print " "*indent + prefix + '='*30 + '>>'
+ print("[%s] %s\n" % (time.strftime("%H:%M:%S"), msg))
+ print(" "*indent + prefix + '='*30 + '>>')
for line in trace.split('\n'):
- print " "*indent + prefix + " " + line
- print " "*indent + prefix + '='*30 + '<<'
+ print(" "*indent + prefix + " " + line)
+ print(" "*indent + prefix + '='*30 + '<<')
def backtrace(skip=0):
@@ -107,12 +107,12 @@ def findRefPath(startObj, endObj, maxLen=8, restart=True, seen={}, path=None, ig
#print prefix+" LOOP", objChainString([r]+path)
continue
except:
- print r
- print path
+ print(r)
+ print(path)
raise
if r is startObj:
refs.append([r])
- print refPathString([startObj]+path)
+ print(refPathString([startObj]+path))
continue
if maxLen == 0:
#print prefix+" END:", objChainString([r]+path)
@@ -125,7 +125,7 @@ def findRefPath(startObj, endObj, maxLen=8, restart=True, seen={}, path=None, ig
if cache[0] >= maxLen:
tree = cache[1]
for p in tree:
- print refPathString(p+path)
+ print(refPathString(p+path))
except KeyError:
pass
@@ -147,14 +147,14 @@ def findRefPath(startObj, endObj, maxLen=8, restart=True, seen={}, path=None, ig
def objString(obj):
"""Return a short but descriptive string for any object"""
try:
- if type(obj) in [int, long, float]:
+ if type(obj) in [int, float]:
return str(obj)
elif isinstance(obj, dict):
if len(obj) > 5:
- return "
" % (",".join(obj.keys()[:5]))
+ return "" % (",".join(list(obj.keys())[:5]))
else:
- return "" % (",".join(obj.keys()))
- elif isinstance(obj, basestring):
+ return "" % (",".join(list(obj.keys())))
+ elif isinstance(obj, str):
if len(obj) > 50:
return '"%s..."' % obj[:50]
else:
@@ -261,19 +261,19 @@ def objectSize(obj, ignore=None, verbose=False, depth=0, recursive=False):
if recursive:
if type(obj) in [list, tuple]:
if verbose:
- print indent+"list:"
+ print(indent+"list:")
for o in obj:
s = objectSize(o, ignore=ignore, verbose=verbose, depth=depth+1)
if verbose:
- print indent+' +', s
+ print(indent+' +', s)
size += s
elif isinstance(obj, dict):
if verbose:
- print indent+"list:"
+ print(indent+"list:")
for k in obj:
s = objectSize(obj[k], ignore=ignore, verbose=verbose, depth=depth+1)
if verbose:
- print indent+' +', k, s
+ print(indent+' +', k, s)
size += s
#elif isinstance(obj, QtCore.QObject):
#try:
@@ -291,7 +291,7 @@ def objectSize(obj, ignore=None, verbose=False, depth=0, recursive=False):
#if isinstance(obj, types.InstanceType):
gc.collect()
if verbose:
- print indent+'attrs:'
+ print(indent+'attrs:')
for k in dir(obj):
if k in ['__dict__']:
continue
@@ -311,13 +311,13 @@ def objectSize(obj, ignore=None, verbose=False, depth=0, recursive=False):
s = objectSize(o, ignore=ignore, verbose=verbose, depth=depth+1)
size += s
if verbose:
- print indent + " +", k, s
+ print(indent + " +", k, s)
#else:
#if verbose:
#print indent + ' -', k, len(refs)
return size
-class GarbageWatcher:
+class GarbageWatcher(object):
"""
Convenient dictionary for holding weak references to objects.
Mainly used to check whether the objects have been collect yet or not.
@@ -349,14 +349,14 @@ class GarbageWatcher:
for k in self.objs:
dead.remove(k)
alive.append(k)
- print "Deleted objects:", dead
- print "Live objects:", alive
+ print("Deleted objects:", dead)
+ print("Live objects:", alive)
def __getitem__(self, item):
return self.objs[item]
-class Profiler:
+class Profiler(object):
"""Simple profiler allowing measurement of multiple time intervals.
Example:
@@ -379,20 +379,20 @@ class Profiler:
self.t0 = ptime.time()
self.t1 = self.t0
self.msg = " "*self.depth + msg
- print self.msg, ">>> Started"
+ print(self.msg, ">>> Started")
def mark(self, msg=''):
if self.disabled:
return
t1 = ptime.time()
- print " "+self.msg, msg, "%gms" % ((t1-self.t1)*1000)
+ print(" "+self.msg, msg, "%gms" % ((t1-self.t1)*1000))
self.t1 = t1
def finish(self):
if self.disabled:
return
t1 = ptime.time()
- print self.msg, '<<< Finished, total time:', "%gms" % ((t1-self.t0)*1000)
+ print(self.msg, '<<< Finished, total time:', "%gms" % ((t1-self.t0)*1000))
def __del__(self):
Profiler.depth -= 1
@@ -419,7 +419,7 @@ def _getr(slist, olist, first=True):
oid = id(e)
typ = type(e)
- if oid in olist or typ is int or typ is long: ## or e in olist: ## since we're excluding all ints, there is no longer a need to check for olist keys
+ if oid in olist or typ is int: ## or e in olist: ## since we're excluding all ints, there is no longer a need to check for olist keys
continue
olist[oid] = e
if first and (i%1000) == 0:
@@ -451,7 +451,7 @@ def lookup(oid, objects=None):
-class ObjTracker:
+class ObjTracker(object):
"""
Tracks all objects under the sun, reporting the changes between snapshots: what objects are created, deleted, and persistent.
This class is very useful for tracking memory leaks. The class goes to great (but not heroic) lengths to avoid tracking
@@ -565,23 +565,23 @@ class ObjTracker:
self.persistentRefs.update(persistentRefs)
- print "----------- Count changes since start: ----------"
+ print("----------- Count changes since start: ----------")
c1 = count.copy()
for k in self.startCount:
c1[k] = c1.get(k, 0) - self.startCount[k]
- typs = c1.keys()
+ typs = list(c1.keys())
typs.sort(lambda a,b: cmp(c1[a], c1[b]))
for t in typs:
if c1[t] == 0:
continue
num = "%d" % c1[t]
- print " " + num + " "*(10-len(num)) + str(t)
+ print(" " + num + " "*(10-len(num)) + str(t))
- print "----------- %d Deleted since last diff: ------------" % len(delRefs)
+ print("----------- %d Deleted since last diff: ------------" % len(delRefs))
self.report(delRefs, objs, **kargs)
- print "----------- %d Created since last diff: ------------" % len(createRefs)
+ print("----------- %d Created since last diff: ------------" % len(createRefs))
self.report(createRefs, objs, **kargs)
- print "----------- %d Created since start (persistent): ------------" % len(persistentRefs)
+ print("----------- %d Created since start (persistent): ------------" % len(persistentRefs))
self.report(persistentRefs, objs, **kargs)
@@ -600,14 +600,14 @@ class ObjTracker:
return type(o) is cls or id(o) in cls.allObjs
def collect(self):
- print "Collecting list of all objects..."
+ print("Collecting list of all objects...")
gc.collect()
objs = get_all_objects()
frame = sys._getframe()
del objs[id(frame)] ## ignore the current frame
del objs[id(frame.f_code)]
- ignoreTypes = [int, long]
+ ignoreTypes = [int]
refs = {}
count = {}
for k in objs:
@@ -628,7 +628,7 @@ class ObjTracker:
ObjTracker.allObjs[id(typStr)] = None
count[typ] = count.get(typ, 0) + 1
- print "All objects: %d Tracked objects: %d" % (len(objs), len(refs))
+ print("All objects: %d Tracked objects: %d" % (len(objs), len(refs)))
return refs, count, objs
def forgetRef(self, ref):
@@ -669,14 +669,14 @@ class ObjTracker:
rev[typ].append(oid)
c = count.get(typ, [0,0])
count[typ] = [c[0]+1, c[1]+objectSize(obj)]
- typs = count.keys()
+ typs = list(count.keys())
typs.sort(lambda a,b: cmp(count[a][1], count[b][1]))
for t in typs:
line = " %d\t%d\t%s" % (count[t][0], count[t][1], t)
if showIDs:
line += "\t"+",".join(map(str,rev[t]))
- print line
+ print(line)
def findTypes(self, refs, regex):
allObjs = get_all_objects()
@@ -709,21 +709,21 @@ def describeObj(obj, depth=4, path=None, ignore=None):
for ref in refs:
if id(ref) in ignore:
continue
- if id(ref) in map(id, path):
- print "Cyclic reference: " + refPathString([ref]+path)
+ if id(ref) in list(map(id, path)):
+ print("Cyclic reference: " + refPathString([ref]+path))
printed = True
continue
newPath = [ref]+path
if len(newPath) >= depth:
refStr = refPathString(newPath)
if '[_]' not in refStr: ## ignore '_' references generated by the interactive shell
- print refStr
+ print(refStr)
printed = True
else:
describeObj(ref, depth, newPath, ignore)
printed = True
if not printed:
- print "Dead end: " + refPathString(path)
+ print("Dead end: " + refPathString(path))
@@ -773,18 +773,18 @@ def searchRefs(obj, *args):
ignore[id(refs)] = None
refs = [r for r in refs if id(r) not in ignore]
elif a == 't':
- print map(typeStr, refs)
+ print(list(map(typeStr, refs)))
elif a == 'i':
- print map(id, refs)
+ print(list(map(id, refs)))
elif a == 'l':
def slen(o):
if hasattr(o, '__len__'):
return len(o)
else:
return None
- print map(slen, refs)
+ print(list(map(slen, refs)))
elif a == 'o':
- print obj
+ print(obj)
elif a == 'ro':
return obj
elif a == 'rr':
@@ -820,14 +820,14 @@ def findObj(regex):
def listRedundantModules():
"""List modules that have been imported more than once via different paths."""
mods = {}
- for name, mod in sys.modules.iteritems():
+ for name, mod in sys.modules.items():
if not hasattr(mod, '__file__'):
continue
mfile = os.path.abspath(mod.__file__)
if mfile[-1] == 'c':
mfile = mfile[:-1]
if mfile in mods:
- print "module at %s has 2 names: %s, %s" % (mfile, name, mods[mfile])
+ print("module at %s has 2 names: %s, %s" % (mfile, name, mods[mfile]))
else:
mods[mfile] = name
@@ -841,7 +841,7 @@ def walkQObjectTree(obj, counts=None, verbose=False, depth=0):
"""
if verbose:
- print " "*depth + typeStr(obj)
+ print(" "*depth + typeStr(obj))
report = False
if counts is None:
counts = {}
@@ -871,12 +871,12 @@ def qObjectReport(verbose=False):
QObjCache[oid] += " " + obj.text()
except:
pass
- print "check obj", oid, unicode(QObjCache[oid])
+ print("check obj", oid, str(QObjCache[oid]))
if obj.parent() is None:
walkQObjectTree(obj, count, verbose)
- typs = count.keys()
+ typs = list(count.keys())
typs.sort()
for t in typs:
- print count[t], "\t", t
+ print(count[t], "\t", t)
diff --git a/pyqtgraph/dockarea/Container.py b/pyqtgraph/dockarea/Container.py
new file mode 100644
index 00000000..83610937
--- /dev/null
+++ b/pyqtgraph/dockarea/Container.py
@@ -0,0 +1,267 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui
+import weakref
+
+class Container(object):
+ #sigStretchChanged = QtCore.Signal() ## can't do this here; not a QObject.
+
+ def __init__(self, area):
+ object.__init__(self)
+ self.area = area
+ self._container = None
+ self._stretch = (10, 10)
+ self.stretches = weakref.WeakKeyDictionary()
+
+ def container(self):
+ return self._container
+
+ def containerChanged(self, c):
+ self._container = c
+
+ def type(self):
+ return None
+
+ def insert(self, new, pos=None, neighbor=None):
+ if not isinstance(new, list):
+ new = [new]
+ if neighbor is None:
+ if pos == 'before':
+ index = 0
+ else:
+ index = self.count()
+ else:
+ index = self.indexOf(neighbor)
+ if index == -1:
+ index = 0
+ if pos == 'after':
+ index += 1
+
+ for n in new:
+ #print "change container", n, " -> ", self
+ n.containerChanged(self)
+ #print "insert", n, " -> ", self, index
+ self._insertItem(n, index)
+ index += 1
+ n.sigStretchChanged.connect(self.childStretchChanged)
+ #print "child added", self
+ self.updateStretch()
+
+ def apoptose(self, propagate=True):
+ ##if there is only one (or zero) item in this container, disappear.
+ cont = self._container
+ c = self.count()
+ if c > 1:
+ return
+ if self.count() == 1: ## if there is one item, give it to the parent container (unless this is the top)
+ if self is self.area.topContainer:
+ return
+ self.container().insert(self.widget(0), 'before', self)
+ #print "apoptose:", self
+ self.close()
+ if propagate and cont is not None:
+ cont.apoptose()
+
+ def close(self):
+ self.area = None
+ self._container = None
+ self.setParent(None)
+
+ def childEvent(self, ev):
+ ch = ev.child()
+ if ev.removed() and hasattr(ch, 'sigStretchChanged'):
+ #print "Child", ev.child(), "removed, updating", self
+ try:
+ ch.sigStretchChanged.disconnect(self.childStretchChanged)
+ except:
+ pass
+ self.updateStretch()
+
+ def childStretchChanged(self):
+ #print "child", QtCore.QObject.sender(self), "changed shape, updating", self
+ self.updateStretch()
+
+ def setStretch(self, x=None, y=None):
+ #print "setStretch", self, x, y
+ self._stretch = (x, y)
+ self.sigStretchChanged.emit()
+
+ def updateStretch(self):
+ ###Set the stretch values for this container to reflect its contents
+ pass
+
+
+ def stretch(self):
+ """Return the stretch factors for this container"""
+ return self._stretch
+
+
+class SplitContainer(Container, QtGui.QSplitter):
+ """Horizontal or vertical splitter with some changes:
+ - save/restore works correctly
+ """
+ sigStretchChanged = QtCore.Signal()
+
+ def __init__(self, area, orientation):
+ QtGui.QSplitter.__init__(self)
+ self.setOrientation(orientation)
+ Container.__init__(self, area)
+ #self.splitterMoved.connect(self.restretchChildren)
+
+ def _insertItem(self, item, index):
+ self.insertWidget(index, item)
+ item.show() ## need to show since it may have been previously hidden by tab
+
+ def saveState(self):
+ sizes = self.sizes()
+ if all([x == 0 for x in sizes]):
+ sizes = [10] * len(sizes)
+ return {'sizes': sizes}
+
+ def restoreState(self, state):
+ sizes = state['sizes']
+ self.setSizes(sizes)
+ for i in range(len(sizes)):
+ self.setStretchFactor(i, sizes[i])
+
+ def childEvent(self, ev):
+ QtGui.QSplitter.childEvent(self, ev)
+ Container.childEvent(self, ev)
+
+ #def restretchChildren(self):
+ #sizes = self.sizes()
+ #tot = sum(sizes)
+
+
+
+
+class HContainer(SplitContainer):
+ def __init__(self, area):
+ SplitContainer.__init__(self, area, QtCore.Qt.Horizontal)
+
+ def type(self):
+ return 'horizontal'
+
+ def updateStretch(self):
+ ##Set the stretch values for this container to reflect its contents
+ #print "updateStretch", self
+ x = 0
+ y = 0
+ sizes = []
+ for i in range(self.count()):
+ wx, wy = self.widget(i).stretch()
+ x += wx
+ y = max(y, wy)
+ sizes.append(wx)
+ #print " child", self.widget(i), wx, wy
+ self.setStretch(x, y)
+ #print sizes
+
+ tot = float(sum(sizes))
+ if tot == 0:
+ scale = 1.0
+ else:
+ scale = self.width() / tot
+ self.setSizes([int(s*scale) for s in sizes])
+
+
+
+class VContainer(SplitContainer):
+ def __init__(self, area):
+ SplitContainer.__init__(self, area, QtCore.Qt.Vertical)
+
+ def type(self):
+ return 'vertical'
+
+ def updateStretch(self):
+ ##Set the stretch values for this container to reflect its contents
+ #print "updateStretch", self
+ x = 0
+ y = 0
+ sizes = []
+ for i in range(self.count()):
+ wx, wy = self.widget(i).stretch()
+ y += wy
+ x = max(x, wx)
+ sizes.append(wy)
+ #print " child", self.widget(i), wx, wy
+ self.setStretch(x, y)
+
+ #print sizes
+ tot = float(sum(sizes))
+ if tot == 0:
+ scale = 1.0
+ else:
+ scale = self.height() / tot
+ self.setSizes([int(s*scale) for s in sizes])
+
+
+class TContainer(Container, QtGui.QWidget):
+ sigStretchChanged = QtCore.Signal()
+ def __init__(self, area):
+ QtGui.QWidget.__init__(self)
+ Container.__init__(self, area)
+ self.layout = QtGui.QGridLayout()
+ self.layout.setSpacing(0)
+ self.layout.setContentsMargins(0,0,0,0)
+ self.setLayout(self.layout)
+
+ self.hTabLayout = QtGui.QHBoxLayout()
+ self.hTabBox = QtGui.QWidget()
+ self.hTabBox.setLayout(self.hTabLayout)
+ self.hTabLayout.setSpacing(2)
+ self.hTabLayout.setContentsMargins(0,0,0,0)
+ self.layout.addWidget(self.hTabBox, 0, 1)
+
+ self.stack = QtGui.QStackedWidget()
+ self.layout.addWidget(self.stack, 1, 1)
+ self.stack.childEvent = self.stackChildEvent
+
+
+ self.setLayout(self.layout)
+ for n in ['count', 'widget', 'indexOf']:
+ setattr(self, n, getattr(self.stack, n))
+
+
+ def _insertItem(self, item, index):
+ if not isinstance(item, Dock.Dock):
+ raise Exception("Tab containers may hold only docks, not other containers.")
+ self.stack.insertWidget(index, item)
+ self.hTabLayout.insertWidget(index, item.label)
+ #QtCore.QObject.connect(item.label, QtCore.SIGNAL('clicked'), self.tabClicked)
+ item.label.sigClicked.connect(self.tabClicked)
+ self.tabClicked(item.label)
+
+ def tabClicked(self, tab, ev=None):
+ if ev is None or ev.button() == QtCore.Qt.LeftButton:
+ for i in range(self.count()):
+ w = self.widget(i)
+ if w is tab.dock:
+ w.label.setDim(False)
+ self.stack.setCurrentIndex(i)
+ else:
+ w.label.setDim(True)
+
+ def type(self):
+ return 'tab'
+
+ def saveState(self):
+ return {'index': self.stack.currentIndex()}
+
+ def restoreState(self, state):
+ self.stack.setCurrentIndex(state['index'])
+
+ def updateStretch(self):
+ ##Set the stretch values for this container to reflect its contents
+ x = 0
+ y = 0
+ for i in range(self.count()):
+ wx, wy = self.widget(i).stretch()
+ x = max(x, wx)
+ y = max(y, wy)
+ self.setStretch(x, y)
+
+ def stackChildEvent(self, ev):
+ QtGui.QStackedWidget.childEvent(self.stack, ev)
+ Container.childEvent(self, ev)
+
+from . import Dock
diff --git a/pyqtgraph/dockarea/Dock.py b/pyqtgraph/dockarea/Dock.py
new file mode 100644
index 00000000..35781535
--- /dev/null
+++ b/pyqtgraph/dockarea/Dock.py
@@ -0,0 +1,313 @@
+from pyqtgraph.Qt import QtCore, QtGui
+
+from .DockDrop import *
+from pyqtgraph.widgets.VerticalLabel import VerticalLabel
+
+class Dock(QtGui.QWidget, DockDrop):
+
+ sigStretchChanged = QtCore.Signal()
+
+ def __init__(self, name, area=None, size=(10, 10), widget=None, hideTitle=False, autoOrientation=True):
+ QtGui.QWidget.__init__(self)
+ DockDrop.__init__(self)
+ self.area = area
+ self.label = DockLabel(name, self)
+ self.labelHidden = False
+ self.moveLabel = True ## If false, the dock is no longer allowed to move the label.
+ self.autoOrient = autoOrientation
+ self.orientation = 'horizontal'
+ #self.label.setAlignment(QtCore.Qt.AlignHCenter)
+ self.topLayout = QtGui.QGridLayout()
+ self.topLayout.setContentsMargins(0, 0, 0, 0)
+ self.topLayout.setSpacing(0)
+ self.setLayout(self.topLayout)
+ self.topLayout.addWidget(self.label, 0, 1)
+ self.widgetArea = QtGui.QWidget()
+ self.topLayout.addWidget(self.widgetArea, 1, 1)
+ self.layout = QtGui.QGridLayout()
+ self.layout.setContentsMargins(0, 0, 0, 0)
+ self.layout.setSpacing(0)
+ self.widgetArea.setLayout(self.layout)
+ self.widgetArea.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
+ self.widgets = []
+ self.currentRow = 0
+ #self.titlePos = 'top'
+ self.raiseOverlay()
+ self.hStyle = """
+ Dock > QWidget {
+ border: 1px solid #000;
+ border-radius: 5px;
+ border-top-left-radius: 0px;
+ border-top-right-radius: 0px;
+ border-top-width: 0px;
+ }"""
+ self.vStyle = """
+ Dock > QWidget {
+ border: 1px solid #000;
+ border-radius: 5px;
+ border-top-left-radius: 0px;
+ border-bottom-left-radius: 0px;
+ border-left-width: 0px;
+ }"""
+ self.nStyle = """
+ Dock > QWidget {
+ border: 1px solid #000;
+ border-radius: 5px;
+ }"""
+ self.dragStyle = """
+ Dock > QWidget {
+ border: 4px solid #00F;
+ border-radius: 5px;
+ }"""
+ self.setAutoFillBackground(False)
+ self.widgetArea.setStyleSheet(self.hStyle)
+
+ self.setStretch(*size)
+
+ if widget is not None:
+ self.addWidget(widget)
+
+ if hideTitle:
+ self.hideTitleBar()
+
+ def implements(self, name=None):
+ if name is None:
+ return ['dock']
+ else:
+ return name == 'dock'
+
+ def setStretch(self, x=None, y=None):
+ """
+ Set the 'target' size for this Dock.
+ The actual size will be determined by comparing this Dock's
+ stretch value to the rest of the docks it shares space with.
+ """
+ #print "setStretch", self, x, y
+ #self._stretch = (x, y)
+ if x is None:
+ x = 0
+ if y is None:
+ y = 0
+ #policy = self.sizePolicy()
+ #policy.setHorizontalStretch(x)
+ #policy.setVerticalStretch(y)
+ #self.setSizePolicy(policy)
+ self._stretch = (x, y)
+ self.sigStretchChanged.emit()
+ #print "setStretch", self, x, y, self.stretch()
+
+ def stretch(self):
+ #policy = self.sizePolicy()
+ #return policy.horizontalStretch(), policy.verticalStretch()
+ return self._stretch
+
+ #def stretch(self):
+ #return self._stretch
+
+ def hideTitleBar(self):
+ """
+ Hide the title bar for this Dock.
+ This will prevent the Dock being moved by the user.
+ """
+ self.label.hide()
+ self.labelHidden = True
+ if 'center' in self.allowedAreas:
+ self.allowedAreas.remove('center')
+ self.updateStyle()
+
+ def showTitleBar(self):
+ """
+ Show the title bar for this Dock.
+ """
+ self.label.show()
+ self.labelHidden = False
+ self.allowedAreas.add('center')
+ self.updateStyle()
+
+ def setOrientation(self, o='auto', force=False):
+ """
+ Sets the orientation of the title bar for this Dock.
+ Must be one of 'auto', 'horizontal', or 'vertical'.
+ By default ('auto'), the orientation is determined
+ based on the aspect ratio of the Dock.
+ """
+ #print self.name(), "setOrientation", o, force
+ if o == 'auto' and self.autoOrient:
+ if self.container().type() == 'tab':
+ o = 'horizontal'
+ elif self.width() > self.height()*1.5:
+ o = 'vertical'
+ else:
+ o = 'horizontal'
+ if force or self.orientation != o:
+ self.orientation = o
+ self.label.setOrientation(o)
+ self.updateStyle()
+
+ def updateStyle(self):
+ ## updates orientation and appearance of title bar
+ #print self.name(), "update style:", self.orientation, self.moveLabel, self.label.isVisible()
+ if self.labelHidden:
+ self.widgetArea.setStyleSheet(self.nStyle)
+ elif self.orientation == 'vertical':
+ self.label.setOrientation('vertical')
+ if self.moveLabel:
+ #print self.name(), "reclaim label"
+ self.topLayout.addWidget(self.label, 1, 0)
+ self.widgetArea.setStyleSheet(self.vStyle)
+ else:
+ self.label.setOrientation('horizontal')
+ if self.moveLabel:
+ #print self.name(), "reclaim label"
+ self.topLayout.addWidget(self.label, 0, 1)
+ self.widgetArea.setStyleSheet(self.hStyle)
+
+ def resizeEvent(self, ev):
+ self.setOrientation()
+ self.resizeOverlay(self.size())
+
+ def name(self):
+ return str(self.label.text())
+
+ def container(self):
+ return self._container
+
+ def addWidget(self, widget, row=None, col=0, rowspan=1, colspan=1):
+ """
+ Add a new widget to the interior of this Dock.
+ Each Dock uses a QGridLayout to arrange widgets within.
+ """
+ if row is None:
+ row = self.currentRow
+ self.currentRow = max(row+1, self.currentRow)
+ self.widgets.append(widget)
+ self.layout.addWidget(widget, row, col, rowspan, colspan)
+ self.raiseOverlay()
+
+
+ def startDrag(self):
+ self.drag = QtGui.QDrag(self)
+ mime = QtCore.QMimeData()
+ #mime.setPlainText("asd")
+ self.drag.setMimeData(mime)
+ self.widgetArea.setStyleSheet(self.dragStyle)
+ self.update()
+ action = self.drag.exec_()
+ self.updateStyle()
+
+ def float(self):
+ self.area.floatDock(self)
+
+ def containerChanged(self, c):
+ #print self.name(), "container changed"
+ self._container = c
+ if c.type() != 'tab':
+ self.moveLabel = True
+ self.label.setDim(False)
+ else:
+ self.moveLabel = False
+
+ self.setOrientation(force=True)
+
+ def __repr__(self):
+ return "" % (self.name(), self.stretch())
+
+
+class DockLabel(VerticalLabel):
+
+ sigClicked = QtCore.Signal(object, object)
+
+ def __init__(self, text, dock):
+ self.dim = False
+ self.fixedWidth = False
+ VerticalLabel.__init__(self, text, orientation='horizontal', forceWidth=False)
+ self.setAlignment(QtCore.Qt.AlignTop|QtCore.Qt.AlignHCenter)
+ self.dock = dock
+ self.updateStyle()
+ self.setAutoFillBackground(False)
+
+ #def minimumSizeHint(self):
+ ##sh = QtGui.QWidget.minimumSizeHint(self)
+ #return QtCore.QSize(20, 20)
+
+ def updateStyle(self):
+ r = '3px'
+ if self.dim:
+ fg = '#aaa'
+ bg = '#44a'
+ border = '#339'
+ else:
+ fg = '#fff'
+ bg = '#66c'
+ border = '#55B'
+
+ if self.orientation == 'vertical':
+ self.vStyle = """DockLabel {
+ background-color : %s;
+ color : %s;
+ border-top-right-radius: 0px;
+ border-top-left-radius: %s;
+ border-bottom-right-radius: 0px;
+ border-bottom-left-radius: %s;
+ border-width: 0px;
+ border-right: 2px solid %s;
+ padding-top: 3px;
+ padding-bottom: 3px;
+ }""" % (bg, fg, r, r, border)
+ self.setStyleSheet(self.vStyle)
+ else:
+ self.hStyle = """DockLabel {
+ background-color : %s;
+ color : %s;
+ border-top-right-radius: %s;
+ border-top-left-radius: %s;
+ border-bottom-right-radius: 0px;
+ border-bottom-left-radius: 0px;
+ border-width: 0px;
+ border-bottom: 2px solid %s;
+ padding-left: 3px;
+ padding-right: 3px;
+ }""" % (bg, fg, r, r, border)
+ self.setStyleSheet(self.hStyle)
+
+ def setDim(self, d):
+ if self.dim != d:
+ self.dim = d
+ self.updateStyle()
+
+ def setOrientation(self, o):
+ VerticalLabel.setOrientation(self, o)
+ self.updateStyle()
+
+ def mousePressEvent(self, ev):
+ if ev.button() == QtCore.Qt.LeftButton:
+ self.pressPos = ev.pos()
+ self.startedDrag = False
+ ev.accept()
+
+ def mouseMoveEvent(self, ev):
+ if not self.startedDrag and (ev.pos() - self.pressPos).manhattanLength() > QtGui.QApplication.startDragDistance():
+ self.dock.startDrag()
+ ev.accept()
+ #print ev.pos()
+
+ def mouseReleaseEvent(self, ev):
+ if not self.startedDrag:
+ #self.emit(QtCore.SIGNAL('clicked'), self, ev)
+ self.sigClicked.emit(self, ev)
+ ev.accept()
+
+ def mouseDoubleClickEvent(self, ev):
+ if ev.button() == QtCore.Qt.LeftButton:
+ self.dock.float()
+
+ #def paintEvent(self, ev):
+ #p = QtGui.QPainter(self)
+ ##p.setBrush(QtGui.QBrush(QtGui.QColor(100, 100, 200)))
+ #p.setPen(QtGui.QPen(QtGui.QColor(50, 50, 100)))
+ #p.drawRect(self.rect().adjusted(0, 0, -1, -1))
+
+ #VerticalLabel.paintEvent(self, ev)
+
+
+
diff --git a/pyqtgraph/dockarea/DockArea.py b/pyqtgraph/dockarea/DockArea.py
new file mode 100644
index 00000000..78d512f3
--- /dev/null
+++ b/pyqtgraph/dockarea/DockArea.py
@@ -0,0 +1,297 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui
+from .Container import *
+from .DockDrop import *
+from .Dock import Dock
+import pyqtgraph.debug as debug
+import weakref
+
+## TODO:
+# - containers should be drop areas, not docks. (but every slot within a container must have its own drop areas?)
+# - drop between tabs
+# - nest splitters inside tab boxes, etc.
+
+
+
+
+class DockArea(Container, QtGui.QWidget, DockDrop):
+ def __init__(self, temporary=False, home=None):
+ Container.__init__(self, self)
+ QtGui.QWidget.__init__(self)
+ DockDrop.__init__(self, allowedAreas=['left', 'right', 'top', 'bottom'])
+ self.layout = QtGui.QVBoxLayout()
+ self.layout.setContentsMargins(0,0,0,0)
+ self.layout.setSpacing(0)
+ self.setLayout(self.layout)
+ self.docks = weakref.WeakValueDictionary()
+ self.topContainer = None
+ self.raiseOverlay()
+ self.temporary = temporary
+ self.tempAreas = []
+ self.home = home
+
+ def type(self):
+ return "top"
+
+ def addDock(self, dock, position='bottom', relativeTo=None):
+ """Adds a dock to this area.
+
+ =========== =================================================================
+ Arguments:
+ dock The new Dock object to add.
+ position 'bottom', 'top', 'left', 'right', 'over', or 'under'
+ relativeTo If relativeTo is None, then the new Dock is added to fill an
+ entire edge of the window. If relativeTo is another Dock, then
+ the new Dock is placed adjacent to it (or in a tabbed
+ configuration for 'over' and 'under').
+ =========== =================================================================
+
+ """
+
+ ## Determine the container to insert this dock into.
+ ## If there is no neighbor, then the container is the top.
+ if relativeTo is None or relativeTo is self:
+ if self.topContainer is None:
+ container = self
+ neighbor = None
+ else:
+ container = self.topContainer
+ neighbor = None
+ else:
+ if isinstance(relativeTo, basestring):
+ relativeTo = self.docks[relativeTo]
+ container = self.getContainer(relativeTo)
+ neighbor = relativeTo
+
+ ## what container type do we need?
+ neededContainer = {
+ 'bottom': 'vertical',
+ 'top': 'vertical',
+ 'left': 'horizontal',
+ 'right': 'horizontal',
+ 'above': 'tab',
+ 'below': 'tab'
+ }[position]
+
+ ## Can't insert new containers into a tab container; insert outside instead.
+ if neededContainer != container.type() and container.type() == 'tab':
+ neighbor = container
+ container = container.container()
+
+ ## Decide if the container we have is suitable.
+ ## If not, insert a new container inside.
+ if neededContainer != container.type():
+ if neighbor is None:
+ container = self.addContainer(neededContainer, self.topContainer)
+ else:
+ container = self.addContainer(neededContainer, neighbor)
+
+ ## Insert the new dock before/after its neighbor
+ insertPos = {
+ 'bottom': 'after',
+ 'top': 'before',
+ 'left': 'before',
+ 'right': 'after',
+ 'above': 'before',
+ 'below': 'after'
+ }[position]
+ #print "request insert", dock, insertPos, neighbor
+ container.insert(dock, insertPos, neighbor)
+ dock.area = self
+ self.docks[dock.name()] = dock
+
+ def moveDock(self, dock, position, neighbor):
+ """
+ Move an existing Dock to a new location.
+ """
+ old = dock.container()
+ ## Moving to the edge of a tabbed dock causes a drop outside the tab box
+ if position in ['left', 'right', 'top', 'bottom'] and neighbor is not None and neighbor.container() is not None and neighbor.container().type() == 'tab':
+ neighbor = neighbor.container()
+ self.addDock(dock, position, neighbor)
+ old.apoptose()
+
+ def getContainer(self, obj):
+ if obj is None:
+ return self
+ return obj.container()
+
+ def makeContainer(self, typ):
+ if typ == 'vertical':
+ new = VContainer(self)
+ elif typ == 'horizontal':
+ new = HContainer(self)
+ elif typ == 'tab':
+ new = TContainer(self)
+ return new
+
+ def addContainer(self, typ, obj):
+ """Add a new container around obj"""
+ new = self.makeContainer(typ)
+
+ container = self.getContainer(obj)
+ container.insert(new, 'before', obj)
+ #print "Add container:", new, " -> ", container
+ if obj is not None:
+ new.insert(obj)
+ self.raiseOverlay()
+ return new
+
+ def insert(self, new, pos=None, neighbor=None):
+ if self.topContainer is not None:
+ self.topContainer.containerChanged(None)
+ self.layout.addWidget(new)
+ self.topContainer = new
+ #print self, "set top:", new
+ new._container = self
+ self.raiseOverlay()
+ #print "Insert top:", new
+
+ def count(self):
+ if self.topContainer is None:
+ return 0
+ return 1
+
+
+ #def paintEvent(self, ev):
+ #self.drawDockOverlay()
+
+ def resizeEvent(self, ev):
+ self.resizeOverlay(self.size())
+
+ def addTempArea(self):
+ if self.home is None:
+ area = DockArea(temporary=True, home=self)
+ self.tempAreas.append(area)
+ win = QtGui.QMainWindow()
+ win.setCentralWidget(area)
+ area.win = win
+ win.show()
+ else:
+ area = self.home.addTempArea()
+ #print "added temp area", area, area.window()
+ return area
+
+ def floatDock(self, dock):
+ """Removes *dock* from this DockArea and places it in a new window."""
+ area = self.addTempArea()
+ area.win.resize(dock.size())
+ area.moveDock(dock, 'top', None)
+
+
+ def removeTempArea(self, area):
+ self.tempAreas.remove(area)
+ #print "close window", area.window()
+ area.window().close()
+
+ def saveState(self):
+ """
+ Return a serialized (storable) representation of the state of
+ all Docks in this DockArea."""
+ state = {'main': self.childState(self.topContainer), 'float': []}
+ for a in self.tempAreas:
+ geo = a.win.geometry()
+ geo = (geo.x(), geo.y(), geo.width(), geo.height())
+ state['float'].append((a.saveState(), geo))
+ return state
+
+ def childState(self, obj):
+ if isinstance(obj, Dock):
+ return ('dock', obj.name(), {})
+ else:
+ childs = []
+ for i in range(obj.count()):
+ childs.append(self.childState(obj.widget(i)))
+ return (obj.type(), childs, obj.saveState())
+
+
+ def restoreState(self, state):
+ """
+ Restore Dock configuration as generated by saveState.
+
+ Note that this function does not create any Docks--it will only
+ restore the arrangement of an existing set of Docks.
+
+ """
+
+ ## 1) make dict of all docks and list of existing containers
+ containers, docks = self.findAll()
+ oldTemps = self.tempAreas[:]
+ #print "found docks:", docks
+
+ ## 2) create container structure, move docks into new containers
+ self.buildFromState(state['main'], docks, self)
+
+ ## 3) create floating areas, populate
+ for s in state['float']:
+ a = self.addTempArea()
+ a.buildFromState(s[0]['main'], docks, a)
+ a.win.setGeometry(*s[1])
+
+ ## 4) Add any remaining docks to the bottom
+ for d in docks.values():
+ self.moveDock(d, 'below', None)
+
+ #print "\nKill old containers:"
+ ## 5) kill old containers
+ for c in containers:
+ c.close()
+ for a in oldTemps:
+ a.apoptose()
+
+
+ def buildFromState(self, state, docks, root, depth=0):
+ typ, contents, state = state
+ pfx = " " * depth
+ if typ == 'dock':
+ try:
+ obj = docks[contents]
+ del docks[contents]
+ except KeyError:
+ raise Exception('Cannot restore dock state; no dock with name "%s"' % contents)
+ else:
+ obj = self.makeContainer(typ)
+
+ root.insert(obj, 'after')
+ #print pfx+"Add:", obj, " -> ", root
+
+ if typ != 'dock':
+ for o in contents:
+ self.buildFromState(o, docks, obj, depth+1)
+ obj.apoptose(propagate=False)
+ obj.restoreState(state) ## this has to be done later?
+
+
+ def findAll(self, obj=None, c=None, d=None):
+ if obj is None:
+ obj = self.topContainer
+
+ ## check all temp areas first
+ if c is None:
+ c = []
+ d = {}
+ for a in self.tempAreas:
+ c1, d1 = a.findAll()
+ c.extend(c1)
+ d.update(d1)
+
+ if isinstance(obj, Dock):
+ d[obj.name()] = obj
+ elif obj is not None:
+ c.append(obj)
+ for i in range(obj.count()):
+ o2 = obj.widget(i)
+ c2, d2 = self.findAll(o2)
+ c.extend(c2)
+ d.update(d2)
+ return (c, d)
+
+ def apoptose(self):
+ #print "apoptose area:", self.temporary, self.topContainer, self.topContainer.count()
+ if self.temporary and self.topContainer.count() == 0:
+ self.topContainer = None
+ self.home.removeTempArea(self)
+ #self.close()
+
+
+
\ No newline at end of file
diff --git a/pyqtgraph/dockarea/DockDrop.py b/pyqtgraph/dockarea/DockDrop.py
new file mode 100644
index 00000000..acab28cd
--- /dev/null
+++ b/pyqtgraph/dockarea/DockDrop.py
@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui
+
+class DockDrop(object):
+ """Provides dock-dropping methods"""
+ def __init__(self, allowedAreas=None):
+ object.__init__(self)
+ if allowedAreas is None:
+ allowedAreas = ['center', 'right', 'left', 'top', 'bottom']
+ self.allowedAreas = set(allowedAreas)
+ self.setAcceptDrops(True)
+ self.dropArea = None
+ self.overlay = DropAreaOverlay(self)
+ self.overlay.raise_()
+
+ def resizeOverlay(self, size):
+ self.overlay.resize(size)
+
+ def raiseOverlay(self):
+ self.overlay.raise_()
+
+ def dragEnterEvent(self, ev):
+ src = ev.source()
+ if hasattr(src, 'implements') and src.implements('dock'):
+ #print "drag enter accept"
+ ev.accept()
+ else:
+ #print "drag enter ignore"
+ ev.ignore()
+
+ def dragMoveEvent(self, ev):
+ #print "drag move"
+ ld = ev.pos().x()
+ rd = self.width() - ld
+ td = ev.pos().y()
+ bd = self.height() - td
+
+ mn = min(ld, rd, td, bd)
+ if mn > 30:
+ self.dropArea = "center"
+ elif (ld == mn or td == mn) and mn > self.height()/3.:
+ self.dropArea = "center"
+ elif (rd == mn or ld == mn) and mn > self.width()/3.:
+ self.dropArea = "center"
+
+ elif rd == mn:
+ self.dropArea = "right"
+ elif ld == mn:
+ self.dropArea = "left"
+ elif td == mn:
+ self.dropArea = "top"
+ elif bd == mn:
+ self.dropArea = "bottom"
+
+ if ev.source() is self and self.dropArea == 'center':
+ #print " no self-center"
+ self.dropArea = None
+ ev.ignore()
+ elif self.dropArea not in self.allowedAreas:
+ #print " not allowed"
+ self.dropArea = None
+ ev.ignore()
+ else:
+ #print " ok"
+ ev.accept()
+ self.overlay.setDropArea(self.dropArea)
+
+ def dragLeaveEvent(self, ev):
+ self.dropArea = None
+ self.overlay.setDropArea(self.dropArea)
+
+ def dropEvent(self, ev):
+ area = self.dropArea
+ if area is None:
+ return
+ if area == 'center':
+ area = 'above'
+ self.area.moveDock(ev.source(), area, self)
+ self.dropArea = None
+ self.overlay.setDropArea(self.dropArea)
+
+
+
+class DropAreaOverlay(QtGui.QWidget):
+ """Overlay widget that draws drop areas during a drag-drop operation"""
+
+ def __init__(self, parent):
+ QtGui.QWidget.__init__(self, parent)
+ self.dropArea = None
+ self.hide()
+ self.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents)
+
+ def setDropArea(self, area):
+ self.dropArea = area
+ if area is None:
+ self.hide()
+ else:
+ ## Resize overlay to just the region where drop area should be displayed.
+ ## This works around a Qt bug--can't display transparent widgets over QGLWidget
+ prgn = self.parent().rect()
+ rgn = QtCore.QRect(prgn)
+ w = min(30, prgn.width()/3.)
+ h = min(30, prgn.height()/3.)
+
+ if self.dropArea == 'left':
+ rgn.setWidth(w)
+ elif self.dropArea == 'right':
+ rgn.setLeft(rgn.left() + prgn.width() - w)
+ elif self.dropArea == 'top':
+ rgn.setHeight(h)
+ elif self.dropArea == 'bottom':
+ rgn.setTop(rgn.top() + prgn.height() - h)
+ elif self.dropArea == 'center':
+ rgn.adjust(w, h, -w, -h)
+ self.setGeometry(rgn)
+ self.show()
+
+ self.update()
+
+ def paintEvent(self, ev):
+ if self.dropArea is None:
+ return
+ p = QtGui.QPainter(self)
+ rgn = self.rect()
+
+ p.setBrush(QtGui.QBrush(QtGui.QColor(100, 100, 255, 50)))
+ p.setPen(QtGui.QPen(QtGui.QColor(50, 50, 150), 3))
+ p.drawRect(rgn)
diff --git a/pyqtgraph/dockarea/__init__.py b/pyqtgraph/dockarea/__init__.py
new file mode 100644
index 00000000..f67c50c3
--- /dev/null
+++ b/pyqtgraph/dockarea/__init__.py
@@ -0,0 +1,2 @@
+from .DockArea import DockArea
+from .Dock import Dock
\ No newline at end of file
diff --git a/pyqtgraph/exceptionHandling.py b/pyqtgraph/exceptionHandling.py
new file mode 100644
index 00000000..daa821b7
--- /dev/null
+++ b/pyqtgraph/exceptionHandling.py
@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""This module installs a wrapper around sys.excepthook which allows multiple
+new exception handlers to be registered.
+
+Optionally, the wrapper also stops exceptions from causing long-term storage
+of local stack frames. This has two major effects:
+ - Unhandled exceptions will no longer cause memory leaks
+ (If an exception occurs while a lot of data is present on the stack,
+ such as when loading large files, the data would ordinarily be kept
+ until the next exception occurs. We would rather release this memory
+ as soon as possible.)
+ - Some debuggers may have a hard time handling uncaught exceptions
+
+The module also provides a callback mechanism allowing others to respond
+to exceptions.
+"""
+
+import sys, time
+#from lib.Manager import logMsg
+import traceback
+#from log import *
+
+#logging = False
+
+callbacks = []
+clear_tracebacks = False
+
+def register(fn):
+ """
+ Register a callable to be invoked when there is an unhandled exception.
+ The callback will be passed the output of sys.exc_info(): (exception type, exception, traceback)
+ Multiple callbacks will be invoked in the order they were registered.
+ """
+ callbacks.append(fn)
+
+def unregister(fn):
+ """Unregister a previously registered callback."""
+ callbacks.remove(fn)
+
+def setTracebackClearing(clear=True):
+ """
+ Enable or disable traceback clearing.
+ By default, clearing is disabled and Python will indefinitely store unhandled exception stack traces.
+ This function is provided since Python's default behavior can cause unexpected retention of
+ large memory-consuming objects.
+ """
+ global clear_tracebacks
+ clear_tracebacks = clear
+
+class ExceptionHandler(object):
+ def __call__(self, *args):
+ ## call original exception handler first (prints exception)
+ global original_excepthook, callbacks, clear_tracebacks
+ print("===== %s =====" % str(time.strftime("%Y.%m.%d %H:%m:%S", time.localtime(time.time()))))
+ ret = original_excepthook(*args)
+
+ for cb in callbacks:
+ try:
+ cb(*args)
+ except:
+ print(" --------------------------------------------------------------")
+ print(" Error occurred during exception callback %s" % str(cb))
+ print(" --------------------------------------------------------------")
+ traceback.print_exception(*sys.exc_info())
+
+
+ ## Clear long-term storage of last traceback to prevent memory-hogging.
+ ## (If an exception occurs while a lot of data is present on the stack,
+ ## such as when loading large files, the data would ordinarily be kept
+ ## until the next exception occurs. We would rather release this memory
+ ## as soon as possible.)
+ if clear_tracebacks is True:
+ sys.last_traceback = None
+
+ def implements(self, interface=None):
+ ## this just makes it easy for us to detect whether an ExceptionHook is already installed.
+ if interface is None:
+ return ['ExceptionHandler']
+ else:
+ return interface == 'ExceptionHandler'
+
+
+
+## replace built-in excepthook only if this has not already been done
+if not (hasattr(sys.excepthook, 'implements') and sys.excepthook.implements('ExceptionHandler')):
+ original_excepthook = sys.excepthook
+ sys.excepthook = ExceptionHandler()
+
+
+
diff --git a/pyqtgraph/exporters/CSVExporter.py b/pyqtgraph/exporters/CSVExporter.py
new file mode 100644
index 00000000..629b2789
--- /dev/null
+++ b/pyqtgraph/exporters/CSVExporter.py
@@ -0,0 +1,61 @@
+import pyqtgraph as pg
+from pyqtgraph.Qt import QtGui, QtCore
+from .Exporter import Exporter
+from pyqtgraph.parametertree import Parameter
+
+
+__all__ = ['CSVExporter']
+
+
+class CSVExporter(Exporter):
+ Name = "CSV from plot data"
+ windows = []
+ def __init__(self, item):
+ Exporter.__init__(self, item)
+ self.params = Parameter(name='params', type='group', children=[
+ {'name': 'separator', 'type': 'list', 'value': 'comma', 'values': ['comma', 'tab']},
+ ])
+
+ def parameters(self):
+ return self.params
+
+ def export(self, fileName=None):
+
+ if not isinstance(self.item, pg.PlotItem):
+ raise Exception("Must have a PlotItem selected for CSV export.")
+
+ if fileName is None:
+ self.fileSaveDialog(filter=["*.csv", "*.tsv"])
+ return
+
+ fd = open(fileName, 'w')
+ data = []
+ header = []
+ for c in self.item.curves:
+ data.append(c.getData())
+ header.extend(['x', 'y'])
+
+ if self.params['separator'] == 'comma':
+ sep = ','
+ else:
+ sep = '\t'
+
+ fd.write(sep.join(header) + '\n')
+ i = 0
+ while True:
+ done = True
+ for d in data:
+ if i < len(d[0]):
+ fd.write('%g%s%g%s'%(d[0][i], sep, d[1][i], sep))
+ done = False
+ else:
+ fd.write(' %s %s' % (sep, sep))
+ fd.write('\n')
+ if done:
+ break
+ i += 1
+ fd.close()
+
+
+
+
diff --git a/pyqtgraph/exporters/Exporter.py b/pyqtgraph/exporters/Exporter.py
new file mode 100644
index 00000000..b1a663bc
--- /dev/null
+++ b/pyqtgraph/exporters/Exporter.py
@@ -0,0 +1,172 @@
+from pyqtgraph.widgets.FileDialog import FileDialog
+import pyqtgraph as pg
+from pyqtgraph.Qt import QtGui, QtCore, QtSvg
+import os, re
+LastExportDirectory = None
+
+
+class Exporter(object):
+ """
+ Abstract class used for exporting graphics to file / printer / whatever.
+ """
+
+ def __init__(self, item):
+ """
+ Initialize with the item to be exported.
+ Can be an individual graphics item or a scene.
+ """
+ object.__init__(self)
+ self.item = item
+
+ #def item(self):
+ #return self.item
+
+ def parameters(self):
+ """Return the parameters used to configure this exporter."""
+ raise Exception("Abstract method must be overridden in subclass.")
+
+ def export(self, fileName=None, toBytes=False):
+ """
+ If *fileName* is None, pop-up a file dialog.
+ If *toString* is True, return a bytes object rather than writing to file.
+ """
+ raise Exception("Abstract method must be overridden in subclass.")
+
+ def fileSaveDialog(self, filter=None, opts=None):
+ ## Show a file dialog, call self.export(fileName) when finished.
+ if opts is None:
+ opts = {}
+ self.fileDialog = FileDialog()
+ self.fileDialog.setFileMode(QtGui.QFileDialog.AnyFile)
+ self.fileDialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
+ if filter is not None:
+ if isinstance(filter, basestring):
+ self.fileDialog.setNameFilter(filter)
+ elif isinstance(filter, list):
+ self.fileDialog.setNameFilters(filter)
+ global LastExportDirectory
+ exportDir = LastExportDirectory
+ if exportDir is not None:
+ self.fileDialog.setDirectory(exportDir)
+ self.fileDialog.show()
+ self.fileDialog.opts = opts
+ self.fileDialog.fileSelected.connect(self.fileSaveFinished)
+ return
+
+ def fileSaveFinished(self, fileName):
+ fileName = str(fileName)
+ global LastExportDirectory
+ LastExportDirectory = os.path.split(fileName)[0]
+
+ ## If file name does not match selected extension, append it now
+ ext = os.path.splitext(fileName)[1].lower().lstrip('.')
+ selectedExt = re.search(r'\*\.(\w+)\b', str(self.fileDialog.selectedNameFilter()))
+ if selectedExt is not None:
+ selectedExt = selectedExt.groups()[0].lower()
+ if ext != selectedExt:
+ fileName = fileName + selectedExt
+
+ self.export(fileName=fileName, **self.fileDialog.opts)
+
+ def getScene(self):
+ if isinstance(self.item, pg.GraphicsScene):
+ return self.item
+ else:
+ return self.item.scene()
+
+ def getSourceRect(self):
+ if isinstance(self.item, pg.GraphicsScene):
+ w = self.item.getViewWidget()
+ return w.viewportTransform().inverted()[0].mapRect(w.rect())
+ else:
+ return self.item.sceneBoundingRect()
+
+ def getTargetRect(self):
+ if isinstance(self.item, pg.GraphicsScene):
+ return self.item.getViewWidget().rect()
+ else:
+ return self.item.mapRectToDevice(self.item.boundingRect())
+
+ def setExportMode(self, export, opts=None):
+ """
+ Call setExportMode(export, opts) on all items that will
+ be painted during the export. This informs the item
+ that it is about to be painted for export, allowing it to
+ alter its appearance temporarily
+
+
+ *export* - bool; must be True before exporting and False afterward
+ *opts* - dict; common parameters are 'antialias' and 'background'
+ """
+ if opts is None:
+ opts = {}
+ for item in self.getPaintItems():
+ if hasattr(item, 'setExportMode'):
+ item.setExportMode(export, opts)
+
+ def getPaintItems(self, root=None):
+ """Return a list of all items that should be painted in the correct order."""
+ if root is None:
+ root = self.item
+ preItems = []
+ postItems = []
+ if isinstance(root, QtGui.QGraphicsScene):
+ childs = [i for i in root.items() if i.parentItem() is None]
+ rootItem = []
+ else:
+ childs = root.childItems()
+ rootItem = [root]
+ childs.sort(lambda a,b: cmp(a.zValue(), b.zValue()))
+ while len(childs) > 0:
+ ch = childs.pop(0)
+ tree = self.getPaintItems(ch)
+ if int(ch.flags() & ch.ItemStacksBehindParent) > 0 or (ch.zValue() < 0 and int(ch.flags() & ch.ItemNegativeZStacksBehindParent) > 0):
+ preItems.extend(tree)
+ else:
+ postItems.extend(tree)
+
+ return preItems + rootItem + postItems
+
+ def render(self, painter, targetRect, sourceRect, item=None):
+
+ #if item is None:
+ #item = self.item
+ #preItems = []
+ #postItems = []
+ #if isinstance(item, QtGui.QGraphicsScene):
+ #childs = [i for i in item.items() if i.parentItem() is None]
+ #rootItem = []
+ #else:
+ #childs = item.childItems()
+ #rootItem = [item]
+ #childs.sort(lambda a,b: cmp(a.zValue(), b.zValue()))
+ #while len(childs) > 0:
+ #ch = childs.pop(0)
+ #if int(ch.flags() & ch.ItemStacksBehindParent) > 0 or (ch.zValue() < 0 and int(ch.flags() & ch.ItemNegativeZStacksBehindParent) > 0):
+ #preItems.extend(tree)
+ #else:
+ #postItems.extend(tree)
+
+ #for ch in preItems:
+ #self.render(painter, sourceRect, targetRect, item=ch)
+ ### paint root here
+ #for ch in postItems:
+ #self.render(painter, sourceRect, targetRect, item=ch)
+
+
+ self.getScene().render(painter, QtCore.QRectF(targetRect), QtCore.QRectF(sourceRect))
+
+ #def writePs(self, fileName=None, item=None):
+ #if fileName is None:
+ #self.fileSaveDialog(self.writeSvg, filter="PostScript (*.ps)")
+ #return
+ #if item is None:
+ #item = self
+ #printer = QtGui.QPrinter(QtGui.QPrinter.HighResolution)
+ #printer.setOutputFileName(fileName)
+ #painter = QtGui.QPainter(printer)
+ #self.render(painter)
+ #painter.end()
+
+ #def writeToPrinter(self):
+ #pass
diff --git a/pyqtgraph/exporters/ImageExporter.py b/pyqtgraph/exporters/ImageExporter.py
new file mode 100644
index 00000000..cb6cf396
--- /dev/null
+++ b/pyqtgraph/exporters/ImageExporter.py
@@ -0,0 +1,83 @@
+from .Exporter import Exporter
+from pyqtgraph.parametertree import Parameter
+from pyqtgraph.Qt import QtGui, QtCore, QtSvg
+import pyqtgraph as pg
+import numpy as np
+
+__all__ = ['ImageExporter']
+
+class ImageExporter(Exporter):
+ Name = "Image File (PNG, TIF, JPG, ...)"
+ def __init__(self, item):
+ Exporter.__init__(self, item)
+ tr = self.getTargetRect()
+ if isinstance(item, QtGui.QGraphicsItem):
+ scene = item.scene()
+ else:
+ scene = item
+ bg = scene.views()[0].backgroundBrush().color()
+ self.params = Parameter(name='params', type='group', children=[
+ {'name': 'width', 'type': 'int', 'value': tr.width(), 'limits': (0, None)},
+ {'name': 'height', 'type': 'int', 'value': tr.height(), 'limits': (0, None)},
+ {'name': 'antialias', 'type': 'bool', 'value': True},
+ {'name': 'background', 'type': 'color', 'value': bg},
+ ])
+ self.params.param('width').sigValueChanged.connect(self.widthChanged)
+ self.params.param('height').sigValueChanged.connect(self.heightChanged)
+
+ def widthChanged(self):
+ sr = self.getSourceRect()
+ ar = float(sr.height()) / sr.width()
+ self.params.param('height').setValue(self.params['width'] * ar, blockSignal=self.heightChanged)
+
+ def heightChanged(self):
+ sr = self.getSourceRect()
+ ar = float(sr.width()) / sr.height()
+ self.params.param('width').setValue(self.params['height'] * ar, blockSignal=self.widthChanged)
+
+ def parameters(self):
+ return self.params
+
+ def export(self, fileName=None):
+ if fileName is None:
+ filter = ["*."+str(f) for f in QtGui.QImageWriter.supportedImageFormats()]
+ preferred = ['*.png', '*.tif', '*.jpg']
+ for p in preferred[::-1]:
+ if p in filter:
+ filter.remove(p)
+ filter.insert(0, p)
+ self.fileSaveDialog(filter=filter)
+ return
+
+ targetRect = QtCore.QRect(0, 0, self.params['width'], self.params['height'])
+ sourceRect = self.getSourceRect()
+
+
+ #self.png = QtGui.QImage(targetRect.size(), QtGui.QImage.Format_ARGB32)
+ #self.png.fill(pyqtgraph.mkColor(self.params['background']))
+ bg = np.empty((self.params['width'], self.params['height'], 4), dtype=np.ubyte)
+ color = self.params['background']
+ bg[:,:,0] = color.blue()
+ bg[:,:,1] = color.green()
+ bg[:,:,2] = color.red()
+ bg[:,:,3] = color.alpha()
+ self.png = pg.makeQImage(bg, alpha=True)
+
+ ## set resolution of image:
+ origTargetRect = self.getTargetRect()
+ resolutionScale = targetRect.width() / origTargetRect.width()
+ #self.png.setDotsPerMeterX(self.png.dotsPerMeterX() * resolutionScale)
+ #self.png.setDotsPerMeterY(self.png.dotsPerMeterY() * resolutionScale)
+
+ painter = QtGui.QPainter(self.png)
+ #dtr = painter.deviceTransform()
+ try:
+ self.setExportMode(True, {'antialias': self.params['antialias'], 'background': self.params['background'], 'painter': painter, 'resolutionScale': resolutionScale})
+ painter.setRenderHint(QtGui.QPainter.Antialiasing, self.params['antialias'])
+ self.getScene().render(painter, QtCore.QRectF(targetRect), QtCore.QRectF(sourceRect))
+ finally:
+ self.setExportMode(False)
+ painter.end()
+ self.png.save(fileName)
+
+
\ No newline at end of file
diff --git a/pyqtgraph/exporters/Matplotlib.py b/pyqtgraph/exporters/Matplotlib.py
new file mode 100644
index 00000000..76f878d2
--- /dev/null
+++ b/pyqtgraph/exporters/Matplotlib.py
@@ -0,0 +1,74 @@
+import pyqtgraph as pg
+from pyqtgraph.Qt import QtGui, QtCore
+from .Exporter import Exporter
+
+
+__all__ = ['MatplotlibExporter']
+
+
+class MatplotlibExporter(Exporter):
+ Name = "Matplotlib Window"
+ windows = []
+ def __init__(self, item):
+ Exporter.__init__(self, item)
+
+ def parameters(self):
+ return None
+
+ def export(self, fileName=None):
+
+ if isinstance(self.item, pg.PlotItem):
+ mpw = MatplotlibWindow()
+ MatplotlibExporter.windows.append(mpw)
+ fig = mpw.getFigure()
+
+ ax = fig.add_subplot(111)
+ ax.clear()
+ #ax.grid(True)
+
+ for item in self.item.curves:
+ x, y = item.getData()
+ opts = item.opts
+ pen = pg.mkPen(opts['pen'])
+ if pen.style() == QtCore.Qt.NoPen:
+ linestyle = ''
+ else:
+ linestyle = '-'
+ color = tuple([c/255. for c in pg.colorTuple(pen.color())])
+ symbol = opts['symbol']
+ if symbol == 't':
+ symbol = '^'
+ symbolPen = pg.mkPen(opts['symbolPen'])
+ symbolBrush = pg.mkBrush(opts['symbolBrush'])
+ markeredgecolor = tuple([c/255. for c in pg.colorTuple(symbolPen.color())])
+ markerfacecolor = tuple([c/255. for c in pg.colorTuple(symbolBrush.color())])
+
+ if opts['fillLevel'] is not None and opts['fillBrush'] is not None:
+ fillBrush = pg.mkBrush(opts['fillBrush'])
+ fillcolor = tuple([c/255. for c in pg.colorTuple(fillBrush.color())])
+ ax.fill_between(x=x, y1=y, y2=opts['fillLevel'], facecolor=fillcolor)
+
+ ax.plot(x, y, marker=symbol, color=color, linewidth=pen.width(), linestyle=linestyle, markeredgecolor=markeredgecolor, markerfacecolor=markerfacecolor)
+
+ xr, yr = self.item.viewRange()
+ ax.set_xbound(*xr)
+ ax.set_ybound(*yr)
+ mpw.draw()
+ else:
+ raise Exception("Matplotlib export currently only works with plot items")
+
+
+
+class MatplotlibWindow(QtGui.QMainWindow):
+ def __init__(self):
+ import pyqtgraph.widgets.MatplotlibWidget
+ QtGui.QMainWindow.__init__(self)
+ self.mpl = pyqtgraph.widgets.MatplotlibWidget.MatplotlibWidget()
+ self.setCentralWidget(self.mpl)
+ self.show()
+
+ def __getattr__(self, attr):
+ return getattr(self.mpl, attr)
+
+ def closeEvent(self, ev):
+ MatplotlibExporter.windows.remove(self)
diff --git a/pyqtgraph/exporters/PrintExporter.py b/pyqtgraph/exporters/PrintExporter.py
new file mode 100644
index 00000000..5b31b45d
--- /dev/null
+++ b/pyqtgraph/exporters/PrintExporter.py
@@ -0,0 +1,65 @@
+from .Exporter import Exporter
+from pyqtgraph.parametertree import Parameter
+from pyqtgraph.Qt import QtGui, QtCore, QtSvg
+import re
+
+__all__ = ['PrintExporter']
+#__all__ = [] ## Printer is disabled for now--does not work very well.
+
+class PrintExporter(Exporter):
+ Name = "Printer"
+ def __init__(self, item):
+ Exporter.__init__(self, item)
+ tr = self.getTargetRect()
+ self.params = Parameter(name='params', type='group', children=[
+ {'name': 'width', 'type': 'float', 'value': 0.1, 'limits': (0, None), 'suffix': 'm', 'siPrefix': True},
+ {'name': 'height', 'type': 'float', 'value': (0.1 * tr.height()) / tr.width(), 'limits': (0, None), 'suffix': 'm', 'siPrefix': True},
+ ])
+ self.params.param('width').sigValueChanged.connect(self.widthChanged)
+ self.params.param('height').sigValueChanged.connect(self.heightChanged)
+
+ def widthChanged(self):
+ sr = self.getSourceRect()
+ ar = sr.height() / sr.width()
+ self.params.param('height').setValue(self.params['width'] * ar, blockSignal=self.heightChanged)
+
+ def heightChanged(self):
+ sr = self.getSourceRect()
+ ar = sr.width() / sr.height()
+ self.params.param('width').setValue(self.params['height'] * ar, blockSignal=self.widthChanged)
+
+ def parameters(self):
+ return self.params
+
+ def export(self, fileName=None):
+ printer = QtGui.QPrinter(QtGui.QPrinter.HighResolution)
+ dialog = QtGui.QPrintDialog(printer)
+ dialog.setWindowTitle("Print Document")
+ if dialog.exec_() != QtGui.QDialog.Accepted:
+ return;
+
+ #dpi = QtGui.QDesktopWidget().physicalDpiX()
+
+ #self.svg.setSize(QtCore.QSize(100,100))
+ #self.svg.setResolution(600)
+ #res = printer.resolution()
+ sr = self.getSourceRect()
+ #res = sr.width() * .4 / (self.params['width'] * 100 / 2.54)
+ res = QtGui.QDesktopWidget().physicalDpiX()
+ printer.setResolution(res)
+ rect = printer.pageRect()
+ center = rect.center()
+ h = self.params['height'] * res * 100. / 2.54
+ w = self.params['width'] * res * 100. / 2.54
+ x = center.x() - w/2.
+ y = center.y() - h/2.
+
+ targetRect = QtCore.QRect(x, y, w, h)
+ sourceRect = self.getSourceRect()
+ painter = QtGui.QPainter(printer)
+ try:
+ self.setExportMode(True, {'painter': painter})
+ self.getScene().render(painter, QtCore.QRectF(targetRect), QtCore.QRectF(sourceRect))
+ finally:
+ self.setExportMode(False)
+ painter.end()
diff --git a/pyqtgraph/exporters/SVGExporter.py b/pyqtgraph/exporters/SVGExporter.py
new file mode 100644
index 00000000..ce05b82d
--- /dev/null
+++ b/pyqtgraph/exporters/SVGExporter.py
@@ -0,0 +1,414 @@
+from .Exporter import Exporter
+from pyqtgraph.parametertree import Parameter
+from pyqtgraph.Qt import QtGui, QtCore, QtSvg
+import pyqtgraph as pg
+import re
+import xml.dom.minidom as xml
+import numpy as np
+
+
+__all__ = ['SVGExporter']
+
+class SVGExporter(Exporter):
+ Name = "Scalable Vector Graphics (SVG)"
+ def __init__(self, item):
+ Exporter.__init__(self, item)
+ #tr = self.getTargetRect()
+ self.params = Parameter(name='params', type='group', children=[
+ #{'name': 'width', 'type': 'float', 'value': tr.width(), 'limits': (0, None)},
+ #{'name': 'height', 'type': 'float', 'value': tr.height(), 'limits': (0, None)},
+ ])
+ #self.params.param('width').sigValueChanged.connect(self.widthChanged)
+ #self.params.param('height').sigValueChanged.connect(self.heightChanged)
+
+ def widthChanged(self):
+ sr = self.getSourceRect()
+ ar = sr.height() / sr.width()
+ self.params.param('height').setValue(self.params['width'] * ar, blockSignal=self.heightChanged)
+
+ def heightChanged(self):
+ sr = self.getSourceRect()
+ ar = sr.width() / sr.height()
+ self.params.param('width').setValue(self.params['height'] * ar, blockSignal=self.widthChanged)
+
+ def parameters(self):
+ return self.params
+
+ def export(self, fileName=None, toBytes=False):
+ if toBytes is False and fileName is None:
+ self.fileSaveDialog(filter="Scalable Vector Graphics (*.svg)")
+ return
+ #self.svg = QtSvg.QSvgGenerator()
+ #self.svg.setFileName(fileName)
+ #dpi = QtGui.QDesktopWidget().physicalDpiX()
+ ### not really sure why this works, but it seems to be important:
+ #self.svg.setSize(QtCore.QSize(self.params['width']*dpi/90., self.params['height']*dpi/90.))
+ #self.svg.setResolution(dpi)
+ ##self.svg.setViewBox()
+ #targetRect = QtCore.QRect(0, 0, self.params['width'], self.params['height'])
+ #sourceRect = self.getSourceRect()
+
+ #painter = QtGui.QPainter(self.svg)
+ #try:
+ #self.setExportMode(True)
+ #self.render(painter, QtCore.QRectF(targetRect), sourceRect)
+ #finally:
+ #self.setExportMode(False)
+ #painter.end()
+
+ ## Workaround to set pen widths correctly
+ #data = open(fileName).readlines()
+ #for i in range(len(data)):
+ #line = data[i]
+ #m = re.match(r'(
+\n"
+
+
+def _generateItemSvg(item, nodes=None, root=None):
+ ## This function is intended to work around some issues with Qt's SVG generator
+ ## and SVG in general.
+ ## 1) Qt SVG does not implement clipping paths. This is absurd.
+ ## The solution is to let Qt generate SVG for each item independently,
+ ## then glue them together manually with clipping.
+ ##
+ ## The format Qt generates for all items looks like this:
+ ##
+ ##
+ ##
+ ## one or more of: or or
+ ##
+ ##
+ ## one or more of: or or
+ ##
+ ## . . .
+ ##
+ ##
+ ## 2) There seems to be wide disagreement over whether path strokes
+ ## should be scaled anisotropically.
+ ## see: http://web.mit.edu/jonas/www/anisotropy/
+ ## Given that both inkscape and illustrator seem to prefer isotropic
+ ## scaling, we will optimize for those cases.
+ ##
+ ## 3) Qt generates paths using non-scaling-stroke from SVG 1.2, but
+ ## inkscape only supports 1.1.
+ ##
+ ## Both 2 and 3 can be addressed by drawing all items in world coordinates.
+
+
+
+ if nodes is None: ## nodes maps all node IDs to their XML element.
+ ## this allows us to ensure all elements receive unique names.
+ nodes = {}
+
+ if root is None:
+ root = item
+
+ ## Skip hidden items
+ if hasattr(item, 'isVisible') and not item.isVisible():
+ return None
+
+ ## If this item defines its own SVG generator, use that.
+ if hasattr(item, 'generateSvg'):
+ return item.generateSvg(nodes)
+
+
+ ## Generate SVG text for just this item (exclude its children; we'll handle them later)
+ tr = QtGui.QTransform()
+ if isinstance(item, QtGui.QGraphicsScene):
+ xmlStr = "\n\n"
+ childs = [i for i in item.items() if i.parentItem() is None]
+ doc = xml.parseString(xmlStr)
+ else:
+ childs = item.childItems()
+ tr = itemTransform(item, root)
+
+ #print item, pg.SRTTransform(tr)
+
+ #tr.translate(item.pos().x(), item.pos().y())
+ #tr = tr * item.transform()
+ arr = QtCore.QByteArray()
+ buf = QtCore.QBuffer(arr)
+ svg = QtSvg.QSvgGenerator()
+ svg.setOutputDevice(buf)
+ dpi = QtGui.QDesktopWidget().physicalDpiX()
+ ### not really sure why this works, but it seems to be important:
+ #self.svg.setSize(QtCore.QSize(self.params['width']*dpi/90., self.params['height']*dpi/90.))
+ svg.setResolution(dpi)
+
+ p = QtGui.QPainter()
+ p.begin(svg)
+ if hasattr(item, 'setExportMode'):
+ item.setExportMode(True, {'painter': p})
+ try:
+ p.setTransform(tr)
+ item.paint(p, QtGui.QStyleOptionGraphicsItem(), None)
+ finally:
+ p.end()
+ ## Can't do this here--we need to wait until all children have painted as well.
+ ## this is taken care of in generateSvg instead.
+ #if hasattr(item, 'setExportMode'):
+ #item.setExportMode(False)
+
+ xmlStr = str(arr)
+ doc = xml.parseString(xmlStr)
+
+ try:
+ ## Get top-level group for this item
+ g1 = doc.getElementsByTagName('g')[0]
+ ## get list of sub-groups
+ g2 = [n for n in g1.childNodes if isinstance(n, xml.Element) and n.tagName == 'g']
+ except:
+ print doc.toxml()
+ raise
+
+
+ ## Get rid of group transformation matrices by applying
+ ## transformation to inner coordinates
+ correctCoordinates(g1, item)
+
+ ## make sure g1 has the transformation matrix
+ #m = (tr.m11(), tr.m12(), tr.m21(), tr.m22(), tr.m31(), tr.m32())
+ #g1.setAttribute('transform', "matrix(%f,%f,%f,%f,%f,%f)" % m)
+
+ #print "=================",item,"====================="
+ #print g1.toprettyxml(indent=" ", newl='')
+
+ ## Inkscape does not support non-scaling-stroke (this is SVG 1.2, inkscape supports 1.1)
+ ## So we need to correct anything attempting to use this.
+ #correctStroke(g1, item, root)
+
+ ## decide on a name for this item
+ baseName = item.__class__.__name__
+ i = 1
+ while True:
+ name = baseName + "_%d" % i
+ if name not in nodes:
+ break
+ i += 1
+ nodes[name] = g1
+ g1.setAttribute('id', name)
+
+ ## If this item clips its children, we need to take car of that.
+ childGroup = g1 ## add children directly to this node unless we are clipping
+ if not isinstance(item, QtGui.QGraphicsScene):
+ ## See if this item clips its children
+ if int(item.flags() & item.ItemClipsChildrenToShape) > 0:
+ ## Generate svg for just the path
+ if isinstance(root, QtGui.QGraphicsScene):
+ path = QtGui.QGraphicsPathItem(item.mapToScene(item.shape()))
+ else:
+ path = QtGui.QGraphicsPathItem(root.mapToParent(item.mapToItem(root, item.shape())))
+ pathNode = _generateItemSvg(path, root=root).getElementsByTagName('path')[0]
+ ## and for the clipPath element
+ clip = name + '_clip'
+ clipNode = g1.ownerDocument.createElement('clipPath')
+ clipNode.setAttribute('id', clip)
+ clipNode.appendChild(pathNode)
+ g1.appendChild(clipNode)
+
+ childGroup = g1.ownerDocument.createElement('g')
+ childGroup.setAttribute('clip-path', 'url(#%s)' % clip)
+ g1.appendChild(childGroup)
+ ## Add all child items as sub-elements.
+ childs.sort(key=lambda c: c.zValue())
+ for ch in childs:
+ cg = _generateItemSvg(ch, nodes, root)
+ if cg is None:
+ continue
+ childGroup.appendChild(cg) ### this isn't quite right--some items draw below their parent (good enough for now)
+
+ return g1
+
+def correctCoordinates(node, item):
+ ## Remove transformation matrices from tags by applying matrix to coordinates inside.
+ groups = node.getElementsByTagName('g')
+ for grp in groups:
+ matrix = grp.getAttribute('transform')
+ match = re.match(r'matrix\((.*)\)', matrix)
+ if match is None:
+ vals = [1,0,0,1,0,0]
+ else:
+ vals = map(float, match.groups()[0].split(','))
+ tr = np.array([[vals[0], vals[2], vals[4]], [vals[1], vals[3], vals[5]]])
+
+ removeTransform = False
+ for ch in grp.childNodes:
+ if not isinstance(ch, xml.Element):
+ continue
+ if ch.tagName == 'polyline':
+ removeTransform = True
+ coords = np.array([map(float, c.split(',')) for c in ch.getAttribute('points').strip().split(' ')])
+ coords = pg.transformCoordinates(tr, coords, transpose=True)
+ ch.setAttribute('points', ' '.join([','.join(map(str, c)) for c in coords]))
+ elif ch.tagName == 'path':
+ removeTransform = True
+ newCoords = ''
+ for c in ch.getAttribute('d').strip().split(' '):
+ x,y = c.split(',')
+ if x[0].isalpha():
+ t = x[0]
+ x = x[1:]
+ else:
+ t = ''
+ nc = pg.transformCoordinates(tr, np.array([[float(x),float(y)]]), transpose=True)
+ newCoords += t+str(nc[0,0])+','+str(nc[0,1])+' '
+ ch.setAttribute('d', newCoords)
+ elif ch.tagName == 'text':
+ removeTransform = False
+ ## leave text alone for now. Might need this later to correctly render text with outline.
+ #c = np.array([
+ #[float(ch.getAttribute('x')), float(ch.getAttribute('y'))],
+ #[float(ch.getAttribute('font-size')), 0],
+ #[0,0]])
+ #c = pg.transformCoordinates(tr, c, transpose=True)
+ #ch.setAttribute('x', str(c[0,0]))
+ #ch.setAttribute('y', str(c[0,1]))
+ #fs = c[1]-c[2]
+ #fs = (fs**2).sum()**0.5
+ #ch.setAttribute('font-size', str(fs))
+ else:
+ print('warning: export not implemented for SVG tag %s (from item %s)' % (ch.tagName, item))
+
+ ## correct line widths if needed
+ if removeTransform and ch.getAttribute('vector-effect') != 'non-scaling-stroke':
+ w = float(grp.getAttribute('stroke-width'))
+ s = pg.transformCoordinates(tr, np.array([[w,0], [0,0]]), transpose=True)
+ w = ((s[0]-s[1])**2).sum()**0.5
+ ch.setAttribute('stroke-width', str(w))
+
+ if removeTransform:
+ grp.removeAttribute('transform')
+
+
+def itemTransform(item, root):
+ ## Return the transformation mapping item to root
+ ## (actually to parent coordinate system of root)
+
+ if item is root:
+ tr = QtGui.QTransform()
+ tr.translate(*item.pos())
+ tr = tr * item.transform()
+ return tr
+
+
+ if int(item.flags() & item.ItemIgnoresTransformations) > 0:
+ pos = item.pos()
+ parent = item.parentItem()
+ if parent is not None:
+ pos = itemTransform(parent, root).map(pos)
+ tr = QtGui.QTransform()
+ tr.translate(pos.x(), pos.y())
+ tr = item.transform() * tr
+ else:
+ ## find next parent that is either the root item or
+ ## an item that ignores its transformation
+ nextRoot = item
+ while True:
+ nextRoot = nextRoot.parentItem()
+ if nextRoot is None:
+ nextRoot = root
+ break
+ if nextRoot is root or int(nextRoot.flags() & nextRoot.ItemIgnoresTransformations) > 0:
+ break
+
+ if isinstance(nextRoot, QtGui.QGraphicsScene):
+ tr = item.sceneTransform()
+ else:
+ tr = itemTransform(nextRoot, root) * item.itemTransform(nextRoot)[0]
+ #pos = QtGui.QTransform()
+ #pos.translate(root.pos().x(), root.pos().y())
+ #tr = pos * root.transform() * item.itemTransform(root)[0]
+
+
+ return tr
+
+
+#def correctStroke(node, item, root, width=1):
+ ##print "==============", item, node
+ #if node.hasAttribute('stroke-width'):
+ #width = float(node.getAttribute('stroke-width'))
+ #if node.getAttribute('vector-effect') == 'non-scaling-stroke':
+ #node.removeAttribute('vector-effect')
+ #if isinstance(root, QtGui.QGraphicsScene):
+ #w = item.mapFromScene(pg.Point(width,0))
+ #o = item.mapFromScene(pg.Point(0,0))
+ #else:
+ #w = item.mapFromItem(root, pg.Point(width,0))
+ #o = item.mapFromItem(root, pg.Point(0,0))
+ #w = w-o
+ ##print " ", w, o, w-o
+ #w = (w.x()**2 + w.y()**2) ** 0.5
+ ##print " ", w
+ #node.setAttribute('stroke-width', str(w))
+
+ #for ch in node.childNodes:
+ #if isinstance(ch, xml.Element):
+ #correctStroke(ch, item, root, width)
+
+def cleanXml(node):
+ ## remove extraneous text; let the xml library do the formatting.
+ hasElement = False
+ nonElement = []
+ for ch in node.childNodes:
+ if isinstance(ch, xml.Element):
+ hasElement = True
+ cleanXml(ch)
+ else:
+ nonElement.append(ch)
+
+ if hasElement:
+ for ch in nonElement:
+ node.removeChild(ch)
+ elif node.tagName == 'g': ## remove childless groups
+ node.parentNode.removeChild(node)
diff --git a/pyqtgraph/exporters/__init__.py b/pyqtgraph/exporters/__init__.py
new file mode 100644
index 00000000..3f3c1f1d
--- /dev/null
+++ b/pyqtgraph/exporters/__init__.py
@@ -0,0 +1,27 @@
+Exporters = []
+from pyqtgraph import importModules
+#from .. import frozenSupport
+import os
+d = os.path.split(__file__)[0]
+#files = []
+#for f in frozenSupport.listdir(d):
+ #if frozenSupport.isdir(os.path.join(d, f)) and f != '__pycache__':
+ #files.append(f)
+ #elif f[-3:] == '.py' and f not in ['__init__.py', 'Exporter.py']:
+ #files.append(f[:-3])
+
+#for modName in files:
+ #mod = __import__(modName, globals(), locals(), fromlist=['*'])
+for mod in importModules('', globals(), locals(), excludes=['Exporter']).values():
+ if hasattr(mod, '__all__'):
+ names = mod.__all__
+ else:
+ names = [n for n in dir(mod) if n[0] != '_']
+ for k in names:
+ if hasattr(mod, k):
+ Exporters.append(getattr(mod, k))
+
+
+def listExporters():
+ return Exporters[:]
+
diff --git a/pyqtgraph/flowchart/Flowchart.py b/pyqtgraph/flowchart/Flowchart.py
new file mode 100644
index 00000000..6b1352d5
--- /dev/null
+++ b/pyqtgraph/flowchart/Flowchart.py
@@ -0,0 +1,951 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui, USE_PYSIDE
+from .Node import *
+from pyqtgraph.pgcollections import OrderedDict
+from pyqtgraph.widgets.TreeWidget import *
+
+## pyside and pyqt use incompatible ui files.
+if USE_PYSIDE:
+ from . import FlowchartTemplate_pyside as FlowchartTemplate
+ from . import FlowchartCtrlTemplate_pyside as FlowchartCtrlTemplate
+else:
+ from . import FlowchartTemplate_pyqt as FlowchartTemplate
+ from . import FlowchartCtrlTemplate_pyqt as FlowchartCtrlTemplate
+
+from .Terminal import Terminal
+from numpy import ndarray
+from . import library
+from pyqtgraph.debug import printExc
+import pyqtgraph.configfile as configfile
+import pyqtgraph.dockarea as dockarea
+import pyqtgraph as pg
+from . import FlowchartGraphicsView
+
+def strDict(d):
+ return dict([(str(k), v) for k, v in d.items()])
+
+
+def toposort(deps, nodes=None, seen=None, stack=None, depth=0):
+ """Topological sort. Arguments are:
+ deps dictionary describing dependencies where a:[b,c] means "a depends on b and c"
+ nodes optional, specifies list of starting nodes (these should be the nodes
+ which are not depended on by any other nodes)
+ """
+
+ if nodes is None:
+ ## run through deps to find nodes that are not depended upon
+ rem = set()
+ for dep in deps.values():
+ rem |= set(dep)
+ nodes = set(deps.keys()) - rem
+ if seen is None:
+ seen = set()
+ stack = []
+ sorted = []
+ #print " "*depth, "Starting from", nodes
+ for n in nodes:
+ if n in stack:
+ raise Exception("Cyclic dependency detected", stack + [n])
+ if n in seen:
+ continue
+ seen.add(n)
+ #print " "*depth, " descending into", n, deps[n]
+ sorted.extend( toposort(deps, deps[n], seen, stack+[n], depth=depth+1))
+ #print " "*depth, " Added", n
+ sorted.append(n)
+ #print " "*depth, " ", sorted
+ return sorted
+
+
+class Flowchart(Node):
+
+ sigFileLoaded = QtCore.Signal(object)
+ sigFileSaved = QtCore.Signal(object)
+
+
+ #sigOutputChanged = QtCore.Signal() ## inherited from Node
+ sigChartLoaded = QtCore.Signal()
+ sigStateChanged = QtCore.Signal()
+
+ def __init__(self, terminals=None, name=None, filePath=None):
+ if name is None:
+ name = "Flowchart"
+ if terminals is None:
+ terminals = {}
+ self.filePath = filePath
+ Node.__init__(self, name, allowAddInput=True, allowAddOutput=True) ## create node without terminals; we'll add these later
+
+
+ self.inputWasSet = False ## flag allows detection of changes in the absence of input change.
+ self._nodes = {}
+ self.nextZVal = 10
+ #self.connects = []
+ #self._chartGraphicsItem = FlowchartGraphicsItem(self)
+ self._widget = None
+ self._scene = None
+ self.processing = False ## flag that prevents recursive node updates
+
+ self.widget()
+
+ self.inputNode = Node('Input', allowRemove=False, allowAddOutput=True)
+ self.outputNode = Node('Output', allowRemove=False, allowAddInput=True)
+ self.addNode(self.inputNode, 'Input', [-150, 0])
+ self.addNode(self.outputNode, 'Output', [300, 0])
+
+ self.outputNode.sigOutputChanged.connect(self.outputChanged)
+ self.outputNode.sigTerminalRenamed.connect(self.internalTerminalRenamed)
+ self.inputNode.sigTerminalRenamed.connect(self.internalTerminalRenamed)
+ self.outputNode.sigTerminalRemoved.connect(self.internalTerminalRemoved)
+ self.inputNode.sigTerminalRemoved.connect(self.internalTerminalRemoved)
+ self.outputNode.sigTerminalAdded.connect(self.internalTerminalAdded)
+ self.inputNode.sigTerminalAdded.connect(self.internalTerminalAdded)
+
+ self.viewBox.autoRange(padding = 0.04)
+
+ for name, opts in terminals.items():
+ self.addTerminal(name, **opts)
+
+ def setInput(self, **args):
+ #print "setInput", args
+ #Node.setInput(self, **args)
+ #print " ....."
+ self.inputWasSet = True
+ self.inputNode.setOutput(**args)
+
+ def outputChanged(self):
+ self.widget().outputChanged(self.outputNode.inputValues())
+ self.sigOutputChanged.emit(self)
+
+ def output(self):
+ return self.outputNode.inputValues()
+
+ def nodes(self):
+ return self._nodes
+
+ def addTerminal(self, name, **opts):
+ term = Node.addTerminal(self, name, **opts)
+ name = term.name()
+ if opts['io'] == 'in': ## inputs to the flowchart become outputs on the input node
+ opts['io'] = 'out'
+ opts['multi'] = False
+ self.inputNode.sigTerminalAdded.disconnect(self.internalTerminalAdded)
+ try:
+ term2 = self.inputNode.addTerminal(name, **opts)
+ finally:
+ self.inputNode.sigTerminalAdded.connect(self.internalTerminalAdded)
+
+ else:
+ opts['io'] = 'in'
+ #opts['multi'] = False
+ self.outputNode.sigTerminalAdded.disconnect(self.internalTerminalAdded)
+ try:
+ term2 = self.outputNode.addTerminal(name, **opts)
+ finally:
+ self.outputNode.sigTerminalAdded.connect(self.internalTerminalAdded)
+ return term
+
+ def removeTerminal(self, name):
+ #print "remove:", name
+ term = self[name]
+ inTerm = self.internalTerminal(term)
+ Node.removeTerminal(self, name)
+ inTerm.node().removeTerminal(inTerm.name())
+
+ def internalTerminalRenamed(self, term, oldName):
+ self[oldName].rename(term.name())
+
+ def internalTerminalAdded(self, node, term):
+ if term._io == 'in':
+ io = 'out'
+ else:
+ io = 'in'
+ Node.addTerminal(self, term.name(), io=io, renamable=term.isRenamable(), removable=term.isRemovable(), multiable=term.isMultiable())
+
+ def internalTerminalRemoved(self, node, term):
+ try:
+ Node.removeTerminal(self, term.name())
+ except KeyError:
+ pass
+
+ def terminalRenamed(self, term, oldName):
+ newName = term.name()
+ #print "flowchart rename", newName, oldName
+ #print self.terminals
+ Node.terminalRenamed(self, self[oldName], oldName)
+ #print self.terminals
+ for n in [self.inputNode, self.outputNode]:
+ if oldName in n.terminals:
+ n[oldName].rename(newName)
+
+ def createNode(self, nodeType, name=None, pos=None):
+ if name is None:
+ n = 0
+ while True:
+ name = "%s.%d" % (nodeType, n)
+ if name not in self._nodes:
+ break
+ n += 1
+
+ node = library.getNodeType(nodeType)(name)
+ self.addNode(node, name, pos)
+ return node
+
+ def addNode(self, node, name, pos=None):
+ if pos is None:
+ pos = [0, 0]
+ if type(pos) in [QtCore.QPoint, QtCore.QPointF]:
+ pos = [pos.x(), pos.y()]
+ item = node.graphicsItem()
+ item.setZValue(self.nextZVal*2)
+ self.nextZVal += 1
+ #item.setParentItem(self.chartGraphicsItem())
+ self.viewBox.addItem(item)
+ #item.setPos(pos2.x(), pos2.y())
+ item.moveBy(*pos)
+ self._nodes[name] = node
+ self.widget().addNode(node)
+ #QtCore.QObject.connect(node, QtCore.SIGNAL('closed'), self.nodeClosed)
+ node.sigClosed.connect(self.nodeClosed)
+ #QtCore.QObject.connect(node, QtCore.SIGNAL('renamed'), self.nodeRenamed)
+ node.sigRenamed.connect(self.nodeRenamed)
+ #QtCore.QObject.connect(node, QtCore.SIGNAL('outputChanged'), self.nodeOutputChanged)
+ node.sigOutputChanged.connect(self.nodeOutputChanged)
+
+ def removeNode(self, node):
+ node.close()
+
+ def nodeClosed(self, node):
+ del self._nodes[node.name()]
+ self.widget().removeNode(node)
+ #QtCore.QObject.disconnect(node, QtCore.SIGNAL('closed'), self.nodeClosed)
+ try:
+ node.sigClosed.disconnect(self.nodeClosed)
+ except TypeError:
+ pass
+ #QtCore.QObject.disconnect(node, QtCore.SIGNAL('renamed'), self.nodeRenamed)
+ try:
+ node.sigRenamed.disconnect(self.nodeRenamed)
+ except TypeError:
+ pass
+ #QtCore.QObject.disconnect(node, QtCore.SIGNAL('outputChanged'), self.nodeOutputChanged)
+ try:
+ node.sigOutputChanged.disconnect(self.nodeOutputChanged)
+ except TypeError:
+ pass
+
+ def nodeRenamed(self, node, oldName):
+ del self._nodes[oldName]
+ self._nodes[node.name()] = node
+ self.widget().nodeRenamed(node, oldName)
+
+ def arrangeNodes(self):
+ pass
+
+ def internalTerminal(self, term):
+ """If the terminal belongs to the external Node, return the corresponding internal terminal"""
+ if term.node() is self:
+ if term.isInput():
+ return self.inputNode[term.name()]
+ else:
+ return self.outputNode[term.name()]
+ else:
+ return term
+
+ def connectTerminals(self, term1, term2):
+ """Connect two terminals together within this flowchart."""
+ term1 = self.internalTerminal(term1)
+ term2 = self.internalTerminal(term2)
+ term1.connectTo(term2)
+
+
+ def process(self, **args):
+ """
+ Process data through the flowchart, returning the output.
+ Keyword arguments must be the names of input terminals
+
+ """
+ data = {} ## Stores terminal:value pairs
+
+ ## determine order of operations
+ ## order should look like [('p', node1), ('p', node2), ('d', terminal1), ...]
+ ## Each tuple specifies either (p)rocess this node or (d)elete the result from this terminal
+ order = self.processOrder()
+ #print "ORDER:", order
+
+ ## Record inputs given to process()
+ for n, t in self.inputNode.outputs().items():
+ if n not in args:
+ raise Exception("Parameter %s required to process this chart." % n)
+ data[t] = args[n]
+
+ ret = {}
+
+ ## process all in order
+ for c, arg in order:
+
+ if c == 'p': ## Process a single node
+ #print "===> process:", arg
+ node = arg
+ if node is self.inputNode:
+ continue ## input node has already been processed.
+
+
+ ## get input and output terminals for this node
+ outs = list(node.outputs().values())
+ ins = list(node.inputs().values())
+
+ ## construct input value dictionary
+ args = {}
+ for inp in ins:
+ inputs = inp.inputTerminals()
+ if len(inputs) == 0:
+ continue
+ if inp.isMultiValue(): ## multi-input terminals require a dict of all inputs
+ args[inp.name()] = dict([(i, data[i]) for i in inputs])
+ else: ## single-inputs terminals only need the single input value available
+ args[inp.name()] = data[inputs[0]]
+
+ if node is self.outputNode:
+ ret = args ## we now have the return value, but must keep processing in case there are other endpoint nodes in the chart
+ else:
+ try:
+ if node.isBypassed():
+ result = node.processBypassed(args)
+ else:
+ result = node.process(display=False, **args)
+ except:
+ print("Error processing node %s. Args are: %s" % (str(node), str(args)))
+ raise
+ for out in outs:
+ #print " Output:", out, out.name()
+ #print out.name()
+ try:
+ data[out] = result[out.name()]
+ except:
+ print(out, out.name())
+ raise
+ elif c == 'd': ## delete a terminal result (no longer needed; may be holding a lot of memory)
+ #print "===> delete", arg
+ if arg in data:
+ del data[arg]
+
+ return ret
+
+ def processOrder(self):
+ """Return the order of operations required to process this chart.
+ The order returned should look like [('p', node1), ('p', node2), ('d', terminal1), ...]
+ where each tuple specifies either (p)rocess this node or (d)elete the result from this terminal
+ """
+
+ ## first collect list of nodes/terminals and their dependencies
+ deps = {}
+ tdeps = {} ## {terminal: [nodes that depend on terminal]}
+ for name, node in self._nodes.items():
+ deps[node] = node.dependentNodes()
+ for t in node.outputs().values():
+ tdeps[t] = t.dependentNodes()
+
+ #print "DEPS:", deps
+ ## determine correct node-processing order
+ #deps[self] = []
+ order = toposort(deps)
+ #print "ORDER1:", order
+
+ ## construct list of operations
+ ops = [('p', n) for n in order]
+
+ ## determine when it is safe to delete terminal values
+ dels = []
+ for t, nodes in tdeps.items():
+ lastInd = 0
+ lastNode = None
+ for n in nodes: ## determine which node is the last to be processed according to order
+ if n is self:
+ lastInd = None
+ break
+ else:
+ try:
+ ind = order.index(n)
+ except ValueError:
+ continue
+ if lastNode is None or ind > lastInd:
+ lastNode = n
+ lastInd = ind
+ #tdeps[t] = lastNode
+ if lastInd is not None:
+ dels.append((lastInd+1, t))
+ dels.sort(lambda a,b: cmp(b[0], a[0]))
+ for i, t in dels:
+ ops.insert(i, ('d', t))
+
+ return ops
+
+
+ def nodeOutputChanged(self, startNode):
+ """Triggered when a node's output values have changed. (NOT called during process())
+ Propagates new data forward through network."""
+ ## first collect list of nodes/terminals and their dependencies
+
+ if self.processing:
+ return
+ self.processing = True
+ try:
+ deps = {}
+ for name, node in self._nodes.items():
+ deps[node] = []
+ for t in node.outputs().values():
+ deps[node].extend(t.dependentNodes())
+
+ ## determine order of updates
+ order = toposort(deps, nodes=[startNode])
+ order.reverse()
+
+ ## keep track of terminals that have been updated
+ terms = set(startNode.outputs().values())
+
+ #print "======= Updating", startNode
+ #print "Order:", order
+ for node in order[1:]:
+ #print "Processing node", node
+ for term in list(node.inputs().values()):
+ #print " checking terminal", term
+ deps = list(term.connections().keys())
+ update = False
+ for d in deps:
+ if d in terms:
+ #print " ..input", d, "changed"
+ update = True
+ term.inputChanged(d, process=False)
+ if update:
+ #print " processing.."
+ node.update()
+ terms |= set(node.outputs().values())
+
+ finally:
+ self.processing = False
+ if self.inputWasSet:
+ self.inputWasSet = False
+ else:
+ self.sigStateChanged.emit()
+
+
+
+ def chartGraphicsItem(self):
+ """Return the graphicsItem which displays the internals of this flowchart.
+ (graphicsItem() still returns the external-view item)"""
+ #return self._chartGraphicsItem
+ return self.viewBox
+
+ def widget(self):
+ if self._widget is None:
+ self._widget = FlowchartCtrlWidget(self)
+ self.scene = self._widget.scene()
+ self.viewBox = self._widget.viewBox()
+ #self._scene = QtGui.QGraphicsScene()
+ #self._widget.setScene(self._scene)
+ #self.scene.addItem(self.chartGraphicsItem())
+
+ #ci = self.chartGraphicsItem()
+ #self.viewBox.addItem(ci)
+ #self.viewBox.autoRange()
+ return self._widget
+
+ def listConnections(self):
+ conn = set()
+ for n in self._nodes.values():
+ terms = n.outputs()
+ for n, t in terms.items():
+ for c in t.connections():
+ conn.add((t, c))
+ return conn
+
+ def saveState(self):
+ state = Node.saveState(self)
+ state['nodes'] = []
+ state['connects'] = []
+ #state['terminals'] = self.saveTerminals()
+
+ for name, node in self._nodes.items():
+ cls = type(node)
+ if hasattr(cls, 'nodeName'):
+ clsName = cls.nodeName
+ pos = node.graphicsItem().pos()
+ ns = {'class': clsName, 'name': name, 'pos': (pos.x(), pos.y()), 'state': node.saveState()}
+ state['nodes'].append(ns)
+
+ conn = self.listConnections()
+ for a, b in conn:
+ state['connects'].append((a.node().name(), a.name(), b.node().name(), b.name()))
+
+ state['inputNode'] = self.inputNode.saveState()
+ state['outputNode'] = self.outputNode.saveState()
+
+ return state
+
+ def restoreState(self, state, clear=False):
+ self.blockSignals(True)
+ try:
+ if clear:
+ self.clear()
+ Node.restoreState(self, state)
+ nodes = state['nodes']
+ nodes.sort(lambda a, b: cmp(a['pos'][0], b['pos'][0]))
+ for n in nodes:
+ if n['name'] in self._nodes:
+ #self._nodes[n['name']].graphicsItem().moveBy(*n['pos'])
+ self._nodes[n['name']].restoreState(n['state'])
+ continue
+ try:
+ node = self.createNode(n['class'], name=n['name'])
+ node.restoreState(n['state'])
+ except:
+ printExc("Error creating node %s: (continuing anyway)" % n['name'])
+ #node.graphicsItem().moveBy(*n['pos'])
+
+ self.inputNode.restoreState(state.get('inputNode', {}))
+ self.outputNode.restoreState(state.get('outputNode', {}))
+
+ #self.restoreTerminals(state['terminals'])
+ for n1, t1, n2, t2 in state['connects']:
+ try:
+ self.connectTerminals(self._nodes[n1][t1], self._nodes[n2][t2])
+ except:
+ print(self._nodes[n1].terminals)
+ print(self._nodes[n2].terminals)
+ printExc("Error connecting terminals %s.%s - %s.%s:" % (n1, t1, n2, t2))
+
+
+ finally:
+ self.blockSignals(False)
+
+ self.sigChartLoaded.emit()
+ self.outputChanged()
+ self.sigStateChanged.emit()
+ #self.sigOutputChanged.emit()
+
+ def loadFile(self, fileName=None, startDir=None):
+ if fileName is None:
+ if startDir is None:
+ startDir = self.filePath
+ if startDir is None:
+ startDir = '.'
+ self.fileDialog = pg.FileDialog(None, "Load Flowchart..", startDir, "Flowchart (*.fc)")
+ #self.fileDialog.setFileMode(QtGui.QFileDialog.AnyFile)
+ #self.fileDialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
+ self.fileDialog.show()
+ self.fileDialog.fileSelected.connect(self.loadFile)
+ return
+ ## NOTE: was previously using a real widget for the file dialog's parent, but this caused weird mouse event bugs..
+ #fileName = QtGui.QFileDialog.getOpenFileName(None, "Load Flowchart..", startDir, "Flowchart (*.fc)")
+ fileName = str(fileName)
+ state = configfile.readConfigFile(fileName)
+ self.restoreState(state, clear=True)
+ self.viewBox.autoRange()
+ #self.emit(QtCore.SIGNAL('fileLoaded'), fileName)
+ self.sigFileLoaded.emit(fileName)
+
+ def saveFile(self, fileName=None, startDir=None, suggestedFileName='flowchart.fc'):
+ if fileName is None:
+ if startDir is None:
+ startDir = self.filePath
+ if startDir is None:
+ startDir = '.'
+ self.fileDialog = pg.FileDialog(None, "Save Flowchart..", startDir, "Flowchart (*.fc)")
+ #self.fileDialog.setFileMode(QtGui.QFileDialog.AnyFile)
+ self.fileDialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
+ #self.fileDialog.setDirectory(startDir)
+ self.fileDialog.show()
+ self.fileDialog.fileSelected.connect(self.saveFile)
+ return
+ #fileName = QtGui.QFileDialog.getSaveFileName(None, "Save Flowchart..", startDir, "Flowchart (*.fc)")
+ configfile.writeConfigFile(self.saveState(), fileName)
+ self.sigFileSaved.emit(fileName)
+
+ def clear(self):
+ for n in list(self._nodes.values()):
+ if n is self.inputNode or n is self.outputNode:
+ continue
+ n.close() ## calls self.nodeClosed(n) by signal
+ #self.clearTerminals()
+ self.widget().clear()
+
+ def clearTerminals(self):
+ Node.clearTerminals(self)
+ self.inputNode.clearTerminals()
+ self.outputNode.clearTerminals()
+
+#class FlowchartGraphicsItem(QtGui.QGraphicsItem):
+class FlowchartGraphicsItem(GraphicsObject):
+
+ def __init__(self, chart):
+ #print "FlowchartGraphicsItem.__init__"
+ #QtGui.QGraphicsItem.__init__(self)
+ GraphicsObject.__init__(self)
+ self.chart = chart ## chart is an instance of Flowchart()
+ self.updateTerminals()
+
+ def updateTerminals(self):
+ #print "FlowchartGraphicsItem.updateTerminals"
+ self.terminals = {}
+ bounds = self.boundingRect()
+ inp = self.chart.inputs()
+ dy = bounds.height() / (len(inp)+1)
+ y = dy
+ for n, t in inp.items():
+ item = t.graphicsItem()
+ self.terminals[n] = item
+ item.setParentItem(self)
+ item.setAnchor(bounds.width(), y)
+ y += dy
+ out = self.chart.outputs()
+ dy = bounds.height() / (len(out)+1)
+ y = dy
+ for n, t in out.items():
+ item = t.graphicsItem()
+ self.terminals[n] = item
+ item.setParentItem(self)
+ item.setAnchor(0, y)
+ y += dy
+
+ def boundingRect(self):
+ #print "FlowchartGraphicsItem.boundingRect"
+ return QtCore.QRectF()
+
+ def paint(self, p, *args):
+ #print "FlowchartGraphicsItem.paint"
+ pass
+ #p.drawRect(self.boundingRect())
+
+
+class FlowchartCtrlWidget(QtGui.QWidget):
+ """The widget that contains the list of all the nodes in a flowchart and their controls, as well as buttons for loading/saving flowcharts."""
+
+ def __init__(self, chart):
+ self.items = {}
+ #self.loadDir = loadDir ## where to look initially for chart files
+ self.currentFileName = None
+ QtGui.QWidget.__init__(self)
+ self.chart = chart
+ self.ui = FlowchartCtrlTemplate.Ui_Form()
+ self.ui.setupUi(self)
+ self.ui.ctrlList.setColumnCount(2)
+ #self.ui.ctrlList.setColumnWidth(0, 200)
+ self.ui.ctrlList.setColumnWidth(1, 20)
+ self.ui.ctrlList.setVerticalScrollMode(self.ui.ctrlList.ScrollPerPixel)
+ self.ui.ctrlList.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+
+ self.chartWidget = FlowchartWidget(chart, self)
+ #self.chartWidget.viewBox().autoRange()
+ self.cwWin = QtGui.QMainWindow()
+ self.cwWin.setWindowTitle('Flowchart')
+ self.cwWin.setCentralWidget(self.chartWidget)
+ self.cwWin.resize(1000,800)
+
+ h = self.ui.ctrlList.header()
+ h.setResizeMode(0, h.Stretch)
+
+ self.ui.ctrlList.itemChanged.connect(self.itemChanged)
+ self.ui.loadBtn.clicked.connect(self.loadClicked)
+ self.ui.saveBtn.clicked.connect(self.saveClicked)
+ self.ui.saveAsBtn.clicked.connect(self.saveAsClicked)
+ self.ui.showChartBtn.toggled.connect(self.chartToggled)
+ self.chart.sigFileLoaded.connect(self.setCurrentFile)
+ self.ui.reloadBtn.clicked.connect(self.reloadClicked)
+ self.chart.sigFileSaved.connect(self.fileSaved)
+
+
+
+ #def resizeEvent(self, ev):
+ #QtGui.QWidget.resizeEvent(self, ev)
+ #self.ui.ctrlList.setColumnWidth(0, self.ui.ctrlList.viewport().width()-20)
+
+ def chartToggled(self, b):
+ if b:
+ self.cwWin.show()
+ else:
+ self.cwWin.hide()
+
+ def reloadClicked(self):
+ try:
+ self.chartWidget.reloadLibrary()
+ self.ui.reloadBtn.success("Reloaded.")
+ except:
+ self.ui.reloadBtn.success("Error.")
+ raise
+
+
+ def loadClicked(self):
+ newFile = self.chart.loadFile()
+ #self.setCurrentFile(newFile)
+
+ def fileSaved(self, fileName):
+ self.setCurrentFile(fileName)
+ self.ui.saveBtn.success("Saved.")
+
+ def saveClicked(self):
+ if self.currentFileName is None:
+ self.saveAsClicked()
+ else:
+ try:
+ self.chart.saveFile(self.currentFileName)
+ #self.ui.saveBtn.success("Saved.")
+ except:
+ self.ui.saveBtn.failure("Error")
+ raise
+
+ def saveAsClicked(self):
+ try:
+ if self.currentFileName is None:
+ newFile = self.chart.saveFile()
+ else:
+ newFile = self.chart.saveFile(suggestedFileName=self.currentFileName)
+ #self.ui.saveAsBtn.success("Saved.")
+ #print "Back to saveAsClicked."
+ except:
+ self.ui.saveBtn.failure("Error")
+ raise
+
+ #self.setCurrentFile(newFile)
+
+ def setCurrentFile(self, fileName):
+ self.currentFileName = fileName
+ if fileName is None:
+ self.ui.fileNameLabel.setText("[ new ]")
+ else:
+ self.ui.fileNameLabel.setText("%s" % os.path.split(self.currentFileName)[1])
+ self.resizeEvent(None)
+
+ def itemChanged(self, *args):
+ pass
+
+ def scene(self):
+ return self.chartWidget.scene() ## returns the GraphicsScene object
+
+ def viewBox(self):
+ return self.chartWidget.viewBox()
+
+ def nodeRenamed(self, node, oldName):
+ self.items[node].setText(0, node.name())
+
+ def addNode(self, node):
+ ctrl = node.ctrlWidget()
+ #if ctrl is None:
+ #return
+ item = QtGui.QTreeWidgetItem([node.name(), '', ''])
+ self.ui.ctrlList.addTopLevelItem(item)
+ byp = QtGui.QPushButton('X')
+ byp.setCheckable(True)
+ byp.setFixedWidth(20)
+ item.bypassBtn = byp
+ self.ui.ctrlList.setItemWidget(item, 1, byp)
+ byp.node = node
+ node.bypassButton = byp
+ byp.setChecked(node.isBypassed())
+ byp.clicked.connect(self.bypassClicked)
+
+ if ctrl is not None:
+ item2 = QtGui.QTreeWidgetItem()
+ item.addChild(item2)
+ self.ui.ctrlList.setItemWidget(item2, 0, ctrl)
+
+ self.items[node] = item
+
+ def removeNode(self, node):
+ if node in self.items:
+ item = self.items[node]
+ #self.disconnect(item.bypassBtn, QtCore.SIGNAL('clicked()'), self.bypassClicked)
+ try:
+ item.bypassBtn.clicked.disconnect(self.bypassClicked)
+ except TypeError:
+ pass
+ self.ui.ctrlList.removeTopLevelItem(item)
+
+ def bypassClicked(self):
+ btn = QtCore.QObject.sender(self)
+ btn.node.bypass(btn.isChecked())
+
+ def chartWidget(self):
+ return self.chartWidget
+
+ def outputChanged(self, data):
+ pass
+ #self.ui.outputTree.setData(data, hideRoot=True)
+
+ def clear(self):
+ self.chartWidget.clear()
+
+ def select(self, node):
+ item = self.items[node]
+ self.ui.ctrlList.setCurrentItem(item)
+
+class FlowchartWidget(dockarea.DockArea):
+ """Includes the actual graphical flowchart and debugging interface"""
+ def __init__(self, chart, ctrl):
+ #QtGui.QWidget.__init__(self)
+ dockarea.DockArea.__init__(self)
+ self.chart = chart
+ self.ctrl = ctrl
+ self.hoverItem = None
+ #self.setMinimumWidth(250)
+ #self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding))
+
+ #self.ui = FlowchartTemplate.Ui_Form()
+ #self.ui.setupUi(self)
+
+ ## build user interface (it was easier to do it here than via developer)
+ self.view = FlowchartGraphicsView.FlowchartGraphicsView(self)
+ self.viewDock = dockarea.Dock('view', size=(1000,600))
+ self.viewDock.addWidget(self.view)
+ self.viewDock.hideTitleBar()
+ self.addDock(self.viewDock)
+
+
+ self.hoverText = QtGui.QTextEdit()
+ self.hoverText.setReadOnly(True)
+ self.hoverDock = dockarea.Dock('Hover Info', size=(1000,20))
+ self.hoverDock.addWidget(self.hoverText)
+ self.addDock(self.hoverDock, 'bottom')
+
+ self.selInfo = QtGui.QWidget()
+ self.selInfoLayout = QtGui.QGridLayout()
+ self.selInfo.setLayout(self.selInfoLayout)
+ self.selDescLabel = QtGui.QLabel()
+ self.selNameLabel = QtGui.QLabel()
+ self.selDescLabel.setWordWrap(True)
+ self.selectedTree = pg.DataTreeWidget()
+ #self.selectedTree.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
+ #self.selInfoLayout.addWidget(self.selNameLabel)
+ self.selInfoLayout.addWidget(self.selDescLabel)
+ self.selInfoLayout.addWidget(self.selectedTree)
+ self.selDock = dockarea.Dock('Selected Node', size=(1000,200))
+ self.selDock.addWidget(self.selInfo)
+ self.addDock(self.selDock, 'bottom')
+
+ self._scene = self.view.scene()
+ self._viewBox = self.view.viewBox()
+ #self._scene = QtGui.QGraphicsScene()
+ #self._scene = FlowchartGraphicsView.FlowchartGraphicsScene()
+ #self.view.setScene(self._scene)
+
+ self.buildMenu()
+ #self.ui.addNodeBtn.mouseReleaseEvent = self.addNodeBtnReleased
+
+ self._scene.selectionChanged.connect(self.selectionChanged)
+ self._scene.sigMouseHover.connect(self.hoverOver)
+ #self.view.sigClicked.connect(self.showViewMenu)
+ #self._scene.sigSceneContextMenu.connect(self.showViewMenu)
+ #self._viewBox.sigActionPositionChanged.connect(self.menuPosChanged)
+
+
+ def reloadLibrary(self):
+ #QtCore.QObject.disconnect(self.nodeMenu, QtCore.SIGNAL('triggered(QAction*)'), self.nodeMenuTriggered)
+ self.nodeMenu.triggered.disconnect(self.nodeMenuTriggered)
+ self.nodeMenu = None
+ self.subMenus = []
+ library.loadLibrary(reloadLibs=True)
+ self.buildMenu()
+
+ def buildMenu(self, pos=None):
+ self.nodeMenu = QtGui.QMenu()
+ self.subMenus = []
+ for section, nodes in library.getNodeTree().items():
+ menu = QtGui.QMenu(section)
+ self.nodeMenu.addMenu(menu)
+ for name in nodes:
+ act = menu.addAction(name)
+ act.nodeType = name
+ act.pos = pos
+ self.subMenus.append(menu)
+ self.nodeMenu.triggered.connect(self.nodeMenuTriggered)
+ return self.nodeMenu
+
+ def menuPosChanged(self, pos):
+ self.menuPos = pos
+
+ def showViewMenu(self, ev):
+ #QtGui.QPushButton.mouseReleaseEvent(self.ui.addNodeBtn, ev)
+ #if ev.button() == QtCore.Qt.RightButton:
+ #self.menuPos = self.view.mapToScene(ev.pos())
+ #self.nodeMenu.popup(ev.globalPos())
+ #print "Flowchart.showViewMenu called"
+
+ #self.menuPos = ev.scenePos()
+ self.buildMenu(ev.scenePos())
+ self.nodeMenu.popup(ev.screenPos())
+
+ def scene(self):
+ return self._scene ## the GraphicsScene item
+
+ def viewBox(self):
+ return self._viewBox ## the viewBox that items should be added to
+
+ def nodeMenuTriggered(self, action):
+ nodeType = action.nodeType
+ if action.pos is not None:
+ pos = action.pos
+ else:
+ pos = self.menuPos
+ pos = self.viewBox().mapSceneToView(pos)
+
+ self.chart.createNode(nodeType, pos=pos)
+
+
+ def selectionChanged(self):
+ #print "FlowchartWidget.selectionChanged called."
+ items = self._scene.selectedItems()
+ #print " scene.selectedItems: ", items
+ if len(items) == 0:
+ data = None
+ else:
+ item = items[0]
+ if hasattr(item, 'node') and isinstance(item.node, Node):
+ n = item.node
+ self.ctrl.select(n)
+ data = {'outputs': n.outputValues(), 'inputs': n.inputValues()}
+ self.selNameLabel.setText(n.name())
+ if hasattr(n, 'nodeName'):
+ self.selDescLabel.setText("%s: %s" % (n.nodeName, n.__class__.__doc__))
+ else:
+ self.selDescLabel.setText("")
+ if n.exception is not None:
+ data['exception'] = n.exception
+ else:
+ data = None
+ self.selectedTree.setData(data, hideRoot=True)
+
+ def hoverOver(self, items):
+ #print "FlowchartWidget.hoverOver called."
+ term = None
+ for item in items:
+ if item is self.hoverItem:
+ return
+ self.hoverItem = item
+ if hasattr(item, 'term') and isinstance(item.term, Terminal):
+ term = item.term
+ break
+ if term is None:
+ self.hoverText.setPlainText("")
+ else:
+ val = term.value()
+ if isinstance(val, ndarray):
+ val = "%s %s %s" % (type(val).__name__, str(val.shape), str(val.dtype))
+ else:
+ val = str(val)
+ if len(val) > 400:
+ val = val[:400] + "..."
+ self.hoverText.setPlainText("%s.%s = %s" % (term.node().name(), term.name(), val))
+ #self.hoverLabel.setCursorPosition(0)
+
+
+
+ def clear(self):
+ #self.outputTree.setData(None)
+ self.selectedTree.setData(None)
+ self.hoverText.setPlainText('')
+ self.selNameLabel.setText('')
+ self.selDescLabel.setText('')
+
+
+class FlowchartNode(Node):
+ pass
+
diff --git a/pyqtgraph/flowchart/FlowchartCtrlTemplate.ui b/pyqtgraph/flowchart/FlowchartCtrlTemplate.ui
new file mode 100644
index 00000000..610846b6
--- /dev/null
+++ b/pyqtgraph/flowchart/FlowchartCtrlTemplate.ui
@@ -0,0 +1,120 @@
+
+
+ Form
+
+
+
+ 0
+ 0
+ 217
+ 499
+
+
+
+ Form
+
+
+
+ 0
+
+
+ 0
+
+ -
+
+
+ Load..
+
+
+
+ -
+
+
+ Save
+
+
+
+ -
+
+
+ As..
+
+
+
+ -
+
+
+ Reload Libs
+
+
+ false
+
+
+ false
+
+
+
+ -
+
+
+ Flowchart
+
+
+ true
+
+
+
+ -
+
+
+ false
+
+
+ false
+
+
+ false
+
+
+ false
+
+
+
+ 1
+
+
+
+
+ -
+
+
+
+ 75
+ true
+
+
+
+
+
+
+ Qt::AlignCenter
+
+
+
+
+
+
+
+ TreeWidget
+ QTreeWidget
+ pyqtgraph.widgets.TreeWidget
+
+
+ FeedbackButton
+ QPushButton
+ pyqtgraph.widgets.FeedbackButton
+
+
+
+
+
diff --git a/pyqtgraph/flowchart/FlowchartCtrlTemplate_pyqt.py b/pyqtgraph/flowchart/FlowchartCtrlTemplate_pyqt.py
new file mode 100644
index 00000000..0410cdf3
--- /dev/null
+++ b/pyqtgraph/flowchart/FlowchartCtrlTemplate_pyqt.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file './flowchart/FlowchartCtrlTemplate.ui'
+#
+# Created: Sun Sep 9 14:41:30 2012
+# by: PyQt4 UI code generator 4.9.1
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+ _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+ _fromUtf8 = lambda s: s
+
+class Ui_Form(object):
+ def setupUi(self, Form):
+ Form.setObjectName(_fromUtf8("Form"))
+ Form.resize(217, 499)
+ self.gridLayout = QtGui.QGridLayout(Form)
+ self.gridLayout.setMargin(0)
+ self.gridLayout.setVerticalSpacing(0)
+ self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
+ self.loadBtn = QtGui.QPushButton(Form)
+ self.loadBtn.setObjectName(_fromUtf8("loadBtn"))
+ self.gridLayout.addWidget(self.loadBtn, 1, 0, 1, 1)
+ self.saveBtn = FeedbackButton(Form)
+ self.saveBtn.setObjectName(_fromUtf8("saveBtn"))
+ self.gridLayout.addWidget(self.saveBtn, 1, 1, 1, 2)
+ self.saveAsBtn = FeedbackButton(Form)
+ self.saveAsBtn.setObjectName(_fromUtf8("saveAsBtn"))
+ self.gridLayout.addWidget(self.saveAsBtn, 1, 3, 1, 1)
+ self.reloadBtn = FeedbackButton(Form)
+ self.reloadBtn.setCheckable(False)
+ self.reloadBtn.setFlat(False)
+ self.reloadBtn.setObjectName(_fromUtf8("reloadBtn"))
+ self.gridLayout.addWidget(self.reloadBtn, 4, 0, 1, 2)
+ self.showChartBtn = QtGui.QPushButton(Form)
+ self.showChartBtn.setCheckable(True)
+ self.showChartBtn.setObjectName(_fromUtf8("showChartBtn"))
+ self.gridLayout.addWidget(self.showChartBtn, 4, 2, 1, 2)
+ self.ctrlList = TreeWidget(Form)
+ self.ctrlList.setObjectName(_fromUtf8("ctrlList"))
+ self.ctrlList.headerItem().setText(0, _fromUtf8("1"))
+ self.ctrlList.header().setVisible(False)
+ self.ctrlList.header().setStretchLastSection(False)
+ self.gridLayout.addWidget(self.ctrlList, 3, 0, 1, 4)
+ self.fileNameLabel = QtGui.QLabel(Form)
+ font = QtGui.QFont()
+ font.setBold(True)
+ font.setWeight(75)
+ self.fileNameLabel.setFont(font)
+ self.fileNameLabel.setText(_fromUtf8(""))
+ self.fileNameLabel.setAlignment(QtCore.Qt.AlignCenter)
+ self.fileNameLabel.setObjectName(_fromUtf8("fileNameLabel"))
+ self.gridLayout.addWidget(self.fileNameLabel, 0, 1, 1, 1)
+
+ self.retranslateUi(Form)
+ QtCore.QMetaObject.connectSlotsByName(Form)
+
+ def retranslateUi(self, Form):
+ Form.setWindowTitle(QtGui.QApplication.translate("Form", "Form", None, QtGui.QApplication.UnicodeUTF8))
+ self.loadBtn.setText(QtGui.QApplication.translate("Form", "Load..", None, QtGui.QApplication.UnicodeUTF8))
+ self.saveBtn.setText(QtGui.QApplication.translate("Form", "Save", None, QtGui.QApplication.UnicodeUTF8))
+ self.saveAsBtn.setText(QtGui.QApplication.translate("Form", "As..", None, QtGui.QApplication.UnicodeUTF8))
+ self.reloadBtn.setText(QtGui.QApplication.translate("Form", "Reload Libs", None, QtGui.QApplication.UnicodeUTF8))
+ self.showChartBtn.setText(QtGui.QApplication.translate("Form", "Flowchart", None, QtGui.QApplication.UnicodeUTF8))
+
+from pyqtgraph.widgets.FeedbackButton import FeedbackButton
+from pyqtgraph.widgets.TreeWidget import TreeWidget
diff --git a/pyqtgraph/flowchart/FlowchartCtrlTemplate_pyside.py b/pyqtgraph/flowchart/FlowchartCtrlTemplate_pyside.py
new file mode 100644
index 00000000..f579c957
--- /dev/null
+++ b/pyqtgraph/flowchart/FlowchartCtrlTemplate_pyside.py
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file './flowchart/FlowchartCtrlTemplate.ui'
+#
+# Created: Sun Sep 9 14:41:30 2012
+# by: pyside-uic 0.2.13 running on PySide 1.1.0
+#
+# WARNING! All changes made in this file will be lost!
+
+from PySide import QtCore, QtGui
+
+class Ui_Form(object):
+ def setupUi(self, Form):
+ Form.setObjectName("Form")
+ Form.resize(217, 499)
+ self.gridLayout = QtGui.QGridLayout(Form)
+ self.gridLayout.setContentsMargins(0, 0, 0, 0)
+ self.gridLayout.setVerticalSpacing(0)
+ self.gridLayout.setObjectName("gridLayout")
+ self.loadBtn = QtGui.QPushButton(Form)
+ self.loadBtn.setObjectName("loadBtn")
+ self.gridLayout.addWidget(self.loadBtn, 1, 0, 1, 1)
+ self.saveBtn = FeedbackButton(Form)
+ self.saveBtn.setObjectName("saveBtn")
+ self.gridLayout.addWidget(self.saveBtn, 1, 1, 1, 2)
+ self.saveAsBtn = FeedbackButton(Form)
+ self.saveAsBtn.setObjectName("saveAsBtn")
+ self.gridLayout.addWidget(self.saveAsBtn, 1, 3, 1, 1)
+ self.reloadBtn = FeedbackButton(Form)
+ self.reloadBtn.setCheckable(False)
+ self.reloadBtn.setFlat(False)
+ self.reloadBtn.setObjectName("reloadBtn")
+ self.gridLayout.addWidget(self.reloadBtn, 4, 0, 1, 2)
+ self.showChartBtn = QtGui.QPushButton(Form)
+ self.showChartBtn.setCheckable(True)
+ self.showChartBtn.setObjectName("showChartBtn")
+ self.gridLayout.addWidget(self.showChartBtn, 4, 2, 1, 2)
+ self.ctrlList = TreeWidget(Form)
+ self.ctrlList.setObjectName("ctrlList")
+ self.ctrlList.headerItem().setText(0, "1")
+ self.ctrlList.header().setVisible(False)
+ self.ctrlList.header().setStretchLastSection(False)
+ self.gridLayout.addWidget(self.ctrlList, 3, 0, 1, 4)
+ self.fileNameLabel = QtGui.QLabel(Form)
+ font = QtGui.QFont()
+ font.setWeight(75)
+ font.setBold(True)
+ self.fileNameLabel.setFont(font)
+ self.fileNameLabel.setText("")
+ self.fileNameLabel.setAlignment(QtCore.Qt.AlignCenter)
+ self.fileNameLabel.setObjectName("fileNameLabel")
+ self.gridLayout.addWidget(self.fileNameLabel, 0, 1, 1, 1)
+
+ self.retranslateUi(Form)
+ QtCore.QMetaObject.connectSlotsByName(Form)
+
+ def retranslateUi(self, Form):
+ Form.setWindowTitle(QtGui.QApplication.translate("Form", "Form", None, QtGui.QApplication.UnicodeUTF8))
+ self.loadBtn.setText(QtGui.QApplication.translate("Form", "Load..", None, QtGui.QApplication.UnicodeUTF8))
+ self.saveBtn.setText(QtGui.QApplication.translate("Form", "Save", None, QtGui.QApplication.UnicodeUTF8))
+ self.saveAsBtn.setText(QtGui.QApplication.translate("Form", "As..", None, QtGui.QApplication.UnicodeUTF8))
+ self.reloadBtn.setText(QtGui.QApplication.translate("Form", "Reload Libs", None, QtGui.QApplication.UnicodeUTF8))
+ self.showChartBtn.setText(QtGui.QApplication.translate("Form", "Flowchart", None, QtGui.QApplication.UnicodeUTF8))
+
+from pyqtgraph.widgets.FeedbackButton import FeedbackButton
+from pyqtgraph.widgets.TreeWidget import TreeWidget
diff --git a/pyqtgraph/flowchart/FlowchartGraphicsView.py b/pyqtgraph/flowchart/FlowchartGraphicsView.py
new file mode 100644
index 00000000..0ec4d5c8
--- /dev/null
+++ b/pyqtgraph/flowchart/FlowchartGraphicsView.py
@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.widgets.GraphicsView import GraphicsView
+from pyqtgraph.GraphicsScene import GraphicsScene
+from pyqtgraph.graphicsItems.ViewBox import ViewBox
+
+#class FlowchartGraphicsView(QtGui.QGraphicsView):
+class FlowchartGraphicsView(GraphicsView):
+
+ sigHoverOver = QtCore.Signal(object)
+ sigClicked = QtCore.Signal(object)
+
+ def __init__(self, widget, *args):
+ #QtGui.QGraphicsView.__init__(self, *args)
+ GraphicsView.__init__(self, *args, useOpenGL=False)
+ #self.setBackgroundBrush(QtGui.QBrush(QtGui.QColor(255,255,255)))
+ self._vb = FlowchartViewBox(widget, lockAspect=True, invertY=True)
+ self.setCentralItem(self._vb)
+ #self.scene().addItem(self.vb)
+ #self.setMouseTracking(True)
+ #self.lastPos = None
+ #self.setTransformationAnchor(self.AnchorViewCenter)
+ #self.setRenderHints(QtGui.QPainter.Antialiasing)
+ self.setRenderHint(QtGui.QPainter.Antialiasing, True)
+ #self.setDragMode(QtGui.QGraphicsView.RubberBandDrag)
+ #self.setRubberBandSelectionMode(QtCore.Qt.ContainsItemBoundingRect)
+
+ def viewBox(self):
+ return self._vb
+
+
+ #def mousePressEvent(self, ev):
+ #self.moved = False
+ #self.lastPos = ev.pos()
+ #return QtGui.QGraphicsView.mousePressEvent(self, ev)
+
+ #def mouseMoveEvent(self, ev):
+ #self.moved = True
+ #callSuper = False
+ #if ev.buttons() & QtCore.Qt.RightButton:
+ #if self.lastPos is not None:
+ #dif = ev.pos() - self.lastPos
+ #self.scale(1.01**-dif.y(), 1.01**-dif.y())
+ #elif ev.buttons() & QtCore.Qt.MidButton:
+ #if self.lastPos is not None:
+ #dif = ev.pos() - self.lastPos
+ #self.translate(dif.x(), -dif.y())
+ #else:
+ ##self.emit(QtCore.SIGNAL('hoverOver'), self.items(ev.pos()))
+ #self.sigHoverOver.emit(self.items(ev.pos()))
+ #callSuper = True
+ #self.lastPos = ev.pos()
+
+ #if callSuper:
+ #QtGui.QGraphicsView.mouseMoveEvent(self, ev)
+
+ #def mouseReleaseEvent(self, ev):
+ #if not self.moved:
+ ##self.emit(QtCore.SIGNAL('clicked'), ev)
+ #self.sigClicked.emit(ev)
+ #return QtGui.QGraphicsView.mouseReleaseEvent(self, ev)
+
+class FlowchartViewBox(ViewBox):
+
+ def __init__(self, widget, *args, **kwargs):
+ ViewBox.__init__(self, *args, **kwargs)
+ self.widget = widget
+ #self.menu = None
+ #self._subMenus = None ## need a place to store the menus otherwise they dissappear (even though they've been added to other menus) ((yes, it doesn't make sense))
+
+
+
+
+ def getMenu(self, ev):
+ ## called by ViewBox to create a new context menu
+ self._fc_menu = QtGui.QMenu()
+ self._subMenus = self.getContextMenus(ev)
+ for menu in self._subMenus:
+ self._fc_menu.addMenu(menu)
+ return self._fc_menu
+
+ def getContextMenus(self, ev):
+ ## called by scene to add menus on to someone else's context menu
+ menu = self.widget.buildMenu(ev.scenePos())
+ menu.setTitle("Add node")
+ return [menu, ViewBox.getMenu(self, ev)]
+
+
+
+
+
+
+
+
+
+
+##class FlowchartGraphicsScene(QtGui.QGraphicsScene):
+#class FlowchartGraphicsScene(GraphicsScene):
+
+ #sigContextMenuEvent = QtCore.Signal(object)
+
+ #def __init__(self, *args):
+ ##QtGui.QGraphicsScene.__init__(self, *args)
+ #GraphicsScene.__init__(self, *args)
+
+ #def mouseClickEvent(self, ev):
+ ##QtGui.QGraphicsScene.contextMenuEvent(self, ev)
+ #if not ev.button() in [QtCore.Qt.RightButton]:
+ #self.sigContextMenuEvent.emit(ev)
\ No newline at end of file
diff --git a/pyqtgraph/flowchart/FlowchartTemplate.ui b/pyqtgraph/flowchart/FlowchartTemplate.ui
new file mode 100644
index 00000000..e4530800
--- /dev/null
+++ b/pyqtgraph/flowchart/FlowchartTemplate.ui
@@ -0,0 +1,98 @@
+
+
+ Form
+
+
+
+ 0
+ 0
+ 529
+ 329
+
+
+
+ Form
+
+
+
+
+ 260
+ 10
+ 264
+ 222
+
+
+
+ -
+
+
+
+
+
+ Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop
+
+
+ true
+
+
+
+ -
+
+
+
+ 75
+ true
+
+
+
+
+
+
+
+ -
+
+
+
+ 1
+
+
+
+
+
+
+
+
+
+ 0
+ 240
+ 521
+ 81
+
+
+
+
+
+
+ 0
+ 0
+ 256
+ 192
+
+
+
+
+
+
+ DataTreeWidget
+ QTreeWidget
+ pyqtgraph.widgets.DataTreeWidget
+
+
+ FlowchartGraphicsView
+ QGraphicsView
+
+
+
+
+
+
diff --git a/pyqtgraph/flowchart/FlowchartTemplate_pyqt.py b/pyqtgraph/flowchart/FlowchartTemplate_pyqt.py
new file mode 100644
index 00000000..2e9ea312
--- /dev/null
+++ b/pyqtgraph/flowchart/FlowchartTemplate_pyqt.py
@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file './flowchart/FlowchartTemplate.ui'
+#
+# Created: Sun Sep 9 14:41:29 2012
+# by: PyQt4 UI code generator 4.9.1
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+ _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+ _fromUtf8 = lambda s: s
+
+class Ui_Form(object):
+ def setupUi(self, Form):
+ Form.setObjectName(_fromUtf8("Form"))
+ Form.resize(529, 329)
+ self.selInfoWidget = QtGui.QWidget(Form)
+ self.selInfoWidget.setGeometry(QtCore.QRect(260, 10, 264, 222))
+ self.selInfoWidget.setObjectName(_fromUtf8("selInfoWidget"))
+ self.gridLayout = QtGui.QGridLayout(self.selInfoWidget)
+ self.gridLayout.setMargin(0)
+ self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
+ self.selDescLabel = QtGui.QLabel(self.selInfoWidget)
+ self.selDescLabel.setText(_fromUtf8(""))
+ self.selDescLabel.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignTop)
+ self.selDescLabel.setWordWrap(True)
+ self.selDescLabel.setObjectName(_fromUtf8("selDescLabel"))
+ self.gridLayout.addWidget(self.selDescLabel, 0, 0, 1, 1)
+ self.selNameLabel = QtGui.QLabel(self.selInfoWidget)
+ font = QtGui.QFont()
+ font.setBold(True)
+ font.setWeight(75)
+ self.selNameLabel.setFont(font)
+ self.selNameLabel.setText(_fromUtf8(""))
+ self.selNameLabel.setObjectName(_fromUtf8("selNameLabel"))
+ self.gridLayout.addWidget(self.selNameLabel, 0, 1, 1, 1)
+ self.selectedTree = DataTreeWidget(self.selInfoWidget)
+ self.selectedTree.setObjectName(_fromUtf8("selectedTree"))
+ self.selectedTree.headerItem().setText(0, _fromUtf8("1"))
+ self.gridLayout.addWidget(self.selectedTree, 1, 0, 1, 2)
+ self.hoverText = QtGui.QTextEdit(Form)
+ self.hoverText.setGeometry(QtCore.QRect(0, 240, 521, 81))
+ self.hoverText.setObjectName(_fromUtf8("hoverText"))
+ self.view = FlowchartGraphicsView(Form)
+ self.view.setGeometry(QtCore.QRect(0, 0, 256, 192))
+ self.view.setObjectName(_fromUtf8("view"))
+
+ self.retranslateUi(Form)
+ QtCore.QMetaObject.connectSlotsByName(Form)
+
+ def retranslateUi(self, Form):
+ Form.setWindowTitle(QtGui.QApplication.translate("Form", "Form", None, QtGui.QApplication.UnicodeUTF8))
+
+from pyqtgraph.widgets.DataTreeWidget import DataTreeWidget
+from FlowchartGraphicsView import FlowchartGraphicsView
diff --git a/pyqtgraph/flowchart/FlowchartTemplate_pyside.py b/pyqtgraph/flowchart/FlowchartTemplate_pyside.py
new file mode 100644
index 00000000..d49d3083
--- /dev/null
+++ b/pyqtgraph/flowchart/FlowchartTemplate_pyside.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file './flowchart/FlowchartTemplate.ui'
+#
+# Created: Sun Sep 9 14:41:30 2012
+# by: pyside-uic 0.2.13 running on PySide 1.1.0
+#
+# WARNING! All changes made in this file will be lost!
+
+from PySide import QtCore, QtGui
+
+class Ui_Form(object):
+ def setupUi(self, Form):
+ Form.setObjectName("Form")
+ Form.resize(529, 329)
+ self.selInfoWidget = QtGui.QWidget(Form)
+ self.selInfoWidget.setGeometry(QtCore.QRect(260, 10, 264, 222))
+ self.selInfoWidget.setObjectName("selInfoWidget")
+ self.gridLayout = QtGui.QGridLayout(self.selInfoWidget)
+ self.gridLayout.setContentsMargins(0, 0, 0, 0)
+ self.gridLayout.setObjectName("gridLayout")
+ self.selDescLabel = QtGui.QLabel(self.selInfoWidget)
+ self.selDescLabel.setText("")
+ self.selDescLabel.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignTop)
+ self.selDescLabel.setWordWrap(True)
+ self.selDescLabel.setObjectName("selDescLabel")
+ self.gridLayout.addWidget(self.selDescLabel, 0, 0, 1, 1)
+ self.selNameLabel = QtGui.QLabel(self.selInfoWidget)
+ font = QtGui.QFont()
+ font.setWeight(75)
+ font.setBold(True)
+ self.selNameLabel.setFont(font)
+ self.selNameLabel.setText("")
+ self.selNameLabel.setObjectName("selNameLabel")
+ self.gridLayout.addWidget(self.selNameLabel, 0, 1, 1, 1)
+ self.selectedTree = DataTreeWidget(self.selInfoWidget)
+ self.selectedTree.setObjectName("selectedTree")
+ self.selectedTree.headerItem().setText(0, "1")
+ self.gridLayout.addWidget(self.selectedTree, 1, 0, 1, 2)
+ self.hoverText = QtGui.QTextEdit(Form)
+ self.hoverText.setGeometry(QtCore.QRect(0, 240, 521, 81))
+ self.hoverText.setObjectName("hoverText")
+ self.view = FlowchartGraphicsView(Form)
+ self.view.setGeometry(QtCore.QRect(0, 0, 256, 192))
+ self.view.setObjectName("view")
+
+ self.retranslateUi(Form)
+ QtCore.QMetaObject.connectSlotsByName(Form)
+
+ def retranslateUi(self, Form):
+ Form.setWindowTitle(QtGui.QApplication.translate("Form", "Form", None, QtGui.QApplication.UnicodeUTF8))
+
+from pyqtgraph.widgets.DataTreeWidget import DataTreeWidget
+from FlowchartGraphicsView import FlowchartGraphicsView
diff --git a/pyqtgraph/flowchart/Node.py b/pyqtgraph/flowchart/Node.py
new file mode 100644
index 00000000..ed5c9714
--- /dev/null
+++ b/pyqtgraph/flowchart/Node.py
@@ -0,0 +1,540 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui
+from pyqtgraph.graphicsItems.GraphicsObject import GraphicsObject
+import pyqtgraph.functions as fn
+from .Terminal import *
+from pyqtgraph.pgcollections import OrderedDict
+from pyqtgraph.debug import *
+import numpy as np
+from .eq import *
+
+
+def strDict(d):
+ return dict([(str(k), v) for k, v in d.items()])
+
+class Node(QtCore.QObject):
+
+ sigOutputChanged = QtCore.Signal(object) # self
+ sigClosed = QtCore.Signal(object)
+ sigRenamed = QtCore.Signal(object, object)
+ sigTerminalRenamed = QtCore.Signal(object, object) # term, oldName
+ sigTerminalAdded = QtCore.Signal(object, object) # self, term
+ sigTerminalRemoved = QtCore.Signal(object, object) # self, term
+
+
+ def __init__(self, name, terminals=None, allowAddInput=False, allowAddOutput=False, allowRemove=True):
+ QtCore.QObject.__init__(self)
+ self._name = name
+ self._bypass = False
+ self.bypassButton = None ## this will be set by the flowchart ctrl widget..
+ self._graphicsItem = None
+ self.terminals = OrderedDict()
+ self._inputs = OrderedDict()
+ self._outputs = OrderedDict()
+ self._allowAddInput = allowAddInput ## flags to allow the user to add/remove terminals
+ self._allowAddOutput = allowAddOutput
+ self._allowRemove = allowRemove
+
+ self.exception = None
+ if terminals is None:
+ return
+ for name, opts in terminals.items():
+ self.addTerminal(name, **opts)
+
+
+ def nextTerminalName(self, name):
+ """Return an unused terminal name"""
+ name2 = name
+ i = 1
+ while name2 in self.terminals:
+ name2 = "%s.%d" % (name, i)
+ i += 1
+ return name2
+
+ def addInput(self, name="Input", **args):
+ #print "Node.addInput called."
+ return self.addTerminal(name, io='in', **args)
+
+ def addOutput(self, name="Output", **args):
+ return self.addTerminal(name, io='out', **args)
+
+ def removeTerminal(self, term):
+ ## term may be a terminal or its name
+
+ if isinstance(term, Terminal):
+ name = term.name()
+ else:
+ name = term
+ term = self.terminals[name]
+
+ #print "remove", name
+ #term.disconnectAll()
+ term.close()
+ del self.terminals[name]
+ if name in self._inputs:
+ del self._inputs[name]
+ if name in self._outputs:
+ del self._outputs[name]
+ self.graphicsItem().updateTerminals()
+ self.sigTerminalRemoved.emit(self, term)
+
+
+ def terminalRenamed(self, term, oldName):
+ """Called after a terminal has been renamed"""
+ newName = term.name()
+ for d in [self.terminals, self._inputs, self._outputs]:
+ if oldName not in d:
+ continue
+ d[newName] = d[oldName]
+ del d[oldName]
+
+ self.graphicsItem().updateTerminals()
+ self.sigTerminalRenamed.emit(term, oldName)
+
+ def addTerminal(self, name, **opts):
+ name = self.nextTerminalName(name)
+ term = Terminal(self, name, **opts)
+ self.terminals[name] = term
+ if term.isInput():
+ self._inputs[name] = term
+ elif term.isOutput():
+ self._outputs[name] = term
+ self.graphicsItem().updateTerminals()
+ self.sigTerminalAdded.emit(self, term)
+ return term
+
+
+ def inputs(self):
+ return self._inputs
+
+ def outputs(self):
+ return self._outputs
+
+ def process(self, **kargs):
+ """Process data through this node. Each named argument supplies data to the corresponding terminal."""
+ return {}
+
+ def graphicsItem(self):
+ """Return a (the?) graphicsitem for this node"""
+ #print "Node.graphicsItem called."
+ if self._graphicsItem is None:
+ #print "Creating NodeGraphicsItem..."
+ self._graphicsItem = NodeGraphicsItem(self)
+ #print "Node.graphicsItem is returning ", self._graphicsItem
+ return self._graphicsItem
+
+ def __getattr__(self, attr):
+ """Return the terminal with the given name"""
+ if attr not in self.terminals:
+ raise AttributeError(attr)
+ else:
+ return self.terminals[attr]
+
+ def __getitem__(self, item):
+ return getattr(self, item)
+
+ def name(self):
+ return self._name
+
+ def rename(self, name):
+ oldName = self._name
+ self._name = name
+ #self.emit(QtCore.SIGNAL('renamed'), self, oldName)
+ self.sigRenamed.emit(self, oldName)
+
+ def dependentNodes(self):
+ """Return the list of nodes which provide direct input to this node"""
+ nodes = set()
+ for t in self.inputs().values():
+ nodes |= set([i.node() for i in t.inputTerminals()])
+ return nodes
+ #return set([t.inputTerminals().node() for t in self.listInputs().itervalues()])
+
+ def __repr__(self):
+ return "" % (self.name(), id(self))
+
+ def ctrlWidget(self):
+ return None
+
+ def bypass(self, byp):
+ self._bypass = byp
+ if self.bypassButton is not None:
+ self.bypassButton.setChecked(byp)
+ self.update()
+
+ def isBypassed(self):
+ return self._bypass
+
+ def setInput(self, **args):
+ """Set the values on input terminals. For most nodes, this will happen automatically through Terminal.inputChanged.
+ This is normally only used for nodes with no connected inputs."""
+ changed = False
+ for k, v in args.items():
+ term = self._inputs[k]
+ oldVal = term.value()
+ if not eq(oldVal, v):
+ changed = True
+ term.setValue(v, process=False)
+ if changed and '_updatesHandled_' not in args:
+ self.update()
+
+ def inputValues(self):
+ vals = {}
+ for n, t in self.inputs().items():
+ vals[n] = t.value()
+ return vals
+
+ def outputValues(self):
+ vals = {}
+ for n, t in self.outputs().items():
+ vals[n] = t.value()
+ return vals
+
+ def connected(self, localTerm, remoteTerm):
+ """Called whenever one of this node's terminals is connected elsewhere."""
+ pass
+
+ def disconnected(self, localTerm, remoteTerm):
+ """Called whenever one of this node's terminals is connected elsewhere."""
+ pass
+
+ def update(self, signal=True):
+ """Collect all input values, attempt to process new output values, and propagate downstream."""
+ vals = self.inputValues()
+ #print " inputs:", vals
+ try:
+ if self.isBypassed():
+ out = self.processBypassed(vals)
+ else:
+ out = self.process(**strDict(vals))
+ #print " output:", out
+ if out is not None:
+ if signal:
+ self.setOutput(**out)
+ else:
+ self.setOutputNoSignal(**out)
+ for n,t in self.inputs().items():
+ t.setValueAcceptable(True)
+ self.clearException()
+ except:
+ #printExc( "Exception while processing %s:" % self.name())
+ for n,t in self.outputs().items():
+ t.setValue(None)
+ self.setException(sys.exc_info())
+
+ if signal:
+ #self.emit(QtCore.SIGNAL('outputChanged'), self) ## triggers flowchart to propagate new data
+ self.sigOutputChanged.emit(self) ## triggers flowchart to propagate new data
+
+ def processBypassed(self, args):
+ result = {}
+ for term in list(self.outputs().values()):
+ byp = term.bypassValue()
+ if byp is None:
+ result[term.name()] = None
+ else:
+ result[term.name()] = args.get(byp, None)
+ return result
+
+ def setOutput(self, **vals):
+ self.setOutputNoSignal(**vals)
+ #self.emit(QtCore.SIGNAL('outputChanged'), self) ## triggers flowchart to propagate new data
+ self.sigOutputChanged.emit(self) ## triggers flowchart to propagate new data
+
+ def setOutputNoSignal(self, **vals):
+ for k, v in vals.items():
+ term = self.outputs()[k]
+ term.setValue(v)
+ #targets = term.connections()
+ #for t in targets: ## propagate downstream
+ #if t is term:
+ #continue
+ #t.inputChanged(term)
+ term.setValueAcceptable(True)
+
+ def setException(self, exc):
+ self.exception = exc
+ self.recolor()
+
+ def clearException(self):
+ self.setException(None)
+
+ def recolor(self):
+ if self.exception is None:
+ self.graphicsItem().setPen(QtGui.QPen(QtGui.QColor(0, 0, 0)))
+ else:
+ self.graphicsItem().setPen(QtGui.QPen(QtGui.QColor(150, 0, 0), 3))
+
+ def saveState(self):
+ pos = self.graphicsItem().pos()
+ state = {'pos': (pos.x(), pos.y()), 'bypass': self.isBypassed()}
+ termsEditable = self._allowAddInput | self._allowAddOutput
+ for term in self._inputs.values() + self._outputs.values():
+ termsEditable |= term._renamable | term._removable | term._multiable
+ if termsEditable:
+ state['terminals'] = self.saveTerminals()
+ return state
+
+ def restoreState(self, state):
+ pos = state.get('pos', (0,0))
+ self.graphicsItem().setPos(*pos)
+ self.bypass(state.get('bypass', False))
+ if 'terminals' in state:
+ self.restoreTerminals(state['terminals'])
+
+ def saveTerminals(self):
+ terms = OrderedDict()
+ for n, t in self.terminals.items():
+ terms[n] = (t.saveState())
+ return terms
+
+ def restoreTerminals(self, state):
+ for name in list(self.terminals.keys()):
+ if name not in state:
+ self.removeTerminal(name)
+ for name, opts in state.items():
+ if name in self.terminals:
+ term = self[name]
+ term.setOpts(**opts)
+ continue
+ try:
+ opts = strDict(opts)
+ self.addTerminal(name, **opts)
+ except:
+ printExc("Error restoring terminal %s (%s):" % (str(name), str(opts)))
+
+
+ def clearTerminals(self):
+ for t in self.terminals.values():
+ t.close()
+ self.terminals = OrderedDict()
+ self._inputs = OrderedDict()
+ self._outputs = OrderedDict()
+
+ def close(self):
+ """Cleans up after the node--removes terminals, graphicsItem, widget"""
+ self.disconnectAll()
+ self.clearTerminals()
+ item = self.graphicsItem()
+ if item.scene() is not None:
+ item.scene().removeItem(item)
+ self._graphicsItem = None
+ w = self.ctrlWidget()
+ if w is not None:
+ w.setParent(None)
+ #self.emit(QtCore.SIGNAL('closed'), self)
+ self.sigClosed.emit(self)
+
+ def disconnectAll(self):
+ for t in self.terminals.values():
+ t.disconnectAll()
+
+
+#class NodeGraphicsItem(QtGui.QGraphicsItem):
+class NodeGraphicsItem(GraphicsObject):
+ def __init__(self, node):
+ #QtGui.QGraphicsItem.__init__(self)
+ GraphicsObject.__init__(self)
+ #QObjectWorkaround.__init__(self)
+
+ #self.shadow = QtGui.QGraphicsDropShadowEffect()
+ #self.shadow.setOffset(5,5)
+ #self.shadow.setBlurRadius(10)
+ #self.setGraphicsEffect(self.shadow)
+
+ self.pen = fn.mkPen(0,0,0)
+ self.selectPen = fn.mkPen(200,200,200,width=2)
+ self.brush = fn.mkBrush(200, 200, 200, 150)
+ self.hoverBrush = fn.mkBrush(200, 200, 200, 200)
+ self.selectBrush = fn.mkBrush(200, 200, 255, 200)
+ self.hovered = False
+
+ self.node = node
+ flags = self.ItemIsMovable | self.ItemIsSelectable | self.ItemIsFocusable |self.ItemSendsGeometryChanges
+ #flags = self.ItemIsFocusable |self.ItemSendsGeometryChanges
+
+ self.setFlags(flags)
+ self.bounds = QtCore.QRectF(0, 0, 100, 100)
+ self.nameItem = QtGui.QGraphicsTextItem(self.node.name(), self)
+ self.nameItem.setDefaultTextColor(QtGui.QColor(50, 50, 50))
+ self.nameItem.moveBy(self.bounds.width()/2. - self.nameItem.boundingRect().width()/2., 0)
+ self.nameItem.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
+ self.updateTerminals()
+ #self.setZValue(10)
+
+ self.nameItem.focusOutEvent = self.labelFocusOut
+ self.nameItem.keyPressEvent = self.labelKeyPress
+
+ self.menu = None
+ self.buildMenu()
+
+ #self.node.sigTerminalRenamed.connect(self.updateActionMenu)
+
+ #def setZValue(self, z):
+ #for t, item in self.terminals.itervalues():
+ #item.setZValue(z+1)
+ #GraphicsObject.setZValue(self, z)
+
+ def labelFocusOut(self, ev):
+ QtGui.QGraphicsTextItem.focusOutEvent(self.nameItem, ev)
+ self.labelChanged()
+
+ def labelKeyPress(self, ev):
+ if ev.key() == QtCore.Qt.Key_Enter or ev.key() == QtCore.Qt.Key_Return:
+ self.labelChanged()
+ else:
+ QtGui.QGraphicsTextItem.keyPressEvent(self.nameItem, ev)
+
+ def labelChanged(self):
+ newName = str(self.nameItem.toPlainText())
+ if newName != self.node.name():
+ self.node.rename(newName)
+
+ ### re-center the label
+ bounds = self.boundingRect()
+ self.nameItem.setPos(bounds.width()/2. - self.nameItem.boundingRect().width()/2., 0)
+
+ def setPen(self, pen):
+ self.pen = pen
+ self.update()
+
+ def setBrush(self, brush):
+ self.brush = brush
+ self.update()
+
+
+ def updateTerminals(self):
+ bounds = self.bounds
+ self.terminals = {}
+ inp = self.node.inputs()
+ dy = bounds.height() / (len(inp)+1)
+ y = dy
+ for i, t in inp.items():
+ item = t.graphicsItem()
+ item.setParentItem(self)
+ #item.setZValue(self.zValue()+1)
+ br = self.bounds
+ item.setAnchor(0, y)
+ self.terminals[i] = (t, item)
+ y += dy
+
+ out = self.node.outputs()
+ dy = bounds.height() / (len(out)+1)
+ y = dy
+ for i, t in out.items():
+ item = t.graphicsItem()
+ item.setParentItem(self)
+ item.setZValue(self.zValue())
+ br = self.bounds
+ item.setAnchor(bounds.width(), y)
+ self.terminals[i] = (t, item)
+ y += dy
+
+ #self.buildMenu()
+
+
+ def boundingRect(self):
+ return self.bounds.adjusted(-5, -5, 5, 5)
+
+ def paint(self, p, *args):
+
+ p.setPen(self.pen)
+ if self.isSelected():
+ p.setPen(self.selectPen)
+ p.setBrush(self.selectBrush)
+ else:
+ p.setPen(self.pen)
+ if self.hovered:
+ p.setBrush(self.hoverBrush)
+ else:
+ p.setBrush(self.brush)
+
+ p.drawRect(self.bounds)
+
+
+ def mousePressEvent(self, ev):
+ ev.ignore()
+
+
+ def mouseClickEvent(self, ev):
+ #print "Node.mouseClickEvent called."
+ if int(ev.button()) == int(QtCore.Qt.LeftButton):
+ ev.accept()
+ #print " ev.button: left"
+ sel = self.isSelected()
+ #ret = QtGui.QGraphicsItem.mousePressEvent(self, ev)
+ self.setSelected(True)
+ if not sel and self.isSelected():
+ #self.setBrush(QtGui.QBrush(QtGui.QColor(200, 200, 255)))
+ #self.emit(QtCore.SIGNAL('selected'))
+ #self.scene().selectionChanged.emit() ## for some reason this doesn't seem to be happening automatically
+ self.update()
+ #return ret
+
+ elif int(ev.button()) == int(QtCore.Qt.RightButton):
+ #print " ev.button: right"
+ ev.accept()
+ #pos = ev.screenPos()
+ self.raiseContextMenu(ev)
+ #self.menu.popup(QtCore.QPoint(pos.x(), pos.y()))
+
+ def mouseDragEvent(self, ev):
+ #print "Node.mouseDrag"
+ if ev.button() == QtCore.Qt.LeftButton:
+ ev.accept()
+ self.setPos(self.pos()+self.mapToParent(ev.pos())-self.mapToParent(ev.lastPos()))
+
+ def hoverEvent(self, ev):
+ if not ev.isExit() and ev.acceptClicks(QtCore.Qt.LeftButton):
+ ev.acceptDrags(QtCore.Qt.LeftButton)
+ self.hovered = True
+ else:
+ self.hovered = False
+ self.update()
+
+ def keyPressEvent(self, ev):
+ if ev.key() == QtCore.Qt.Key_Delete or ev.key() == QtCore.Qt.Key_Backspace:
+ ev.accept()
+ if not self.node._allowRemove:
+ return
+ self.node.close()
+ else:
+ ev.ignore()
+
+ def itemChange(self, change, val):
+ if change == self.ItemPositionHasChanged:
+ for k, t in self.terminals.items():
+ t[1].nodeMoved()
+ return GraphicsObject.itemChange(self, change, val)
+
+
+ def getMenu(self):
+ return self.menu
+
+ def getContextMenus(self, event):
+ return [self.menu]
+
+ def raiseContextMenu(self, ev):
+ menu = self.scene().addParentContextMenus(self, self.getMenu(), ev)
+ pos = ev.screenPos()
+ menu.popup(QtCore.QPoint(pos.x(), pos.y()))
+
+ def buildMenu(self):
+ self.menu = QtGui.QMenu()
+ self.menu.setTitle("Node")
+ a = self.menu.addAction("Add input", self.addInputFromMenu)
+ if not self.node._allowAddInput:
+ a.setEnabled(False)
+ a = self.menu.addAction("Add output", self.addOutputFromMenu)
+ if not self.node._allowAddOutput:
+ a.setEnabled(False)
+ a = self.menu.addAction("Remove node", self.node.close)
+ if not self.node._allowRemove:
+ a.setEnabled(False)
+
+ def addInputFromMenu(self): ## called when add input is clicked in context menu
+ self.node.addInput(renamable=True, removable=True, multiable=True)
+
+ def addOutputFromMenu(self): ## called when add output is clicked in context menu
+ self.node.addOutput(renamable=True, removable=True, multiable=False)
+
diff --git a/pyqtgraph/flowchart/Terminal.py b/pyqtgraph/flowchart/Terminal.py
new file mode 100644
index 00000000..18ff12c1
--- /dev/null
+++ b/pyqtgraph/flowchart/Terminal.py
@@ -0,0 +1,599 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui
+import weakref
+from pyqtgraph.graphicsItems.GraphicsObject import GraphicsObject
+import pyqtgraph.functions as fn
+from pyqtgraph.Point import Point
+#from PySide import QtCore, QtGui
+from .eq import *
+
+class Terminal(object):
+ def __init__(self, node, name, io, optional=False, multi=False, pos=None, renamable=False, removable=False, multiable=False, bypass=None):
+ """
+ Construct a new terminal.
+
+ ============== =================================================================================
+ **Arguments:**
+ node the node to which this terminal belongs
+ name string, the name of the terminal
+ io 'in' or 'out'
+ optional bool, whether the node may process without connection to this terminal
+ multi bool, for inputs: whether this terminal may make multiple connections
+ for outputs: whether this terminal creates a different value for each connection
+ pos [x, y], the position of the terminal within its node's boundaries
+ renamable (bool) Whether the terminal can be renamed by the user
+ removable (bool) Whether the terminal can be removed by the user
+ multiable (bool) Whether the user may toggle the *multi* option for this terminal
+ ============== =================================================================================
+ """
+ self._io = io
+ #self._isOutput = opts[0] in ['out', 'io']
+ #self._isInput = opts[0]] in ['in', 'io']
+ #self._isIO = opts[0]=='io'
+ self._optional = optional
+ self._multi = multi
+ self._node = weakref.ref(node)
+ self._name = name
+ self._renamable = renamable
+ self._removable = removable
+ self._multiable = multiable
+ self._connections = {}
+ self._graphicsItem = TerminalGraphicsItem(self, parent=self._node().graphicsItem())
+ self._bypass = bypass
+
+ if multi:
+ self._value = {} ## dictionary of terminal:value pairs.
+ else:
+ self._value = None
+
+ self.valueOk = None
+ self.recolor()
+
+ def value(self, term=None):
+ """Return the value this terminal provides for the connected terminal"""
+ if term is None:
+ return self._value
+
+ if self.isMultiValue():
+ return self._value.get(term, None)
+ else:
+ return self._value
+
+ def bypassValue(self):
+ return self._bypass
+
+ def setValue(self, val, process=True):
+ """If this is a single-value terminal, val should be a single value.
+ If this is a multi-value terminal, val should be a dict of terminal:value pairs"""
+ if not self.isMultiValue():
+ if eq(val, self._value):
+ return
+ self._value = val
+ else:
+ if not isinstance(self._value, dict):
+ self._value = {}
+ if val is not None:
+ self._value.update(val)
+
+ self.setValueAcceptable(None) ## by default, input values are 'unchecked' until Node.update().
+ if self.isInput() and process:
+ self.node().update()
+
+ ## Let the flowchart handle this.
+ #if self.isOutput():
+ #for c in self.connections():
+ #if c.isInput():
+ #c.inputChanged(self)
+ self.recolor()
+
+ def setOpts(self, **opts):
+ self._renamable = opts.get('renamable', self._renamable)
+ self._removable = opts.get('removable', self._removable)
+ self._multiable = opts.get('multiable', self._multiable)
+ if 'multi' in opts:
+ self.setMultiValue(opts['multi'])
+
+
+ def connected(self, term):
+ """Called whenever this terminal has been connected to another. (note--this function is called on both terminals)"""
+ if self.isInput() and term.isOutput():
+ self.inputChanged(term)
+ if self.isOutput() and self.isMultiValue():
+ self.node().update()
+ self.node().connected(self, term)
+
+ def disconnected(self, term):
+ """Called whenever this terminal has been disconnected from another. (note--this function is called on both terminals)"""
+ if self.isMultiValue() and term in self._value:
+ del self._value[term]
+ self.node().update()
+ #self.recolor()
+ else:
+ if self.isInput():
+ self.setValue(None)
+ self.node().disconnected(self, term)
+ #self.node().update()
+
+ def inputChanged(self, term, process=True):
+ """Called whenever there is a change to the input value to this terminal.
+ It may often be useful to override this function."""
+ if self.isMultiValue():
+ self.setValue({term: term.value(self)}, process=process)
+ else:
+ self.setValue(term.value(self), process=process)
+
+ def valueIsAcceptable(self):
+ """Returns True->acceptable None->unknown False->Unacceptable"""
+ return self.valueOk
+
+ def setValueAcceptable(self, v=True):
+ self.valueOk = v
+ self.recolor()
+
+ def connections(self):
+ return self._connections
+
+ def node(self):
+ return self._node()
+
+ def isInput(self):
+ return self._io == 'in'
+
+ def isMultiValue(self):
+ return self._multi
+
+ def setMultiValue(self, multi):
+ """Set whether this is a multi-value terminal."""
+ self._multi = multi
+ if not multi and len(self.inputTerminals()) > 1:
+ self.disconnectAll()
+
+ for term in self.inputTerminals():
+ self.inputChanged(term)
+
+ def isOutput(self):
+ return self._io == 'out'
+
+ def isRenamable(self):
+ return self._renamable
+
+ def isRemovable(self):
+ return self._removable
+
+ def isMultiable(self):
+ return self._multiable
+
+ def name(self):
+ return self._name
+
+ def graphicsItem(self):
+ return self._graphicsItem
+
+ def isConnected(self):
+ return len(self.connections()) > 0
+
+ def connectedTo(self, term):
+ return term in self.connections()
+
+ def hasInput(self):
+ #conn = self.extendedConnections()
+ for t in self.connections():
+ if t.isOutput():
+ return True
+ return False
+
+ def inputTerminals(self):
+ """Return the terminal(s) that give input to this one."""
+ #terms = self.extendedConnections()
+ #for t in terms:
+ #if t.isOutput():
+ #return t
+ return [t for t in self.connections() if t.isOutput()]
+
+
+ def dependentNodes(self):
+ """Return the list of nodes which receive input from this terminal."""
+ #conn = self.extendedConnections()
+ #del conn[self]
+ return set([t.node() for t in self.connections() if t.isInput()])
+
+ def connectTo(self, term, connectionItem=None):
+ try:
+ if self.connectedTo(term):
+ raise Exception('Already connected')
+ if term is self:
+ raise Exception('Not connecting terminal to self')
+ if term.node() is self.node():
+ raise Exception("Can't connect to terminal on same node.")
+ for t in [self, term]:
+ if t.isInput() and not t._multi and len(t.connections()) > 0:
+ raise Exception("Cannot connect %s <-> %s: Terminal %s is already connected to %s (and does not allow multiple connections)" % (self, term, t, list(t.connections().keys())))
+ #if self.hasInput() and term.hasInput():
+ #raise Exception('Target terminal already has input')
+
+ #if term in self.node().terminals.values():
+ #if self.isOutput() or term.isOutput():
+ #raise Exception('Can not connect an output back to the same node.')
+ except:
+ if connectionItem is not None:
+ connectionItem.close()
+ raise
+
+ if connectionItem is None:
+ connectionItem = ConnectionItem(self.graphicsItem(), term.graphicsItem())
+ #self.graphicsItem().scene().addItem(connectionItem)
+ self.graphicsItem().getViewBox().addItem(connectionItem)
+ #connectionItem.setParentItem(self.graphicsItem().parent().parent())
+ self._connections[term] = connectionItem
+ term._connections[self] = connectionItem
+
+ self.recolor()
+
+ #if self.isOutput() and term.isInput():
+ #term.inputChanged(self)
+ #if term.isInput() and term.isOutput():
+ #self.inputChanged(term)
+ self.connected(term)
+ term.connected(self)
+
+ return connectionItem
+
+ def disconnectFrom(self, term):
+ if not self.connectedTo(term):
+ return
+ item = self._connections[term]
+ #print "removing connection", item
+ #item.scene().removeItem(item)
+ item.close()
+ del self._connections[term]
+ del term._connections[self]
+ self.recolor()
+ term.recolor()
+
+ self.disconnected(term)
+ term.disconnected(self)
+ #if self.isOutput() and term.isInput():
+ #term.inputChanged(self)
+ #if term.isInput() and term.isOutput():
+ #self.inputChanged(term)
+
+
+ def disconnectAll(self):
+ for t in list(self._connections.keys()):
+ self.disconnectFrom(t)
+
+ def recolor(self, color=None, recurse=True):
+ if color is None:
+ if not self.isConnected(): ## disconnected terminals are black
+ color = QtGui.QColor(0,0,0)
+ elif self.isInput() and not self.hasInput(): ## input terminal with no connected output terminals
+ color = QtGui.QColor(200,200,0)
+ elif self._value is None or eq(self._value, {}): ## terminal is connected but has no data (possibly due to processing error)
+ color = QtGui.QColor(255,255,255)
+ elif self.valueIsAcceptable() is None: ## terminal has data, but it is unknown if the data is ok
+ color = QtGui.QColor(200, 200, 0)
+ elif self.valueIsAcceptable() is True: ## terminal has good input, all ok
+ color = QtGui.QColor(0, 200, 0)
+ else: ## terminal has bad input
+ color = QtGui.QColor(200, 0, 0)
+ self.graphicsItem().setBrush(QtGui.QBrush(color))
+
+ if recurse:
+ for t in self.connections():
+ t.recolor(color, recurse=False)
+
+
+ def rename(self, name):
+ oldName = self._name
+ self._name = name
+ self.node().terminalRenamed(self, oldName)
+ self.graphicsItem().termRenamed(name)
+
+ def __repr__(self):
+ return "" % (str(self.node().name()), str(self.name()))
+
+ #def extendedConnections(self, terms=None):
+ #"""Return list of terminals (including this one) that are directly or indirectly wired to this."""
+ #if terms is None:
+ #terms = {}
+ #terms[self] = None
+ #for t in self._connections:
+ #if t in terms:
+ #continue
+ #terms.update(t.extendedConnections(terms))
+ #return terms
+
+ def __hash__(self):
+ return id(self)
+
+ def close(self):
+ self.disconnectAll()
+ item = self.graphicsItem()
+ if item.scene() is not None:
+ item.scene().removeItem(item)
+
+ def saveState(self):
+ return {'io': self._io, 'multi': self._multi, 'optional': self._optional, 'renamable': self._renamable, 'removable': self._removable, 'multiable': self._multiable}
+
+
+#class TerminalGraphicsItem(QtGui.QGraphicsItem):
+class TerminalGraphicsItem(GraphicsObject):
+
+ def __init__(self, term, parent=None):
+ self.term = term
+ #QtGui.QGraphicsItem.__init__(self, parent)
+ GraphicsObject.__init__(self, parent)
+ self.brush = fn.mkBrush(0,0,0)
+ self.box = QtGui.QGraphicsRectItem(0, 0, 10, 10, self)
+ self.label = QtGui.QGraphicsTextItem(self.term.name(), self)
+ self.label.scale(0.7, 0.7)
+ #self.setAcceptHoverEvents(True)
+ self.newConnection = None
+ self.setFiltersChildEvents(True) ## to pick up mouse events on the rectitem
+ if self.term.isRenamable():
+ self.label.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
+ self.label.focusOutEvent = self.labelFocusOut
+ self.label.keyPressEvent = self.labelKeyPress
+ self.setZValue(1)
+ self.menu = None
+
+
+ def labelFocusOut(self, ev):
+ QtGui.QGraphicsTextItem.focusOutEvent(self.label, ev)
+ self.labelChanged()
+
+ def labelKeyPress(self, ev):
+ if ev.key() == QtCore.Qt.Key_Enter or ev.key() == QtCore.Qt.Key_Return:
+ self.labelChanged()
+ else:
+ QtGui.QGraphicsTextItem.keyPressEvent(self.label, ev)
+
+ def labelChanged(self):
+ newName = str(self.label.toPlainText())
+ if newName != self.term.name():
+ self.term.rename(newName)
+
+ def termRenamed(self, name):
+ self.label.setPlainText(name)
+
+ def setBrush(self, brush):
+ self.brush = brush
+ self.box.setBrush(brush)
+
+ def disconnect(self, target):
+ self.term.disconnectFrom(target.term)
+
+ def boundingRect(self):
+ br = self.box.mapRectToParent(self.box.boundingRect())
+ lr = self.label.mapRectToParent(self.label.boundingRect())
+ return br | lr
+
+ def paint(self, p, *args):
+ pass
+
+ def setAnchor(self, x, y):
+ pos = QtCore.QPointF(x, y)
+ self.anchorPos = pos
+ br = self.box.mapRectToParent(self.box.boundingRect())
+ lr = self.label.mapRectToParent(self.label.boundingRect())
+
+
+ if self.term.isInput():
+ self.box.setPos(pos.x(), pos.y()-br.height()/2.)
+ self.label.setPos(pos.x() + br.width(), pos.y() - lr.height()/2.)
+ else:
+ self.box.setPos(pos.x()-br.width(), pos.y()-br.height()/2.)
+ self.label.setPos(pos.x()-br.width()-lr.width(), pos.y()-lr.height()/2.)
+ self.updateConnections()
+
+ def updateConnections(self):
+ for t, c in self.term.connections().items():
+ c.updateLine()
+
+ def mousePressEvent(self, ev):
+ #ev.accept()
+ ev.ignore() ## necessary to allow click/drag events to process correctly
+
+ def mouseClickEvent(self, ev):
+ if ev.button() == QtCore.Qt.LeftButton:
+ ev.accept()
+ self.label.setFocus(QtCore.Qt.MouseFocusReason)
+ elif ev.button() == QtCore.Qt.RightButton:
+ ev.accept()
+ self.raiseContextMenu(ev)
+
+ def raiseContextMenu(self, ev):
+ ## only raise menu if this terminal is removable
+ menu = self.getMenu()
+ menu = self.scene().addParentContextMenus(self, menu, ev)
+ pos = ev.screenPos()
+ menu.popup(QtCore.QPoint(pos.x(), pos.y()))
+
+ def getMenu(self):
+ if self.menu is None:
+ self.menu = QtGui.QMenu()
+ self.menu.setTitle("Terminal")
+ remAct = QtGui.QAction("Remove terminal", self.menu)
+ remAct.triggered.connect(self.removeSelf)
+ self.menu.addAction(remAct)
+ self.menu.remAct = remAct
+ if not self.term.isRemovable():
+ remAct.setEnabled(False)
+ multiAct = QtGui.QAction("Multi-value", self.menu)
+ multiAct.setCheckable(True)
+ multiAct.setChecked(self.term.isMultiValue())
+ multiAct.setEnabled(self.term.isMultiable())
+
+ multiAct.triggered.connect(self.toggleMulti)
+ self.menu.addAction(multiAct)
+ self.menu.multiAct = multiAct
+ if self.term.isMultiable():
+ multiAct.setEnabled = False
+ return self.menu
+
+ def toggleMulti(self):
+ multi = self.menu.multiAct.isChecked()
+ self.term.setMultiValue(multi)
+
+ ## probably never need this
+ #def getContextMenus(self, ev):
+ #return [self.getMenu()]
+
+ def removeSelf(self):
+ self.term.node().removeTerminal(self.term)
+
+ def mouseDragEvent(self, ev):
+ if ev.button() != QtCore.Qt.LeftButton:
+ ev.ignore()
+ return
+
+ ev.accept()
+ if ev.isStart():
+ if self.newConnection is None:
+ self.newConnection = ConnectionItem(self)
+ #self.scene().addItem(self.newConnection)
+ self.getViewBox().addItem(self.newConnection)
+ #self.newConnection.setParentItem(self.parent().parent())
+
+ self.newConnection.setTarget(self.mapToView(ev.pos()))
+ elif ev.isFinish():
+ if self.newConnection is not None:
+ items = self.scene().items(ev.scenePos())
+ gotTarget = False
+ for i in items:
+ if isinstance(i, TerminalGraphicsItem):
+ self.newConnection.setTarget(i)
+ try:
+ self.term.connectTo(i.term, self.newConnection)
+ gotTarget = True
+ except:
+ self.scene().removeItem(self.newConnection)
+ self.newConnection = None
+ raise
+ break
+
+ if not gotTarget:
+ #print "remove unused connection"
+ #self.scene().removeItem(self.newConnection)
+ self.newConnection.close()
+ self.newConnection = None
+ else:
+ if self.newConnection is not None:
+ self.newConnection.setTarget(self.mapToView(ev.pos()))
+
+ def hoverEvent(self, ev):
+ if not ev.isExit() and ev.acceptDrags(QtCore.Qt.LeftButton):
+ ev.acceptClicks(QtCore.Qt.LeftButton) ## we don't use the click, but we also don't want anyone else to use it.
+ ev.acceptClicks(QtCore.Qt.RightButton)
+ self.box.setBrush(fn.mkBrush('w'))
+ else:
+ self.box.setBrush(self.brush)
+ self.update()
+
+ #def hoverEnterEvent(self, ev):
+ #self.hover = True
+
+ #def hoverLeaveEvent(self, ev):
+ #self.hover = False
+
+ def connectPoint(self):
+ ## return the connect position of this terminal in view coords
+ return self.mapToView(self.mapFromItem(self.box, self.box.boundingRect().center()))
+
+ def nodeMoved(self):
+ for t, item in self.term.connections().items():
+ item.updateLine()
+
+
+#class ConnectionItem(QtGui.QGraphicsItem):
+class ConnectionItem(GraphicsObject):
+
+ def __init__(self, source, target=None):
+ #QtGui.QGraphicsItem.__init__(self)
+ GraphicsObject.__init__(self)
+ self.setFlags(
+ self.ItemIsSelectable |
+ self.ItemIsFocusable
+ )
+ self.source = source
+ self.target = target
+ self.length = 0
+ self.hovered = False
+ #self.line = QtGui.QGraphicsLineItem(self)
+ self.source.getViewBox().addItem(self)
+ self.updateLine()
+ self.setZValue(0)
+
+ def close(self):
+ if self.scene() is not None:
+ #self.scene().removeItem(self.line)
+ self.scene().removeItem(self)
+
+ def setTarget(self, target):
+ self.target = target
+ self.updateLine()
+
+ def updateLine(self):
+ start = Point(self.source.connectPoint())
+ if isinstance(self.target, TerminalGraphicsItem):
+ stop = Point(self.target.connectPoint())
+ elif isinstance(self.target, QtCore.QPointF):
+ stop = Point(self.target)
+ else:
+ return
+ self.prepareGeometryChange()
+ self.resetTransform()
+ ang = (stop-start).angle(Point(0, 1))
+ if ang is None:
+ ang = 0
+ self.rotate(ang)
+ self.setPos(start)
+ self.length = (start-stop).length()
+ self.update()
+ #self.line.setLine(start.x(), start.y(), stop.x(), stop.y())
+
+ def keyPressEvent(self, ev):
+ if ev.key() == QtCore.Qt.Key_Delete or ev.key() == QtCore.Qt.Key_Backspace:
+ #if isinstance(self.target, TerminalGraphicsItem):
+ self.source.disconnect(self.target)
+ ev.accept()
+ else:
+ ev.ignore()
+
+ def mousePressEvent(self, ev):
+ ev.ignore()
+
+ def mouseClickEvent(self, ev):
+ if ev.button() == QtCore.Qt.LeftButton:
+ ev.accept()
+ sel = self.isSelected()
+ self.setSelected(True)
+ if not sel and self.isSelected():
+ self.update()
+
+ def hoverEvent(self, ev):
+ if (not ev.isExit()) and ev.acceptClicks(QtCore.Qt.LeftButton):
+ self.hovered = True
+ else:
+ self.hovered = False
+ self.update()
+
+
+ def boundingRect(self):
+ #return self.line.boundingRect()
+ px = self.pixelWidth()
+ return QtCore.QRectF(-5*px, 0, 10*px, self.length)
+
+ #def shape(self):
+ #return self.line.shape()
+
+ def paint(self, p, *args):
+ if self.isSelected():
+ p.setPen(fn.mkPen(200, 200, 0, width=3))
+ else:
+ if self.hovered:
+ p.setPen(fn.mkPen(150, 150, 250, width=1))
+ else:
+ p.setPen(fn.mkPen(100, 100, 250, width=1))
+
+ p.drawLine(0, 0, 0, self.length)
diff --git a/pyqtgraph/flowchart/__init__.py b/pyqtgraph/flowchart/__init__.py
new file mode 100644
index 00000000..46e04db0
--- /dev/null
+++ b/pyqtgraph/flowchart/__init__.py
@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from .Flowchart import *
+
+from .library import getNodeType, registerNodeType, getNodeTree
\ No newline at end of file
diff --git a/pyqtgraph/flowchart/eq.py b/pyqtgraph/flowchart/eq.py
new file mode 100644
index 00000000..031ebce8
--- /dev/null
+++ b/pyqtgraph/flowchart/eq.py
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+from numpy import ndarray, bool_
+from pyqtgraph.metaarray import MetaArray
+
+def eq(a, b):
+ """The great missing equivalence function: Guaranteed evaluation to a single bool value."""
+ if a is b:
+ return True
+
+ try:
+ e = a==b
+ except ValueError:
+ return False
+ except AttributeError:
+ return False
+ except:
+ print("a:", str(type(a)), str(a))
+ print("b:", str(type(b)), str(b))
+ raise
+ t = type(e)
+ if t is bool:
+ return e
+ elif t is bool_:
+ return bool(e)
+ elif isinstance(e, ndarray) or (hasattr(e, 'implements') and e.implements('MetaArray')):
+ try: ## disaster: if a is an empty array and b is not, then e.all() is True
+ if a.shape != b.shape:
+ return False
+ except:
+ return False
+ if (hasattr(e, 'implements') and e.implements('MetaArray')):
+ return e.asarray().all()
+ else:
+ return e.all()
+ else:
+ raise Exception("== operator returned type %s" % str(type(e)))
diff --git a/pyqtgraph/flowchart/library/Data.py b/pyqtgraph/flowchart/library/Data.py
new file mode 100644
index 00000000..85ab6232
--- /dev/null
+++ b/pyqtgraph/flowchart/library/Data.py
@@ -0,0 +1,357 @@
+# -*- coding: utf-8 -*-
+from ..Node import Node
+from pyqtgraph.Qt import QtGui, QtCore
+import numpy as np
+from .common import *
+from pyqtgraph.SRTTransform import SRTTransform
+from pyqtgraph.Point import Point
+from pyqtgraph.widgets.TreeWidget import TreeWidget
+from pyqtgraph.graphicsItems.LinearRegionItem import LinearRegionItem
+
+from . import functions
+
+class ColumnSelectNode(Node):
+ """Select named columns from a record array or MetaArray."""
+ nodeName = "ColumnSelect"
+ def __init__(self, name):
+ Node.__init__(self, name, terminals={'In': {'io': 'in'}})
+ self.columns = set()
+ self.columnList = QtGui.QListWidget()
+ self.axis = 0
+ self.columnList.itemChanged.connect(self.itemChanged)
+
+ def process(self, In, display=True):
+ if display:
+ self.updateList(In)
+
+ out = {}
+ if hasattr(In, 'implements') and In.implements('MetaArray'):
+ for c in self.columns:
+ out[c] = In[self.axis:c]
+ elif isinstance(In, np.ndarray) and In.dtype.fields is not None:
+ for c in self.columns:
+ out[c] = In[c]
+ else:
+ self.In.setValueAcceptable(False)
+ raise Exception("Input must be MetaArray or ndarray with named fields")
+
+ return out
+
+ def ctrlWidget(self):
+ return self.columnList
+
+ def updateList(self, data):
+ if hasattr(data, 'implements') and data.implements('MetaArray'):
+ cols = data.listColumns()
+ for ax in cols: ## find first axis with columns
+ if len(cols[ax]) > 0:
+ self.axis = ax
+ cols = set(cols[ax])
+ break
+ else:
+ cols = list(data.dtype.fields.keys())
+
+ rem = set()
+ for c in self.columns:
+ if c not in cols:
+ self.removeTerminal(c)
+ rem.add(c)
+ self.columns -= rem
+
+ self.columnList.blockSignals(True)
+ self.columnList.clear()
+ for c in cols:
+ item = QtGui.QListWidgetItem(c)
+ item.setFlags(QtCore.Qt.ItemIsEnabled|QtCore.Qt.ItemIsUserCheckable)
+ if c in self.columns:
+ item.setCheckState(QtCore.Qt.Checked)
+ else:
+ item.setCheckState(QtCore.Qt.Unchecked)
+ self.columnList.addItem(item)
+ self.columnList.blockSignals(False)
+
+
+ def itemChanged(self, item):
+ col = str(item.text())
+ if item.checkState() == QtCore.Qt.Checked:
+ if col not in self.columns:
+ self.columns.add(col)
+ self.addOutput(col)
+ else:
+ if col in self.columns:
+ self.columns.remove(col)
+ self.removeTerminal(col)
+ self.update()
+
+ def saveState(self):
+ state = Node.saveState(self)
+ state['columns'] = list(self.columns)
+ return state
+
+ def restoreState(self, state):
+ Node.restoreState(self, state)
+ self.columns = set(state.get('columns', []))
+ for c in self.columns:
+ self.addOutput(c)
+
+
+
+class RegionSelectNode(CtrlNode):
+ """Returns a slice from a 1-D array. Connect the 'widget' output to a plot to display a region-selection widget."""
+ nodeName = "RegionSelect"
+ uiTemplate = [
+ ('start', 'spin', {'value': 0, 'step': 0.1}),
+ ('stop', 'spin', {'value': 0.1, 'step': 0.1}),
+ ('display', 'check', {'value': True}),
+ ('movable', 'check', {'value': True}),
+ ]
+
+ def __init__(self, name):
+ self.items = {}
+ CtrlNode.__init__(self, name, terminals={
+ 'data': {'io': 'in'},
+ 'selected': {'io': 'out'},
+ 'region': {'io': 'out'},
+ 'widget': {'io': 'out', 'multi': True}
+ })
+ self.ctrls['display'].toggled.connect(self.displayToggled)
+ self.ctrls['movable'].toggled.connect(self.movableToggled)
+
+ def displayToggled(self, b):
+ for item in self.items.values():
+ item.setVisible(b)
+
+ def movableToggled(self, b):
+ for item in self.items.values():
+ item.setMovable(b)
+
+
+ def process(self, data=None, display=True):
+ #print "process.."
+ s = self.stateGroup.state()
+ region = [s['start'], s['stop']]
+
+ if display:
+ conn = self['widget'].connections()
+ for c in conn:
+ plot = c.node().getPlot()
+ if plot is None:
+ continue
+ if c in self.items:
+ item = self.items[c]
+ item.setRegion(region)
+ #print " set rgn:", c, region
+ #item.setXVals(events)
+ else:
+ item = LinearRegionItem(values=region)
+ self.items[c] = item
+ #item.connect(item, QtCore.SIGNAL('regionChanged'), self.rgnChanged)
+ item.sigRegionChanged.connect(self.rgnChanged)
+ item.setVisible(s['display'])
+ item.setMovable(s['movable'])
+ #print " new rgn:", c, region
+ #self.items[c].setYRange([0., 0.2], relative=True)
+
+ if self.selected.isConnected():
+ if data is None:
+ sliced = None
+ elif (hasattr(data, 'implements') and data.implements('MetaArray')):
+ sliced = data[0:s['start']:s['stop']]
+ else:
+ mask = (data['time'] >= s['start']) * (data['time'] < s['stop'])
+ sliced = data[mask]
+ else:
+ sliced = None
+
+ return {'selected': sliced, 'widget': self.items, 'region': region}
+
+
+ def rgnChanged(self, item):
+ region = item.getRegion()
+ self.stateGroup.setState({'start': region[0], 'stop': region[1]})
+ self.update()
+
+
+class EvalNode(Node):
+ """Return the output of a string evaluated/executed by the python interpreter.
+ The string may be either an expression or a python script, and inputs are accessed as the name of the terminal.
+ For expressions, a single value may be evaluated for a single output, or a dict for multiple outputs.
+ For a script, the text will be executed as the body of a function."""
+ nodeName = 'PythonEval'
+
+ def __init__(self, name):
+ Node.__init__(self, name,
+ terminals = {
+ 'input': {'io': 'in', 'renamable': True},
+ 'output': {'io': 'out', 'renamable': True},
+ },
+ allowAddInput=True, allowAddOutput=True)
+
+ self.ui = QtGui.QWidget()
+ self.layout = QtGui.QGridLayout()
+ #self.addInBtn = QtGui.QPushButton('+Input')
+ #self.addOutBtn = QtGui.QPushButton('+Output')
+ self.text = QtGui.QTextEdit()
+ self.text.setTabStopWidth(30)
+ self.text.setPlainText("# Access inputs as args['input_name']\nreturn {'output': None} ## one key per output terminal")
+ #self.layout.addWidget(self.addInBtn, 0, 0)
+ #self.layout.addWidget(self.addOutBtn, 0, 1)
+ self.layout.addWidget(self.text, 1, 0, 1, 2)
+ self.ui.setLayout(self.layout)
+
+ #QtCore.QObject.connect(self.addInBtn, QtCore.SIGNAL('clicked()'), self.addInput)
+ #self.addInBtn.clicked.connect(self.addInput)
+ #QtCore.QObject.connect(self.addOutBtn, QtCore.SIGNAL('clicked()'), self.addOutput)
+ #self.addOutBtn.clicked.connect(self.addOutput)
+ self.text.focusOutEvent = self.focusOutEvent
+ self.lastText = None
+
+ def ctrlWidget(self):
+ return self.ui
+
+ #def addInput(self):
+ #Node.addInput(self, 'input', renamable=True)
+
+ #def addOutput(self):
+ #Node.addOutput(self, 'output', renamable=True)
+
+ def focusOutEvent(self, ev):
+ text = str(self.text.toPlainText())
+ if text != self.lastText:
+ self.lastText = text
+ print("eval node update")
+ self.update()
+ return QtGui.QTextEdit.focusOutEvent(self.text, ev)
+
+ def process(self, display=True, **args):
+ l = locals()
+ l.update(args)
+ ## try eval first, then exec
+ try:
+ text = str(self.text.toPlainText()).replace('\n', ' ')
+ output = eval(text, globals(), l)
+ except SyntaxError:
+ fn = "def fn(**args):\n"
+ run = "\noutput=fn(**args)\n"
+ text = fn + "\n".join([" "+l for l in str(self.text.toPlainText()).split('\n')]) + run
+ exec(text)
+ except:
+ print "Error processing node:", self.name()
+ raise
+ return output
+
+ def saveState(self):
+ state = Node.saveState(self)
+ state['text'] = str(self.text.toPlainText())
+ #state['terminals'] = self.saveTerminals()
+ return state
+
+ def restoreState(self, state):
+ Node.restoreState(self, state)
+ self.text.clear()
+ self.text.insertPlainText(state['text'])
+ self.restoreTerminals(state['terminals'])
+ self.update()
+
+class ColumnJoinNode(Node):
+ """Concatenates record arrays and/or adds new columns"""
+ nodeName = 'ColumnJoin'
+
+ def __init__(self, name):
+ Node.__init__(self, name, terminals = {
+ 'output': {'io': 'out'},
+ })
+
+ #self.items = []
+
+ self.ui = QtGui.QWidget()
+ self.layout = QtGui.QGridLayout()
+ self.ui.setLayout(self.layout)
+
+ self.tree = TreeWidget()
+ self.addInBtn = QtGui.QPushButton('+ Input')
+ self.remInBtn = QtGui.QPushButton('- Input')
+
+ self.layout.addWidget(self.tree, 0, 0, 1, 2)
+ self.layout.addWidget(self.addInBtn, 1, 0)
+ self.layout.addWidget(self.remInBtn, 1, 1)
+
+ self.addInBtn.clicked.connect(self.addInput)
+ self.remInBtn.clicked.connect(self.remInput)
+ self.tree.sigItemMoved.connect(self.update)
+
+ def ctrlWidget(self):
+ return self.ui
+
+ def addInput(self):
+ #print "ColumnJoinNode.addInput called."
+ term = Node.addInput(self, 'input', renamable=True, removable=True, multiable=True)
+ #print "Node.addInput returned. term:", term
+ item = QtGui.QTreeWidgetItem([term.name()])
+ item.term = term
+ term.joinItem = item
+ #self.items.append((term, item))
+ self.tree.addTopLevelItem(item)
+
+ def remInput(self):
+ sel = self.tree.currentItem()
+ term = sel.term
+ term.joinItem = None
+ sel.term = None
+ self.tree.removeTopLevelItem(sel)
+ self.removeTerminal(term)
+ self.update()
+
+ def process(self, display=True, **args):
+ order = self.order()
+ vals = []
+ for name in order:
+ if name not in args:
+ continue
+ val = args[name]
+ if isinstance(val, np.ndarray) and len(val.dtype) > 0:
+ vals.append(val)
+ else:
+ vals.append((name, None, val))
+ return {'output': functions.concatenateColumns(vals)}
+
+ def order(self):
+ return [str(self.tree.topLevelItem(i).text(0)) for i in range(self.tree.topLevelItemCount())]
+
+ def saveState(self):
+ state = Node.saveState(self)
+ state['order'] = self.order()
+ return state
+
+ def restoreState(self, state):
+ Node.restoreState(self, state)
+ inputs = self.inputs()
+
+ ## Node.restoreState should have created all of the terminals we need
+ ## However: to maintain support for some older flowchart files, we need
+ ## to manually add any terminals that were not taken care of.
+ for name in [n for n in state['order'] if n not in inputs]:
+ Node.addInput(self, name, renamable=True, removable=True, multiable=True)
+ inputs = self.inputs()
+
+ order = [name for name in state['order'] if name in inputs]
+ for name in inputs:
+ if name not in order:
+ order.append(name)
+
+ self.tree.clear()
+ for name in order:
+ term = self[name]
+ item = QtGui.QTreeWidgetItem([name])
+ item.term = term
+ term.joinItem = item
+ #self.items.append((term, item))
+ self.tree.addTopLevelItem(item)
+
+ def terminalRenamed(self, term, oldName):
+ Node.terminalRenamed(self, term, oldName)
+ item = term.joinItem
+ item.setText(0, term.name())
+ self.update()
+
+
diff --git a/pyqtgraph/flowchart/library/Display.py b/pyqtgraph/flowchart/library/Display.py
new file mode 100644
index 00000000..7979d7a7
--- /dev/null
+++ b/pyqtgraph/flowchart/library/Display.py
@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+from ..Node import Node
+import weakref
+#from pyqtgraph import graphicsItems
+from pyqtgraph.Qt import QtCore, QtGui
+from pyqtgraph.graphicsItems.ScatterPlotItem import ScatterPlotItem
+from pyqtgraph.graphicsItems.PlotCurveItem import PlotCurveItem
+from pyqtgraph import PlotDataItem
+
+from .common import *
+import numpy as np
+
+class PlotWidgetNode(Node):
+ """Connection to PlotWidget. Will plot arrays, metaarrays, and display event lists."""
+ nodeName = 'PlotWidget'
+ sigPlotChanged = QtCore.Signal(object)
+
+ def __init__(self, name):
+ Node.__init__(self, name, terminals={'In': {'io': 'in', 'multi': True}})
+ self.plot = None
+ self.items = {}
+
+ def disconnected(self, localTerm, remoteTerm):
+ if localTerm is self.In and remoteTerm in self.items:
+ self.plot.removeItem(self.items[remoteTerm])
+ del self.items[remoteTerm]
+
+ def setPlot(self, plot):
+ #print "======set plot"
+ self.plot = plot
+ self.sigPlotChanged.emit(self)
+
+ def getPlot(self):
+ return self.plot
+
+ def process(self, In, display=True):
+ if display:
+ #self.plot.clearPlots()
+ items = set()
+ for name, vals in In.items():
+ if vals is None:
+ continue
+ if type(vals) is not list:
+ vals = [vals]
+
+ for val in vals:
+ vid = id(val)
+ if vid in self.items and self.items[vid].scene() is self.plot.scene():
+ items.add(vid)
+ else:
+ #if isinstance(val, PlotCurveItem):
+ #self.plot.addItem(val)
+ #item = val
+ #if isinstance(val, ScatterPlotItem):
+ #self.plot.addItem(val)
+ #item = val
+ if isinstance(val, QtGui.QGraphicsItem):
+ self.plot.addItem(val)
+ item = val
+ else:
+ item = self.plot.plot(val)
+ self.items[vid] = item
+ items.add(vid)
+ for vid in list(self.items.keys()):
+ if vid not in items:
+ #print "remove", self.items[vid]
+ self.plot.removeItem(self.items[vid])
+ del self.items[vid]
+
+ def processBypassed(self, args):
+ for item in list(self.items.values()):
+ self.plot.removeItem(item)
+ self.items = {}
+
+ #def setInput(self, **args):
+ #for k in args:
+ #self.plot.plot(args[k])
+
+
+
+class CanvasNode(Node):
+ """Connection to a Canvas widget."""
+ nodeName = 'CanvasWidget'
+
+ def __init__(self, name):
+ Node.__init__(self, name, terminals={'In': {'io': 'in', 'multi': True}})
+ self.canvas = None
+ self.items = {}
+
+ def disconnected(self, localTerm, remoteTerm):
+ if localTerm is self.In and remoteTerm in self.items:
+ self.canvas.removeItem(self.items[remoteTerm])
+ del self.items[remoteTerm]
+
+ def setCanvas(self, canvas):
+ self.canvas = canvas
+
+ def getCanvas(self):
+ return self.canvas
+
+ def process(self, In, display=True):
+ if display:
+ items = set()
+ for name, vals in In.items():
+ if vals is None:
+ continue
+ if type(vals) is not list:
+ vals = [vals]
+
+ for val in vals:
+ vid = id(val)
+ if vid in self.items:
+ items.add(vid)
+ else:
+ self.canvas.addItem(val)
+ item = val
+ self.items[vid] = item
+ items.add(vid)
+ for vid in list(self.items.keys()):
+ if vid not in items:
+ #print "remove", self.items[vid]
+ self.canvas.removeItem(self.items[vid])
+ del self.items[vid]
+
+
+class PlotCurve(CtrlNode):
+ """Generates a plot curve from x/y data"""
+ nodeName = 'PlotCurve'
+ uiTemplate = [
+ ('color', 'color'),
+ ]
+
+ def __init__(self, name):
+ CtrlNode.__init__(self, name, terminals={
+ 'x': {'io': 'in'},
+ 'y': {'io': 'in'},
+ 'plot': {'io': 'out'}
+ })
+ self.item = PlotDataItem()
+
+ def process(self, x, y, display=True):
+ #print "scatterplot process"
+ if not display:
+ return {'plot': None}
+
+ self.item.setData(x, y, pen=self.ctrls['color'].color())
+ return {'plot': self.item}
+
+
+
+
+class ScatterPlot(CtrlNode):
+ """Generates a scatter plot from a record array or nested dicts"""
+ nodeName = 'ScatterPlot'
+ uiTemplate = [
+ ('x', 'combo', {'values': [], 'index': 0}),
+ ('y', 'combo', {'values': [], 'index': 0}),
+ ('sizeEnabled', 'check', {'value': False}),
+ ('size', 'combo', {'values': [], 'index': 0}),
+ ('absoluteSize', 'check', {'value': False}),
+ ('colorEnabled', 'check', {'value': False}),
+ ('color', 'colormap', {}),
+ ('borderEnabled', 'check', {'value': False}),
+ ('border', 'colormap', {}),
+ ]
+
+ def __init__(self, name):
+ CtrlNode.__init__(self, name, terminals={
+ 'input': {'io': 'in'},
+ 'plot': {'io': 'out'}
+ })
+ self.item = ScatterPlotItem()
+ self.keys = []
+
+ #self.ui = QtGui.QWidget()
+ #self.layout = QtGui.QGridLayout()
+ #self.ui.setLayout(self.layout)
+
+ #self.xCombo = QtGui.QComboBox()
+ #self.yCombo = QtGui.QComboBox()
+
+
+
+ def process(self, input, display=True):
+ #print "scatterplot process"
+ if not display:
+ return {'plot': None}
+
+ self.updateKeys(input[0])
+
+ x = str(self.ctrls['x'].currentText())
+ y = str(self.ctrls['y'].currentText())
+ size = str(self.ctrls['size'].currentText())
+ pen = QtGui.QPen(QtGui.QColor(0,0,0,0))
+ points = []
+ for i in input:
+ pt = {'pos': (i[x], i[y])}
+ if self.ctrls['sizeEnabled'].isChecked():
+ pt['size'] = i[size]
+ if self.ctrls['borderEnabled'].isChecked():
+ pt['pen'] = QtGui.QPen(self.ctrls['border'].getColor(i))
+ else:
+ pt['pen'] = pen
+ if self.ctrls['colorEnabled'].isChecked():
+ pt['brush'] = QtGui.QBrush(self.ctrls['color'].getColor(i))
+ points.append(pt)
+ self.item.setPxMode(not self.ctrls['absoluteSize'].isChecked())
+
+ self.item.setPoints(points)
+
+ return {'plot': self.item}
+
+
+
+ def updateKeys(self, data):
+ if isinstance(data, dict):
+ keys = list(data.keys())
+ elif isinstance(data, list) or isinstance(data, tuple):
+ keys = data
+ elif isinstance(data, np.ndarray) or isinstance(data, np.void):
+ keys = data.dtype.names
+ else:
+ print("Unknown data type:", type(data), data)
+ return
+
+ for c in self.ctrls.values():
+ c.blockSignals(True)
+ for c in [self.ctrls['x'], self.ctrls['y'], self.ctrls['size']]:
+ cur = str(c.currentText())
+ c.clear()
+ for k in keys:
+ c.addItem(k)
+ if k == cur:
+ c.setCurrentIndex(c.count()-1)
+ for c in [self.ctrls['color'], self.ctrls['border']]:
+ c.setArgList(keys)
+ for c in self.ctrls.values():
+ c.blockSignals(False)
+
+ self.keys = keys
+
+
+ def saveState(self):
+ state = CtrlNode.saveState(self)
+ return {'keys': self.keys, 'ctrls': state}
+
+ def restoreState(self, state):
+ self.updateKeys(state['keys'])
+ CtrlNode.restoreState(self, state['ctrls'])
+
+#class ImageItem(Node):
+ #"""Creates an ImageItem for display in a canvas from a file handle."""
+ #nodeName = 'Image'
+
+ #def __init__(self, name):
+ #Node.__init__(self, name, terminals={
+ #'file': {'io': 'in'},
+ #'image': {'io': 'out'}
+ #})
+ #self.imageItem = graphicsItems.ImageItem()
+ #self.handle = None
+
+ #def process(self, file, display=True):
+ #if not display:
+ #return {'image': None}
+
+ #if file != self.handle:
+ #self.handle = file
+ #data = file.read()
+ #self.imageItem.updateImage(data)
+
+ #pos = file.
+
+
+
\ No newline at end of file
diff --git a/pyqtgraph/flowchart/library/Filters.py b/pyqtgraph/flowchart/library/Filters.py
new file mode 100644
index 00000000..090c261c
--- /dev/null
+++ b/pyqtgraph/flowchart/library/Filters.py
@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui
+from ..Node import Node
+from scipy.signal import detrend
+from scipy.ndimage import median_filter, gaussian_filter
+#from pyqtgraph.SignalProxy import SignalProxy
+from . import functions
+from .common import *
+import numpy as np
+
+import pyqtgraph.metaarray as metaarray
+
+
+class Downsample(CtrlNode):
+ """Downsample by averaging samples together."""
+ nodeName = 'Downsample'
+ uiTemplate = [
+ ('n', 'intSpin', {'min': 1, 'max': 1000000})
+ ]
+
+ def processData(self, data):
+ return functions.downsample(data, self.ctrls['n'].value(), axis=0)
+
+
+class Subsample(CtrlNode):
+ """Downsample by selecting every Nth sample."""
+ nodeName = 'Subsample'
+ uiTemplate = [
+ ('n', 'intSpin', {'min': 1, 'max': 1000000})
+ ]
+
+ def processData(self, data):
+ return data[::self.ctrls['n'].value()]
+
+
+class Bessel(CtrlNode):
+ """Bessel filter. Input data must have time values."""
+ nodeName = 'BesselFilter'
+ uiTemplate = [
+ ('band', 'combo', {'values': ['lowpass', 'highpass'], 'index': 0}),
+ ('cutoff', 'spin', {'value': 1000., 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'Hz', 'siPrefix': True}),
+ ('order', 'intSpin', {'value': 4, 'min': 1, 'max': 16}),
+ ('bidir', 'check', {'checked': True})
+ ]
+
+ def processData(self, data):
+ s = self.stateGroup.state()
+ if s['band'] == 'lowpass':
+ mode = 'low'
+ else:
+ mode = 'high'
+ return functions.besselFilter(data, bidir=s['bidir'], btype=mode, cutoff=s['cutoff'], order=s['order'])
+
+
+class Butterworth(CtrlNode):
+ """Butterworth filter"""
+ nodeName = 'ButterworthFilter'
+ uiTemplate = [
+ ('band', 'combo', {'values': ['lowpass', 'highpass'], 'index': 0}),
+ ('wPass', 'spin', {'value': 1000., 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'Hz', 'siPrefix': True}),
+ ('wStop', 'spin', {'value': 2000., 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'Hz', 'siPrefix': True}),
+ ('gPass', 'spin', {'value': 2.0, 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'dB', 'siPrefix': True}),
+ ('gStop', 'spin', {'value': 20.0, 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'dB', 'siPrefix': True}),
+ ('bidir', 'check', {'checked': True})
+ ]
+
+ def processData(self, data):
+ s = self.stateGroup.state()
+ if s['band'] == 'lowpass':
+ mode = 'low'
+ else:
+ mode = 'high'
+ ret = functions.butterworthFilter(data, bidir=s['bidir'], btype=mode, wPass=s['wPass'], wStop=s['wStop'], gPass=s['gPass'], gStop=s['gStop'])
+ return ret
+
+
+class ButterworthNotch(CtrlNode):
+ """Butterworth notch filter"""
+ nodeName = 'ButterworthNotchFilter'
+ uiTemplate = [
+ ('low_wPass', 'spin', {'value': 1000., 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'Hz', 'siPrefix': True}),
+ ('low_wStop', 'spin', {'value': 2000., 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'Hz', 'siPrefix': True}),
+ ('low_gPass', 'spin', {'value': 2.0, 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'dB', 'siPrefix': True}),
+ ('low_gStop', 'spin', {'value': 20.0, 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'dB', 'siPrefix': True}),
+ ('high_wPass', 'spin', {'value': 3000., 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'Hz', 'siPrefix': True}),
+ ('high_wStop', 'spin', {'value': 4000., 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'Hz', 'siPrefix': True}),
+ ('high_gPass', 'spin', {'value': 2.0, 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'dB', 'siPrefix': True}),
+ ('high_gStop', 'spin', {'value': 20.0, 'step': 1, 'dec': True, 'range': [0.0, None], 'suffix': 'dB', 'siPrefix': True}),
+ ('bidir', 'check', {'checked': True})
+ ]
+
+ def processData(self, data):
+ s = self.stateGroup.state()
+
+ low = functions.butterworthFilter(data, bidir=s['bidir'], btype='low', wPass=s['low_wPass'], wStop=s['low_wStop'], gPass=s['low_gPass'], gStop=s['low_gStop'])
+ high = functions.butterworthFilter(data, bidir=s['bidir'], btype='high', wPass=s['high_wPass'], wStop=s['high_wStop'], gPass=s['high_gPass'], gStop=s['high_gStop'])
+ return low + high
+
+
+class Mean(CtrlNode):
+ """Filters data by taking the mean of a sliding window"""
+ nodeName = 'MeanFilter'
+ uiTemplate = [
+ ('n', 'intSpin', {'min': 1, 'max': 1000000})
+ ]
+
+ @metaArrayWrapper
+ def processData(self, data):
+ n = self.ctrls['n'].value()
+ return functions.rollingSum(data, n) / n
+
+
+class Median(CtrlNode):
+ """Filters data by taking the median of a sliding window"""
+ nodeName = 'MedianFilter'
+ uiTemplate = [
+ ('n', 'intSpin', {'min': 1, 'max': 1000000})
+ ]
+
+ @metaArrayWrapper
+ def processData(self, data):
+ return median_filter(data, self.ctrls['n'].value())
+
+class Mode(CtrlNode):
+ """Filters data by taking the mode (histogram-based) of a sliding window"""
+ nodeName = 'ModeFilter'
+ uiTemplate = [
+ ('window', 'intSpin', {'value': 500, 'min': 1, 'max': 1000000}),
+ ]
+
+ @metaArrayWrapper
+ def processData(self, data):
+ return functions.modeFilter(data, self.ctrls['window'].value())
+
+
+class Denoise(CtrlNode):
+ """Removes anomalous spikes from data, replacing with nearby values"""
+ nodeName = 'DenoiseFilter'
+ uiTemplate = [
+ ('radius', 'intSpin', {'value': 2, 'min': 0, 'max': 1000000}),
+ ('threshold', 'doubleSpin', {'value': 4.0, 'min': 0, 'max': 1000})
+ ]
+
+ def processData(self, data):
+ #print "DENOISE"
+ s = self.stateGroup.state()
+ return functions.denoise(data, **s)
+
+
+class Gaussian(CtrlNode):
+ """Gaussian smoothing filter."""
+ nodeName = 'GaussianFilter'
+ uiTemplate = [
+ ('sigma', 'doubleSpin', {'min': 0, 'max': 1000000})
+ ]
+
+ @metaArrayWrapper
+ def processData(self, data):
+ return gaussian_filter(data, self.ctrls['sigma'].value())
+
+
+class Derivative(CtrlNode):
+ """Returns the pointwise derivative of the input"""
+ nodeName = 'DerivativeFilter'
+
+ def processData(self, data):
+ if hasattr(data, 'implements') and data.implements('MetaArray'):
+ info = data.infoCopy()
+ if 'values' in info[0]:
+ info[0]['values'] = info[0]['values'][:-1]
+ return metaarray.MetaArray(data[1:] - data[:-1], info=info)
+ else:
+ return data[1:] - data[:-1]
+
+
+class Integral(CtrlNode):
+ """Returns the pointwise integral of the input"""
+ nodeName = 'IntegralFilter'
+
+ @metaArrayWrapper
+ def processData(self, data):
+ data[1:] += data[:-1]
+ return data
+
+
+class Detrend(CtrlNode):
+ """Removes linear trend from the data"""
+ nodeName = 'DetrendFilter'
+
+ @metaArrayWrapper
+ def processData(self, data):
+ return detrend(data)
+
+
+class AdaptiveDetrend(CtrlNode):
+ """Removes baseline from data, ignoring anomalous events"""
+ nodeName = 'AdaptiveDetrend'
+ uiTemplate = [
+ ('threshold', 'doubleSpin', {'value': 3.0, 'min': 0, 'max': 1000000})
+ ]
+
+ def processData(self, data):
+ return functions.adaptiveDetrend(data, threshold=self.ctrls['threshold'].value())
+
+class HistogramDetrend(CtrlNode):
+ """Removes baseline from data by computing mode (from histogram) of beginning and end of data."""
+ nodeName = 'HistogramDetrend'
+ uiTemplate = [
+ ('windowSize', 'intSpin', {'value': 500, 'min': 10, 'max': 1000000, 'suffix': 'pts'}),
+ ('numBins', 'intSpin', {'value': 50, 'min': 3, 'max': 1000000}),
+ ('offsetOnly', 'check', {'checked': False}),
+ ]
+
+ def processData(self, data):
+ s = self.stateGroup.state()
+ #ws = self.ctrls['windowSize'].value()
+ #bn = self.ctrls['numBins'].value()
+ #offset = self.ctrls['offsetOnly'].checked()
+ return functions.histogramDetrend(data, window=s['windowSize'], bins=s['numBins'], offsetOnly=s['offsetOnly'])
+
+
+
+class RemovePeriodic(CtrlNode):
+ nodeName = 'RemovePeriodic'
+ uiTemplate = [
+ #('windowSize', 'intSpin', {'value': 500, 'min': 10, 'max': 1000000, 'suffix': 'pts'}),
+ #('numBins', 'intSpin', {'value': 50, 'min': 3, 'max': 1000000})
+ ('f0', 'spin', {'value': 60, 'suffix': 'Hz', 'siPrefix': True, 'min': 0, 'max': None}),
+ ('harmonics', 'intSpin', {'value': 30, 'min': 0}),
+ ('samples', 'intSpin', {'value': 1, 'min': 1}),
+ ]
+
+ def processData(self, data):
+ times = data.xvals('Time')
+ dt = times[1]-times[0]
+
+ data1 = data.asarray()
+ ft = np.fft.fft(data1)
+
+ ## determine frequencies in fft data
+ df = 1.0 / (len(data1) * dt)
+ freqs = np.linspace(0.0, (len(ft)-1) * df, len(ft))
+
+ ## flatten spikes at f0 and harmonics
+ f0 = self.ctrls['f0'].value()
+ for i in xrange(1, self.ctrls['harmonics'].value()+2):
+ f = f0 * i # target frequency
+
+ ## determine index range to check for this frequency
+ ind1 = int(np.floor(f / df))
+ ind2 = int(np.ceil(f / df)) + (self.ctrls['samples'].value()-1)
+ if ind1 > len(ft)/2.:
+ break
+ mag = (abs(ft[ind1-1]) + abs(ft[ind2+1])) * 0.5
+ for j in range(ind1, ind2+1):
+ phase = np.angle(ft[j]) ## Must preserve the phase of each point, otherwise any transients in the trace might lead to large artifacts.
+ re = mag * np.cos(phase)
+ im = mag * np.sin(phase)
+ ft[j] = re + im*1j
+ ft[len(ft)-j] = re - im*1j
+
+ data2 = np.fft.ifft(ft).real
+
+ ma = metaarray.MetaArray(data2, info=data.infoCopy())
+ return ma
+
+
+
\ No newline at end of file
diff --git a/pyqtgraph/flowchart/library/Operators.py b/pyqtgraph/flowchart/library/Operators.py
new file mode 100644
index 00000000..412af573
--- /dev/null
+++ b/pyqtgraph/flowchart/library/Operators.py
@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+from ..Node import Node
+
+class UniOpNode(Node):
+ """Generic node for performing any operation like Out = In.fn()"""
+ def __init__(self, name, fn):
+ self.fn = fn
+ Node.__init__(self, name, terminals={
+ 'In': {'io': 'in'},
+ 'Out': {'io': 'out', 'bypass': 'In'}
+ })
+
+ def process(self, **args):
+ return {'Out': getattr(args['In'], self.fn)()}
+
+class BinOpNode(Node):
+ """Generic node for performing any operation like A.fn(B)"""
+ def __init__(self, name, fn):
+ self.fn = fn
+ Node.__init__(self, name, terminals={
+ 'A': {'io': 'in'},
+ 'B': {'io': 'in'},
+ 'Out': {'io': 'out', 'bypass': 'A'}
+ })
+
+ def process(self, **args):
+ fn = getattr(args['A'], self.fn)
+ out = fn(args['B'])
+ if out is NotImplemented:
+ raise Exception("Operation %s not implemented between %s and %s" % (fn, str(type(args['A'])), str(type(args['B']))))
+ #print " ", fn, out
+ return {'Out': out}
+
+
+class AbsNode(UniOpNode):
+ """Returns abs(Inp). Does not check input types."""
+ nodeName = 'Abs'
+ def __init__(self, name):
+ UniOpNode.__init__(self, name, '__abs__')
+
+class AddNode(BinOpNode):
+ """Returns A + B. Does not check input types."""
+ nodeName = 'Add'
+ def __init__(self, name):
+ BinOpNode.__init__(self, name, '__add__')
+
+class SubtractNode(BinOpNode):
+ """Returns A - B. Does not check input types."""
+ nodeName = 'Subtract'
+ def __init__(self, name):
+ BinOpNode.__init__(self, name, '__sub__')
+
+class MultiplyNode(BinOpNode):
+ """Returns A * B. Does not check input types."""
+ nodeName = 'Multiply'
+ def __init__(self, name):
+ BinOpNode.__init__(self, name, '__mul__')
+
+class DivideNode(BinOpNode):
+ """Returns A / B. Does not check input types."""
+ nodeName = 'Divide'
+ def __init__(self, name):
+ BinOpNode.__init__(self, name, '__div__')
+
diff --git a/pyqtgraph/flowchart/library/__init__.py b/pyqtgraph/flowchart/library/__init__.py
new file mode 100644
index 00000000..1e44edff
--- /dev/null
+++ b/pyqtgraph/flowchart/library/__init__.py
@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.pgcollections import OrderedDict
+from pyqtgraph import importModules
+import os, types
+from pyqtgraph.debug import printExc
+from ..Node import Node
+import pyqtgraph.reload as reload
+
+
+NODE_LIST = OrderedDict() ## maps name:class for all registered Node subclasses
+NODE_TREE = OrderedDict() ## categorized tree of Node subclasses
+
+def getNodeType(name):
+ try:
+ return NODE_LIST[name]
+ except KeyError:
+ raise Exception("No node type called '%s'" % name)
+
+def getNodeTree():
+ return NODE_TREE
+
+def registerNodeType(cls, paths, override=False):
+ """
+ Register a new node type. If the type's name is already in use,
+ an exception will be raised (unless override=True).
+
+ Arguments:
+ cls - a subclass of Node (must have typ.nodeName)
+ paths - list of tuples specifying the location(s) this
+ type will appear in the library tree.
+ override - if True, overwrite any class having the same name
+ """
+ if not isNodeClass(cls):
+ raise Exception("Object %s is not a Node subclass" % str(cls))
+
+ name = cls.nodeName
+ if not override and name in NODE_LIST:
+ raise Exception("Node type name '%s' is already registered." % name)
+
+ NODE_LIST[name] = cls
+ for path in paths:
+ root = NODE_TREE
+ for n in path:
+ if n not in root:
+ root[n] = OrderedDict()
+ root = root[n]
+ root[name] = cls
+
+
+
+def isNodeClass(cls):
+ try:
+ if not issubclass(cls, Node):
+ return False
+ except:
+ return False
+ return hasattr(cls, 'nodeName')
+
+def loadLibrary(reloadLibs=False, libPath=None):
+ """Import all Node subclasses found within files in the library module."""
+
+ global NODE_LIST, NODE_TREE
+ #if libPath is None:
+ #libPath = os.path.dirname(os.path.abspath(__file__))
+
+ if reloadLibs:
+ reload.reloadAll(libPath)
+
+ mods = importModules('', globals(), locals())
+ #for f in frozenSupport.listdir(libPath):
+ #pathName, ext = os.path.splitext(f)
+ #if ext not in ('.py', '.pyc') or '__init__' in pathName or '__pycache__' in pathName:
+ #continue
+ #try:
+ ##print "importing from", f
+ #mod = __import__(pathName, globals(), locals())
+ #except:
+ #printExc("Error loading flowchart library %s:" % pathName)
+ #continue
+
+ for name, mod in mods.items():
+ nodes = []
+ for n in dir(mod):
+ o = getattr(mod, n)
+ if isNodeClass(o):
+ #print " ", str(o)
+ registerNodeType(o, [(name,)], override=reloadLibs)
+ #nodes.append((o.nodeName, o))
+ #if len(nodes) > 0:
+ #NODE_TREE[name] = OrderedDict(nodes)
+ #NODE_LIST.extend(nodes)
+ #NODE_LIST = OrderedDict(NODE_LIST)
+
+def reloadLibrary():
+ loadLibrary(reloadLibs=True)
+
+loadLibrary()
+#NODE_LIST = []
+#for o in locals().values():
+ #if type(o) is type(AddNode) and issubclass(o, Node) and o is not Node and hasattr(o, 'nodeName'):
+ #NODE_LIST.append((o.nodeName, o))
+#NODE_LIST.sort(lambda a,b: cmp(a[0], b[0]))
+#NODE_LIST = OrderedDict(NODE_LIST)
\ No newline at end of file
diff --git a/pyqtgraph/flowchart/library/common.py b/pyqtgraph/flowchart/library/common.py
new file mode 100644
index 00000000..65f8c1fd
--- /dev/null
+++ b/pyqtgraph/flowchart/library/common.py
@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui
+from pyqtgraph.widgets.SpinBox import SpinBox
+#from pyqtgraph.SignalProxy import SignalProxy
+from pyqtgraph.WidgetGroup import WidgetGroup
+#from ColorMapper import ColorMapper
+from ..Node import Node
+import numpy as np
+from pyqtgraph.widgets.ColorButton import ColorButton
+try:
+ import metaarray
+ HAVE_METAARRAY = True
+except:
+ HAVE_METAARRAY = False
+
+
+def generateUi(opts):
+ """Convenience function for generating common UI types"""
+ widget = QtGui.QWidget()
+ l = QtGui.QFormLayout()
+ l.setSpacing(0)
+ widget.setLayout(l)
+ ctrls = {}
+ row = 0
+ for opt in opts:
+ if len(opt) == 2:
+ k, t = opt
+ o = {}
+ elif len(opt) == 3:
+ k, t, o = opt
+ else:
+ raise Exception("Widget specification must be (name, type) or (name, type, {opts})")
+ if t == 'intSpin':
+ w = QtGui.QSpinBox()
+ if 'max' in o:
+ w.setMaximum(o['max'])
+ if 'min' in o:
+ w.setMinimum(o['min'])
+ if 'value' in o:
+ w.setValue(o['value'])
+ elif t == 'doubleSpin':
+ w = QtGui.QDoubleSpinBox()
+ if 'max' in o:
+ w.setMaximum(o['max'])
+ if 'min' in o:
+ w.setMinimum(o['min'])
+ if 'value' in o:
+ w.setValue(o['value'])
+ elif t == 'spin':
+ w = SpinBox()
+ w.setOpts(**o)
+ elif t == 'check':
+ w = QtGui.QCheckBox()
+ if 'checked' in o:
+ w.setChecked(o['checked'])
+ elif t == 'combo':
+ w = QtGui.QComboBox()
+ for i in o['values']:
+ w.addItem(i)
+ #elif t == 'colormap':
+ #w = ColorMapper()
+ elif t == 'color':
+ w = ColorButton()
+ else:
+ raise Exception("Unknown widget type '%s'" % str(t))
+ if 'tip' in o:
+ w.setToolTip(o['tip'])
+ w.setObjectName(k)
+ l.addRow(k, w)
+ if o.get('hidden', False):
+ w.hide()
+ label = l.labelForField(w)
+ label.hide()
+
+ ctrls[k] = w
+ w.rowNum = row
+ row += 1
+ group = WidgetGroup(widget)
+ return widget, group, ctrls
+
+
+class CtrlNode(Node):
+ """Abstract class for nodes with auto-generated control UI"""
+
+ sigStateChanged = QtCore.Signal(object)
+
+ def __init__(self, name, ui=None, terminals=None):
+ if ui is None:
+ if hasattr(self, 'uiTemplate'):
+ ui = self.uiTemplate
+ else:
+ ui = []
+ if terminals is None:
+ terminals = {'In': {'io': 'in'}, 'Out': {'io': 'out', 'bypass': 'In'}}
+ Node.__init__(self, name=name, terminals=terminals)
+
+ self.ui, self.stateGroup, self.ctrls = generateUi(ui)
+ self.stateGroup.sigChanged.connect(self.changed)
+
+ def ctrlWidget(self):
+ return self.ui
+
+ def changed(self):
+ self.update()
+ self.sigStateChanged.emit(self)
+
+ def process(self, In, display=True):
+ out = self.processData(In)
+ return {'Out': out}
+
+ def saveState(self):
+ state = Node.saveState(self)
+ state['ctrl'] = self.stateGroup.state()
+ return state
+
+ def restoreState(self, state):
+ Node.restoreState(self, state)
+ if self.stateGroup is not None:
+ self.stateGroup.setState(state.get('ctrl', {}))
+
+ def hideRow(self, name):
+ w = self.ctrls[name]
+ l = self.ui.layout().labelForField(w)
+ w.hide()
+ l.hide()
+
+ def showRow(self, name):
+ w = self.ctrls[name]
+ l = self.ui.layout().labelForField(w)
+ w.show()
+ l.show()
+
+
+
+def metaArrayWrapper(fn):
+ def newFn(self, data, *args, **kargs):
+ if HAVE_METAARRAY and (hasattr(data, 'implements') and data.implements('MetaArray')):
+ d1 = fn(self, data.view(np.ndarray), *args, **kargs)
+ info = data.infoCopy()
+ if d1.shape != data.shape:
+ for i in range(data.ndim):
+ if 'values' in info[i]:
+ info[i]['values'] = info[i]['values'][:d1.shape[i]]
+ return metaarray.MetaArray(d1, info=info)
+ else:
+ return fn(self, data, *args, **kargs)
+ return newFn
+
diff --git a/pyqtgraph/flowchart/library/functions.py b/pyqtgraph/flowchart/library/functions.py
new file mode 100644
index 00000000..0476e02f
--- /dev/null
+++ b/pyqtgraph/flowchart/library/functions.py
@@ -0,0 +1,336 @@
+import scipy
+import numpy as np
+from pyqtgraph.metaarray import MetaArray
+
+def downsample(data, n, axis=0, xvals='subsample'):
+ """Downsample by averaging points together across axis.
+ If multiple axes are specified, runs once per axis.
+ If a metaArray is given, then the axis values can be either subsampled
+ or downsampled to match.
+ """
+ ma = None
+ if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ ma = data
+ data = data.view(np.ndarray)
+
+
+ if hasattr(axis, '__len__'):
+ if not hasattr(n, '__len__'):
+ n = [n]*len(axis)
+ for i in range(len(axis)):
+ data = downsample(data, n[i], axis[i])
+ return data
+
+ nPts = int(data.shape[axis] / n)
+ s = list(data.shape)
+ s[axis] = nPts
+ s.insert(axis+1, n)
+ sl = [slice(None)] * data.ndim
+ sl[axis] = slice(0, nPts*n)
+ d1 = data[tuple(sl)]
+ #print d1.shape, s
+ d1.shape = tuple(s)
+ d2 = d1.mean(axis+1)
+
+ if ma is None:
+ return d2
+ else:
+ info = ma.infoCopy()
+ if 'values' in info[axis]:
+ if xvals == 'subsample':
+ info[axis]['values'] = info[axis]['values'][::n][:nPts]
+ elif xvals == 'downsample':
+ info[axis]['values'] = downsample(info[axis]['values'], n)
+ return MetaArray(d2, info=info)
+
+
+def applyFilter(data, b, a, padding=100, bidir=True):
+ """Apply a linear filter with coefficients a, b. Optionally pad the data before filtering
+ and/or run the filter in both directions."""
+ d1 = data.view(np.ndarray)
+
+ if padding > 0:
+ d1 = np.hstack([d1[:padding], d1, d1[-padding:]])
+
+ if bidir:
+ d1 = scipy.signal.lfilter(b, a, scipy.signal.lfilter(b, a, d1)[::-1])[::-1]
+ else:
+ d1 = scipy.signal.lfilter(b, a, d1)
+
+ if padding > 0:
+ d1 = d1[padding:-padding]
+
+ if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ return MetaArray(d1, info=data.infoCopy())
+ else:
+ return d1
+
+def besselFilter(data, cutoff, order=1, dt=None, btype='low', bidir=True):
+ """return data passed through bessel filter"""
+ if dt is None:
+ try:
+ tvals = data.xvals('Time')
+ dt = (tvals[-1]-tvals[0]) / (len(tvals)-1)
+ except:
+ dt = 1.0
+
+ b,a = scipy.signal.bessel(order, cutoff * dt, btype=btype)
+
+ return applyFilter(data, b, a, bidir=bidir)
+ #base = data.mean()
+ #d1 = scipy.signal.lfilter(b, a, data.view(ndarray)-base) + base
+ #if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ #return MetaArray(d1, info=data.infoCopy())
+ #return d1
+
+def butterworthFilter(data, wPass, wStop=None, gPass=2.0, gStop=20.0, order=1, dt=None, btype='low', bidir=True):
+ """return data passed through bessel filter"""
+ if dt is None:
+ try:
+ tvals = data.xvals('Time')
+ dt = (tvals[-1]-tvals[0]) / (len(tvals)-1)
+ except:
+ dt = 1.0
+
+ if wStop is None:
+ wStop = wPass * 2.0
+ ord, Wn = scipy.signal.buttord(wPass*dt*2., wStop*dt*2., gPass, gStop)
+ #print "butterworth ord %f Wn %f c %f sc %f" % (ord, Wn, cutoff, stopCutoff)
+ b,a = scipy.signal.butter(ord, Wn, btype=btype)
+
+ return applyFilter(data, b, a, bidir=bidir)
+
+
+def rollingSum(data, n):
+ d1 = data.copy()
+ d1[1:] += d1[:-1] # integrate
+ d2 = np.empty(len(d1) - n + 1, dtype=data.dtype)
+ d2[0] = d1[n-1] # copy first point
+ d2[1:] = d1[n:] - d1[:-n] # subtract
+ return d2
+
+
+def mode(data, bins=None):
+ """Returns location max value from histogram."""
+ if bins is None:
+ bins = int(len(data)/10.)
+ if bins < 2:
+ bins = 2
+ y, x = np.histogram(data, bins=bins)
+ ind = np.argmax(y)
+ mode = 0.5 * (x[ind] + x[ind+1])
+ return mode
+
+def modeFilter(data, window=500, step=None, bins=None):
+ """Filter based on histogram-based mode function"""
+ d1 = data.view(np.ndarray)
+ vals = []
+ l2 = int(window/2.)
+ if step is None:
+ step = l2
+ i = 0
+ while True:
+ if i > len(data)-step:
+ break
+ vals.append(mode(d1[i:i+window], bins))
+ i += step
+
+ chunks = [np.linspace(vals[0], vals[0], l2)]
+ for i in range(len(vals)-1):
+ chunks.append(np.linspace(vals[i], vals[i+1], step))
+ remain = len(data) - step*(len(vals)-1) - l2
+ chunks.append(np.linspace(vals[-1], vals[-1], remain))
+ d2 = np.hstack(chunks)
+
+ if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ return MetaArray(d2, info=data.infoCopy())
+ return d2
+
+def denoise(data, radius=2, threshold=4):
+ """Very simple noise removal function. Compares a point to surrounding points,
+ replaces with nearby values if the difference is too large."""
+
+
+ r2 = radius * 2
+ d1 = data.view(np.ndarray)
+ d2 = d1[radius:] - d1[:-radius] #a derivative
+ #d3 = data[r2:] - data[:-r2]
+ #d4 = d2 - d3
+ stdev = d2.std()
+ #print "denoise: stdev of derivative:", stdev
+ mask1 = d2 > stdev*threshold #where derivative is large and positive
+ mask2 = d2 < -stdev*threshold #where derivative is large and negative
+ maskpos = mask1[:-radius] * mask2[radius:] #both need to be true
+ maskneg = mask1[radius:] * mask2[:-radius]
+ mask = maskpos + maskneg
+ d5 = np.where(mask, d1[:-r2], d1[radius:-radius]) #where both are true replace the value with the value from 2 points before
+ d6 = np.empty(d1.shape, dtype=d1.dtype) #add points back to the ends
+ d6[radius:-radius] = d5
+ d6[:radius] = d1[:radius]
+ d6[-radius:] = d1[-radius:]
+
+ if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ return MetaArray(d6, info=data.infoCopy())
+ return d6
+
+def adaptiveDetrend(data, x=None, threshold=3.0):
+ """Return the signal with baseline removed. Discards outliers from baseline measurement."""
+ if x is None:
+ x = data.xvals(0)
+
+ d = data.view(np.ndarray)
+
+ d2 = scipy.signal.detrend(d)
+
+ stdev = d2.std()
+ mask = abs(d2) < stdev*threshold
+ #d3 = where(mask, 0, d2)
+ #d4 = d2 - lowPass(d3, cutoffs[1], dt=dt)
+
+ lr = stats.linregress(x[mask], d[mask])
+ base = lr[1] + lr[0]*x
+ d4 = d - base
+
+ if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ return MetaArray(d4, info=data.infoCopy())
+ return d4
+
+
+def histogramDetrend(data, window=500, bins=50, threshold=3.0, offsetOnly=False):
+ """Linear detrend. Works by finding the most common value at the beginning and end of a trace, excluding outliers.
+ If offsetOnly is True, then only the offset from the beginning of the trace is subtracted.
+ """
+
+ d1 = data.view(np.ndarray)
+ d2 = [d1[:window], d1[-window:]]
+ v = [0, 0]
+ for i in [0, 1]:
+ d3 = d2[i]
+ stdev = d3.std()
+ mask = abs(d3-np.median(d3)) < stdev*threshold
+ d4 = d3[mask]
+ y, x = np.histogram(d4, bins=bins)
+ ind = np.argmax(y)
+ v[i] = 0.5 * (x[ind] + x[ind+1])
+
+ if offsetOnly:
+ d3 = data.view(np.ndarray) - v[0]
+ else:
+ base = np.linspace(v[0], v[1], len(data))
+ d3 = data.view(np.ndarray) - base
+
+ if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ return MetaArray(d3, info=data.infoCopy())
+ return d3
+
+def concatenateColumns(data):
+ """Returns a single record array with columns taken from the elements in data.
+ data should be a list of elements, which can be either record arrays or tuples (name, type, data)
+ """
+
+ ## first determine dtype
+ dtype = []
+ names = set()
+ maxLen = 0
+ for element in data:
+ if isinstance(element, np.ndarray):
+ ## use existing columns
+ for i in range(len(element.dtype)):
+ name = element.dtype.names[i]
+ dtype.append((name, element.dtype[i]))
+ maxLen = max(maxLen, len(element))
+ else:
+ name, type, d = element
+ if type is None:
+ type = suggestDType(d)
+ dtype.append((name, type))
+ if isinstance(d, list) or isinstance(d, np.ndarray):
+ maxLen = max(maxLen, len(d))
+ if name in names:
+ raise Exception('Name "%s" repeated' % name)
+ names.add(name)
+
+
+
+ ## create empty array
+ out = np.empty(maxLen, dtype)
+
+ ## fill columns
+ for element in data:
+ if isinstance(element, np.ndarray):
+ for i in range(len(element.dtype)):
+ name = element.dtype.names[i]
+ try:
+ out[name] = element[name]
+ except:
+ print("Column:", name)
+ print("Input shape:", element.shape, element.dtype)
+ print("Output shape:", out.shape, out.dtype)
+ raise
+ else:
+ name, type, d = element
+ out[name] = d
+
+ return out
+
+def suggestDType(x):
+ """Return a suitable dtype for x"""
+ if isinstance(x, list) or isinstance(x, tuple):
+ if len(x) == 0:
+ raise Exception('can not determine dtype for empty list')
+ x = x[0]
+
+ if hasattr(x, 'dtype'):
+ return x.dtype
+ elif isinstance(x, float):
+ return float
+ elif isinstance(x, int):
+ return int
+ #elif isinstance(x, basestring): ## don't try to guess correct string length; use object instead.
+ #return ' len(ft)/2.:
+ break
+ mag = (abs(ft[ind1-1]) + abs(ft[ind2+1])) * 0.5
+ for j in range(ind1, ind2+1):
+ phase = np.angle(ft[j]) ## Must preserve the phase of each point, otherwise any transients in the trace might lead to large artifacts.
+ re = mag * np.cos(phase)
+ im = mag * np.sin(phase)
+ ft[j] = re + im*1j
+ ft[len(ft)-j] = re - im*1j
+
+ data2 = np.fft.ifft(ft).real
+
+ if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ return metaarray.MetaArray(data2, info=data.infoCopy())
+ else:
+ return data2
+
+
+
\ No newline at end of file
diff --git a/pyqtgraph/frozenSupport.py b/pyqtgraph/frozenSupport.py
new file mode 100644
index 00000000..385bb435
--- /dev/null
+++ b/pyqtgraph/frozenSupport.py
@@ -0,0 +1,52 @@
+## Definitions helpful in frozen environments (eg py2exe)
+import os, sys, zipfile
+
+def listdir(path):
+ """Replacement for os.listdir that works in frozen environments."""
+ if not hasattr(sys, 'frozen'):
+ return os.listdir(path)
+
+ (zipPath, archivePath) = splitZip(path)
+ if archivePath is None:
+ return os.listdir(path)
+
+ with zipfile.ZipFile(zipPath, "r") as zipobj:
+ contents = zipobj.namelist()
+ results = set()
+ for name in contents:
+ # components in zip archive paths are always separated by forward slash
+ if name.startswith(archivePath) and len(name) > len(archivePath):
+ name = name[len(archivePath):].split('/')[0]
+ results.add(name)
+ return list(results)
+
+def isdir(path):
+ """Replacement for os.path.isdir that works in frozen environments."""
+ if not hasattr(sys, 'frozen'):
+ return os.path.isdir(path)
+
+ (zipPath, archivePath) = splitZip(path)
+ if archivePath is None:
+ return os.path.isdir(path)
+ with zipfile.ZipFile(zipPath, "r") as zipobj:
+ contents = zipobj.namelist()
+ archivePath = archivePath.rstrip('/') + '/' ## make sure there's exactly one '/' at the end
+ for c in contents:
+ if c.startswith(archivePath):
+ return True
+ return False
+
+
+def splitZip(path):
+ """Splits a path containing a zip file into (zipfile, subpath).
+ If there is no zip file, returns (path, None)"""
+ components = os.path.normpath(path).split(os.sep)
+ for index, component in enumerate(components):
+ if component.endswith('.zip'):
+ zipPath = os.sep.join(components[0:index+1])
+ archivePath = ''.join([x+'/' for x in components[index+1:]])
+ return (zipPath, archivePath)
+ else:
+ return (path, None)
+
+
\ No newline at end of file
diff --git a/pyqtgraph/functions.py b/pyqtgraph/functions.py
new file mode 100644
index 00000000..23b2580c
--- /dev/null
+++ b/pyqtgraph/functions.py
@@ -0,0 +1,1874 @@
+# -*- coding: utf-8 -*-
+"""
+functions.py - Miscellaneous functions with no other home
+Copyright 2010 Luke Campagnola
+Distributed under MIT/X11 license. See license.txt for more infomation.
+"""
+
+from .python2_3 import asUnicode
+Colors = {
+ 'b': (0,0,255,255),
+ 'g': (0,255,0,255),
+ 'r': (255,0,0,255),
+ 'c': (0,255,255,255),
+ 'm': (255,0,255,255),
+ 'y': (255,255,0,255),
+ 'k': (0,0,0,255),
+ 'w': (255,255,255,255),
+}
+
+SI_PREFIXES = asUnicode('yzafpnµm kMGTPEZY')
+SI_PREFIXES_ASCII = 'yzafpnum kMGTPEZY'
+
+
+
+from .Qt import QtGui, QtCore, USE_PYSIDE
+import numpy as np
+import decimal, re
+import ctypes
+
+try:
+ import scipy.ndimage
+ HAVE_SCIPY = True
+ try:
+ import scipy.weave
+ USE_WEAVE = True
+ except:
+ USE_WEAVE = False
+except ImportError:
+ HAVE_SCIPY = False
+
+from . import debug
+
+def siScale(x, minVal=1e-25, allowUnicode=True):
+ """
+ Return the recommended scale factor and SI prefix string for x.
+
+ Example::
+
+ siScale(0.0001) # returns (1e6, 'μ')
+ # This indicates that the number 0.0001 is best represented as 0.0001 * 1e6 = 100 μUnits
+ """
+
+ if isinstance(x, decimal.Decimal):
+ x = float(x)
+
+ try:
+ if np.isnan(x) or np.isinf(x):
+ return(1, '')
+ except:
+ print(x, type(x))
+ raise
+ if abs(x) < minVal:
+ m = 0
+ x = 0
+ else:
+ m = int(np.clip(np.floor(np.log(abs(x))/np.log(1000)), -9.0, 9.0))
+
+ if m == 0:
+ pref = ''
+ elif m < -8 or m > 8:
+ pref = 'e%d' % (m*3)
+ else:
+ if allowUnicode:
+ pref = SI_PREFIXES[m+8]
+ else:
+ pref = SI_PREFIXES_ASCII[m+8]
+ p = .001**m
+
+ return (p, pref)
+
+def siFormat(x, precision=3, suffix='', space=True, error=None, minVal=1e-25, allowUnicode=True):
+ """
+ Return the number x formatted in engineering notation with SI prefix.
+
+ Example::
+ siFormat(0.0001, suffix='V') # returns "100 μV"
+ """
+
+ if space is True:
+ space = ' '
+ if space is False:
+ space = ''
+
+
+ (p, pref) = siScale(x, minVal, allowUnicode)
+ if not (len(pref) > 0 and pref[0] == 'e'):
+ pref = space + pref
+
+ if error is None:
+ fmt = "%." + str(precision) + "g%s%s"
+ return fmt % (x*p, pref, suffix)
+ else:
+ if allowUnicode:
+ plusminus = space + asUnicode("±") + space
+ else:
+ plusminus = " +/- "
+ fmt = "%." + str(precision) + "g%s%s%s%s"
+ return fmt % (x*p, pref, suffix, plusminus, siFormat(error, precision=precision, suffix=suffix, space=space, minVal=minVal))
+
+def siEval(s):
+ """
+ Convert a value written in SI notation to its equivalent prefixless value
+
+ Example::
+
+ siEval("100 μV") # returns 0.0001
+ """
+
+ s = asUnicode(s)
+ m = re.match(r'(-?((\d+(\.\d*)?)|(\.\d+))([eE]-?\d+)?)\s*([u' + SI_PREFIXES + r']?).*$', s)
+ if m is None:
+ raise Exception("Can't convert string '%s' to number." % s)
+ v = float(m.groups()[0])
+ p = m.groups()[6]
+ #if p not in SI_PREFIXES:
+ #raise Exception("Can't convert string '%s' to number--unknown prefix." % s)
+ if p == '':
+ n = 0
+ elif p == 'u':
+ n = -2
+ else:
+ n = SI_PREFIXES.index(p) - 8
+ return v * 1000**n
+
+
+class Color(QtGui.QColor):
+ def __init__(self, *args):
+ QtGui.QColor.__init__(self, mkColor(*args))
+
+ def glColor(self):
+ """Return (r,g,b,a) normalized for use in opengl"""
+ return (self.red()/255., self.green()/255., self.blue()/255., self.alpha()/255.)
+
+ def __getitem__(self, ind):
+ return (self.red, self.green, self.blue, self.alpha)[ind]()
+
+
+def mkColor(*args):
+ """
+ Convenience function for constructing QColor from a variety of argument types. Accepted arguments are:
+
+ ================ ================================================
+ 'c' one of: r, g, b, c, m, y, k, w
+ R, G, B, [A] integers 0-255
+ (R, G, B, [A]) tuple of integers 0-255
+ float greyscale, 0.0-1.0
+ int see :func:`intColor() `
+ (int, hues) see :func:`intColor() `
+ "RGB" hexadecimal strings; may begin with '#'
+ "RGBA"
+ "RRGGBB"
+ "RRGGBBAA"
+ QColor QColor instance; makes a copy.
+ ================ ================================================
+ """
+ err = 'Not sure how to make a color from "%s"' % str(args)
+ if len(args) == 1:
+ if isinstance(args[0], QtGui.QColor):
+ return QtGui.QColor(args[0])
+ elif isinstance(args[0], float):
+ r = g = b = int(args[0] * 255)
+ a = 255
+ elif isinstance(args[0], basestring):
+ c = args[0]
+ if c[0] == '#':
+ c = c[1:]
+ if len(c) == 1:
+ (r, g, b, a) = Colors[c]
+ if len(c) == 3:
+ r = int(c[0]*2, 16)
+ g = int(c[1]*2, 16)
+ b = int(c[2]*2, 16)
+ a = 255
+ elif len(c) == 4:
+ r = int(c[0]*2, 16)
+ g = int(c[1]*2, 16)
+ b = int(c[2]*2, 16)
+ a = int(c[3]*2, 16)
+ elif len(c) == 6:
+ r = int(c[0:2], 16)
+ g = int(c[2:4], 16)
+ b = int(c[4:6], 16)
+ a = 255
+ elif len(c) == 8:
+ r = int(c[0:2], 16)
+ g = int(c[2:4], 16)
+ b = int(c[4:6], 16)
+ a = int(c[6:8], 16)
+ elif hasattr(args[0], '__len__'):
+ if len(args[0]) == 3:
+ (r, g, b) = args[0]
+ a = 255
+ elif len(args[0]) == 4:
+ (r, g, b, a) = args[0]
+ elif len(args[0]) == 2:
+ return intColor(*args[0])
+ else:
+ raise Exception(err)
+ elif type(args[0]) == int:
+ return intColor(args[0])
+ else:
+ raise Exception(err)
+ elif len(args) == 3:
+ (r, g, b) = args
+ a = 255
+ elif len(args) == 4:
+ (r, g, b, a) = args
+ else:
+ raise Exception(err)
+
+ args = [r,g,b,a]
+ args = [0 if np.isnan(a) or np.isinf(a) else a for a in args]
+ args = list(map(int, args))
+ return QtGui.QColor(*args)
+
+
+def mkBrush(*args, **kwds):
+ """
+ | Convenience function for constructing Brush.
+ | This function always constructs a solid brush and accepts the same arguments as :func:`mkColor() `
+ | Calling mkBrush(None) returns an invisible brush.
+ """
+ if 'color' in kwds:
+ color = kwds['color']
+ elif len(args) == 1:
+ arg = args[0]
+ if arg is None:
+ return QtGui.QBrush(QtCore.Qt.NoBrush)
+ elif isinstance(arg, QtGui.QBrush):
+ return QtGui.QBrush(arg)
+ else:
+ color = arg
+ elif len(args) > 1:
+ color = args
+ return QtGui.QBrush(mkColor(color))
+
+def mkPen(*args, **kargs):
+ """
+ Convenience function for constructing QPen.
+
+ Examples::
+
+ mkPen(color)
+ mkPen(color, width=2)
+ mkPen(cosmetic=False, width=4.5, color='r')
+ mkPen({'color': "FF0", width: 2})
+ mkPen(None) # (no pen)
+
+ In these examples, *color* may be replaced with any arguments accepted by :func:`mkColor() ` """
+
+ color = kargs.get('color', None)
+ width = kargs.get('width', 1)
+ style = kargs.get('style', None)
+ cosmetic = kargs.get('cosmetic', True)
+ hsv = kargs.get('hsv', None)
+
+ if len(args) == 1:
+ arg = args[0]
+ if isinstance(arg, dict):
+ return mkPen(**arg)
+ if isinstance(arg, QtGui.QPen):
+ return QtGui.QPen(arg) ## return a copy of this pen
+ elif arg is None:
+ style = QtCore.Qt.NoPen
+ else:
+ color = arg
+ if len(args) > 1:
+ color = args
+
+ if color is None:
+ color = mkColor(200, 200, 200)
+ if hsv is not None:
+ color = hsvColor(*hsv)
+ else:
+ color = mkColor(color)
+
+ pen = QtGui.QPen(QtGui.QBrush(color), width)
+ pen.setCosmetic(cosmetic)
+ if style is not None:
+ pen.setStyle(style)
+ return pen
+
+def hsvColor(hue, sat=1.0, val=1.0, alpha=1.0):
+ """Generate a QColor from HSVa values. (all arguments are float 0.0-1.0)"""
+ c = QtGui.QColor()
+ c.setHsvF(hue, sat, val, alpha)
+ return c
+
+
+def colorTuple(c):
+ """Return a tuple (R,G,B,A) from a QColor"""
+ return (c.red(), c.green(), c.blue(), c.alpha())
+
+def colorStr(c):
+ """Generate a hex string code from a QColor"""
+ return ('%02x'*4) % colorTuple(c)
+
+def intColor(index, hues=9, values=1, maxValue=255, minValue=150, maxHue=360, minHue=0, sat=255, alpha=255, **kargs):
+ """
+ Creates a QColor from a single index. Useful for stepping through a predefined list of colors.
+
+ The argument *index* determines which color from the set will be returned. All other arguments determine what the set of predefined colors will be
+
+ Colors are chosen by cycling across hues while varying the value (brightness).
+ By default, this selects from a list of 9 hues."""
+ hues = int(hues)
+ values = int(values)
+ ind = int(index) % (hues * values)
+ indh = ind % hues
+ indv = ind / hues
+ if values > 1:
+ v = minValue + indv * ((maxValue-minValue) / (values-1))
+ else:
+ v = maxValue
+ h = minHue + (indh * (maxHue-minHue)) / hues
+
+ c = QtGui.QColor()
+ c.setHsv(h, sat, v)
+ c.setAlpha(alpha)
+ return c
+
+def glColor(*args, **kargs):
+ """
+ Convert a color to OpenGL color format (r,g,b,a) floats 0.0-1.0
+ Accepts same arguments as :func:`mkColor `.
+ """
+ c = mkColor(*args, **kargs)
+ return (c.red()/255., c.green()/255., c.blue()/255., c.alpha()/255.)
+
+
+
+def makeArrowPath(headLen=20, tipAngle=20, tailLen=20, tailWidth=3, baseAngle=0):
+ """
+ Construct a path outlining an arrow with the given dimensions.
+ The arrow points in the -x direction with tip positioned at 0,0.
+ If *tipAngle* is supplied (in degrees), it overrides *headWidth*.
+ If *tailLen* is None, no tail will be drawn.
+ """
+ headWidth = headLen * np.tan(tipAngle * 0.5 * np.pi/180.)
+ path = QtGui.QPainterPath()
+ path.moveTo(0,0)
+ path.lineTo(headLen, -headWidth)
+ if tailLen is None:
+ innerY = headLen - headWidth * np.tan(baseAngle*np.pi/180.)
+ path.lineTo(innerY, 0)
+ else:
+ tailWidth *= 0.5
+ innerY = headLen - (headWidth-tailWidth) * np.tan(baseAngle*np.pi/180.)
+ path.lineTo(innerY, -tailWidth)
+ path.lineTo(headLen + tailLen, -tailWidth)
+ path.lineTo(headLen + tailLen, tailWidth)
+ path.lineTo(innerY, tailWidth)
+ path.lineTo(headLen, headWidth)
+ path.lineTo(0,0)
+ return path
+
+
+
+def affineSlice(data, shape, origin, vectors, axes, order=1, returnCoords=False, **kargs):
+ """
+ Take a slice of any orientation through an array. This is useful for extracting sections of multi-dimensional arrays such as MRI images for viewing as 1D or 2D data.
+
+ The slicing axes are aribtrary; they do not need to be orthogonal to the original data or even to each other. It is possible to use this function to extract arbitrary linear, rectangular, or parallelepiped shapes from within larger datasets. The original data is interpolated onto a new array of coordinates using scipy.ndimage.map_coordinates (see the scipy documentation for more information about this).
+
+ For a graphical interface to this function, see :func:`ROI.getArrayRegion `
+
+ ============== ====================================================================================================
+ Arguments:
+ *data* (ndarray) the original dataset
+ *shape* the shape of the slice to take (Note the return value may have more dimensions than len(shape))
+ *origin* the location in the original dataset that will become the origin of the sliced data.
+ *vectors* list of unit vectors which point in the direction of the slice axes. Each vector must have the same
+ length as *axes*. If the vectors are not unit length, the result will be scaled relative to the
+ original data. If the vectors are not orthogonal, the result will be sheared relative to the
+ original data.
+ *axes* The axes in the original dataset which correspond to the slice *vectors*
+ *order* The order of spline interpolation. Default is 1 (linear). See scipy.ndimage.map_coordinates
+ for more information.
+ *returnCoords* If True, return a tuple (result, coords) where coords is the array of coordinates used to select
+ values from the original dataset.
+ *All extra keyword arguments are passed to scipy.ndimage.map_coordinates.*
+ --------------------------------------------------------------------------------------------------------------------
+ ============== ====================================================================================================
+
+ Note the following must be true:
+
+ | len(shape) == len(vectors)
+ | len(origin) == len(axes) == len(vectors[i])
+
+ Example: start with a 4D fMRI data set, take a diagonal-planar slice out of the last 3 axes
+
+ * data = array with dims (time, x, y, z) = (100, 40, 40, 40)
+ * The plane to pull out is perpendicular to the vector (x,y,z) = (1,1,1)
+ * The origin of the slice will be at (x,y,z) = (40, 0, 0)
+ * We will slice a 20x20 plane from each timepoint, giving a final shape (100, 20, 20)
+
+ The call for this example would look like::
+
+ affineSlice(data, shape=(20,20), origin=(40,0,0), vectors=((-1, 1, 0), (-1, 0, 1)), axes=(1,2,3))
+
+ """
+ if not HAVE_SCIPY:
+ raise Exception("This function requires the scipy library, but it does not appear to be importable.")
+
+ # sanity check
+ if len(shape) != len(vectors):
+ raise Exception("shape and vectors must have same length.")
+ if len(origin) != len(axes):
+ raise Exception("origin and axes must have same length.")
+ for v in vectors:
+ if len(v) != len(axes):
+ raise Exception("each vector must be same length as axes.")
+
+ shape = list(map(np.ceil, shape))
+
+ ## transpose data so slice axes come first
+ trAx = list(range(data.ndim))
+ for x in axes:
+ trAx.remove(x)
+ tr1 = tuple(axes) + tuple(trAx)
+ data = data.transpose(tr1)
+ #print "tr1:", tr1
+ ## dims are now [(slice axes), (other axes)]
+
+
+ ## make sure vectors are arrays
+ if not isinstance(vectors, np.ndarray):
+ vectors = np.array(vectors)
+ if not isinstance(origin, np.ndarray):
+ origin = np.array(origin)
+ origin.shape = (len(axes),) + (1,)*len(shape)
+
+ ## Build array of sample locations.
+ grid = np.mgrid[tuple([slice(0,x) for x in shape])] ## mesh grid of indexes
+ #print shape, grid.shape
+ x = (grid[np.newaxis,...] * vectors.transpose()[(Ellipsis,) + (np.newaxis,)*len(shape)]).sum(axis=1) ## magic
+ x += origin
+ #print "X values:"
+ #print x
+ ## iterate manually over unused axes since map_coordinates won't do it for us
+ extraShape = data.shape[len(axes):]
+ output = np.empty(tuple(shape) + extraShape, dtype=data.dtype)
+ for inds in np.ndindex(*extraShape):
+ ind = (Ellipsis,) + inds
+ #print data[ind].shape, x.shape, output[ind].shape, output.shape
+ output[ind] = scipy.ndimage.map_coordinates(data[ind], x, order=order, **kargs)
+
+ tr = list(range(output.ndim))
+ trb = []
+ for i in range(min(axes)):
+ ind = tr1.index(i) + (len(shape)-len(axes))
+ tr.remove(ind)
+ trb.append(ind)
+ tr2 = tuple(trb+tr)
+
+ ## Untranspose array before returning
+ output = output.transpose(tr2)
+ if returnCoords:
+ return (output, x)
+ else:
+ return output
+
+def transformToArray(tr):
+ """
+ Given a QTransform, return a 3x3 numpy array.
+ Given a QMatrix4x4, return a 4x4 numpy array.
+
+ Example: map an array of x,y coordinates through a transform::
+
+ ## coordinates to map are (1,5), (2,6), (3,7), and (4,8)
+ coords = np.array([[1,2,3,4], [5,6,7,8], [1,1,1,1]]) # the extra '1' coordinate is needed for translation to work
+
+ ## Make an example transform
+ tr = QtGui.QTransform()
+ tr.translate(3,4)
+ tr.scale(2, 0.1)
+
+ ## convert to array
+ m = pg.transformToArray()[:2] # ignore the perspective portion of the transformation
+
+ ## map coordinates through transform
+ mapped = np.dot(m, coords)
+ """
+ #return np.array([[tr.m11(), tr.m12(), tr.m13()],[tr.m21(), tr.m22(), tr.m23()],[tr.m31(), tr.m32(), tr.m33()]])
+ ## The order of elements given by the method names m11..m33 is misleading--
+ ## It is most common for x,y translation to occupy the positions 1,3 and 2,3 in
+ ## a transformation matrix. However, with QTransform these values appear at m31 and m32.
+ ## So the correct interpretation is transposed:
+ if isinstance(tr, QtGui.QTransform):
+ return np.array([[tr.m11(), tr.m21(), tr.m31()], [tr.m12(), tr.m22(), tr.m32()], [tr.m13(), tr.m23(), tr.m33()]])
+ elif isinstance(tr, QtGui.QMatrix4x4):
+ return np.array(tr.copyDataTo()).reshape(4,4)
+ else:
+ raise Exception("Transform argument must be either QTransform or QMatrix4x4.")
+
+def transformCoordinates(tr, coords, transpose=False):
+ """
+ Map a set of 2D or 3D coordinates through a QTransform or QMatrix4x4.
+ The shape of coords must be (2,...) or (3,...)
+ The mapping will _ignore_ any perspective transformations.
+
+ For coordinate arrays with ndim=2, this is basically equivalent to matrix multiplication.
+ Most arrays, however, prefer to put the coordinate axis at the end (eg. shape=(...,3)). To
+ allow this, use transpose=True.
+
+ """
+
+ if transpose:
+ ## move last axis to beginning. This transposition will be reversed before returning the mapped coordinates.
+ coords = coords.transpose((coords.ndim-1,) + tuple(range(0,coords.ndim-1)))
+
+ nd = coords.shape[0]
+ if isinstance(tr, np.ndarray):
+ m = tr
+ else:
+ m = transformToArray(tr)
+ m = m[:m.shape[0]-1] # remove perspective
+
+ ## If coords are 3D and tr is 2D, assume no change for Z axis
+ if m.shape == (2,3) and nd == 3:
+ m2 = np.zeros((3,4))
+ m2[:2, :2] = m[:2,:2]
+ m2[:2, 3] = m[:2,2]
+ m2[2,2] = 1
+ m = m2
+
+ ## if coords are 2D and tr is 3D, ignore Z axis
+ if m.shape == (3,4) and nd == 2:
+ m2 = np.empty((2,3))
+ m2[:,:2] = m[:2,:2]
+ m2[:,2] = m[:2,3]
+ m = m2
+
+ ## reshape tr and coords to prepare for multiplication
+ m = m.reshape(m.shape + (1,)*(coords.ndim-1))
+ coords = coords[np.newaxis, ...]
+
+ # separate scale/rotate and translation
+ translate = m[:,-1]
+ m = m[:, :-1]
+
+ ## map coordinates and return
+ mapped = (m*coords).sum(axis=1) ## apply scale/rotate
+ mapped += translate
+
+ if transpose:
+ ## move first axis to end.
+ mapped = mapped.transpose(tuple(range(1,mapped.ndim)) + (0,))
+ return mapped
+
+
+
+
+def solve3DTransform(points1, points2):
+ """
+ Find a 3D transformation matrix that maps points1 onto points2
+ points must be specified as a list of 4 Vectors.
+ """
+ if not HAVE_SCIPY:
+ raise Exception("This function depends on the scipy library, but it does not appear to be importable.")
+ A = np.array([[points1[i].x(), points1[i].y(), points1[i].z(), 1] for i in range(4)])
+ B = np.array([[points2[i].x(), points2[i].y(), points2[i].z(), 1] for i in range(4)])
+
+ ## solve 3 sets of linear equations to determine transformation matrix elements
+ matrix = np.zeros((4,4))
+ for i in range(3):
+ matrix[i] = scipy.linalg.solve(A, B[:,i]) ## solve Ax = B; x is one row of the desired transformation matrix
+
+ return matrix
+
+def solveBilinearTransform(points1, points2):
+ """
+ Find a bilinear transformation matrix (2x4) that maps points1 onto points2
+ points must be specified as a list of 4 Vector, Point, QPointF, etc.
+
+ To use this matrix to map a point [x,y]::
+
+ mapped = np.dot(matrix, [x*y, x, y, 1])
+ """
+ if not HAVE_SCIPY:
+ raise Exception("This function depends on the scipy library, but it does not appear to be importable.")
+ ## A is 4 rows (points) x 4 columns (xy, x, y, 1)
+ ## B is 4 rows (points) x 2 columns (x, y)
+ A = np.array([[points1[i].x()*points1[i].y(), points1[i].x(), points1[i].y(), 1] for i in range(4)])
+ B = np.array([[points2[i].x(), points2[i].y()] for i in range(4)])
+
+ ## solve 2 sets of linear equations to determine transformation matrix elements
+ matrix = np.zeros((2,4))
+ for i in range(2):
+ matrix[i] = scipy.linalg.solve(A, B[:,i]) ## solve Ax = B; x is one row of the desired transformation matrix
+
+ return matrix
+
+def rescaleData(data, scale, offset, dtype=None):
+ """Return data rescaled and optionally cast to a new dtype::
+
+ data => (data-offset) * scale
+
+ Uses scipy.weave (if available) to improve performance.
+ """
+ global USE_WEAVE
+ if dtype is None:
+ dtype = data.dtype
+
+ try:
+ if not USE_WEAVE:
+ raise Exception('Weave is disabled; falling back to slower version.')
+
+ newData = np.empty((data.size,), dtype=dtype)
+ flat = np.ascontiguousarray(data).reshape(data.size)
+ size = data.size
+
+ code = """
+ double sc = (double)scale;
+ double off = (double)offset;
+ for( int i=0; i0 and max->*scale*::
+
+ rescaled = (clip(data, min, max) - min) * (*scale* / (max - min))
+
+ It is also possible to use a 2D (N,2) array of values for levels. In this case,
+ it is assumed that each pair of min,max values in the levels array should be
+ applied to a different subset of the input data (for example, the input data may
+ already have RGB values and the levels are used to independently scale each
+ channel). The use of this feature requires that levels.shape[0] == data.shape[-1].
+ scale The maximum value to which data will be rescaled before being passed through the
+ lookup table (or returned if there is no lookup table). By default this will
+ be set to the length of the lookup table, or 256 is no lookup table is provided.
+ For OpenGL color specifications (as in GLColor4f) use scale=1.0
+ lut Optional lookup table (array with dtype=ubyte).
+ Values in data will be converted to color by indexing directly from lut.
+ The output data shape will be input.shape + lut.shape[1:].
+
+ Note: the output of makeARGB will have the same dtype as the lookup table, so
+ for conversion to QImage, the dtype must be ubyte.
+
+ Lookup tables can be built using GradientWidget.
+ useRGBA If True, the data is returned in RGBA order (useful for building OpenGL textures).
+ The default is False, which returns in ARGB order for use with QImage
+ (Note that 'ARGB' is a term used by the Qt documentation; the _actual_ order
+ is BGRA).
+ ============ ==================================================================================
+ """
+ prof = debug.Profiler('functions.makeARGB', disabled=True)
+
+ if lut is not None and not isinstance(lut, np.ndarray):
+ lut = np.array(lut)
+ if levels is not None and not isinstance(levels, np.ndarray):
+ levels = np.array(levels)
+
+ ## sanity checks
+ #if data.ndim == 3:
+ #if data.shape[2] not in (3,4):
+ #raise Exception("data.shape[2] must be 3 or 4")
+ ##if lut is not None:
+ ##raise Exception("can not use lookup table with 3D data")
+ #elif data.ndim != 2:
+ #raise Exception("data must be 2D or 3D")
+
+ #if lut is not None:
+ ##if lut.ndim == 2:
+ ##if lut.shape[1] :
+ ##raise Exception("lut.shape[1] must be 3 or 4")
+ ##elif lut.ndim != 1:
+ ##raise Exception("lut must be 1D or 2D")
+ #if lut.dtype != np.ubyte:
+ #raise Exception('lookup table must have dtype=ubyte (got %s instead)' % str(lut.dtype))
+
+
+ if levels is not None:
+ if levels.ndim == 1:
+ if len(levels) != 2:
+ raise Exception('levels argument must have length 2')
+ elif levels.ndim == 2:
+ if lut is not None and lut.ndim > 1:
+ raise Exception('Cannot make ARGB data when bot levels and lut have ndim > 2')
+ if levels.shape != (data.shape[-1], 2):
+ raise Exception('levels must have shape (data.shape[-1], 2)')
+ else:
+ print levels
+ raise Exception("levels argument must be 1D or 2D.")
+ #levels = np.array(levels)
+ #if levels.shape == (2,):
+ #pass
+ #elif levels.shape in [(3,2), (4,2)]:
+ #if data.ndim == 3:
+ #raise Exception("Can not use 2D levels with 3D data.")
+ #if lut is not None:
+ #raise Exception('Can not use 2D levels and lookup table together.')
+ #else:
+ #raise Exception("Levels must have shape (2,) or (3,2) or (4,2)")
+
+ prof.mark('1')
+
+ if scale is None:
+ if lut is not None:
+ scale = lut.shape[0]
+ else:
+ scale = 255.
+
+ ## Apply levels if given
+ if levels is not None:
+
+ if isinstance(levels, np.ndarray) and levels.ndim == 2:
+ ## we are going to rescale each channel independently
+ if levels.shape[0] != data.shape[-1]:
+ raise Exception("When rescaling multi-channel data, there must be the same number of levels as channels (data.shape[-1] == levels.shape[0])")
+ newData = np.empty(data.shape, dtype=int)
+ for i in range(data.shape[-1]):
+ minVal, maxVal = levels[i]
+ if minVal == maxVal:
+ maxVal += 1e-16
+ newData[...,i] = rescaleData(data[...,i], scale/(maxVal-minVal), minVal, dtype=int)
+ data = newData
+ else:
+ minVal, maxVal = levels
+ if minVal == maxVal:
+ maxVal += 1e-16
+ data = rescaleData(data, scale/(maxVal-minVal), minVal, dtype=int)
+
+ prof.mark('2')
+
+
+ ## apply LUT if given
+ if lut is not None:
+ data = applyLookupTable(data, lut)
+ else:
+ if data.dtype is not np.ubyte:
+ data = np.clip(data, 0, 255).astype(np.ubyte)
+
+ prof.mark('3')
+
+
+ ## copy data into ARGB ordered array
+ imgData = np.empty(data.shape[:2]+(4,), dtype=np.ubyte)
+ if data.ndim == 2:
+ data = data[..., np.newaxis]
+
+ prof.mark('4')
+
+ if useRGBA:
+ order = [0,1,2,3] ## array comes out RGBA
+ else:
+ order = [2,1,0,3] ## for some reason, the colors line up as BGR in the final image.
+
+ if data.shape[2] == 1:
+ for i in range(3):
+ imgData[..., order[i]] = data[..., 0]
+ else:
+ for i in range(0, data.shape[2]):
+ imgData[..., order[i]] = data[..., i]
+
+ prof.mark('5')
+
+ if data.shape[2] == 4:
+ alpha = True
+ else:
+ alpha = False
+ imgData[..., 3] = 255
+
+ prof.mark('6')
+
+ prof.finish()
+ return imgData, alpha
+
+
+def makeQImage(imgData, alpha=None, copy=True, transpose=True):
+ """
+ Turn an ARGB array into QImage.
+ By default, the data is copied; changes to the array will not
+ be reflected in the image. The image will be given a 'data' attribute
+ pointing to the array which shares its data to prevent python
+ freeing that memory while the image is in use.
+
+ =========== ===================================================================
+ Arguments:
+ imgData Array of data to convert. Must have shape (width, height, 3 or 4)
+ and dtype=ubyte. The order of values in the 3rd axis must be
+ (b, g, r, a).
+ alpha If True, the QImage returned will have format ARGB32. If False,
+ the format will be RGB32. By default, _alpha_ is True if
+ array.shape[2] == 4.
+ copy If True, the data is copied before converting to QImage.
+ If False, the new QImage points directly to the data in the array.
+ Note that the array must be contiguous for this to work.
+ transpose If True (the default), the array x/y axes are transposed before
+ creating the image. Note that Qt expects the axes to be in
+ (height, width) order whereas pyqtgraph usually prefers the
+ opposite.
+ =========== ===================================================================
+ """
+ ## create QImage from buffer
+ prof = debug.Profiler('functions.makeQImage', disabled=True)
+
+ ## If we didn't explicitly specify alpha, check the array shape.
+ if alpha is None:
+ alpha = (imgData.shape[2] == 4)
+
+ copied = False
+ if imgData.shape[2] == 3: ## need to make alpha channel (even if alpha==False; QImage requires 32 bpp)
+ if copy is True:
+ d2 = np.empty(imgData.shape[:2] + (4,), dtype=imgData.dtype)
+ d2[:,:,:3] = imgData
+ d2[:,:,3] = 255
+ imgData = d2
+ copied = True
+ else:
+ raise Exception('Array has only 3 channels; cannot make QImage without copying.')
+
+ if alpha:
+ imgFormat = QtGui.QImage.Format_ARGB32
+ else:
+ imgFormat = QtGui.QImage.Format_RGB32
+
+ if transpose:
+ imgData = imgData.transpose((1, 0, 2)) ## QImage expects the row/column order to be opposite
+
+ if not imgData.flags['C_CONTIGUOUS']:
+ if copy is False:
+ extra = ' (try setting transpose=False)' if transpose else ''
+ raise Exception('Array is not contiguous; cannot make QImage without copying.'+extra)
+ imgData = np.ascontiguousarray(imgData)
+ copied = True
+
+ if copy is True and copied is False:
+ imgData = imgData.copy()
+
+ if USE_PYSIDE:
+ ch = ctypes.c_char.from_buffer(imgData, 0)
+ img = QtGui.QImage(ch, imgData.shape[1], imgData.shape[0], imgFormat)
+ else:
+ addr = ctypes.addressof(ctypes.c_char.from_buffer(imgData, 0))
+ img = QtGui.QImage(addr, imgData.shape[1], imgData.shape[0], imgFormat)
+ img.data = imgData
+ return img
+ #try:
+ #buf = imgData.data
+ #except AttributeError: ## happens when image data is non-contiguous
+ #buf = imgData.data
+
+ #prof.mark('1')
+ #qimage = QtGui.QImage(buf, imgData.shape[1], imgData.shape[0], imgFormat)
+ #prof.mark('2')
+ #qimage.data = imgData
+ #prof.finish()
+ #return qimage
+
+def imageToArray(img, copy=False, transpose=True):
+ """
+ Convert a QImage into numpy array. The image must have format RGB32, ARGB32, or ARGB32_Premultiplied.
+ By default, the image is not copied; changes made to the array will appear in the QImage as well (beware: if
+ the QImage is collected before the array, there may be trouble).
+ The array will have shape (width, height, (b,g,r,a)).
+ """
+ fmt = img.format()
+ ptr = img.bits()
+ if USE_PYSIDE:
+ arr = np.frombuffer(ptr, dtype=np.ubyte)
+ else:
+ ptr.setsize(img.byteCount())
+ arr = np.asarray(ptr)
+
+ if fmt == img.Format_RGB32:
+ arr = arr.reshape(img.height(), img.width(), 3)
+ elif fmt == img.Format_ARGB32 or fmt == img.Format_ARGB32_Premultiplied:
+ arr = arr.reshape(img.height(), img.width(), 4)
+
+ if copy:
+ arr = arr.copy()
+
+ if transpose:
+ return arr.transpose((1,0,2))
+ else:
+ return arr
+
+def colorToAlpha(data, color):
+ """
+ Given an RGBA image in *data*, convert *color* to be transparent.
+ *data* must be an array (w, h, 3 or 4) of ubyte values and *color* must be
+ an array (3) of ubyte values.
+ This is particularly useful for use with images that have a black or white background.
+
+ Algorithm is taken from Gimp's color-to-alpha function in plug-ins/common/colortoalpha.c
+ Credit:
+ /*
+ * Color To Alpha plug-in v1.0 by Seth Burgess, sjburges@gimp.org 1999/05/14
+ * with algorithm by clahey
+ */
+
+ """
+ data = data.astype(float)
+ if data.shape[-1] == 3: ## add alpha channel if needed
+ d2 = np.empty(data.shape[:2]+(4,), dtype=data.dtype)
+ d2[...,:3] = data
+ d2[...,3] = 255
+ data = d2
+
+ color = color.astype(float)
+ alpha = np.zeros(data.shape[:2]+(3,), dtype=float)
+ output = data.copy()
+
+ for i in [0,1,2]:
+ d = data[...,i]
+ c = color[i]
+ mask = d > c
+ alpha[...,i][mask] = (d[mask] - c) / (255. - c)
+ imask = d < c
+ alpha[...,i][imask] = (c - d[imask]) / c
+
+ output[...,3] = alpha.max(axis=2) * 255.
+
+ mask = output[...,3] >= 1.0 ## avoid zero division while processing alpha channel
+ correction = 255. / output[...,3][mask] ## increase value to compensate for decreased alpha
+ for i in [0,1,2]:
+ output[...,i][mask] = ((output[...,i][mask]-color[i]) * correction) + color[i]
+ output[...,3][mask] *= data[...,3][mask] / 255. ## combine computed and previous alpha values
+
+ #raise Exception()
+ return np.clip(output, 0, 255).astype(np.ubyte)
+
+
+
+#def isosurface(data, level):
+ #"""
+ #Generate isosurface from volumetric data using marching tetrahedra algorithm.
+ #See Paul Bourke, "Polygonising a Scalar Field Using Tetrahedrons" (http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/)
+
+ #*data* 3D numpy array of scalar values
+ #*level* The level at which to generate an isosurface
+ #"""
+
+ #facets = []
+
+ ### mark everything below the isosurface level
+ #mask = data < level
+
+ #### make eight sub-fields
+ #fields = np.empty((2,2,2), dtype=object)
+ #slices = [slice(0,-1), slice(1,None)]
+ #for i in [0,1]:
+ #for j in [0,1]:
+ #for k in [0,1]:
+ #fields[i,j,k] = mask[slices[i], slices[j], slices[k]]
+
+
+
+ ### split each cell into 6 tetrahedra
+ ### these all have the same 'orienation'; points 1,2,3 circle
+ ### clockwise around point 0
+ #tetrahedra = [
+ #[(0,1,0), (1,1,1), (0,1,1), (1,0,1)],
+ #[(0,1,0), (0,1,1), (0,0,1), (1,0,1)],
+ #[(0,1,0), (0,0,1), (0,0,0), (1,0,1)],
+ #[(0,1,0), (0,0,0), (1,0,0), (1,0,1)],
+ #[(0,1,0), (1,0,0), (1,1,0), (1,0,1)],
+ #[(0,1,0), (1,1,0), (1,1,1), (1,0,1)]
+ #]
+
+ ### each tetrahedron will be assigned an index
+ ### which determines how to generate its facets.
+ ### this structure is:
+ ### facets[index][facet1, facet2, ...]
+ ### where each facet is triangular and its points are each
+ ### interpolated between two points on the tetrahedron
+ ### facet = [(p1a, p1b), (p2a, p2b), (p3a, p3b)]
+ ### facet points always circle clockwise if you are looking
+ ### at them from below the isosurface.
+ #indexFacets = [
+ #[], ## all above
+ #[[(0,1), (0,2), (0,3)]], # 0 below
+ #[[(1,0), (1,3), (1,2)]], # 1 below
+ #[[(0,2), (1,3), (1,2)], [(0,2), (0,3), (1,3)]], # 0,1 below
+ #[[(2,0), (2,1), (2,3)]], # 2 below
+ #[[(0,3), (1,2), (2,3)], [(0,3), (0,1), (1,2)]], # 0,2 below
+ #[[(1,0), (2,3), (2,0)], [(1,0), (1,3), (2,3)]], # 1,2 below
+ #[[(3,0), (3,1), (3,2)]], # 3 above
+ #[[(3,0), (3,2), (3,1)]], # 3 below
+ #[[(1,0), (2,0), (2,3)], [(1,0), (2,3), (1,3)]], # 0,3 below
+ #[[(0,3), (2,3), (1,2)], [(0,3), (1,2), (0,1)]], # 1,3 below
+ #[[(2,0), (2,3), (2,1)]], # 0,1,3 below
+ #[[(0,2), (1,2), (1,3)], [(0,2), (1,3), (0,3)]], # 2,3 below
+ #[[(1,0), (1,2), (1,3)]], # 0,2,3 below
+ #[[(0,1), (0,3), (0,2)]], # 1,2,3 below
+ #[] ## all below
+ #]
+
+ #for tet in tetrahedra:
+
+ ### get the 4 fields for this tetrahedron
+ #tetFields = [fields[c] for c in tet]
+
+ ### generate an index for each grid cell
+ #index = tetFields[0] + tetFields[1]*2 + tetFields[2]*4 + tetFields[3]*8
+
+ ### add facets
+ #for i in xrange(index.shape[0]): # data x-axis
+ #for j in xrange(index.shape[1]): # data y-axis
+ #for k in xrange(index.shape[2]): # data z-axis
+ #for f in indexFacets[index[i,j,k]]: # faces to generate for this tet
+ #pts = []
+ #for l in [0,1,2]: # points in this face
+ #p1 = tet[f[l][0]] # tet corner 1
+ #p2 = tet[f[l][1]] # tet corner 2
+ #pts.append([(p1[x]+p2[x])*0.5+[i,j,k][x]+0.5 for x in [0,1,2]]) ## interpolate between tet corners
+ #facets.append(pts)
+
+ #return facets
+
+
+def isocurve(data, level, connected=False, extendToEdge=False, path=False):
+ """
+ Generate isocurve from 2D data using marching squares algorithm.
+
+ ============= =========================================================
+ Arguments
+ data 2D numpy array of scalar values
+ level The level at which to generate an isosurface
+ connected If False, return a single long list of point pairs
+ If True, return multiple long lists of connected point
+ locations. (This is slower but better for drawing
+ continuous lines)
+ extendToEdge If True, extend the curves to reach the exact edges of
+ the data.
+ path if True, return a QPainterPath rather than a list of
+ vertex coordinates. This forces connected=True.
+ ============= =========================================================
+
+ This function is SLOW; plenty of room for optimization here.
+ """
+
+ if path is True:
+ connected = True
+
+ if extendToEdge:
+ d2 = np.empty((data.shape[0]+2, data.shape[1]+2), dtype=data.dtype)
+ d2[1:-1, 1:-1] = data
+ d2[0, 1:-1] = data[0]
+ d2[-1, 1:-1] = data[-1]
+ d2[1:-1, 0] = data[:, 0]
+ d2[1:-1, -1] = data[:, -1]
+ d2[0,0] = d2[0,1]
+ d2[0,-1] = d2[1,-1]
+ d2[-1,0] = d2[-1,1]
+ d2[-1,-1] = d2[-1,-2]
+ data = d2
+
+ sideTable = [
+ [],
+ [0,1],
+ [1,2],
+ [0,2],
+ [0,3],
+ [1,3],
+ [0,1,2,3],
+ [2,3],
+ [2,3],
+ [0,1,2,3],
+ [1,3],
+ [0,3],
+ [0,2],
+ [1,2],
+ [0,1],
+ []
+ ]
+
+ edgeKey=[
+ [(0,1), (0,0)],
+ [(0,0), (1,0)],
+ [(1,0), (1,1)],
+ [(1,1), (0,1)]
+ ]
+
+
+ lines = []
+
+ ## mark everything below the isosurface level
+ mask = data < level
+
+ ### make four sub-fields and compute indexes for grid cells
+ index = np.zeros([x-1 for x in data.shape], dtype=np.ubyte)
+ fields = np.empty((2,2), dtype=object)
+ slices = [slice(0,-1), slice(1,None)]
+ for i in [0,1]:
+ for j in [0,1]:
+ fields[i,j] = mask[slices[i], slices[j]]
+ #vertIndex = i - 2*j*i + 3*j + 4*k ## this is just to match Bourk's vertex numbering scheme
+ vertIndex = i+2*j
+ #print i,j,k," : ", fields[i,j,k], 2**vertIndex
+ index += fields[i,j] * 2**vertIndex
+ #print index
+ #print index
+
+ ## add lines
+ for i in range(index.shape[0]): # data x-axis
+ for j in range(index.shape[1]): # data y-axis
+ sides = sideTable[index[i,j]]
+ for l in range(0, len(sides), 2): ## faces for this grid cell
+ edges = sides[l:l+2]
+ pts = []
+ for m in [0,1]: # points in this face
+ p1 = edgeKey[edges[m]][0] # p1, p2 are points at either side of an edge
+ p2 = edgeKey[edges[m]][1]
+ v1 = data[i+p1[0], j+p1[1]] # v1 and v2 are the values at p1 and p2
+ v2 = data[i+p2[0], j+p2[1]]
+ f = (level-v1) / (v2-v1)
+ fi = 1.0 - f
+ p = ( ## interpolate between corners
+ p1[0]*fi + p2[0]*f + i + 0.5,
+ p1[1]*fi + p2[1]*f + j + 0.5
+ )
+ if extendToEdge:
+ ## check bounds
+ p = (
+ min(data.shape[0]-2, max(0, p[0]-1)),
+ min(data.shape[1]-2, max(0, p[1]-1)),
+ )
+ if connected:
+ gridKey = i + (1 if edges[m]==2 else 0), j + (1 if edges[m]==3 else 0), edges[m]%2
+ pts.append((p, gridKey)) ## give the actual position and a key identifying the grid location (for connecting segments)
+ else:
+ pts.append(p)
+
+ lines.append(pts)
+
+ if not connected:
+ return lines
+
+ ## turn disjoint list of segments into continuous lines
+
+ #lines = [[2,5], [5,4], [3,4], [1,3], [6,7], [7,8], [8,6], [11,12], [12,15], [11,13], [13,14]]
+ #lines = [[(float(a), a), (float(b), b)] for a,b in lines]
+ points = {} ## maps each point to its connections
+ for a,b in lines:
+ if a[1] not in points:
+ points[a[1]] = []
+ points[a[1]].append([a,b])
+ if b[1] not in points:
+ points[b[1]] = []
+ points[b[1]].append([b,a])
+
+ ## rearrange into chains
+ for k in points.keys():
+ try:
+ chains = points[k]
+ except KeyError: ## already used this point elsewhere
+ continue
+ #print "===========", k
+ for chain in chains:
+ #print " chain:", chain
+ x = None
+ while True:
+ if x == chain[-1][1]:
+ break ## nothing left to do on this chain
+
+ x = chain[-1][1]
+ if x == k:
+ break ## chain has looped; we're done and can ignore the opposite chain
+ y = chain[-2][1]
+ connects = points[x]
+ for conn in connects[:]:
+ if conn[1][1] != y:
+ #print " ext:", conn
+ chain.extend(conn[1:])
+ #print " del:", x
+ del points[x]
+ if chain[0][1] == chain[-1][1]: # looped chain; no need to continue the other direction
+ chains.pop()
+ break
+
+
+ ## extract point locations
+ lines = []
+ for chain in points.values():
+ if len(chain) == 2:
+ chain = chain[1][1:][::-1] + chain[0] # join together ends of chain
+ else:
+ chain = chain[0]
+ lines.append([p[0] for p in chain])
+
+ if not path:
+ return lines ## a list of pairs of points
+
+ path = QtGui.QPainterPath()
+ for line in lines:
+ path.moveTo(*line[0])
+ for p in line[1:]:
+ path.lineTo(*p)
+
+ return path
+
+
+def traceImage(image, values, smooth=0.5):
+ """
+ Convert an image to a set of QPainterPath curves.
+ One curve will be generated for each item in *values*; each curve outlines the area
+ of the image that is closer to its value than to any others.
+
+ If image is RGB or RGBA, then the shape of values should be (nvals, 3/4)
+ The parameter *smooth* is expressed in pixels.
+ """
+ import scipy.ndimage as ndi
+ if values.ndim == 2:
+ values = values.T
+ values = values[np.newaxis, np.newaxis, ...].astype(float)
+ image = image[..., np.newaxis].astype(float)
+ diff = np.abs(image-values)
+ if values.ndim == 4:
+ diff = diff.sum(axis=2)
+
+ labels = np.argmin(diff, axis=2)
+
+ paths = []
+ for i in range(diff.shape[-1]):
+ d = (labels==i).astype(float)
+ d = ndi.gaussian_filter(d, (smooth, smooth))
+ lines = isocurve(d, 0.5, connected=True, extendToEdge=True)
+ path = QtGui.QPainterPath()
+ for line in lines:
+ path.moveTo(*line[0])
+ for p in line[1:]:
+ path.lineTo(*p)
+
+ paths.append(path)
+ return paths
+
+
+
+IsosurfaceDataCache = None
+def isosurface(data, level):
+ """
+ Generate isosurface from volumetric data using marching cubes algorithm.
+ See Paul Bourke, "Polygonising a Scalar Field"
+ (http://paulbourke.net/geometry/polygonise/)
+
+ *data* 3D numpy array of scalar values
+ *level* The level at which to generate an isosurface
+
+ Returns an array of vertex coordinates (Nv, 3) and an array of
+ per-face vertex indexes (Nf, 3)
+ """
+ ## For improvement, see:
+ ##
+ ## Efficient implementation of Marching Cubes' cases with topological guarantees.
+ ## Thomas Lewiner, Helio Lopes, Antonio Wilson Vieira and Geovan Tavares.
+ ## Journal of Graphics Tools 8(2): pp. 1-15 (december 2003)
+
+ ## Precompute lookup tables on the first run
+ global IsosurfaceDataCache
+ if IsosurfaceDataCache is None:
+ ## map from grid cell index to edge index.
+ ## grid cell index tells us which corners are below the isosurface,
+ ## edge index tells us which edges are cut by the isosurface.
+ ## (Data stolen from Bourk; see above.)
+ edgeTable = np.array([
+ 0x0 , 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c,
+ 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
+ 0x190, 0x99 , 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c,
+ 0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
+ 0x230, 0x339, 0x33 , 0x13a, 0x636, 0x73f, 0x435, 0x53c,
+ 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
+ 0x3a0, 0x2a9, 0x1a3, 0xaa , 0x7a6, 0x6af, 0x5a5, 0x4ac,
+ 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
+ 0x460, 0x569, 0x663, 0x76a, 0x66 , 0x16f, 0x265, 0x36c,
+ 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
+ 0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff , 0x3f5, 0x2fc,
+ 0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
+ 0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55 , 0x15c,
+ 0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
+ 0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc ,
+ 0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
+ 0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc,
+ 0xcc , 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
+ 0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c,
+ 0x15c, 0x55 , 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
+ 0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc,
+ 0x2fc, 0x3f5, 0xff , 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
+ 0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c,
+ 0x36c, 0x265, 0x16f, 0x66 , 0x76a, 0x663, 0x569, 0x460,
+ 0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac,
+ 0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa , 0x1a3, 0x2a9, 0x3a0,
+ 0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c,
+ 0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33 , 0x339, 0x230,
+ 0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c,
+ 0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99 , 0x190,
+ 0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c,
+ 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0 ], dtype=np.uint16)
+
+ ## Table of triangles to use for filling each grid cell.
+ ## Each set of three integers tells us which three edges to
+ ## draw a triangle between.
+ ## (Data stolen from Bourk; see above.)
+ triTable = [
+ [],
+ [0, 8, 3],
+ [0, 1, 9],
+ [1, 8, 3, 9, 8, 1],
+ [1, 2, 10],
+ [0, 8, 3, 1, 2, 10],
+ [9, 2, 10, 0, 2, 9],
+ [2, 8, 3, 2, 10, 8, 10, 9, 8],
+ [3, 11, 2],
+ [0, 11, 2, 8, 11, 0],
+ [1, 9, 0, 2, 3, 11],
+ [1, 11, 2, 1, 9, 11, 9, 8, 11],
+ [3, 10, 1, 11, 10, 3],
+ [0, 10, 1, 0, 8, 10, 8, 11, 10],
+ [3, 9, 0, 3, 11, 9, 11, 10, 9],
+ [9, 8, 10, 10, 8, 11],
+ [4, 7, 8],
+ [4, 3, 0, 7, 3, 4],
+ [0, 1, 9, 8, 4, 7],
+ [4, 1, 9, 4, 7, 1, 7, 3, 1],
+ [1, 2, 10, 8, 4, 7],
+ [3, 4, 7, 3, 0, 4, 1, 2, 10],
+ [9, 2, 10, 9, 0, 2, 8, 4, 7],
+ [2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4],
+ [8, 4, 7, 3, 11, 2],
+ [11, 4, 7, 11, 2, 4, 2, 0, 4],
+ [9, 0, 1, 8, 4, 7, 2, 3, 11],
+ [4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1],
+ [3, 10, 1, 3, 11, 10, 7, 8, 4],
+ [1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4],
+ [4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3],
+ [4, 7, 11, 4, 11, 9, 9, 11, 10],
+ [9, 5, 4],
+ [9, 5, 4, 0, 8, 3],
+ [0, 5, 4, 1, 5, 0],
+ [8, 5, 4, 8, 3, 5, 3, 1, 5],
+ [1, 2, 10, 9, 5, 4],
+ [3, 0, 8, 1, 2, 10, 4, 9, 5],
+ [5, 2, 10, 5, 4, 2, 4, 0, 2],
+ [2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8],
+ [9, 5, 4, 2, 3, 11],
+ [0, 11, 2, 0, 8, 11, 4, 9, 5],
+ [0, 5, 4, 0, 1, 5, 2, 3, 11],
+ [2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5],
+ [10, 3, 11, 10, 1, 3, 9, 5, 4],
+ [4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10],
+ [5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3],
+ [5, 4, 8, 5, 8, 10, 10, 8, 11],
+ [9, 7, 8, 5, 7, 9],
+ [9, 3, 0, 9, 5, 3, 5, 7, 3],
+ [0, 7, 8, 0, 1, 7, 1, 5, 7],
+ [1, 5, 3, 3, 5, 7],
+ [9, 7, 8, 9, 5, 7, 10, 1, 2],
+ [10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3],
+ [8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2],
+ [2, 10, 5, 2, 5, 3, 3, 5, 7],
+ [7, 9, 5, 7, 8, 9, 3, 11, 2],
+ [9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11],
+ [2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7],
+ [11, 2, 1, 11, 1, 7, 7, 1, 5],
+ [9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11],
+ [5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0],
+ [11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0],
+ [11, 10, 5, 7, 11, 5],
+ [10, 6, 5],
+ [0, 8, 3, 5, 10, 6],
+ [9, 0, 1, 5, 10, 6],
+ [1, 8, 3, 1, 9, 8, 5, 10, 6],
+ [1, 6, 5, 2, 6, 1],
+ [1, 6, 5, 1, 2, 6, 3, 0, 8],
+ [9, 6, 5, 9, 0, 6, 0, 2, 6],
+ [5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8],
+ [2, 3, 11, 10, 6, 5],
+ [11, 0, 8, 11, 2, 0, 10, 6, 5],
+ [0, 1, 9, 2, 3, 11, 5, 10, 6],
+ [5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11],
+ [6, 3, 11, 6, 5, 3, 5, 1, 3],
+ [0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6],
+ [3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9],
+ [6, 5, 9, 6, 9, 11, 11, 9, 8],
+ [5, 10, 6, 4, 7, 8],
+ [4, 3, 0, 4, 7, 3, 6, 5, 10],
+ [1, 9, 0, 5, 10, 6, 8, 4, 7],
+ [10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4],
+ [6, 1, 2, 6, 5, 1, 4, 7, 8],
+ [1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7],
+ [8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6],
+ [7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9],
+ [3, 11, 2, 7, 8, 4, 10, 6, 5],
+ [5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11],
+ [0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6],
+ [9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6],
+ [8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6],
+ [5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11],
+ [0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7],
+ [6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9],
+ [10, 4, 9, 6, 4, 10],
+ [4, 10, 6, 4, 9, 10, 0, 8, 3],
+ [10, 0, 1, 10, 6, 0, 6, 4, 0],
+ [8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10],
+ [1, 4, 9, 1, 2, 4, 2, 6, 4],
+ [3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4],
+ [0, 2, 4, 4, 2, 6],
+ [8, 3, 2, 8, 2, 4, 4, 2, 6],
+ [10, 4, 9, 10, 6, 4, 11, 2, 3],
+ [0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6],
+ [3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10],
+ [6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1],
+ [9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3],
+ [8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1],
+ [3, 11, 6, 3, 6, 0, 0, 6, 4],
+ [6, 4, 8, 11, 6, 8],
+ [7, 10, 6, 7, 8, 10, 8, 9, 10],
+ [0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10],
+ [10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0],
+ [10, 6, 7, 10, 7, 1, 1, 7, 3],
+ [1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7],
+ [2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9],
+ [7, 8, 0, 7, 0, 6, 6, 0, 2],
+ [7, 3, 2, 6, 7, 2],
+ [2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7],
+ [2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7],
+ [1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11],
+ [11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1],
+ [8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6],
+ [0, 9, 1, 11, 6, 7],
+ [7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0],
+ [7, 11, 6],
+ [7, 6, 11],
+ [3, 0, 8, 11, 7, 6],
+ [0, 1, 9, 11, 7, 6],
+ [8, 1, 9, 8, 3, 1, 11, 7, 6],
+ [10, 1, 2, 6, 11, 7],
+ [1, 2, 10, 3, 0, 8, 6, 11, 7],
+ [2, 9, 0, 2, 10, 9, 6, 11, 7],
+ [6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8],
+ [7, 2, 3, 6, 2, 7],
+ [7, 0, 8, 7, 6, 0, 6, 2, 0],
+ [2, 7, 6, 2, 3, 7, 0, 1, 9],
+ [1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6],
+ [10, 7, 6, 10, 1, 7, 1, 3, 7],
+ [10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8],
+ [0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7],
+ [7, 6, 10, 7, 10, 8, 8, 10, 9],
+ [6, 8, 4, 11, 8, 6],
+ [3, 6, 11, 3, 0, 6, 0, 4, 6],
+ [8, 6, 11, 8, 4, 6, 9, 0, 1],
+ [9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6],
+ [6, 8, 4, 6, 11, 8, 2, 10, 1],
+ [1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6],
+ [4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9],
+ [10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3],
+ [8, 2, 3, 8, 4, 2, 4, 6, 2],
+ [0, 4, 2, 4, 6, 2],
+ [1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8],
+ [1, 9, 4, 1, 4, 2, 2, 4, 6],
+ [8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1],
+ [10, 1, 0, 10, 0, 6, 6, 0, 4],
+ [4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3],
+ [10, 9, 4, 6, 10, 4],
+ [4, 9, 5, 7, 6, 11],
+ [0, 8, 3, 4, 9, 5, 11, 7, 6],
+ [5, 0, 1, 5, 4, 0, 7, 6, 11],
+ [11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5],
+ [9, 5, 4, 10, 1, 2, 7, 6, 11],
+ [6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5],
+ [7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2],
+ [3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6],
+ [7, 2, 3, 7, 6, 2, 5, 4, 9],
+ [9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7],
+ [3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0],
+ [6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8],
+ [9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7],
+ [1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4],
+ [4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10],
+ [7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10],
+ [6, 9, 5, 6, 11, 9, 11, 8, 9],
+ [3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5],
+ [0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11],
+ [6, 11, 3, 6, 3, 5, 5, 3, 1],
+ [1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6],
+ [0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10],
+ [11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5],
+ [6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3],
+ [5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2],
+ [9, 5, 6, 9, 6, 0, 0, 6, 2],
+ [1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8],
+ [1, 5, 6, 2, 1, 6],
+ [1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6],
+ [10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0],
+ [0, 3, 8, 5, 6, 10],
+ [10, 5, 6],
+ [11, 5, 10, 7, 5, 11],
+ [11, 5, 10, 11, 7, 5, 8, 3, 0],
+ [5, 11, 7, 5, 10, 11, 1, 9, 0],
+ [10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1],
+ [11, 1, 2, 11, 7, 1, 7, 5, 1],
+ [0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11],
+ [9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7],
+ [7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2],
+ [2, 5, 10, 2, 3, 5, 3, 7, 5],
+ [8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5],
+ [9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2],
+ [9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2],
+ [1, 3, 5, 3, 7, 5],
+ [0, 8, 7, 0, 7, 1, 1, 7, 5],
+ [9, 0, 3, 9, 3, 5, 5, 3, 7],
+ [9, 8, 7, 5, 9, 7],
+ [5, 8, 4, 5, 10, 8, 10, 11, 8],
+ [5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0],
+ [0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5],
+ [10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4],
+ [2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8],
+ [0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11],
+ [0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5],
+ [9, 4, 5, 2, 11, 3],
+ [2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4],
+ [5, 10, 2, 5, 2, 4, 4, 2, 0],
+ [3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9],
+ [5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2],
+ [8, 4, 5, 8, 5, 3, 3, 5, 1],
+ [0, 4, 5, 1, 0, 5],
+ [8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5],
+ [9, 4, 5],
+ [4, 11, 7, 4, 9, 11, 9, 10, 11],
+ [0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11],
+ [1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11],
+ [3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4],
+ [4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2],
+ [9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3],
+ [11, 7, 4, 11, 4, 2, 2, 4, 0],
+ [11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4],
+ [2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9],
+ [9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7],
+ [3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10],
+ [1, 10, 2, 8, 7, 4],
+ [4, 9, 1, 4, 1, 7, 7, 1, 3],
+ [4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1],
+ [4, 0, 3, 7, 4, 3],
+ [4, 8, 7],
+ [9, 10, 8, 10, 11, 8],
+ [3, 0, 9, 3, 9, 11, 11, 9, 10],
+ [0, 1, 10, 0, 10, 8, 8, 10, 11],
+ [3, 1, 10, 11, 3, 10],
+ [1, 2, 11, 1, 11, 9, 9, 11, 8],
+ [3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9],
+ [0, 2, 11, 8, 0, 11],
+ [3, 2, 11],
+ [2, 3, 8, 2, 8, 10, 10, 8, 9],
+ [9, 10, 2, 0, 9, 2],
+ [2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8],
+ [1, 10, 2],
+ [1, 3, 8, 9, 1, 8],
+ [0, 9, 1],
+ [0, 3, 8],
+ []
+ ]
+ edgeShifts = np.array([ ## maps edge ID (0-11) to (x,y,z) cell offset and edge ID (0-2)
+ [0, 0, 0, 0],
+ [1, 0, 0, 1],
+ [0, 1, 0, 0],
+ [0, 0, 0, 1],
+ [0, 0, 1, 0],
+ [1, 0, 1, 1],
+ [0, 1, 1, 0],
+ [0, 0, 1, 1],
+ [0, 0, 0, 2],
+ [1, 0, 0, 2],
+ [1, 1, 0, 2],
+ [0, 1, 0, 2],
+ #[9, 9, 9, 9] ## fake
+ ], dtype=np.ubyte)
+ nTableFaces = np.array([len(f)/3 for f in triTable], dtype=np.ubyte)
+ faceShiftTables = [None]
+ for i in range(1,6):
+ ## compute lookup table of index: vertexes mapping
+ faceTableI = np.zeros((len(triTable), i*3), dtype=np.ubyte)
+ faceTableInds = np.argwhere(nTableFaces == i)
+ faceTableI[faceTableInds[:,0]] = np.array([triTable[j] for j in faceTableInds])
+ faceTableI = faceTableI.reshape((len(triTable), i, 3))
+ faceShiftTables.append(edgeShifts[faceTableI])
+
+ ## Let's try something different:
+ #faceTable = np.empty((256, 5, 3, 4), dtype=np.ubyte) # (grid cell index, faces, vertexes, edge lookup)
+ #for i,f in enumerate(triTable):
+ #f = np.array(f + [12] * (15-len(f))).reshape(5,3)
+ #faceTable[i] = edgeShifts[f]
+
+
+ IsosurfaceDataCache = (faceShiftTables, edgeShifts, edgeTable, nTableFaces)
+ else:
+ faceShiftTables, edgeShifts, edgeTable, nTableFaces = IsosurfaceDataCache
+
+
+
+ ## mark everything below the isosurface level
+ mask = data < level
+
+ ### make eight sub-fields and compute indexes for grid cells
+ index = np.zeros([x-1 for x in data.shape], dtype=np.ubyte)
+ fields = np.empty((2,2,2), dtype=object)
+ slices = [slice(0,-1), slice(1,None)]
+ for i in [0,1]:
+ for j in [0,1]:
+ for k in [0,1]:
+ fields[i,j,k] = mask[slices[i], slices[j], slices[k]]
+ vertIndex = i - 2*j*i + 3*j + 4*k ## this is just to match Bourk's vertex numbering scheme
+ index += fields[i,j,k] * 2**vertIndex
+
+ ### Generate table of edges that have been cut
+ cutEdges = np.zeros([x+1 for x in index.shape]+[3], dtype=np.uint32)
+ edges = edgeTable[index]
+ for i, shift in enumerate(edgeShifts[:12]):
+ slices = [slice(shift[j],cutEdges.shape[j]+(shift[j]-1)) for j in range(3)]
+ cutEdges[slices[0], slices[1], slices[2], shift[3]] += edges & 2**i
+
+ ## for each cut edge, interpolate to see where exactly the edge is cut and generate vertex positions
+ m = cutEdges > 0
+ vertexInds = np.argwhere(m) ## argwhere is slow!
+ vertexes = vertexInds[:,:3].astype(np.float32)
+ dataFlat = data.reshape(data.shape[0]*data.shape[1]*data.shape[2])
+
+ ## re-use the cutEdges array as a lookup table for vertex IDs
+ cutEdges[vertexInds[:,0], vertexInds[:,1], vertexInds[:,2], vertexInds[:,3]] = np.arange(vertexInds.shape[0])
+
+ for i in [0,1,2]:
+ vim = vertexInds[:,3] == i
+ vi = vertexInds[vim, :3]
+ viFlat = (vi * (np.array(data.strides[:3]) / data.itemsize)[np.newaxis,:]).sum(axis=1)
+ v1 = dataFlat[viFlat]
+ v2 = dataFlat[viFlat + data.strides[i]/data.itemsize]
+ vertexes[vim,i] += (level-v1) / (v2-v1)
+
+ ### compute the set of vertex indexes for each face.
+
+ ## This works, but runs a bit slower.
+ #cells = np.argwhere((index != 0) & (index != 255)) ## all cells with at least one face
+ #cellInds = index[cells[:,0], cells[:,1], cells[:,2]]
+ #verts = faceTable[cellInds]
+ #mask = verts[...,0,0] != 9
+ #verts[...,:3] += cells[:,np.newaxis,np.newaxis,:] ## we now have indexes into cutEdges
+ #verts = verts[mask]
+ #faces = cutEdges[verts[...,0], verts[...,1], verts[...,2], verts[...,3]] ## and these are the vertex indexes we want.
+
+
+ ## To allow this to be vectorized efficiently, we count the number of faces in each
+ ## grid cell and handle each group of cells with the same number together.
+ ## determine how many faces to assign to each grid cell
+ nFaces = nTableFaces[index]
+ totFaces = nFaces.sum()
+ faces = np.empty((totFaces, 3), dtype=np.uint32)
+ ptr = 0
+ #import debug
+ #p = debug.Profiler('isosurface', disabled=False)
+
+ ## this helps speed up an indexing operation later on
+ cs = np.array(cutEdges.strides)/cutEdges.itemsize
+ cutEdges = cutEdges.flatten()
+
+ ## this, strangely, does not seem to help.
+ #ins = np.array(index.strides)/index.itemsize
+ #index = index.flatten()
+
+ for i in range(1,6):
+ ### expensive:
+ #p.mark('1')
+ cells = np.argwhere(nFaces == i) ## all cells which require i faces (argwhere is expensive)
+ #p.mark('2')
+ if cells.shape[0] == 0:
+ continue
+ #cellInds = index[(cells*ins[np.newaxis,:]).sum(axis=1)]
+ cellInds = index[cells[:,0], cells[:,1], cells[:,2]] ## index values of cells to process for this round
+ #p.mark('3')
+
+ ### expensive:
+ verts = faceShiftTables[i][cellInds]
+ #p.mark('4')
+ verts[...,:3] += cells[:,np.newaxis,np.newaxis,:] ## we now have indexes into cutEdges
+ verts = verts.reshape((verts.shape[0]*i,)+verts.shape[2:])
+ #p.mark('5')
+
+ ### expensive:
+ #print verts.shape
+ verts = (verts * cs[np.newaxis, np.newaxis, :]).sum(axis=2)
+ #vertInds = cutEdges[verts[...,0], verts[...,1], verts[...,2], verts[...,3]] ## and these are the vertex indexes we want.
+ vertInds = cutEdges[verts]
+ #p.mark('6')
+ nv = vertInds.shape[0]
+ #p.mark('7')
+ faces[ptr:ptr+nv] = vertInds #.reshape((nv, 3))
+ #p.mark('8')
+ ptr += nv
+
+ return vertexes, faces
+
+
+
+def invertQTransform(tr):
+ """Return a QTransform that is the inverse of *tr*.
+ Rasises an exception if tr is not invertible.
+
+ Note that this function is preferred over QTransform.inverted() due to
+ bugs in that method. (specifically, Qt has floating-point precision issues
+ when determining whether a matrix is invertible)
+ """
+ if not HAVE_SCIPY:
+ inv = tr.inverted()
+ if inv[1] is False:
+ raise Exception("Transform is not invertible.")
+ return inv[0]
+ arr = np.array([[tr.m11(), tr.m12(), tr.m13()], [tr.m21(), tr.m22(), tr.m23()], [tr.m31(), tr.m32(), tr.m33()]])
+ inv = scipy.linalg.inv(arr)
+ return QtGui.QTransform(inv[0,0], inv[0,1], inv[0,2], inv[1,0], inv[1,1], inv[1,2], inv[2,0], inv[2,1])
+
+
+def pseudoScatter(data, spacing=None, shuffle=True):
+ """
+ Used for examining the distribution of values in a set.
+
+ Given a list of x-values, construct a set of y-values such that an x,y scatter-plot
+ will not have overlapping points (it will look similar to a histogram).
+ """
+ inds = np.arange(len(data))
+ if shuffle:
+ np.random.shuffle(inds)
+
+ data = data[inds]
+
+ if spacing is None:
+ spacing = 2.*np.std(data)/len(data)**0.5
+ s2 = spacing**2
+
+ yvals = np.empty(len(data))
+ yvals[0] = 0
+ for i in range(1,len(data)):
+ x = data[i] # current x value to be placed
+ x0 = data[:i] # all x values already placed
+ y0 = yvals[:i] # all y values already placed
+ y = 0
+
+ dx = (x0-x)**2 # x-distance to each previous point
+ xmask = dx < s2 # exclude anything too far away
+
+ if xmask.sum() > 0:
+ dx = dx[xmask]
+ dy = (s2 - dx)**0.5
+ limits = np.empty((2,len(dy))) # ranges of y-values to exclude
+ limits[0] = y0[xmask] - dy
+ limits[1] = y0[xmask] + dy
+
+ while True:
+ # ignore anything below this y-value
+ mask = limits[1] >= y
+ limits = limits[:,mask]
+
+ # are we inside an excluded region?
+ mask = (limits[0] < y) & (limits[1] > y)
+ if mask.sum() == 0:
+ break
+ y = limits[:,mask].max()
+
+ yvals[i] = y
+
+ return yvals[np.argsort(inds)] ## un-shuffle values before returning
\ No newline at end of file
diff --git a/pyqtgraph/graphicsItems/ArrowItem.py b/pyqtgraph/graphicsItems/ArrowItem.py
new file mode 100644
index 00000000..153ea712
--- /dev/null
+++ b/pyqtgraph/graphicsItems/ArrowItem.py
@@ -0,0 +1,56 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import pyqtgraph.functions as fn
+import numpy as np
+__all__ = ['ArrowItem']
+
+class ArrowItem(QtGui.QGraphicsPathItem):
+ """
+ For displaying scale-invariant arrows.
+ For arrows pointing to a location on a curve, see CurveArrow
+
+ """
+
+
+ def __init__(self, **opts):
+ QtGui.QGraphicsPathItem.__init__(self, opts.get('parent', None))
+ if 'size' in opts:
+ opts['headLen'] = opts['size']
+ if 'width' in opts:
+ opts['headWidth'] = opts['width']
+ defOpts = {
+ 'pxMode': True,
+ 'angle': -150, ## If the angle is 0, the arrow points left
+ 'pos': (0,0),
+ 'headLen': 20,
+ 'tipAngle': 25,
+ 'baseAngle': 0,
+ 'tailLen': None,
+ 'tailWidth': 3,
+ 'pen': (200,200,200),
+ 'brush': (50,50,200),
+ }
+ defOpts.update(opts)
+
+ self.setStyle(**defOpts)
+
+ self.setPen(fn.mkPen(defOpts['pen']))
+ self.setBrush(fn.mkBrush(defOpts['brush']))
+
+ self.rotate(self.opts['angle'])
+ self.moveBy(*self.opts['pos'])
+
+ def setStyle(self, **opts):
+ self.opts = opts
+
+ opt = dict([(k,self.opts[k]) for k in ['headLen', 'tipAngle', 'baseAngle', 'tailLen', 'tailWidth']])
+ self.path = fn.makeArrowPath(**opt)
+ self.setPath(self.path)
+
+ if opts['pxMode']:
+ self.setFlags(self.flags() | self.ItemIgnoresTransformations)
+ else:
+ self.setFlags(self.flags() & ~self.ItemIgnoresTransformations)
+
+ def paint(self, p, *args):
+ p.setRenderHint(QtGui.QPainter.Antialiasing)
+ QtGui.QGraphicsPathItem.paint(self, p, *args)
diff --git a/pyqtgraph/graphicsItems/AxisItem.py b/pyqtgraph/graphicsItems/AxisItem.py
new file mode 100644
index 00000000..82cbcfae
--- /dev/null
+++ b/pyqtgraph/graphicsItems/AxisItem.py
@@ -0,0 +1,711 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.python2_3 import asUnicode
+import numpy as np
+from pyqtgraph.Point import Point
+import pyqtgraph.debug as debug
+import weakref
+import pyqtgraph.functions as fn
+import pyqtgraph as pg
+from .GraphicsWidget import GraphicsWidget
+
+__all__ = ['AxisItem']
+class AxisItem(GraphicsWidget):
+ """
+ GraphicsItem showing a single plot axis with ticks, values, and label.
+ Can be configured to fit on any side of a plot, and can automatically synchronize its displayed scale with ViewBox items.
+ Ticks can be extended to draw a grid.
+ If maxTickLength is negative, ticks point into the plot.
+ """
+
+ def __init__(self, orientation, pen=None, linkView=None, parent=None, maxTickLength=-5, showValues=True):
+ """
+ ============== ===============================================================
+ **Arguments:**
+ orientation one of 'left', 'right', 'top', or 'bottom'
+ maxTickLength (px) maximum length of ticks to draw. Negative values draw
+ into the plot, positive values draw outward.
+ linkView (ViewBox) causes the range of values displayed in the axis
+ to be linked to the visible range of a ViewBox.
+ showValues (bool) Whether to display values adjacent to ticks
+ pen (QPen) Pen used when drawing ticks.
+ ============== ===============================================================
+ """
+
+ GraphicsWidget.__init__(self, parent)
+ self.label = QtGui.QGraphicsTextItem(self)
+ self.showValues = showValues
+ self.picture = None
+ self.orientation = orientation
+ if orientation not in ['left', 'right', 'top', 'bottom']:
+ raise Exception("Orientation argument must be one of 'left', 'right', 'top', or 'bottom'.")
+ if orientation in ['left', 'right']:
+ #self.setMinimumWidth(25)
+ #self.setSizePolicy(QtGui.QSizePolicy(
+ #QtGui.QSizePolicy.Minimum,
+ #QtGui.QSizePolicy.Expanding
+ #))
+ self.label.rotate(-90)
+ #else:
+ #self.setMinimumHeight(50)
+ #self.setSizePolicy(QtGui.QSizePolicy(
+ #QtGui.QSizePolicy.Expanding,
+ #QtGui.QSizePolicy.Minimum
+ #))
+ #self.drawLabel = False
+
+ self.labelText = ''
+ self.labelUnits = ''
+ self.labelUnitPrefix=''
+ self.labelStyle = {}
+ self.logMode = False
+
+ self.textHeight = 18
+ self.tickLength = maxTickLength
+ self._tickLevels = None ## used to override the automatic ticking system with explicit ticks
+ self.scale = 1.0
+ self.autoScale = True
+
+ self.setRange(0, 1)
+
+ self.setPen(pen)
+
+ self._linkedView = None
+ if linkView is not None:
+ self.linkToView(linkView)
+
+ self.showLabel(False)
+
+ self.grid = False
+ #self.setCacheMode(self.DeviceCoordinateCache)
+
+ def close(self):
+ self.scene().removeItem(self.label)
+ self.label = None
+ self.scene().removeItem(self)
+
+ def setGrid(self, grid):
+ """Set the alpha value for the grid, or False to disable."""
+ self.grid = grid
+ self.picture = None
+ self.prepareGeometryChange()
+ self.update()
+
+ def setLogMode(self, log):
+ """
+ If *log* is True, then ticks are displayed on a logarithmic scale and values
+ are adjusted accordingly. (This is usually accessed by changing the log mode
+ of a :func:`PlotItem `)
+ """
+ self.logMode = log
+ self.picture = None
+ self.update()
+
+ def resizeEvent(self, ev=None):
+ #s = self.size()
+
+ ## Set the position of the label
+ nudge = 5
+ br = self.label.boundingRect()
+ p = QtCore.QPointF(0, 0)
+ if self.orientation == 'left':
+ p.setY(int(self.size().height()/2 + br.width()/2))
+ p.setX(-nudge)
+ #s.setWidth(10)
+ elif self.orientation == 'right':
+ #s.setWidth(10)
+ p.setY(int(self.size().height()/2 + br.width()/2))
+ p.setX(int(self.size().width()-br.height()+nudge))
+ elif self.orientation == 'top':
+ #s.setHeight(10)
+ p.setY(-nudge)
+ p.setX(int(self.size().width()/2. - br.width()/2.))
+ elif self.orientation == 'bottom':
+ p.setX(int(self.size().width()/2. - br.width()/2.))
+ #s.setHeight(10)
+ p.setY(int(self.size().height()-br.height()+nudge))
+ #self.label.resize(s)
+ self.label.setPos(p)
+ self.picture = None
+
+ def showLabel(self, show=True):
+ """Show/hide the label text for this axis."""
+ #self.drawLabel = show
+ self.label.setVisible(show)
+ if self.orientation in ['left', 'right']:
+ self.setWidth()
+ else:
+ self.setHeight()
+ if self.autoScale:
+ self.setScale()
+
+ def setLabel(self, text=None, units=None, unitPrefix=None, **args):
+ """Set the text displayed adjacent to the axis."""
+ if text is not None:
+ self.labelText = text
+ self.showLabel()
+ if units is not None:
+ self.labelUnits = units
+ self.showLabel()
+ if unitPrefix is not None:
+ self.labelUnitPrefix = unitPrefix
+ if len(args) > 0:
+ self.labelStyle = args
+ self.label.setHtml(self.labelString())
+ self.resizeEvent()
+ self.picture = None
+ self.update()
+
+ def labelString(self):
+ if self.labelUnits == '':
+ if self.scale == 1.0:
+ units = ''
+ else:
+ units = asUnicode('(x%g)') % (1.0/self.scale)
+ else:
+ #print repr(self.labelUnitPrefix), repr(self.labelUnits)
+ units = asUnicode('(%s%s)') % (self.labelUnitPrefix, self.labelUnits)
+
+ s = asUnicode('%s %s') % (self.labelText, units)
+
+ style = ';'.join(['%s: %s' % (k, self.labelStyle[k]) for k in self.labelStyle])
+
+ return asUnicode("%s") % (style, s)
+
+ def setHeight(self, h=None):
+ """Set the height of this axis reserved for ticks and tick labels.
+ The height of the axis label is automatically added."""
+ if h is None:
+ h = self.textHeight + max(0, self.tickLength)
+ if self.label.isVisible():
+ h += self.textHeight
+ self.setMaximumHeight(h)
+ self.setMinimumHeight(h)
+ self.picture = None
+
+
+ def setWidth(self, w=None):
+ """Set the width of this axis reserved for ticks and tick labels.
+ The width of the axis label is automatically added."""
+ if w is None:
+ w = max(0, self.tickLength) + 40
+ if self.label.isVisible():
+ w += self.textHeight
+ self.setMaximumWidth(w)
+ self.setMinimumWidth(w)
+
+ def pen(self):
+ if self._pen is None:
+ return fn.mkPen(pg.getConfigOption('foreground'))
+ return pg.mkPen(self._pen)
+
+ def setPen(self, pen):
+ """
+ Set the pen used for drawing text, axes, ticks, and grid lines.
+ if pen == None, the default will be used (see :func:`setConfigOption
+ `)
+ """
+ self._pen = pen
+ self.picture = None
+ if pen is None:
+ pen = pg.getConfigOption('foreground')
+ self.labelStyle['color'] = '#' + pg.colorStr(pg.mkPen(pen).color())[:6]
+ self.setLabel()
+ self.update()
+
+ def setScale(self, scale=None):
+ """
+ Set the value scaling for this axis. Values on the axis are multiplied
+ by this scale factor before being displayed as text. By default,
+ this scaling value is automatically determined based on the visible range
+ and the axis units are updated to reflect the chosen scale factor.
+
+ For example: If the axis spans values from -0.1 to 0.1 and has units set
+ to 'V' then a scale of 1000 would cause the axis to display values -100 to 100
+ and the units would appear as 'mV'
+ """
+ if scale is None:
+ #if self.drawLabel: ## If there is a label, then we are free to rescale the values
+ if self.label.isVisible():
+ #d = self.range[1] - self.range[0]
+ #(scale, prefix) = fn.siScale(d / 2.)
+ (scale, prefix) = fn.siScale(max(abs(self.range[0]), abs(self.range[1])))
+ if self.labelUnits == '' and prefix in ['k', 'm']: ## If we are not showing units, wait until 1e6 before scaling.
+ scale = 1.0
+ prefix = ''
+ self.setLabel(unitPrefix=prefix)
+ else:
+ scale = 1.0
+ else:
+ self.setLabel(unitPrefix='')
+ self.autoScale = False
+
+ if scale != self.scale:
+ self.scale = scale
+ self.setLabel()
+ self.picture = None
+ self.update()
+
+ def setRange(self, mn, mx):
+ """Set the range of values displayed by the axis.
+ Usually this is handled automatically by linking the axis to a ViewBox with :func:`linkToView `"""
+ if any(np.isinf((mn, mx))) or any(np.isnan((mn, mx))):
+ raise Exception("Not setting range to [%s, %s]" % (str(mn), str(mx)))
+ self.range = [mn, mx]
+ if self.autoScale:
+ self.setScale()
+ self.picture = None
+ self.update()
+
+ def linkedView(self):
+ """Return the ViewBox this axis is linked to"""
+ if self._linkedView is None:
+ return None
+ else:
+ return self._linkedView()
+
+ def linkToView(self, view):
+ """Link this axis to a ViewBox, causing its displayed range to match the visible range of the view."""
+ oldView = self.linkedView()
+ self._linkedView = weakref.ref(view)
+ if self.orientation in ['right', 'left']:
+ if oldView is not None:
+ oldView.sigYRangeChanged.disconnect(self.linkedViewChanged)
+ view.sigYRangeChanged.connect(self.linkedViewChanged)
+ else:
+ if oldView is not None:
+ oldView.sigXRangeChanged.disconnect(self.linkedViewChanged)
+ view.sigXRangeChanged.connect(self.linkedViewChanged)
+
+ def linkedViewChanged(self, view, newRange):
+ if self.orientation in ['right', 'left'] and view.yInverted():
+ self.setRange(*newRange[::-1])
+ else:
+ self.setRange(*newRange)
+
+ def boundingRect(self):
+ linkedView = self.linkedView()
+ if linkedView is None or self.grid is False:
+ rect = self.mapRectFromParent(self.geometry())
+ ## extend rect if ticks go in negative direction
+ if self.orientation == 'left':
+ rect.setRight(rect.right() - min(0,self.tickLength))
+ elif self.orientation == 'right':
+ rect.setLeft(rect.left() + min(0,self.tickLength))
+ elif self.orientation == 'top':
+ rect.setBottom(rect.bottom() - min(0,self.tickLength))
+ elif self.orientation == 'bottom':
+ rect.setTop(rect.top() + min(0,self.tickLength))
+ return rect
+ else:
+ return self.mapRectFromParent(self.geometry()) | linkedView.mapRectToItem(self, linkedView.boundingRect())
+
+ def paint(self, p, opt, widget):
+ if self.picture is None:
+ self.picture = QtGui.QPicture()
+ painter = QtGui.QPainter(self.picture)
+ try:
+ self.drawPicture(painter)
+ finally:
+ painter.end()
+ #p.setRenderHint(p.Antialiasing, False) ## Sometimes we get a segfault here ???
+ #p.setRenderHint(p.TextAntialiasing, True)
+ self.picture.play(p)
+
+
+ def setTicks(self, ticks):
+ """Explicitly determine which ticks to display.
+ This overrides the behavior specified by tickSpacing(), tickValues(), and tickStrings()
+ The format for *ticks* looks like::
+
+ [
+ [ (majorTickValue1, majorTickString1), (majorTickValue2, majorTickString2), ... ],
+ [ (minorTickValue1, minorTickString1), (minorTickValue2, minorTickString2), ... ],
+ ...
+ ]
+
+ If *ticks* is None, then the default tick system will be used instead.
+ """
+ self._tickLevels = ticks
+ self.picture = None
+ self.update()
+
+ def tickSpacing(self, minVal, maxVal, size):
+ """Return values describing the desired spacing and offset of ticks.
+
+ This method is called whenever the axis needs to be redrawn and is a
+ good method to override in subclasses that require control over tick locations.
+
+ The return value must be a list of three tuples::
+
+ [
+ (major tick spacing, offset),
+ (minor tick spacing, offset),
+ (sub-minor tick spacing, offset),
+ ...
+ ]
+ """
+ dif = abs(maxVal - minVal)
+ if dif == 0:
+ return []
+
+ ## decide optimal minor tick spacing in pixels (this is just aesthetics)
+ pixelSpacing = np.log(size+10) * 5
+ optimalTickCount = size / pixelSpacing
+ if optimalTickCount < 1:
+ optimalTickCount = 1
+
+ ## optimal minor tick spacing
+ optimalSpacing = dif / optimalTickCount
+
+ ## the largest power-of-10 spacing which is smaller than optimal
+ p10unit = 10 ** np.floor(np.log10(optimalSpacing))
+
+ ## Determine major/minor tick spacings which flank the optimal spacing.
+ intervals = np.array([1., 2., 10., 20., 100.]) * p10unit
+ minorIndex = 0
+ while intervals[minorIndex+1] <= optimalSpacing:
+ minorIndex += 1
+
+ return [
+ (intervals[minorIndex+2], 0),
+ (intervals[minorIndex+1], 0),
+ (intervals[minorIndex], 0)
+ ]
+
+ ##### This does not work -- switching between 2/5 confuses the automatic text-level-selection
+ ### Determine major/minor tick spacings which flank the optimal spacing.
+ #intervals = np.array([1., 2., 5., 10., 20., 50., 100.]) * p10unit
+ #minorIndex = 0
+ #while intervals[minorIndex+1] <= optimalSpacing:
+ #minorIndex += 1
+
+ ### make sure we never see 5 and 2 at the same time
+ #intIndexes = [
+ #[0,1,3],
+ #[0,2,3],
+ #[2,3,4],
+ #[3,4,6],
+ #[3,5,6],
+ #][minorIndex]
+
+ #return [
+ #(intervals[intIndexes[2]], 0),
+ #(intervals[intIndexes[1]], 0),
+ #(intervals[intIndexes[0]], 0)
+ #]
+
+
+
+ def tickValues(self, minVal, maxVal, size):
+ """
+ Return the values and spacing of ticks to draw::
+
+ [
+ (spacing, [major ticks]),
+ (spacing, [minor ticks]),
+ ...
+ ]
+
+ By default, this method calls tickSpacing to determine the correct tick locations.
+ This is a good method to override in subclasses.
+ """
+ minVal, maxVal = sorted((minVal, maxVal))
+
+
+ ticks = []
+ tickLevels = self.tickSpacing(minVal, maxVal, size)
+ allValues = np.array([])
+ for i in range(len(tickLevels)):
+ spacing, offset = tickLevels[i]
+
+ ## determine starting tick
+ start = (np.ceil((minVal-offset) / spacing) * spacing) + offset
+
+ ## determine number of ticks
+ num = int((maxVal-start) / spacing) + 1
+ values = np.arange(num) * spacing + start
+ ## remove any ticks that were present in higher levels
+ ## we assume here that if the difference between a tick value and a previously seen tick value
+ ## is less than spacing/100, then they are 'equal' and we can ignore the new tick.
+ values = list(filter(lambda x: all(np.abs(allValues-x) > spacing*0.01), values) )
+ allValues = np.concatenate([allValues, values])
+ ticks.append((spacing, values))
+
+ if self.logMode:
+ return self.logTickValues(minVal, maxVal, size, ticks)
+
+ return ticks
+
+ def logTickValues(self, minVal, maxVal, size, stdTicks):
+
+ ## start with the tick spacing given by tickValues().
+ ## Any level whose spacing is < 1 needs to be converted to log scale
+
+ ticks = []
+ for (spacing, t) in stdTicks:
+ if spacing >= 1.0:
+ ticks.append((spacing, t))
+
+ if len(ticks) < 3:
+ v1 = int(np.floor(minVal))
+ v2 = int(np.ceil(maxVal))
+ #major = list(range(v1+1, v2))
+
+ minor = []
+ for v in range(v1, v2):
+ minor.extend(v + np.log10(np.arange(1, 10)))
+ minor = [x for x in minor if x>minVal and x= 10000:
+ vstr = "%g" % vs
+ else:
+ vstr = ("%%0.%df" % places) % vs
+ strings.append(vstr)
+ return strings
+
+ def logTickStrings(self, values, scale, spacing):
+ return ["%0.1g"%x for x in 10 ** np.array(values).astype(float)]
+
+ def drawPicture(self, p):
+
+ p.setRenderHint(p.Antialiasing, False)
+ p.setRenderHint(p.TextAntialiasing, True)
+
+ prof = debug.Profiler("AxisItem.paint", disabled=True)
+
+ #bounds = self.boundingRect()
+ bounds = self.mapRectFromParent(self.geometry())
+
+ linkedView = self.linkedView()
+ if linkedView is None or self.grid is False:
+ tickBounds = bounds
+ else:
+ tickBounds = linkedView.mapRectToItem(self, linkedView.boundingRect())
+
+ if self.orientation == 'left':
+ span = (bounds.topRight(), bounds.bottomRight())
+ tickStart = tickBounds.right()
+ tickStop = bounds.right()
+ tickDir = -1
+ axis = 0
+ elif self.orientation == 'right':
+ span = (bounds.topLeft(), bounds.bottomLeft())
+ tickStart = tickBounds.left()
+ tickStop = bounds.left()
+ tickDir = 1
+ axis = 0
+ elif self.orientation == 'top':
+ span = (bounds.bottomLeft(), bounds.bottomRight())
+ tickStart = tickBounds.bottom()
+ tickStop = bounds.bottom()
+ tickDir = -1
+ axis = 1
+ elif self.orientation == 'bottom':
+ span = (bounds.topLeft(), bounds.topRight())
+ tickStart = tickBounds.top()
+ tickStop = bounds.top()
+ tickDir = 1
+ axis = 1
+ #print tickStart, tickStop, span
+
+ ## draw long line along axis
+ p.setPen(self.pen())
+ p.drawLine(*span)
+ p.translate(0.5,0) ## resolves some damn pixel ambiguity
+
+ ## determine size of this item in pixels
+ points = list(map(self.mapToDevice, span))
+ if None in points:
+ return
+ lengthInPixels = Point(points[1] - points[0]).length()
+ if lengthInPixels == 0:
+ return
+
+ if self._tickLevels is None:
+ tickLevels = self.tickValues(self.range[0], self.range[1], lengthInPixels)
+ tickStrings = None
+ else:
+ ## parse self.tickLevels into the formats returned by tickLevels() and tickStrings()
+ tickLevels = []
+ tickStrings = []
+ for level in self._tickLevels:
+ values = []
+ strings = []
+ tickLevels.append((None, values))
+ tickStrings.append(strings)
+ for val, strn in level:
+ values.append(val)
+ strings.append(strn)
+
+ textLevel = 1 ## draw text at this scale level
+
+ ## determine mapping between tick values and local coordinates
+ dif = self.range[1] - self.range[0]
+ if axis == 0:
+ xScale = -bounds.height() / dif
+ offset = self.range[0] * xScale - bounds.height()
+ else:
+ xScale = bounds.width() / dif
+ offset = self.range[0] * xScale
+
+ xRange = [x * xScale - offset for x in self.range]
+ xMin = min(xRange)
+ xMax = max(xRange)
+
+ prof.mark('init')
+
+ tickPositions = [] # remembers positions of previously drawn ticks
+
+ ## draw ticks
+ ## (to improve performance, we do not interleave line and text drawing, since this causes unnecessary pipeline switching)
+ ## draw three different intervals, long ticks first
+
+ for i in range(len(tickLevels)):
+ tickPositions.append([])
+ ticks = tickLevels[i][1]
+
+ ## length of tick
+ tickLength = self.tickLength / ((i*1.0)+1.0)
+
+ lineAlpha = 255 / (i+1)
+ if self.grid is not False:
+ lineAlpha *= self.grid/255. * np.clip((0.05 * lengthInPixels / (len(ticks)+1)), 0., 1.)
+
+ for v in ticks:
+ ## determine actual position to draw this tick
+ x = (v * xScale) - offset
+ if x < xMin or x > xMax: ## last check to make sure no out-of-bounds ticks are drawn
+ tickPositions[i].append(None)
+ continue
+ tickPositions[i].append(x)
+
+ p1 = [x, x]
+ p2 = [x, x]
+ p1[axis] = tickStart
+ p2[axis] = tickStop
+ if self.grid is False:
+ p2[axis] += tickLength*tickDir
+ tickPen = self.pen()
+ color = tickPen.color()
+ color.setAlpha(lineAlpha)
+ tickPen.setColor(color)
+ p.setPen(tickPen)
+ p.drawLine(Point(p1), Point(p2))
+ prof.mark('draw ticks')
+
+ ## Draw text until there is no more room (or no more text)
+ textRects = []
+ for i in range(len(tickLevels)):
+ ## Get the list of strings to display for this level
+ if tickStrings is None:
+ spacing, values = tickLevels[i]
+ strings = self.tickStrings(values, self.scale, spacing)
+ else:
+ strings = tickStrings[i]
+
+ if len(strings) == 0:
+ continue
+
+ ## ignore strings belonging to ticks that were previously ignored
+ for j in range(len(strings)):
+ if tickPositions[i][j] is None:
+ strings[j] = None
+
+ textRects.extend([p.boundingRect(QtCore.QRectF(0, 0, 100, 100), QtCore.Qt.AlignCenter, s) for s in strings if s is not None])
+ if i > 0: ## always draw top level
+ ## measure all text, make sure there's enough room
+ if axis == 0:
+ textSize = np.sum([r.height() for r in textRects])
+ else:
+ textSize = np.sum([r.width() for r in textRects])
+
+ ## If the strings are too crowded, stop drawing text now
+ textFillRatio = float(textSize) / lengthInPixels
+ if textFillRatio > 0.7:
+ break
+ #spacing, values = tickLevels[best]
+ #strings = self.tickStrings(values, self.scale, spacing)
+ for j in range(len(strings)):
+ vstr = strings[j]
+ if vstr is None:## this tick was ignored because it is out of bounds
+ continue
+ x = tickPositions[i][j]
+ textRect = p.boundingRect(QtCore.QRectF(0, 0, 100, 100), QtCore.Qt.AlignCenter, vstr)
+ height = textRect.height()
+ self.textHeight = height
+ if self.orientation == 'left':
+ textFlags = QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter
+ rect = QtCore.QRectF(tickStop-100, x-(height/2), 99-max(0,self.tickLength), height)
+ elif self.orientation == 'right':
+ textFlags = QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter
+ rect = QtCore.QRectF(tickStop+max(0,self.tickLength)+1, x-(height/2), 100-max(0,self.tickLength), height)
+ elif self.orientation == 'top':
+ textFlags = QtCore.Qt.AlignCenter|QtCore.Qt.AlignBottom
+ rect = QtCore.QRectF(x-100, tickStop-max(0,self.tickLength)-height, 200, height)
+ elif self.orientation == 'bottom':
+ textFlags = QtCore.Qt.AlignCenter|QtCore.Qt.AlignTop
+ rect = QtCore.QRectF(x-100, tickStop+max(0,self.tickLength), 200, height)
+
+ p.setPen(self.pen())
+ p.drawText(rect, textFlags, vstr)
+ prof.mark('draw text')
+ prof.finish()
+
+ def show(self):
+
+ if self.orientation in ['left', 'right']:
+ self.setWidth()
+ else:
+ self.setHeight()
+ GraphicsWidget.show(self)
+
+ def hide(self):
+ if self.orientation in ['left', 'right']:
+ self.setWidth(0)
+ else:
+ self.setHeight(0)
+ GraphicsWidget.hide(self)
+
+ def wheelEvent(self, ev):
+ if self.linkedView() is None:
+ return
+ if self.orientation in ['left', 'right']:
+ self.linkedView().wheelEvent(ev, axis=1)
+ else:
+ self.linkedView().wheelEvent(ev, axis=0)
+ ev.accept()
+
+ def mouseDragEvent(self, event):
+ if self.linkedView() is None:
+ return
+ if self.orientation in ['left', 'right']:
+ return self.linkedView().mouseDragEvent(event, axis=1)
+ else:
+ return self.linkedView().mouseDragEvent(event, axis=0)
+
+ def mouseClickEvent(self, event):
+ if self.linkedView() is None:
+ return
+ return self.linkedView().mouseClickEvent(event)
diff --git a/pyqtgraph/graphicsItems/ButtonItem.py b/pyqtgraph/graphicsItems/ButtonItem.py
new file mode 100644
index 00000000..741f2666
--- /dev/null
+++ b/pyqtgraph/graphicsItems/ButtonItem.py
@@ -0,0 +1,58 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from .GraphicsObject import GraphicsObject
+
+__all__ = ['ButtonItem']
+class ButtonItem(GraphicsObject):
+ """Button graphicsItem displaying an image."""
+
+ clicked = QtCore.Signal(object)
+
+ def __init__(self, imageFile=None, width=None, parentItem=None, pixmap=None):
+ self.enabled = True
+ GraphicsObject.__init__(self)
+ if imageFile is not None:
+ self.setImageFile(imageFile)
+ elif pixmap is not None:
+ self.setPixmap(pixmap)
+
+ if width is not None:
+ s = float(width) / self.pixmap.width()
+ self.scale(s, s)
+ if parentItem is not None:
+ self.setParentItem(parentItem)
+ self.setOpacity(0.7)
+
+ def setImageFile(self, imageFile):
+ self.setPixmap(QtGui.QPixmap(imageFile))
+
+ def setPixmap(self, pixmap):
+ self.pixmap = pixmap
+ self.update()
+
+ def mouseClickEvent(self, ev):
+ if self.enabled:
+ self.clicked.emit(self)
+
+ def mouseHoverEvent(self, ev):
+ if not self.enabled:
+ return
+ if ev.isEnter():
+ self.setOpacity(1.0)
+ else:
+ self.setOpacity(0.7)
+
+ def disable(self):
+ self.enabled = False
+ self.setOpacity(0.4)
+
+ def enable(self):
+ self.enabled = True
+ self.setOpacity(0.7)
+
+ def paint(self, p, *args):
+ p.setRenderHint(p.Antialiasing)
+ p.drawPixmap(0, 0, self.pixmap)
+
+ def boundingRect(self):
+ return QtCore.QRectF(self.pixmap.rect())
+
diff --git a/pyqtgraph/graphicsItems/CurvePoint.py b/pyqtgraph/graphicsItems/CurvePoint.py
new file mode 100644
index 00000000..668830f7
--- /dev/null
+++ b/pyqtgraph/graphicsItems/CurvePoint.py
@@ -0,0 +1,117 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from . import ArrowItem
+import numpy as np
+from pyqtgraph.Point import Point
+import weakref
+from .GraphicsObject import GraphicsObject
+
+__all__ = ['CurvePoint', 'CurveArrow']
+class CurvePoint(GraphicsObject):
+ """A GraphicsItem that sets its location to a point on a PlotCurveItem.
+ Also rotates to be tangent to the curve.
+ The position along the curve is a Qt property, and thus can be easily animated.
+
+ Note: This class does not display anything; see CurveArrow for an applied example
+ """
+
+ def __init__(self, curve, index=0, pos=None, rotate=True):
+ """Position can be set either as an index referring to the sample number or
+ the position 0.0 - 1.0
+ If *rotate* is True, then the item rotates to match the tangent of the curve.
+ """
+
+ GraphicsObject.__init__(self)
+ #QObjectWorkaround.__init__(self)
+ self._rotate = rotate
+ self.curve = weakref.ref(curve)
+ self.setParentItem(curve)
+ self.setProperty('position', 0.0)
+ self.setProperty('index', 0)
+
+ if hasattr(self, 'ItemHasNoContents'):
+ self.setFlags(self.flags() | self.ItemHasNoContents)
+
+ if pos is not None:
+ self.setPos(pos)
+ else:
+ self.setIndex(index)
+
+ def setPos(self, pos):
+ self.setProperty('position', float(pos))## cannot use numpy types here, MUST be python float.
+
+ def setIndex(self, index):
+ self.setProperty('index', int(index)) ## cannot use numpy types here, MUST be python int.
+
+ def event(self, ev):
+ if not isinstance(ev, QtCore.QDynamicPropertyChangeEvent) or self.curve() is None:
+ return False
+
+ if ev.propertyName() == 'index':
+ index = self.property('index')
+ if 'QVariant' in repr(index):
+ index = index.toInt()[0]
+ elif ev.propertyName() == 'position':
+ index = None
+ else:
+ return False
+
+ (x, y) = self.curve().getData()
+ if index is None:
+ #print ev.propertyName(), self.property('position').toDouble()[0], self.property('position').typeName()
+ pos = self.property('position')
+ if 'QVariant' in repr(pos): ## need to support 2 APIs :(
+ pos = pos.toDouble()[0]
+ index = (len(x)-1) * np.clip(pos, 0.0, 1.0)
+
+ if index != int(index): ## interpolate floating-point values
+ i1 = int(index)
+ i2 = np.clip(i1+1, 0, len(x)-1)
+ s2 = index-i1
+ s1 = 1.0-s2
+ newPos = (x[i1]*s1+x[i2]*s2, y[i1]*s1+y[i2]*s2)
+ else:
+ index = int(index)
+ i1 = np.clip(index-1, 0, len(x)-1)
+ i2 = np.clip(index+1, 0, len(x)-1)
+ newPos = (x[index], y[index])
+
+ p1 = self.parentItem().mapToScene(QtCore.QPointF(x[i1], y[i1]))
+ p2 = self.parentItem().mapToScene(QtCore.QPointF(x[i2], y[i2]))
+ ang = np.arctan2(p2.y()-p1.y(), p2.x()-p1.x()) ## returns radians
+ self.resetTransform()
+ if self._rotate:
+ self.rotate(180+ ang * 180 / np.pi) ## takes degrees
+ QtGui.QGraphicsItem.setPos(self, *newPos)
+ return True
+
+ def boundingRect(self):
+ return QtCore.QRectF()
+
+ def paint(self, *args):
+ pass
+
+ def makeAnimation(self, prop='position', start=0.0, end=1.0, duration=10000, loop=1):
+ anim = QtCore.QPropertyAnimation(self, prop)
+ anim.setDuration(duration)
+ anim.setStartValue(start)
+ anim.setEndValue(end)
+ anim.setLoopCount(loop)
+ return anim
+
+
+class CurveArrow(CurvePoint):
+ """Provides an arrow that points to any specific sample on a PlotCurveItem.
+ Provides properties that can be animated."""
+
+ def __init__(self, curve, index=0, pos=None, **opts):
+ CurvePoint.__init__(self, curve, index=index, pos=pos)
+ if opts.get('pxMode', True):
+ opts['pxMode'] = False
+ self.setFlags(self.flags() | self.ItemIgnoresTransformations)
+ opts['angle'] = 0
+ self.arrow = ArrowItem.ArrowItem(**opts)
+ self.arrow.setParentItem(self)
+
+ def setStyle(**opts):
+ return self.arrow.setStyle(**opts)
+
diff --git a/pyqtgraph/graphicsItems/FillBetweenItem.py b/pyqtgraph/graphicsItems/FillBetweenItem.py
new file mode 100644
index 00000000..e0011177
--- /dev/null
+++ b/pyqtgraph/graphicsItems/FillBetweenItem.py
@@ -0,0 +1,23 @@
+import pyqtgraph as pg
+
+class FillBetweenItem(pg.QtGui.QGraphicsPathItem):
+ """
+ GraphicsItem filling the space between two PlotDataItems.
+ """
+ def __init__(self, p1, p2, brush=None):
+ pg.QtGui.QGraphicsPathItem.__init__(self)
+ self.p1 = p1
+ self.p2 = p2
+ p1.sigPlotChanged.connect(self.updatePath)
+ p2.sigPlotChanged.connect(self.updatePath)
+ if brush is not None:
+ self.setBrush(pg.mkBrush(brush))
+ self.setZValue(min(p1.zValue(), p2.zValue())-1)
+ self.updatePath()
+
+ def updatePath(self):
+ p1 = self.p1.curve.path
+ p2 = self.p2.curve.path
+ path = pg.QtGui.QPainterPath()
+ path.addPolygon(p1.toSubpathPolygons()[0] + p2.toReversed().toSubpathPolygons()[0])
+ self.setPath(path)
diff --git a/pyqtgraph/graphicsItems/GradientEditorItem.py b/pyqtgraph/graphicsItems/GradientEditorItem.py
new file mode 100644
index 00000000..3c078ede
--- /dev/null
+++ b/pyqtgraph/graphicsItems/GradientEditorItem.py
@@ -0,0 +1,880 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.python2_3 import sortList
+import pyqtgraph.functions as fn
+from .GraphicsObject import GraphicsObject
+from .GraphicsWidget import GraphicsWidget
+import weakref
+from pyqtgraph.pgcollections import OrderedDict
+import numpy as np
+
+__all__ = ['TickSliderItem', 'GradientEditorItem']
+
+
+Gradients = OrderedDict([
+ ('thermal', {'ticks': [(0.3333, (185, 0, 0, 255)), (0.6666, (255, 220, 0, 255)), (1, (255, 255, 255, 255)), (0, (0, 0, 0, 255))], 'mode': 'rgb'}),
+ ('flame', {'ticks': [(0.2, (7, 0, 220, 255)), (0.5, (236, 0, 134, 255)), (0.8, (246, 246, 0, 255)), (1.0, (255, 255, 255, 255)), (0.0, (0, 0, 0, 255))], 'mode': 'rgb'}),
+ ('yellowy', {'ticks': [(0.0, (0, 0, 0, 255)), (0.2328863796753704, (32, 0, 129, 255)), (0.8362738179251941, (255, 255, 0, 255)), (0.5257586450247, (115, 15, 255, 255)), (1.0, (255, 255, 255, 255))], 'mode': 'rgb'} ),
+ ('bipolar', {'ticks': [(0.0, (0, 255, 255, 255)), (1.0, (255, 255, 0, 255)), (0.5, (0, 0, 0, 255)), (0.25, (0, 0, 255, 255)), (0.75, (255, 0, 0, 255))], 'mode': 'rgb'}),
+ ('spectrum', {'ticks': [(1.0, (255, 0, 255, 255)), (0.0, (255, 0, 0, 255))], 'mode': 'hsv'}),
+ ('cyclic', {'ticks': [(0.0, (255, 0, 4, 255)), (1.0, (255, 0, 0, 255))], 'mode': 'hsv'}),
+ ('greyclip', {'ticks': [(0.0, (0, 0, 0, 255)), (0.99, (255, 255, 255, 255)), (1.0, (255, 0, 0, 255))], 'mode': 'rgb'}),
+ ('grey', {'ticks': [(0.0, (0, 0, 0, 255)), (1.0, (255, 255, 255, 255))], 'mode': 'rgb'}),
+])
+
+
+class TickSliderItem(GraphicsWidget):
+ ## public class
+ """**Bases:** :class:`GraphicsWidget `
+
+ A rectangular item with tick marks along its length that can (optionally) be moved by the user."""
+
+ def __init__(self, orientation='bottom', allowAdd=True, **kargs):
+ """
+ ============= =================================================================================
+ **Arguments**
+ orientation Set the orientation of the gradient. Options are: 'left', 'right'
+ 'top', and 'bottom'.
+ allowAdd Specifies whether ticks can be added to the item by the user.
+ tickPen Default is white. Specifies the color of the outline of the ticks.
+ Can be any of the valid arguments for :func:`mkPen `
+ ============= =================================================================================
+ """
+ ## public
+ GraphicsWidget.__init__(self)
+ self.orientation = orientation
+ self.length = 100
+ self.tickSize = 15
+ self.ticks = {}
+ self.maxDim = 20
+ self.allowAdd = allowAdd
+ if 'tickPen' in kargs:
+ self.tickPen = fn.mkPen(kargs['tickPen'])
+ else:
+ self.tickPen = fn.mkPen('w')
+
+ self.orientations = {
+ 'left': (90, 1, 1),
+ 'right': (90, 1, 1),
+ 'top': (0, 1, -1),
+ 'bottom': (0, 1, 1)
+ }
+
+ self.setOrientation(orientation)
+ #self.setFrameStyle(QtGui.QFrame.NoFrame | QtGui.QFrame.Plain)
+ #self.setBackgroundRole(QtGui.QPalette.NoRole)
+ #self.setMouseTracking(True)
+
+ #def boundingRect(self):
+ #return self.mapRectFromParent(self.geometry()).normalized()
+
+ #def shape(self): ## No idea why this is necessary, but rotated items do not receive clicks otherwise.
+ #p = QtGui.QPainterPath()
+ #p.addRect(self.boundingRect())
+ #return p
+
+ def paint(self, p, opt, widget):
+ #p.setPen(fn.mkPen('g', width=3))
+ #p.drawRect(self.boundingRect())
+ return
+
+ def keyPressEvent(self, ev):
+ ev.ignore()
+
+ def setMaxDim(self, mx=None):
+ if mx is None:
+ mx = self.maxDim
+ else:
+ self.maxDim = mx
+
+ if self.orientation in ['bottom', 'top']:
+ self.setFixedHeight(mx)
+ self.setMaximumWidth(16777215)
+ else:
+ self.setFixedWidth(mx)
+ self.setMaximumHeight(16777215)
+
+
+ def setOrientation(self, orientation):
+ ## public
+ """Set the orientation of the TickSliderItem.
+
+ ============= ===================================================================
+ **Arguments**
+ orientation Options are: 'left', 'right', 'top', 'bottom'
+ The orientation option specifies which side of the slider the
+ ticks are on, as well as whether the slider is vertical ('right'
+ and 'left') or horizontal ('top' and 'bottom').
+ ============= ===================================================================
+ """
+ self.orientation = orientation
+ self.setMaxDim()
+ self.resetTransform()
+ ort = orientation
+ if ort == 'top':
+ self.scale(1, -1)
+ self.translate(0, -self.height())
+ elif ort == 'left':
+ self.rotate(270)
+ self.scale(1, -1)
+ self.translate(-self.height(), -self.maxDim)
+ elif ort == 'right':
+ self.rotate(270)
+ self.translate(-self.height(), 0)
+ #self.setPos(0, -self.height())
+ elif ort != 'bottom':
+ raise Exception("%s is not a valid orientation. Options are 'left', 'right', 'top', and 'bottom'" %str(ort))
+
+ self.translate(self.tickSize/2., 0)
+
+ def addTick(self, x, color=None, movable=True):
+ ## public
+ """
+ Add a tick to the item.
+
+ ============= ==================================================================
+ **Arguments**
+ x Position where tick should be added.
+ color Color of added tick. If color is not specified, the color will be
+ white.
+ movable Specifies whether the tick is movable with the mouse.
+ ============= ==================================================================
+ """
+
+ if color is None:
+ color = QtGui.QColor(255,255,255)
+ tick = Tick(self, [x*self.length, 0], color, movable, self.tickSize, pen=self.tickPen)
+ self.ticks[tick] = x
+ tick.setParentItem(self)
+ return tick
+
+ def removeTick(self, tick):
+ ## public
+ """
+ Removes the specified tick.
+ """
+ del self.ticks[tick]
+ tick.setParentItem(None)
+ if self.scene() is not None:
+ self.scene().removeItem(tick)
+
+ def tickMoved(self, tick, pos):
+ #print "tick changed"
+ ## Correct position of tick if it has left bounds.
+ newX = min(max(0, pos.x()), self.length)
+ pos.setX(newX)
+ tick.setPos(pos)
+ self.ticks[tick] = float(newX) / self.length
+
+ def tickMoveFinished(self, tick):
+ pass
+
+ def tickClicked(self, tick, ev):
+ if ev.button() == QtCore.Qt.RightButton:
+ self.removeTick(tick)
+
+ def widgetLength(self):
+ if self.orientation in ['bottom', 'top']:
+ return self.width()
+ else:
+ return self.height()
+
+ def resizeEvent(self, ev):
+ wlen = max(40, self.widgetLength())
+ self.setLength(wlen-self.tickSize-2)
+ self.setOrientation(self.orientation)
+ #bounds = self.scene().itemsBoundingRect()
+ #bounds.setLeft(min(-self.tickSize*0.5, bounds.left()))
+ #bounds.setRight(max(self.length + self.tickSize, bounds.right()))
+ #self.setSceneRect(bounds)
+ #self.fitInView(bounds, QtCore.Qt.KeepAspectRatio)
+
+ def setLength(self, newLen):
+ #private
+ for t, x in list(self.ticks.items()):
+ t.setPos(x * newLen + 1, t.pos().y())
+ self.length = float(newLen)
+
+ #def mousePressEvent(self, ev):
+ #QtGui.QGraphicsView.mousePressEvent(self, ev)
+ #self.ignoreRelease = False
+ #for i in self.items(ev.pos()):
+ #if isinstance(i, Tick):
+ #self.ignoreRelease = True
+ #break
+ ##if len(self.items(ev.pos())) > 0: ## Let items handle their own clicks
+ ##self.ignoreRelease = True
+
+ #def mouseReleaseEvent(self, ev):
+ #QtGui.QGraphicsView.mouseReleaseEvent(self, ev)
+ #if self.ignoreRelease:
+ #return
+
+ #pos = self.mapToScene(ev.pos())
+
+ #if ev.button() == QtCore.Qt.LeftButton and self.allowAdd:
+ #if pos.x() < 0 or pos.x() > self.length:
+ #return
+ #if pos.y() < 0 or pos.y() > self.tickSize:
+ #return
+ #pos.setX(min(max(pos.x(), 0), self.length))
+ #self.addTick(pos.x()/self.length)
+ #elif ev.button() == QtCore.Qt.RightButton:
+ #self.showMenu(ev)
+
+ def mouseClickEvent(self, ev):
+ if ev.button() == QtCore.Qt.LeftButton and self.allowAdd:
+ pos = ev.pos()
+ if pos.x() < 0 or pos.x() > self.length:
+ return
+ if pos.y() < 0 or pos.y() > self.tickSize:
+ return
+ pos.setX(min(max(pos.x(), 0), self.length))
+ self.addTick(pos.x()/self.length)
+ elif ev.button() == QtCore.Qt.RightButton:
+ self.showMenu(ev)
+
+ #if ev.button() == QtCore.Qt.RightButton:
+ #if self.moving:
+ #ev.accept()
+ #self.setPos(self.startPosition)
+ #self.moving = False
+ #self.sigMoving.emit(self)
+ #self.sigMoved.emit(self)
+ #else:
+ #pass
+ #self.view().tickClicked(self, ev)
+ ###remove
+
+ def hoverEvent(self, ev):
+ if (not ev.isExit()) and ev.acceptClicks(QtCore.Qt.LeftButton):
+ ev.acceptClicks(QtCore.Qt.RightButton)
+ ## show ghost tick
+ #self.currentPen = fn.mkPen(255, 0,0)
+ #else:
+ #self.currentPen = self.pen
+ #self.update()
+
+ def showMenu(self, ev):
+ pass
+
+ def setTickColor(self, tick, color):
+ """Set the color of the specified tick.
+
+ ============= ==================================================================
+ **Arguments**
+ tick Can be either an integer corresponding to the index of the tick
+ or a Tick object. Ex: if you had a slider with 3 ticks and you
+ wanted to change the middle tick, the index would be 1.
+ color The color to make the tick. Can be any argument that is valid for
+ :func:`mkBrush `
+ ============= ==================================================================
+ """
+ tick = self.getTick(tick)
+ tick.color = color
+ tick.update()
+ #tick.setBrush(QtGui.QBrush(QtGui.QColor(tick.color)))
+
+ def setTickValue(self, tick, val):
+ ## public
+ """
+ Set the position (along the slider) of the tick.
+
+ ============= ==================================================================
+ **Arguments**
+ tick Can be either an integer corresponding to the index of the tick
+ or a Tick object. Ex: if you had a slider with 3 ticks and you
+ wanted to change the middle tick, the index would be 1.
+ val The desired position of the tick. If val is < 0, position will be
+ set to 0. If val is > 1, position will be set to 1.
+ ============= ==================================================================
+ """
+ tick = self.getTick(tick)
+ val = min(max(0.0, val), 1.0)
+ x = val * self.length
+ pos = tick.pos()
+ pos.setX(x)
+ tick.setPos(pos)
+ self.ticks[tick] = val
+
+ def tickValue(self, tick):
+ ## public
+ """Return the value (from 0.0 to 1.0) of the specified tick.
+
+ ============= ==================================================================
+ **Arguments**
+ tick Can be either an integer corresponding to the index of the tick
+ or a Tick object. Ex: if you had a slider with 3 ticks and you
+ wanted the value of the middle tick, the index would be 1.
+ ============= ==================================================================
+ """
+ tick = self.getTick(tick)
+ return self.ticks[tick]
+
+ def getTick(self, tick):
+ ## public
+ """Return the Tick object at the specified index.
+
+ ============= ==================================================================
+ **Arguments**
+ tick An integer corresponding to the index of the desired tick. If the
+ argument is not an integer it will be returned unchanged.
+ ============= ==================================================================
+ """
+ if type(tick) is int:
+ tick = self.listTicks()[tick][0]
+ return tick
+
+ #def mouseMoveEvent(self, ev):
+ #QtGui.QGraphicsView.mouseMoveEvent(self, ev)
+
+ def listTicks(self):
+ """Return a sorted list of all the Tick objects on the slider."""
+ ## public
+ ticks = list(self.ticks.items())
+ sortList(ticks, lambda a,b: cmp(a[1], b[1])) ## see pyqtgraph.python2_3.sortList
+ return ticks
+
+
+class GradientEditorItem(TickSliderItem):
+ """
+ **Bases:** :class:`TickSliderItem `
+
+ An item that can be used to define a color gradient. Implements common pre-defined gradients that are
+ customizable by the user. :class: `GradientWidget ` provides a widget
+ with a GradientEditorItem that can be added to a GUI.
+
+ ================================ ===========================================================
+ **Signals**
+ sigGradientChanged(self) Signal is emitted anytime the gradient changes. The signal
+ is emitted in real time while ticks are being dragged or
+ colors are being changed.
+ sigGradientChangeFinished(self) Signal is emitted when the gradient is finished changing.
+ ================================ ===========================================================
+
+ """
+
+ sigGradientChanged = QtCore.Signal(object)
+ sigGradientChangeFinished = QtCore.Signal(object)
+
+ def __init__(self, *args, **kargs):
+ """
+ Create a new GradientEditorItem.
+ All arguments are passed to :func:`TickSliderItem.__init__ `
+
+ ============= =================================================================================
+ **Arguments**
+ orientation Set the orientation of the gradient. Options are: 'left', 'right'
+ 'top', and 'bottom'.
+ allowAdd Default is True. Specifies whether ticks can be added to the item.
+ tickPen Default is white. Specifies the color of the outline of the ticks.
+ Can be any of the valid arguments for :func:`mkPen `
+ ============= =================================================================================
+ """
+ self.currentTick = None
+ self.currentTickColor = None
+ self.rectSize = 15
+ self.gradRect = QtGui.QGraphicsRectItem(QtCore.QRectF(0, self.rectSize, 100, self.rectSize))
+ self.backgroundRect = QtGui.QGraphicsRectItem(QtCore.QRectF(0, -self.rectSize, 100, self.rectSize))
+ self.backgroundRect.setBrush(QtGui.QBrush(QtCore.Qt.DiagCrossPattern))
+ self.colorMode = 'rgb'
+
+ TickSliderItem.__init__(self, *args, **kargs)
+
+ self.colorDialog = QtGui.QColorDialog()
+ self.colorDialog.setOption(QtGui.QColorDialog.ShowAlphaChannel, True)
+ self.colorDialog.setOption(QtGui.QColorDialog.DontUseNativeDialog, True)
+
+ self.colorDialog.currentColorChanged.connect(self.currentColorChanged)
+ self.colorDialog.rejected.connect(self.currentColorRejected)
+ self.colorDialog.accepted.connect(self.currentColorAccepted)
+
+ self.backgroundRect.setParentItem(self)
+ self.gradRect.setParentItem(self)
+
+ self.setMaxDim(self.rectSize + self.tickSize)
+
+ self.rgbAction = QtGui.QAction('RGB', self)
+ self.rgbAction.setCheckable(True)
+ self.rgbAction.triggered.connect(lambda: self.setColorMode('rgb'))
+ self.hsvAction = QtGui.QAction('HSV', self)
+ self.hsvAction.setCheckable(True)
+ self.hsvAction.triggered.connect(lambda: self.setColorMode('hsv'))
+
+ self.menu = QtGui.QMenu()
+
+ ## build context menu of gradients
+ l = self.length
+ self.length = 100
+ global Gradients
+ for g in Gradients:
+ px = QtGui.QPixmap(100, 15)
+ p = QtGui.QPainter(px)
+ self.restoreState(Gradients[g])
+ grad = self.getGradient()
+ brush = QtGui.QBrush(grad)
+ p.fillRect(QtCore.QRect(0, 0, 100, 15), brush)
+ p.end()
+ label = QtGui.QLabel()
+ label.setPixmap(px)
+ label.setContentsMargins(1, 1, 1, 1)
+ act = QtGui.QWidgetAction(self)
+ act.setDefaultWidget(label)
+ act.triggered.connect(self.contextMenuClicked)
+ act.name = g
+ self.menu.addAction(act)
+ self.length = l
+ self.menu.addSeparator()
+ self.menu.addAction(self.rgbAction)
+ self.menu.addAction(self.hsvAction)
+
+
+ for t in list(self.ticks.keys()):
+ self.removeTick(t)
+ self.addTick(0, QtGui.QColor(0,0,0), True)
+ self.addTick(1, QtGui.QColor(255,0,0), True)
+ self.setColorMode('rgb')
+ self.updateGradient()
+
+ def setOrientation(self, orientation):
+ ## public
+ """
+ Set the orientation of the GradientEditorItem.
+
+ ============= ===================================================================
+ **Arguments**
+ orientation Options are: 'left', 'right', 'top', 'bottom'
+ The orientation option specifies which side of the gradient the
+ ticks are on, as well as whether the gradient is vertical ('right'
+ and 'left') or horizontal ('top' and 'bottom').
+ ============= ===================================================================
+ """
+ TickSliderItem.setOrientation(self, orientation)
+ self.translate(0, self.rectSize)
+
+ def showMenu(self, ev):
+ #private
+ self.menu.popup(ev.screenPos().toQPoint())
+
+ def contextMenuClicked(self, b=None):
+ #private
+ #global Gradients
+ act = self.sender()
+ self.loadPreset(act.name)
+
+ def loadPreset(self, name):
+ """
+ Load a predefined gradient.
+
+ """ ## TODO: provide image with names of defined gradients
+ #global Gradients
+ self.restoreState(Gradients[name])
+
+ def setColorMode(self, cm):
+ """
+ Set the color mode for the gradient. Options are: 'hsv', 'rgb'
+
+ """
+
+ ## public
+ if cm not in ['rgb', 'hsv']:
+ raise Exception("Unknown color mode %s. Options are 'rgb' and 'hsv'." % str(cm))
+
+ try:
+ self.rgbAction.blockSignals(True)
+ self.hsvAction.blockSignals(True)
+ self.rgbAction.setChecked(cm == 'rgb')
+ self.hsvAction.setChecked(cm == 'hsv')
+ finally:
+ self.rgbAction.blockSignals(False)
+ self.hsvAction.blockSignals(False)
+ self.colorMode = cm
+ self.updateGradient()
+
+ def updateGradient(self):
+ #private
+ self.gradient = self.getGradient()
+ self.gradRect.setBrush(QtGui.QBrush(self.gradient))
+ self.sigGradientChanged.emit(self)
+
+ def setLength(self, newLen):
+ #private (but maybe public)
+ TickSliderItem.setLength(self, newLen)
+ self.backgroundRect.setRect(1, -self.rectSize, newLen, self.rectSize)
+ self.gradRect.setRect(1, -self.rectSize, newLen, self.rectSize)
+ self.updateGradient()
+
+ def currentColorChanged(self, color):
+ #private
+ if color.isValid() and self.currentTick is not None:
+ self.setTickColor(self.currentTick, color)
+ self.updateGradient()
+
+ def currentColorRejected(self):
+ #private
+ self.setTickColor(self.currentTick, self.currentTickColor)
+ self.updateGradient()
+
+ def currentColorAccepted(self):
+ self.sigGradientChangeFinished.emit(self)
+
+ def tickClicked(self, tick, ev):
+ #private
+ if ev.button() == QtCore.Qt.LeftButton:
+ if not tick.colorChangeAllowed:
+ return
+ self.currentTick = tick
+ self.currentTickColor = tick.color
+ self.colorDialog.setCurrentColor(tick.color)
+ self.colorDialog.open()
+ #color = QtGui.QColorDialog.getColor(tick.color, self, "Select Color", QtGui.QColorDialog.ShowAlphaChannel)
+ #if color.isValid():
+ #self.setTickColor(tick, color)
+ #self.updateGradient()
+ elif ev.button() == QtCore.Qt.RightButton:
+ if not tick.removeAllowed:
+ return
+ if len(self.ticks) > 2:
+ self.removeTick(tick)
+ self.updateGradient()
+
+ def tickMoved(self, tick, pos):
+ #private
+ TickSliderItem.tickMoved(self, tick, pos)
+ self.updateGradient()
+
+ def tickMoveFinished(self, tick):
+ self.sigGradientChangeFinished.emit(self)
+
+
+ def getGradient(self):
+ """Return a QLinearGradient object."""
+ g = QtGui.QLinearGradient(QtCore.QPointF(0,0), QtCore.QPointF(self.length,0))
+ if self.colorMode == 'rgb':
+ ticks = self.listTicks()
+ g.setStops([(x, QtGui.QColor(t.color)) for t,x in ticks])
+ elif self.colorMode == 'hsv': ## HSV mode is approximated for display by interpolating 10 points between each stop
+ ticks = self.listTicks()
+ stops = []
+ stops.append((ticks[0][1], ticks[0][0].color))
+ for i in range(1,len(ticks)):
+ x1 = ticks[i-1][1]
+ x2 = ticks[i][1]
+ dx = (x2-x1) / 10.
+ for j in range(1,10):
+ x = x1 + dx*j
+ stops.append((x, self.getColor(x)))
+ stops.append((x2, self.getColor(x2)))
+ g.setStops(stops)
+ return g
+
+ def getColor(self, x, toQColor=True):
+ """
+ Return a color for a given value.
+
+ ============= ==================================================================
+ **Arguments**
+ x Value (position on gradient) of requested color.
+ toQColor If true, returns a QColor object, else returns a (r,g,b,a) tuple.
+ ============= ==================================================================
+ """
+ ticks = self.listTicks()
+ if x <= ticks[0][1]:
+ c = ticks[0][0].color
+ if toQColor:
+ return QtGui.QColor(c) # always copy colors before handing them out
+ else:
+ return (c.red(), c.green(), c.blue(), c.alpha())
+ if x >= ticks[-1][1]:
+ c = ticks[-1][0].color
+ if toQColor:
+ return QtGui.QColor(c) # always copy colors before handing them out
+ else:
+ return (c.red(), c.green(), c.blue(), c.alpha())
+
+ x2 = ticks[0][1]
+ for i in range(1,len(ticks)):
+ x1 = x2
+ x2 = ticks[i][1]
+ if x1 <= x and x2 >= x:
+ break
+
+ dx = (x2-x1)
+ if dx == 0:
+ f = 0.
+ else:
+ f = (x-x1) / dx
+ c1 = ticks[i-1][0].color
+ c2 = ticks[i][0].color
+ if self.colorMode == 'rgb':
+ r = c1.red() * (1.-f) + c2.red() * f
+ g = c1.green() * (1.-f) + c2.green() * f
+ b = c1.blue() * (1.-f) + c2.blue() * f
+ a = c1.alpha() * (1.-f) + c2.alpha() * f
+ if toQColor:
+ return QtGui.QColor(r, g, b,a)
+ else:
+ return (r,g,b,a)
+ elif self.colorMode == 'hsv':
+ h1,s1,v1,_ = c1.getHsv()
+ h2,s2,v2,_ = c2.getHsv()
+ h = h1 * (1.-f) + h2 * f
+ s = s1 * (1.-f) + s2 * f
+ v = v1 * (1.-f) + v2 * f
+ c = QtGui.QColor()
+ c.setHsv(h,s,v)
+ if toQColor:
+ return c
+ else:
+ return (c.red(), c.green(), c.blue(), c.alpha())
+
+ def getLookupTable(self, nPts, alpha=None):
+ """
+ Return an RGB(A) lookup table (ndarray).
+
+ ============= ============================================================================
+ **Arguments**
+ nPts The number of points in the returned lookup table.
+ alpha True, False, or None - Specifies whether or not alpha values are included
+ in the table.If alpha is None, alpha will be automatically determined.
+ ============= ============================================================================
+ """
+ if alpha is None:
+ alpha = self.usesAlpha()
+ if alpha:
+ table = np.empty((nPts,4), dtype=np.ubyte)
+ else:
+ table = np.empty((nPts,3), dtype=np.ubyte)
+
+ for i in range(nPts):
+ x = float(i)/(nPts-1)
+ color = self.getColor(x, toQColor=False)
+ table[i] = color[:table.shape[1]]
+
+ return table
+
+ def usesAlpha(self):
+ """Return True if any ticks have an alpha < 255"""
+
+ ticks = self.listTicks()
+ for t in ticks:
+ if t[0].color.alpha() < 255:
+ return True
+
+ return False
+
+ def isLookupTrivial(self):
+ """Return True if the gradient has exactly two stops in it: black at 0.0 and white at 1.0"""
+ ticks = self.listTicks()
+ if len(ticks) != 2:
+ return False
+ if ticks[0][1] != 0.0 or ticks[1][1] != 1.0:
+ return False
+ c1 = fn.colorTuple(ticks[0][0].color)
+ c2 = fn.colorTuple(ticks[1][0].color)
+ if c1 != (0,0,0,255) or c2 != (255,255,255,255):
+ return False
+ return True
+
+
+ def mouseReleaseEvent(self, ev):
+ #private
+ TickSliderItem.mouseReleaseEvent(self, ev)
+ self.updateGradient()
+
+ def addTick(self, x, color=None, movable=True, finish=True):
+ """
+ Add a tick to the gradient. Return the tick.
+
+ ============= ==================================================================
+ **Arguments**
+ x Position where tick should be added.
+ color Color of added tick. If color is not specified, the color will be
+ the color of the gradient at the specified position.
+ movable Specifies whether the tick is movable with the mouse.
+ ============= ==================================================================
+ """
+
+
+ if color is None:
+ color = self.getColor(x)
+ t = TickSliderItem.addTick(self, x, color=color, movable=movable)
+ t.colorChangeAllowed = True
+ t.removeAllowed = True
+
+ if finish:
+ self.sigGradientChangeFinished.emit(self)
+ return t
+
+
+ def removeTick(self, tick, finish=True):
+ TickSliderItem.removeTick(self, tick)
+ if finish:
+ self.sigGradientChangeFinished.emit(self)
+
+
+ def saveState(self):
+ """
+ Return a dictionary with parameters for rebuilding the gradient. Keys will include:
+
+ - 'mode': hsv or rgb
+ - 'ticks': a list of tuples (pos, (r,g,b,a))
+ """
+ ## public
+ ticks = []
+ for t in self.ticks:
+ c = t.color
+ ticks.append((self.ticks[t], (c.red(), c.green(), c.blue(), c.alpha())))
+ state = {'mode': self.colorMode, 'ticks': ticks}
+ return state
+
+ def restoreState(self, state):
+ """
+ Restore the gradient specified in state.
+
+ ============= ====================================================================
+ **Arguments**
+ state A dictionary with same structure as those returned by
+ :func:`saveState `
+
+ Keys must include:
+
+ - 'mode': hsv or rgb
+ - 'ticks': a list of tuples (pos, (r,g,b,a))
+ ============= ====================================================================
+ """
+ ## public
+ self.setColorMode(state['mode'])
+ for t in list(self.ticks.keys()):
+ self.removeTick(t, finish=False)
+ for t in state['ticks']:
+ c = QtGui.QColor(*t[1])
+ self.addTick(t[0], c, finish=False)
+ self.updateGradient()
+ self.sigGradientChangeFinished.emit(self)
+
+
+class Tick(GraphicsObject):
+ ## private class
+
+ sigMoving = QtCore.Signal(object)
+ sigMoved = QtCore.Signal(object)
+
+ def __init__(self, view, pos, color, movable=True, scale=10, pen='w'):
+ self.movable = movable
+ self.moving = False
+ self.view = weakref.ref(view)
+ self.scale = scale
+ self.color = color
+ self.pen = fn.mkPen(pen)
+ self.hoverPen = fn.mkPen(255,255,0)
+ self.currentPen = self.pen
+ self.pg = QtGui.QPainterPath(QtCore.QPointF(0,0))
+ self.pg.lineTo(QtCore.QPointF(-scale/3**0.5, scale))
+ self.pg.lineTo(QtCore.QPointF(scale/3**0.5, scale))
+ self.pg.closeSubpath()
+
+ GraphicsObject.__init__(self)
+ self.setPos(pos[0], pos[1])
+ if self.movable:
+ self.setZValue(1)
+ else:
+ self.setZValue(0)
+
+ def boundingRect(self):
+ return self.pg.boundingRect()
+
+ def shape(self):
+ return self.pg
+
+ def paint(self, p, *args):
+ p.setRenderHints(QtGui.QPainter.Antialiasing)
+ p.fillPath(self.pg, fn.mkBrush(self.color))
+
+ p.setPen(self.currentPen)
+ p.drawPath(self.pg)
+
+
+ def mouseDragEvent(self, ev):
+ if self.movable and ev.button() == QtCore.Qt.LeftButton:
+ if ev.isStart():
+ self.moving = True
+ self.cursorOffset = self.pos() - self.mapToParent(ev.buttonDownPos())
+ self.startPosition = self.pos()
+ ev.accept()
+
+ if not self.moving:
+ return
+
+ newPos = self.cursorOffset + self.mapToParent(ev.pos())
+ newPos.setY(self.pos().y())
+
+ self.setPos(newPos)
+ self.view().tickMoved(self, newPos)
+ self.sigMoving.emit(self)
+ if ev.isFinish():
+ self.moving = False
+ self.sigMoved.emit(self)
+ self.view().tickMoveFinished(self)
+
+ def mouseClickEvent(self, ev):
+ if ev.button() == QtCore.Qt.RightButton and self.moving:
+ ev.accept()
+ self.setPos(self.startPosition)
+ self.view().tickMoved(self, self.startPosition)
+ self.moving = False
+ self.sigMoving.emit(self)
+ self.sigMoved.emit(self)
+ else:
+ self.view().tickClicked(self, ev)
+ ##remove
+
+ def hoverEvent(self, ev):
+ if (not ev.isExit()) and ev.acceptDrags(QtCore.Qt.LeftButton):
+ ev.acceptClicks(QtCore.Qt.LeftButton)
+ ev.acceptClicks(QtCore.Qt.RightButton)
+ self.currentPen = self.hoverPen
+ else:
+ self.currentPen = self.pen
+ self.update()
+
+ #def mouseMoveEvent(self, ev):
+ ##print self, "move", ev.scenePos()
+ #if not self.movable:
+ #return
+ #if not ev.buttons() & QtCore.Qt.LeftButton:
+ #return
+
+
+ #newPos = ev.scenePos() + self.mouseOffset
+ #newPos.setY(self.pos().y())
+ ##newPos.setX(min(max(newPos.x(), 0), 100))
+ #self.setPos(newPos)
+ #self.view().tickMoved(self, newPos)
+ #self.movedSincePress = True
+ ##self.emit(QtCore.SIGNAL('tickChanged'), self)
+ #ev.accept()
+
+ #def mousePressEvent(self, ev):
+ #self.movedSincePress = False
+ #if ev.button() == QtCore.Qt.LeftButton:
+ #ev.accept()
+ #self.mouseOffset = self.pos() - ev.scenePos()
+ #self.pressPos = ev.scenePos()
+ #elif ev.button() == QtCore.Qt.RightButton:
+ #ev.accept()
+ ##if self.endTick:
+ ##return
+ ##self.view.tickChanged(self, delete=True)
+
+ #def mouseReleaseEvent(self, ev):
+ ##print self, "release", ev.scenePos()
+ #if not self.movedSincePress:
+ #self.view().tickClicked(self, ev)
+
+ ##if ev.button() == QtCore.Qt.LeftButton and ev.scenePos() == self.pressPos:
+ ##color = QtGui.QColorDialog.getColor(self.color, None, "Select Color", QtGui.QColorDialog.ShowAlphaChannel)
+ ##if color.isValid():
+ ##self.color = color
+ ##self.setBrush(QtGui.QBrush(QtGui.QColor(self.color)))
+ ###self.emit(QtCore.SIGNAL('tickChanged'), self)
+ ##self.view.tickChanged(self)
diff --git a/pyqtgraph/graphicsItems/GradientLegend.py b/pyqtgraph/graphicsItems/GradientLegend.py
new file mode 100644
index 00000000..4528b7ed
--- /dev/null
+++ b/pyqtgraph/graphicsItems/GradientLegend.py
@@ -0,0 +1,114 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from .UIGraphicsItem import *
+import pyqtgraph.functions as fn
+
+__all__ = ['GradientLegend']
+
+class GradientLegend(UIGraphicsItem):
+ """
+ Draws a color gradient rectangle along with text labels denoting the value at specific
+ points along the gradient.
+ """
+
+ def __init__(self, size, offset):
+ self.size = size
+ self.offset = offset
+ UIGraphicsItem.__init__(self)
+ self.setAcceptedMouseButtons(QtCore.Qt.NoButton)
+ self.brush = QtGui.QBrush(QtGui.QColor(200,0,0))
+ self.pen = QtGui.QPen(QtGui.QColor(0,0,0))
+ self.labels = {'max': 1, 'min': 0}
+ self.gradient = QtGui.QLinearGradient()
+ self.gradient.setColorAt(0, QtGui.QColor(0,0,0))
+ self.gradient.setColorAt(1, QtGui.QColor(255,0,0))
+
+ def setGradient(self, g):
+ self.gradient = g
+ self.update()
+
+ def setIntColorScale(self, minVal, maxVal, *args, **kargs):
+ colors = [fn.intColor(i, maxVal-minVal, *args, **kargs) for i in range(minVal, maxVal)]
+ g = QtGui.QLinearGradient()
+ for i in range(len(colors)):
+ x = float(i)/len(colors)
+ g.setColorAt(x, colors[i])
+ self.setGradient(g)
+ if 'labels' not in kargs:
+ self.setLabels({str(minVal/10.): 0, str(maxVal): 1})
+ else:
+ self.setLabels({kargs['labels'][0]:0, kargs['labels'][1]:1})
+
+ def setLabels(self, l):
+ """Defines labels to appear next to the color scale. Accepts a dict of {text: value} pairs"""
+ self.labels = l
+ self.update()
+
+ def paint(self, p, opt, widget):
+ UIGraphicsItem.paint(self, p, opt, widget)
+ rect = self.boundingRect() ## Boundaries of visible area in scene coords.
+ unit = self.pixelSize() ## Size of one view pixel in scene coords.
+ if unit[0] is None:
+ return
+
+ ## determine max width of all labels
+ labelWidth = 0
+ labelHeight = 0
+ for k in self.labels:
+ b = p.boundingRect(QtCore.QRectF(0, 0, 0, 0), QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter, str(k))
+ labelWidth = max(labelWidth, b.width())
+ labelHeight = max(labelHeight, b.height())
+
+ labelWidth *= unit[0]
+ labelHeight *= unit[1]
+
+ textPadding = 2 # in px
+
+ if self.offset[0] < 0:
+ x3 = rect.right() + unit[0] * self.offset[0]
+ x2 = x3 - labelWidth - unit[0]*textPadding*2
+ x1 = x2 - unit[0] * self.size[0]
+ else:
+ x1 = rect.left() + unit[0] * self.offset[0]
+ x2 = x1 + unit[0] * self.size[0]
+ x3 = x2 + labelWidth + unit[0]*textPadding*2
+ if self.offset[1] < 0:
+ y2 = rect.top() - unit[1] * self.offset[1]
+ y1 = y2 + unit[1] * self.size[1]
+ else:
+ y1 = rect.bottom() - unit[1] * self.offset[1]
+ y2 = y1 - unit[1] * self.size[1]
+ self.b = [x1,x2,x3,y1,y2,labelWidth]
+
+ ## Draw background
+ p.setPen(self.pen)
+ p.setBrush(QtGui.QBrush(QtGui.QColor(255,255,255,100)))
+ rect = QtCore.QRectF(
+ QtCore.QPointF(x1 - unit[0]*textPadding, y1 + labelHeight/2 + unit[1]*textPadding),
+ QtCore.QPointF(x3, y2 - labelHeight/2 - unit[1]*textPadding)
+ )
+ p.drawRect(rect)
+
+
+ ## Have to scale painter so that text and gradients are correct size. Bleh.
+ p.scale(unit[0], unit[1])
+
+ ## Draw color bar
+ self.gradient.setStart(0, y1/unit[1])
+ self.gradient.setFinalStop(0, y2/unit[1])
+ p.setBrush(self.gradient)
+ rect = QtCore.QRectF(
+ QtCore.QPointF(x1/unit[0], y1/unit[1]),
+ QtCore.QPointF(x2/unit[0], y2/unit[1])
+ )
+ p.drawRect(rect)
+
+
+ ## draw labels
+ p.setPen(QtGui.QPen(QtGui.QColor(0,0,0)))
+ tx = x2 + unit[0]*textPadding
+ lh = labelHeight/unit[1]
+ for k in self.labels:
+ y = y1 + self.labels[k] * (y2-y1)
+ p.drawText(QtCore.QRectF(tx/unit[0], y/unit[1] - lh/2.0, 1000, lh), QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter, str(k))
+
+
diff --git a/pyqtgraph/graphicsItems/GraphicsItem.py b/pyqtgraph/graphicsItems/GraphicsItem.py
new file mode 100644
index 00000000..6a0825dd
--- /dev/null
+++ b/pyqtgraph/graphicsItems/GraphicsItem.py
@@ -0,0 +1,499 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.GraphicsScene import GraphicsScene
+from pyqtgraph.Point import Point
+import pyqtgraph.functions as fn
+import weakref
+import operator
+
+class GraphicsItem(object):
+ """
+ **Bases:** :class:`object`
+
+ Abstract class providing useful methods to GraphicsObject and GraphicsWidget.
+ (This is required because we cannot have multiple inheritance with QObject subclasses.)
+
+ A note about Qt's GraphicsView framework:
+
+ The GraphicsView system places a lot of emphasis on the notion that the graphics within the scene should be device independent--you should be able to take the same graphics and display them on screens of different resolutions, printers, export to SVG, etc. This is nice in principle, but causes me a lot of headache in practice. It means that I have to circumvent all the device-independent expectations any time I want to operate in pixel coordinates rather than arbitrary scene coordinates. A lot of the code in GraphicsItem is devoted to this task--keeping track of view widgets and device transforms, computing the size and shape of a pixel in local item coordinates, etc. Note that in item coordinates, a pixel does not have to be square or even rectangular, so just asking how to increase a bounding rect by 2px can be a rather complex task.
+ """
+ def __init__(self, register=True):
+ if not hasattr(self, '_qtBaseClass'):
+ for b in self.__class__.__bases__:
+ if issubclass(b, QtGui.QGraphicsItem):
+ self.__class__._qtBaseClass = b
+ break
+ if not hasattr(self, '_qtBaseClass'):
+ raise Exception('Could not determine Qt base class for GraphicsItem: %s' % str(self))
+
+ self._viewWidget = None
+ self._viewBox = None
+ self._connectedView = None
+ self._exportOpts = False ## If False, not currently exporting. Otherwise, contains dict of export options.
+ if register:
+ GraphicsScene.registerObject(self) ## workaround for pyqt bug in graphicsscene.items()
+
+
+
+
+ def getViewWidget(self):
+ """
+ Return the view widget for this item. If the scene has multiple views, only the first view is returned.
+ The return value is cached; clear the cached value with forgetViewWidget()
+ """
+ if self._viewWidget is None:
+ scene = self.scene()
+ if scene is None:
+ return None
+ views = scene.views()
+ if len(views) < 1:
+ return None
+ self._viewWidget = weakref.ref(self.scene().views()[0])
+ return self._viewWidget()
+
+ def forgetViewWidget(self):
+ self._viewWidget = None
+
+ def getViewBox(self):
+ """
+ Return the first ViewBox or GraphicsView which bounds this item's visible space.
+ If this item is not contained within a ViewBox, then the GraphicsView is returned.
+ If the item is contained inside nested ViewBoxes, then the inner-most ViewBox is returned.
+ The result is cached; clear the cache with forgetViewBox()
+ """
+ if self._viewBox is None:
+ p = self
+ while True:
+ p = p.parentItem()
+ if p is None:
+ vb = self.getViewWidget()
+ if vb is None:
+ return None
+ else:
+ self._viewBox = weakref.ref(vb)
+ break
+ if hasattr(p, 'implements') and p.implements('ViewBox'):
+ self._viewBox = weakref.ref(p)
+ break
+ return self._viewBox() ## If we made it this far, _viewBox is definitely not None
+
+ def forgetViewBox(self):
+ self._viewBox = None
+
+
+ def deviceTransform(self, viewportTransform=None):
+ """
+ Return the transform that converts local item coordinates to device coordinates (usually pixels).
+ Extends deviceTransform to automatically determine the viewportTransform.
+ """
+ if self._exportOpts is not False and 'painter' in self._exportOpts: ## currently exporting; device transform may be different.
+ return self._exportOpts['painter'].deviceTransform()
+
+ if viewportTransform is None:
+ view = self.getViewWidget()
+ if view is None:
+ return None
+ viewportTransform = view.viewportTransform()
+ dt = self._qtBaseClass.deviceTransform(self, viewportTransform)
+
+ #xmag = abs(dt.m11())+abs(dt.m12())
+ #ymag = abs(dt.m21())+abs(dt.m22())
+ #if xmag * ymag == 0:
+ if dt.determinant() == 0: ## occurs when deviceTransform is invalid because widget has not been displayed
+ return None
+ else:
+ return dt
+
+ def viewTransform(self):
+ """Return the transform that maps from local coordinates to the item's ViewBox coordinates
+ If there is no ViewBox, return the scene transform.
+ Returns None if the item does not have a view."""
+ view = self.getViewBox()
+ if view is None:
+ return None
+ if hasattr(view, 'implements') and view.implements('ViewBox'):
+ tr = self.itemTransform(view.innerSceneItem())
+ if isinstance(tr, tuple):
+ tr = tr[0] ## difference between pyside and pyqt
+ return tr
+ else:
+ return self.sceneTransform()
+ #return self.deviceTransform(view.viewportTransform())
+
+
+
+ def getBoundingParents(self):
+ """Return a list of parents to this item that have child clipping enabled."""
+ p = self
+ parents = []
+ while True:
+ p = p.parentItem()
+ if p is None:
+ break
+ if p.flags() & self.ItemClipsChildrenToShape:
+ parents.append(p)
+ return parents
+
+ def viewRect(self):
+ """Return the bounds (in item coordinates) of this item's ViewBox or GraphicsWidget"""
+ view = self.getViewBox()
+ if view is None:
+ return None
+ bounds = self.mapRectFromView(view.viewRect())
+ if bounds is None:
+ return None
+
+ bounds = bounds.normalized()
+
+ ## nah.
+ #for p in self.getBoundingParents():
+ #bounds &= self.mapRectFromScene(p.sceneBoundingRect())
+
+ return bounds
+
+
+
+
+ def pixelVectors(self, direction=None):
+ """Return vectors in local coordinates representing the width and height of a view pixel.
+ If direction is specified, then return vectors parallel and orthogonal to it.
+
+ Return (None, None) if pixel size is not yet defined (usually because the item has not yet been displayed)
+ or if pixel size is below floating-point precision limit.
+ """
+
+ dt = self.deviceTransform()
+ if dt is None:
+ return None, None
+
+ if direction is None:
+ direction = Point(1, 0)
+ if direction.manhattanLength() == 0:
+ raise Exception("Cannot compute pixel length for 0-length vector.")
+
+ ## attempt to re-scale direction vector to fit within the precision of the coordinate system
+ if direction.x() == 0:
+ r = abs(dt.m32())/(abs(dt.m12()) + abs(dt.m22()))
+ #r = 1.0/(abs(dt.m12()) + abs(dt.m22()))
+ elif direction.y() == 0:
+ r = abs(dt.m31())/(abs(dt.m11()) + abs(dt.m21()))
+ #r = 1.0/(abs(dt.m11()) + abs(dt.m21()))
+ else:
+ r = ((abs(dt.m32())/(abs(dt.m12()) + abs(dt.m22()))) * (abs(dt.m31())/(abs(dt.m11()) + abs(dt.m21()))))**0.5
+ directionr = direction * r
+
+ viewDir = Point(dt.map(directionr) - dt.map(Point(0,0)))
+ if viewDir.manhattanLength() == 0:
+ return None, None ## pixel size cannot be represented on this scale
+
+ orthoDir = Point(viewDir[1], -viewDir[0]) ## orthogonal to line in pixel-space
+
+ try:
+ normView = viewDir.norm() ## direction of one pixel orthogonal to line
+ normOrtho = orthoDir.norm()
+ except:
+ raise Exception("Invalid direction %s" %directionr)
+
+
+ dti = fn.invertQTransform(dt)
+ return Point(dti.map(normView)-dti.map(Point(0,0))), Point(dti.map(normOrtho)-dti.map(Point(0,0)))
+
+ #vt = self.deviceTransform()
+ #if vt is None:
+ #return None
+ #vt = vt.inverted()[0]
+ #orig = vt.map(QtCore.QPointF(0, 0))
+ #return vt.map(QtCore.QPointF(1, 0))-orig, vt.map(QtCore.QPointF(0, 1))-orig
+
+ def pixelLength(self, direction, ortho=False):
+ """Return the length of one pixel in the direction indicated (in local coordinates)
+ If ortho=True, then return the length of one pixel orthogonal to the direction indicated.
+
+ Return None if pixel size is not yet defined (usually because the item has not yet been displayed).
+ """
+ normV, orthoV = self.pixelVectors(direction)
+ if normV == None or orthoV == None:
+ return None
+ if ortho:
+ return orthoV.length()
+ return normV.length()
+
+
+
+ def pixelSize(self):
+ ## deprecated
+ v = self.pixelVectors()
+ if v == (None, None):
+ return None, None
+ return (v[0].x()**2+v[0].y()**2)**0.5, (v[1].x()**2+v[1].y()**2)**0.5
+
+ def pixelWidth(self):
+ ## deprecated
+ vt = self.deviceTransform()
+ if vt is None:
+ return 0
+ vt = fn.invertQTransform(vt)
+ return Point(vt.map(QtCore.QPointF(1, 0))-vt.map(QtCore.QPointF(0, 0))).length()
+
+ def pixelHeight(self):
+ ## deprecated
+ vt = self.deviceTransform()
+ if vt is None:
+ return 0
+ vt = fn.invertQTransform(vt)
+ return Point(vt.map(QtCore.QPointF(0, 1))-vt.map(QtCore.QPointF(0, 0))).length()
+
+
+ def mapToDevice(self, obj):
+ """
+ Return *obj* mapped from local coordinates to device coordinates (pixels).
+ If there is no device mapping available, return None.
+ """
+ vt = self.deviceTransform()
+ if vt is None:
+ return None
+ return vt.map(obj)
+
+ def mapFromDevice(self, obj):
+ """
+ Return *obj* mapped from device coordinates (pixels) to local coordinates.
+ If there is no device mapping available, return None.
+ """
+ vt = self.deviceTransform()
+ if vt is None:
+ return None
+ vt = fn.invertQTransform(vt)
+ return vt.map(obj)
+
+ def mapRectToDevice(self, rect):
+ """
+ Return *rect* mapped from local coordinates to device coordinates (pixels).
+ If there is no device mapping available, return None.
+ """
+ vt = self.deviceTransform()
+ if vt is None:
+ return None
+ return vt.mapRect(rect)
+
+ def mapRectFromDevice(self, rect):
+ """
+ Return *rect* mapped from device coordinates (pixels) to local coordinates.
+ If there is no device mapping available, return None.
+ """
+ vt = self.deviceTransform()
+ if vt is None:
+ return None
+ vt = fn.invertQTransform(vt)
+ return vt.mapRect(rect)
+
+ def mapToView(self, obj):
+ vt = self.viewTransform()
+ if vt is None:
+ return None
+ return vt.map(obj)
+
+ def mapRectToView(self, obj):
+ vt = self.viewTransform()
+ if vt is None:
+ return None
+ return vt.mapRect(obj)
+
+ def mapFromView(self, obj):
+ vt = self.viewTransform()
+ if vt is None:
+ return None
+ vt = fn.invertQTransform(vt)
+ return vt.map(obj)
+
+ def mapRectFromView(self, obj):
+ vt = self.viewTransform()
+ if vt is None:
+ return None
+ vt = fn.invertQTransform(vt)
+ return vt.mapRect(obj)
+
+ def pos(self):
+ return Point(self._qtBaseClass.pos(self))
+
+ def viewPos(self):
+ return self.mapToView(self.mapFromParent(self.pos()))
+
+ def parentItem(self):
+ ## PyQt bug -- some items are returned incorrectly.
+ return GraphicsScene.translateGraphicsItem(self._qtBaseClass.parentItem(self))
+
+ def setParentItem(self, parent):
+ ## Workaround for Qt bug: https://bugreports.qt-project.org/browse/QTBUG-18616
+ if parent is not None:
+ pscene = parent.scene()
+ if pscene is not None and self.scene() is not pscene:
+ pscene.addItem(self)
+ return self._qtBaseClass.setParentItem(self, parent)
+
+ def childItems(self):
+ ## PyQt bug -- some child items are returned incorrectly.
+ return list(map(GraphicsScene.translateGraphicsItem, self._qtBaseClass.childItems(self)))
+
+
+ def sceneTransform(self):
+ ## Qt bug: do no allow access to sceneTransform() until
+ ## the item has a scene.
+
+ if self.scene() is None:
+ return self.transform()
+ else:
+ return self._qtBaseClass.sceneTransform(self)
+
+
+ def transformAngle(self, relativeItem=None):
+ """Return the rotation produced by this item's transform (this assumes there is no shear in the transform)
+ If relativeItem is given, then the angle is determined relative to that item.
+ """
+ if relativeItem is None:
+ relativeItem = self.parentItem()
+
+
+ tr = self.itemTransform(relativeItem)
+ if isinstance(tr, tuple): ## difference between pyside and pyqt
+ tr = tr[0]
+ vec = tr.map(Point(1,0)) - tr.map(Point(0,0))
+ return Point(vec).angle(Point(1,0))
+
+
+ #def itemChange(self, change, value):
+ #ret = self._qtBaseClass.itemChange(self, change, value)
+ #if change == self.ItemParentHasChanged or change == self.ItemSceneHasChanged:
+ #print "Item scene changed:", self
+ #self.setChildScene(self) ## This is bizarre.
+ #return ret
+
+ #def setChildScene(self, ch):
+ #scene = self.scene()
+ #for ch2 in ch.childItems():
+ #if ch2.scene() is not scene:
+ #print "item", ch2, "has different scene:", ch2.scene(), scene
+ #scene.addItem(ch2)
+ #QtGui.QApplication.processEvents()
+ #print " --> ", ch2.scene()
+ #self.setChildScene(ch2)
+
+ def _updateView(self):
+ ## called to see whether this item has a new view to connect to
+ ## NOTE: This is called from GraphicsObject.itemChange or GraphicsWidget.itemChange.
+
+ ## It is possible this item has moved to a different ViewBox or widget;
+ ## clear out previously determined references to these.
+ self.forgetViewBox()
+ self.forgetViewWidget()
+
+ ## check for this item's current viewbox or view widget
+ view = self.getViewBox()
+ #if view is None:
+ ##print " no view"
+ #return
+
+ oldView = None
+ if self._connectedView is not None:
+ oldView = self._connectedView()
+
+ if view is oldView:
+ #print " already have view", view
+ return
+
+ ## disconnect from previous view
+ if oldView is not None:
+ #print "disconnect:", self, oldView
+ try:
+ oldView.sigRangeChanged.disconnect(self.viewRangeChanged)
+ except TypeError:
+ pass
+
+ try:
+ oldView.sigTransformChanged.disconnect(self.viewTransformChanged)
+ except TypeError:
+ pass
+
+ self._connectedView = None
+
+ ## connect to new view
+ if view is not None:
+ #print "connect:", self, view
+ view.sigRangeChanged.connect(self.viewRangeChanged)
+ view.sigTransformChanged.connect(self.viewTransformChanged)
+ self._connectedView = weakref.ref(view)
+ self.viewRangeChanged()
+ self.viewTransformChanged()
+
+ ## inform children that their view might have changed
+ self._replaceView(oldView)
+
+
+ def _replaceView(self, oldView, item=None):
+ if item is None:
+ item = self
+ for child in item.childItems():
+ if isinstance(child, GraphicsItem):
+ if child.getViewBox() is oldView:
+ child._updateView()
+ #self._replaceView(oldView, child)
+ else:
+ self._replaceView(oldView, child)
+
+
+
+ def viewRangeChanged(self):
+ """
+ Called whenever the view coordinates of the ViewBox containing this item have changed.
+ """
+ pass
+
+ def viewTransformChanged(self):
+ """
+ Called whenever the transformation matrix of the view has changed.
+ """
+ pass
+
+ #def prepareGeometryChange(self):
+ #self._qtBaseClass.prepareGeometryChange(self)
+ #self.informViewBoundsChanged()
+
+ def informViewBoundsChanged(self):
+ """
+ Inform this item's container ViewBox that the bounds of this item have changed.
+ This is used by ViewBox to react if auto-range is enabled.
+ """
+ view = self.getViewBox()
+ if view is not None and hasattr(view, 'implements') and view.implements('ViewBox'):
+ view.itemBoundsChanged(self) ## inform view so it can update its range if it wants
+
+ def childrenShape(self):
+ """Return the union of the shapes of all descendants of this item in local coordinates."""
+ childs = self.allChildItems()
+ shapes = [self.mapFromItem(c, c.shape()) for c in self.allChildItems()]
+ return reduce(operator.add, shapes)
+
+ def allChildItems(self, root=None):
+ """Return list of the entire item tree descending from this item."""
+ if root is None:
+ root = self
+ tree = []
+ for ch in root.childItems():
+ tree.append(ch)
+ tree.extend(self.allChildItems(ch))
+ return tree
+
+
+ def setExportMode(self, export, opts=None):
+ """
+ This method is called by exporters to inform items that they are being drawn for export
+ with a specific set of options. Items access these via self._exportOptions.
+ When exporting is complete, _exportOptions is set to False.
+ """
+ if opts is None:
+ opts = {}
+ if export:
+ self._exportOpts = opts
+ #if 'antialias' not in opts:
+ #self._exportOpts['antialias'] = True
+ else:
+ self._exportOpts = False
+
\ No newline at end of file
diff --git a/pyqtgraph/graphicsItems/GraphicsLayout.py b/pyqtgraph/graphicsItems/GraphicsLayout.py
new file mode 100644
index 00000000..9d48e627
--- /dev/null
+++ b/pyqtgraph/graphicsItems/GraphicsLayout.py
@@ -0,0 +1,154 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import pyqtgraph.functions as fn
+from .GraphicsWidget import GraphicsWidget
+## Must be imported at the end to avoid cyclic-dependency hell:
+from .ViewBox import ViewBox
+from .PlotItem import PlotItem
+from .LabelItem import LabelItem
+
+__all__ = ['GraphicsLayout']
+class GraphicsLayout(GraphicsWidget):
+ """
+ Used for laying out GraphicsWidgets in a grid.
+ This is usually created automatically as part of a :class:`GraphicsWindow ` or :class:`GraphicsLayoutWidget `.
+ """
+
+
+ def __init__(self, parent=None, border=None):
+ GraphicsWidget.__init__(self, parent)
+ if border is True:
+ border = (100,100,100)
+ self.border = border
+ self.layout = QtGui.QGraphicsGridLayout()
+ self.setLayout(self.layout)
+ self.items = {} ## item: [(row, col), (row, col), ...] lists all cells occupied by the item
+ self.rows = {} ## row: {col1: item1, col2: item2, ...} maps cell location to item
+ self.currentRow = 0
+ self.currentCol = 0
+ self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding))
+
+ #def resizeEvent(self, ev):
+ #ret = GraphicsWidget.resizeEvent(self, ev)
+ #print self.pos(), self.mapToDevice(self.rect().topLeft())
+ #return ret
+
+ def nextRow(self):
+ """Advance to next row for automatic item placement"""
+ self.currentRow += 1
+ self.currentCol = -1
+ self.nextColumn()
+
+ def nextColumn(self):
+ """Advance to next available column
+ (generally only for internal use--called by addItem)"""
+ self.currentCol += 1
+ while self.getItem(self.currentRow, self.currentCol) is not None:
+ self.currentCol += 1
+
+ def nextCol(self, *args, **kargs):
+ """Alias of nextColumn"""
+ return self.nextColumn(*args, **kargs)
+
+ def addPlot(self, row=None, col=None, rowspan=1, colspan=1, **kargs):
+ """
+ Create a PlotItem and place it in the next available cell (or in the cell specified)
+ All extra keyword arguments are passed to :func:`PlotItem.__init__ `
+ Returns the created item.
+ """
+ plot = PlotItem(**kargs)
+ self.addItem(plot, row, col, rowspan, colspan)
+ return plot
+
+ def addViewBox(self, row=None, col=None, rowspan=1, colspan=1, **kargs):
+ """
+ Create a ViewBox and place it in the next available cell (or in the cell specified)
+ All extra keyword arguments are passed to :func:`ViewBox.__init__ `
+ Returns the created item.
+ """
+ vb = ViewBox(**kargs)
+ self.addItem(vb, row, col, rowspan, colspan)
+ return vb
+
+ def addLabel(self, text=' ', row=None, col=None, rowspan=1, colspan=1, **kargs):
+ """
+ Create a LabelItem with *text* and place it in the next available cell (or in the cell specified)
+ All extra keyword arguments are passed to :func:`LabelItem.__init__ `
+ Returns the created item.
+
+ To create a vertical label, use *angle* = -90.
+ """
+ text = LabelItem(text, **kargs)
+ self.addItem(text, row, col, rowspan, colspan)
+ return text
+
+ def addLayout(self, row=None, col=None, rowspan=1, colspan=1, **kargs):
+ """
+ Create an empty GraphicsLayout and place it in the next available cell (or in the cell specified)
+ All extra keyword arguments are passed to :func:`GraphicsLayout.__init__ `
+ Returns the created item.
+ """
+ layout = GraphicsLayout(**kargs)
+ self.addItem(layout, row, col, rowspan, colspan)
+ return layout
+
+ def addItem(self, item, row=None, col=None, rowspan=1, colspan=1):
+ """
+ Add an item to the layout and place it in the next available cell (or in the cell specified).
+ The item must be an instance of a QGraphicsWidget subclass.
+ """
+ if row is None:
+ row = self.currentRow
+ if col is None:
+ col = self.currentCol
+
+ self.items[item] = []
+ for i in range(rowspan):
+ for j in range(colspan):
+ row2 = row + i
+ col2 = col + j
+ if row2 not in self.rows:
+ self.rows[row2] = {}
+ self.rows[row2][col2] = item
+ self.items[item].append((row2, col2))
+
+ self.layout.addItem(item, row, col, rowspan, colspan)
+ self.nextColumn()
+
+ def getItem(self, row, col):
+ """Return the item in (*row*, *col*). If the cell is empty, return None."""
+ return self.rows.get(row, {}).get(col, None)
+
+ def boundingRect(self):
+ return self.rect()
+
+ def paint(self, p, *args):
+ if self.border is None:
+ return
+ p.setPen(fn.mkPen(self.border))
+ for i in self.items:
+ r = i.mapRectToParent(i.boundingRect())
+ p.drawRect(r)
+
+ def itemIndex(self, item):
+ for i in range(self.layout.count()):
+ if self.layout.itemAt(i).graphicsItem() is item:
+ return i
+ raise Exception("Could not determine index of item " + str(item))
+
+ def removeItem(self, item):
+ """Remove *item* from the layout."""
+ ind = self.itemIndex(item)
+ self.layout.removeAt(ind)
+ self.scene().removeItem(item)
+
+ for r,c in self.items[item]:
+ del self.rows[r][c]
+ del self.items[item]
+ self.update()
+
+ def clear(self):
+ items = []
+ for i in list(self.items.keys()):
+ self.removeItem(i)
+
+
diff --git a/pyqtgraph/graphicsItems/GraphicsObject.py b/pyqtgraph/graphicsItems/GraphicsObject.py
new file mode 100644
index 00000000..121a67ea
--- /dev/null
+++ b/pyqtgraph/graphicsItems/GraphicsObject.py
@@ -0,0 +1,31 @@
+from pyqtgraph.Qt import QtGui, QtCore, USE_PYSIDE
+if not USE_PYSIDE:
+ import sip
+from .GraphicsItem import GraphicsItem
+
+__all__ = ['GraphicsObject']
+class GraphicsObject(GraphicsItem, QtGui.QGraphicsObject):
+ """
+ **Bases:** :class:`GraphicsItem `, :class:`QtGui.QGraphicsObject`
+
+ Extension of QGraphicsObject with some useful methods (provided by :class:`GraphicsItem `)
+ """
+ _qtBaseClass = QtGui.QGraphicsObject
+ def __init__(self, *args):
+ QtGui.QGraphicsObject.__init__(self, *args)
+ self.setFlag(self.ItemSendsGeometryChanges)
+ GraphicsItem.__init__(self)
+
+ def itemChange(self, change, value):
+ ret = QtGui.QGraphicsObject.itemChange(self, change, value)
+ if change in [self.ItemParentHasChanged, self.ItemSceneHasChanged]:
+ self._updateView()
+ if change in [self.ItemPositionHasChanged, self.ItemTransformHasChanged]:
+ self.informViewBoundsChanged()
+
+ ## workaround for pyqt bug:
+ ## http://www.riverbankcomputing.com/pipermail/pyqt/2012-August/031818.html
+ if not USE_PYSIDE and change == self.ItemParentChange and isinstance(ret, QtGui.QGraphicsItem):
+ ret = sip.cast(ret, QtGui.QGraphicsItem)
+
+ return ret
diff --git a/pyqtgraph/graphicsItems/GraphicsWidget.py b/pyqtgraph/graphicsItems/GraphicsWidget.py
new file mode 100644
index 00000000..8f28d208
--- /dev/null
+++ b/pyqtgraph/graphicsItems/GraphicsWidget.py
@@ -0,0 +1,58 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.GraphicsScene import GraphicsScene
+from .GraphicsItem import GraphicsItem
+
+__all__ = ['GraphicsWidget']
+
+class GraphicsWidget(GraphicsItem, QtGui.QGraphicsWidget):
+
+ _qtBaseClass = QtGui.QGraphicsWidget
+ def __init__(self, *args, **kargs):
+ """
+ **Bases:** :class:`GraphicsItem `, :class:`QtGui.QGraphicsWidget`
+
+ Extends QGraphicsWidget with several helpful methods and workarounds for PyQt bugs.
+ Most of the extra functionality is inherited from :class:`GraphicsItem `.
+ """
+ QtGui.QGraphicsWidget.__init__(self, *args, **kargs)
+ GraphicsItem.__init__(self)
+
+ ## done by GraphicsItem init
+ #GraphicsScene.registerObject(self) ## workaround for pyqt bug in graphicsscene.items()
+
+## Removed because this causes segmentation faults. Don't know why.
+# def itemChange(self, change, value):
+# ret = QtGui.QGraphicsWidget.itemChange(self, change, value) ## segv occurs here
+# if change in [self.ItemParentHasChanged, self.ItemSceneHasChanged]:
+# self._updateView()
+# return ret
+
+ #def getMenu(self):
+ #pass
+
+ def setFixedHeight(self, h):
+ self.setMaximumHeight(h)
+ self.setMinimumHeight(h)
+
+ def setFixedWidth(self, h):
+ self.setMaximumWidth(h)
+ self.setMinimumWidth(h)
+
+ def height(self):
+ return self.geometry().height()
+
+ def width(self):
+ return self.geometry().width()
+
+ def boundingRect(self):
+ br = self.mapRectFromParent(self.geometry()).normalized()
+ #print "bounds:", br
+ return br
+
+ def shape(self): ## No idea why this is necessary, but rotated items do not receive clicks otherwise.
+ p = QtGui.QPainterPath()
+ p.addRect(self.boundingRect())
+ #print "shape:", p.boundingRect()
+ return p
+
+
diff --git a/pyqtgraph/graphicsItems/GraphicsWidgetAnchor.py b/pyqtgraph/graphicsItems/GraphicsWidgetAnchor.py
new file mode 100644
index 00000000..9770b661
--- /dev/null
+++ b/pyqtgraph/graphicsItems/GraphicsWidgetAnchor.py
@@ -0,0 +1,63 @@
+from ..Qt import QtGui, QtCore
+from ..Point import Point
+
+
+class GraphicsWidgetAnchor(object):
+ """
+ Class used to allow GraphicsWidgets to anchor to a specific position on their
+ parent.
+
+ """
+
+ def __init__(self):
+ self.__parent = None
+ self.__parentAnchor = None
+ self.__itemAnchor = None
+ self.__offset = (0,0)
+ if hasattr(self, 'geometryChanged'):
+ self.geometryChanged.connect(self.__geometryChanged)
+
+ def anchor(self, itemPos, parentPos, offset=(0,0)):
+ """
+ Anchors the item at its local itemPos to the item's parent at parentPos.
+ Both positions are expressed in values relative to the size of the item or parent;
+ a value of 0 indicates left or top edge, while 1 indicates right or bottom edge.
+
+ Optionally, offset may be specified to introduce an absolute offset.
+
+ Example: anchor a box such that its upper-right corner is fixed 10px left
+ and 10px down from its parent's upper-right corner::
+
+ box.anchor(itemPos=(1,0), parentPos=(1,0), offset=(-10,10))
+ """
+ parent = self.parentItem()
+ if parent is None:
+ raise Exception("Cannot anchor; parent is not set.")
+
+ if self.__parent is not parent:
+ if self.__parent is not None:
+ self.__parent.geometryChanged.disconnect(self.__geometryChanged)
+
+ self.__parent = parent
+ parent.geometryChanged.connect(self.__geometryChanged)
+
+ self.__itemAnchor = itemPos
+ self.__parentAnchor = parentPos
+ self.__offset = offset
+ self.__geometryChanged()
+
+ def __geometryChanged(self):
+ if self.__parent is None:
+ return
+ if self.__itemAnchor is None:
+ return
+
+ o = self.mapToParent(Point(0,0))
+ a = self.boundingRect().bottomRight() * Point(self.__itemAnchor)
+ a = self.mapToParent(a)
+ p = self.__parent.boundingRect().bottomRight() * Point(self.__parentAnchor)
+ off = Point(self.__offset)
+ pos = p + (o-a) + off
+ self.setPos(pos)
+
+
\ No newline at end of file
diff --git a/pyqtgraph/graphicsItems/GridItem.py b/pyqtgraph/graphicsItems/GridItem.py
new file mode 100644
index 00000000..29b0aa2c
--- /dev/null
+++ b/pyqtgraph/graphicsItems/GridItem.py
@@ -0,0 +1,120 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from .UIGraphicsItem import *
+import numpy as np
+from pyqtgraph.Point import Point
+import pyqtgraph.functions as fn
+
+__all__ = ['GridItem']
+class GridItem(UIGraphicsItem):
+ """
+ **Bases:** :class:`UIGraphicsItem `
+
+ Displays a rectangular grid of lines indicating major divisions within a coordinate system.
+ Automatically determines what divisions to use.
+ """
+
+ def __init__(self):
+ UIGraphicsItem.__init__(self)
+ #QtGui.QGraphicsItem.__init__(self, *args)
+ #self.setFlag(QtGui.QGraphicsItem.ItemClipsToShape)
+ #self.setCacheMode(QtGui.QGraphicsItem.DeviceCoordinateCache)
+
+ self.picture = None
+
+
+ def viewRangeChanged(self):
+ UIGraphicsItem.viewRangeChanged(self)
+ self.picture = None
+ #UIGraphicsItem.viewRangeChanged(self)
+ #self.update()
+
+ def paint(self, p, opt, widget):
+ #p.setPen(QtGui.QPen(QtGui.QColor(100, 100, 100)))
+ #p.drawRect(self.boundingRect())
+ #UIGraphicsItem.paint(self, p, opt, widget)
+ ### draw picture
+ if self.picture is None:
+ #print "no pic, draw.."
+ self.generatePicture()
+ p.drawPicture(QtCore.QPointF(0, 0), self.picture)
+ #p.setPen(QtGui.QPen(QtGui.QColor(255,0,0)))
+ #p.drawLine(0, -100, 0, 100)
+ #p.drawLine(-100, 0, 100, 0)
+ #print "drawing Grid."
+
+
+ def generatePicture(self):
+ self.picture = QtGui.QPicture()
+ p = QtGui.QPainter()
+ p.begin(self.picture)
+
+ dt = fn.invertQTransform(self.viewTransform())
+ vr = self.getViewWidget().rect()
+ unit = self.pixelWidth(), self.pixelHeight()
+ dim = [vr.width(), vr.height()]
+ lvr = self.boundingRect()
+ ul = np.array([lvr.left(), lvr.top()])
+ br = np.array([lvr.right(), lvr.bottom()])
+
+ texts = []
+
+ if ul[1] > br[1]:
+ x = ul[1]
+ ul[1] = br[1]
+ br[1] = x
+ for i in [2,1,0]: ## Draw three different scales of grid
+ dist = br-ul
+ nlTarget = 10.**i
+ d = 10. ** np.floor(np.log10(abs(dist/nlTarget))+0.5)
+ ul1 = np.floor(ul / d) * d
+ br1 = np.ceil(br / d) * d
+ dist = br1-ul1
+ nl = (dist / d) + 0.5
+ #print "level", i
+ #print " dim", dim
+ #print " dist", dist
+ #print " d", d
+ #print " nl", nl
+ for ax in range(0,2): ## Draw grid for both axes
+ ppl = dim[ax] / nl[ax]
+ c = np.clip(3.*(ppl-3), 0., 30.)
+ linePen = QtGui.QPen(QtGui.QColor(255, 255, 255, c))
+ textPen = QtGui.QPen(QtGui.QColor(255, 255, 255, c*2))
+ #linePen.setCosmetic(True)
+ #linePen.setWidth(1)
+ bx = (ax+1) % 2
+ for x in range(0, int(nl[ax])):
+ linePen.setCosmetic(False)
+ if ax == 0:
+ linePen.setWidthF(self.pixelWidth())
+ #print "ax 0 height", self.pixelHeight()
+ else:
+ linePen.setWidthF(self.pixelHeight())
+ #print "ax 1 width", self.pixelWidth()
+ p.setPen(linePen)
+ p1 = np.array([0.,0.])
+ p2 = np.array([0.,0.])
+ p1[ax] = ul1[ax] + x * d[ax]
+ p2[ax] = p1[ax]
+ p1[bx] = ul[bx]
+ p2[bx] = br[bx]
+ ## don't draw lines that are out of bounds.
+ if p1[ax] < min(ul[ax], br[ax]) or p1[ax] > max(ul[ax], br[ax]):
+ continue
+ p.drawLine(QtCore.QPointF(p1[0], p1[1]), QtCore.QPointF(p2[0], p2[1]))
+ if i < 2:
+ p.setPen(textPen)
+ if ax == 0:
+ x = p1[0] + unit[0]
+ y = ul[1] + unit[1] * 8.
+ else:
+ x = ul[0] + unit[0]*3
+ y = p1[1] + unit[1]
+ texts.append((QtCore.QPointF(x, y), "%g"%p1[ax]))
+ tr = self.deviceTransform()
+ #tr.scale(1.5, 1.5)
+ p.setWorldTransform(fn.invertQTransform(tr))
+ for t in texts:
+ x = tr.map(t[0]) + Point(0.5, 0.5)
+ p.drawText(x, t[1])
+ p.end()
diff --git a/pyqtgraph/graphicsItems/HistogramLUTItem.py b/pyqtgraph/graphicsItems/HistogramLUTItem.py
new file mode 100644
index 00000000..5a3b63d6
--- /dev/null
+++ b/pyqtgraph/graphicsItems/HistogramLUTItem.py
@@ -0,0 +1,205 @@
+"""
+GraphicsWidget displaying an image histogram along with gradient editor. Can be used to adjust the appearance of images.
+"""
+
+
+from pyqtgraph.Qt import QtGui, QtCore
+import pyqtgraph.functions as fn
+from .GraphicsWidget import GraphicsWidget
+from .ViewBox import *
+from .GradientEditorItem import *
+from .LinearRegionItem import *
+from .PlotDataItem import *
+from .AxisItem import *
+from .GridItem import *
+from pyqtgraph.Point import Point
+import pyqtgraph.functions as fn
+import numpy as np
+import pyqtgraph.debug as debug
+
+
+__all__ = ['HistogramLUTItem']
+
+
+class HistogramLUTItem(GraphicsWidget):
+ """
+ This is a graphicsWidget which provides controls for adjusting the display of an image.
+ Includes:
+
+ - Image histogram
+ - Movable region over histogram to select black/white levels
+ - Gradient editor to define color lookup table for single-channel images
+ """
+
+ sigLookupTableChanged = QtCore.Signal(object)
+ sigLevelsChanged = QtCore.Signal(object)
+ sigLevelChangeFinished = QtCore.Signal(object)
+
+ def __init__(self, image=None, fillHistogram=True):
+ """
+ If *image* (ImageItem) is provided, then the control will be automatically linked to the image and changes to the control will be immediately reflected in the image's appearance.
+ By default, the histogram is rendered with a fill. For performance, set *fillHistogram* = False.
+ """
+ GraphicsWidget.__init__(self)
+ self.lut = None
+ self.imageItem = None
+
+ self.layout = QtGui.QGraphicsGridLayout()
+ self.setLayout(self.layout)
+ self.layout.setContentsMargins(1,1,1,1)
+ self.layout.setSpacing(0)
+ self.vb = ViewBox()
+ self.vb.setMaximumWidth(152)
+ self.vb.setMinimumWidth(45)
+ self.vb.setMouseEnabled(x=False, y=True)
+ self.gradient = GradientEditorItem()
+ self.gradient.setOrientation('right')
+ self.gradient.loadPreset('grey')
+ self.region = LinearRegionItem([0, 1], LinearRegionItem.Horizontal)
+ self.region.setZValue(1000)
+ self.vb.addItem(self.region)
+ self.axis = AxisItem('left', linkView=self.vb, maxTickLength=-10, showValues=False)
+ self.layout.addItem(self.axis, 0, 0)
+ self.layout.addItem(self.vb, 0, 1)
+ self.layout.addItem(self.gradient, 0, 2)
+ self.range = None
+ self.gradient.setFlag(self.gradient.ItemStacksBehindParent)
+ self.vb.setFlag(self.gradient.ItemStacksBehindParent)
+
+ #self.grid = GridItem()
+ #self.vb.addItem(self.grid)
+
+ self.gradient.sigGradientChanged.connect(self.gradientChanged)
+ self.region.sigRegionChanged.connect(self.regionChanging)
+ self.region.sigRegionChangeFinished.connect(self.regionChanged)
+ self.vb.sigRangeChanged.connect(self.viewRangeChanged)
+ self.plot = PlotDataItem()
+ self.plot.rotate(90)
+ self.fillHistogram(fillHistogram)
+
+ self.vb.addItem(self.plot)
+ self.autoHistogramRange()
+
+ if image is not None:
+ self.setImageItem(image)
+ #self.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding)
+
+ def fillHistogram(self, fill=True, level=0.0, color=(100, 100, 200)):
+ if fill:
+ self.plot.setFillLevel(level)
+ self.plot.setFillBrush(color)
+ else:
+ self.plot.setFillLevel(None)
+
+ #def sizeHint(self, *args):
+ #return QtCore.QSizeF(115, 200)
+
+ def paint(self, p, *args):
+ pen = self.region.lines[0].pen
+ rgn = self.getLevels()
+ p1 = self.vb.mapFromViewToItem(self, Point(self.vb.viewRect().center().x(), rgn[0]))
+ p2 = self.vb.mapFromViewToItem(self, Point(self.vb.viewRect().center().x(), rgn[1]))
+ gradRect = self.gradient.mapRectToParent(self.gradient.gradRect.rect())
+ for pen in [fn.mkPen('k', width=3), pen]:
+ p.setPen(pen)
+ p.drawLine(p1, gradRect.bottomLeft())
+ p.drawLine(p2, gradRect.topLeft())
+ p.drawLine(gradRect.topLeft(), gradRect.topRight())
+ p.drawLine(gradRect.bottomLeft(), gradRect.bottomRight())
+ #p.drawRect(self.boundingRect())
+
+
+ def setHistogramRange(self, mn, mx, padding=0.1):
+ """Set the Y range on the histogram plot. This disables auto-scaling."""
+ self.vb.enableAutoRange(self.vb.YAxis, False)
+ self.vb.setYRange(mn, mx, padding)
+
+ #d = mx-mn
+ #mn -= d*padding
+ #mx += d*padding
+ #self.range = [mn,mx]
+ #self.updateRange()
+ #self.vb.setMouseEnabled(False, True)
+ #self.region.setBounds([mn,mx])
+
+ def autoHistogramRange(self):
+ """Enable auto-scaling on the histogram plot."""
+ self.vb.enableAutoRange(self.vb.XYAxes)
+ #self.range = None
+ #self.updateRange()
+ #self.vb.setMouseEnabled(False, False)
+
+ #def updateRange(self):
+ #self.vb.autoRange()
+ #if self.range is not None:
+ #self.vb.setYRange(*self.range)
+ #vr = self.vb.viewRect()
+
+ #self.region.setBounds([vr.top(), vr.bottom()])
+
+ def setImageItem(self, img):
+ self.imageItem = img
+ img.sigImageChanged.connect(self.imageChanged)
+ img.setLookupTable(self.getLookupTable) ## send function pointer, not the result
+ #self.gradientChanged()
+ self.regionChanged()
+ self.imageChanged(autoLevel=True)
+ #self.vb.autoRange()
+
+ def viewRangeChanged(self):
+ self.update()
+
+ def gradientChanged(self):
+ if self.imageItem is not None:
+ if self.gradient.isLookupTrivial():
+ self.imageItem.setLookupTable(None) #lambda x: x.astype(np.uint8))
+ else:
+ self.imageItem.setLookupTable(self.getLookupTable) ## send function pointer, not the result
+
+ self.lut = None
+ #if self.imageItem is not None:
+ #self.imageItem.setLookupTable(self.gradient.getLookupTable(512))
+ self.sigLookupTableChanged.emit(self)
+
+ def getLookupTable(self, img=None, n=None, alpha=None):
+ if n is None:
+ if img.dtype == np.uint8:
+ n = 256
+ else:
+ n = 512
+ if self.lut is None:
+ self.lut = self.gradient.getLookupTable(n, alpha=alpha)
+ return self.lut
+
+ def regionChanged(self):
+ #if self.imageItem is not None:
+ #self.imageItem.setLevels(self.region.getRegion())
+ self.sigLevelChangeFinished.emit(self)
+ #self.update()
+
+ def regionChanging(self):
+ if self.imageItem is not None:
+ self.imageItem.setLevels(self.region.getRegion())
+ self.sigLevelsChanged.emit(self)
+ self.update()
+
+ def imageChanged(self, autoLevel=False, autoRange=False):
+ prof = debug.Profiler('HistogramLUTItem.imageChanged', disabled=True)
+ h = self.imageItem.getHistogram()
+ prof.mark('get histogram')
+ if h[0] is None:
+ return
+ self.plot.setData(*h)
+ prof.mark('set plot')
+ if autoLevel:
+ mn = h[0][0]
+ mx = h[0][-1]
+ self.region.setRegion([mn, mx])
+ prof.mark('set region')
+ prof.finish()
+
+ def getLevels(self):
+ return self.region.getRegion()
+
+ def setLevels(self, mn, mx):
+ self.region.setRegion([mn, mx])
diff --git a/pyqtgraph/graphicsItems/ImageItem.py b/pyqtgraph/graphicsItems/ImageItem.py
new file mode 100644
index 00000000..123612b8
--- /dev/null
+++ b/pyqtgraph/graphicsItems/ImageItem.py
@@ -0,0 +1,449 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import numpy as np
+import collections
+import pyqtgraph.functions as fn
+import pyqtgraph.debug as debug
+from .GraphicsObject import GraphicsObject
+
+__all__ = ['ImageItem']
+class ImageItem(GraphicsObject):
+ """
+ **Bases:** :class:`GraphicsObject `
+
+ GraphicsObject displaying an image. Optimized for rapid update (ie video display).
+ This item displays either a 2D numpy array (height, width) or
+ a 3D array (height, width, RGBa). This array is optionally scaled (see
+ :func:`setLevels `) and/or colored
+ with a lookup table (see :func:`setLookupTable `)
+ before being displayed.
+
+ ImageItem is frequently used in conjunction with
+ :class:`HistogramLUTItem ` or
+ :class:`HistogramLUTWidget ` to provide a GUI
+ for controlling the levels and lookup table used to display the image.
+ """
+
+
+ sigImageChanged = QtCore.Signal()
+ sigRemoveRequested = QtCore.Signal(object) # self; emitted when 'remove' is selected from context menu
+
+ def __init__(self, image=None, **kargs):
+ """
+ See :func:`setImage ` for all allowed initialization arguments.
+ """
+ GraphicsObject.__init__(self)
+ #self.pixmapItem = QtGui.QGraphicsPixmapItem(self)
+ #self.qimage = QtGui.QImage()
+ #self._pixmap = None
+ self.menu = None
+ self.image = None ## original image data
+ self.qimage = None ## rendered image for display
+ #self.clipMask = None
+
+ self.paintMode = None
+
+ self.levels = None ## [min, max] or [[redMin, redMax], ...]
+ self.lut = None
+
+ #self.clipLevel = None
+ self.drawKernel = None
+ self.border = None
+ self.removable = False
+
+ if image is not None:
+ self.setImage(image, **kargs)
+ else:
+ self.setOpts(**kargs)
+
+ def setCompositionMode(self, mode):
+ """Change the composition mode of the item (see QPainter::CompositionMode
+ in the Qt documentation). This is useful when overlaying multiple ImageItems.
+
+ ============================================ ============================================================
+ **Most common arguments:**
+ QtGui.QPainter.CompositionMode_SourceOver Default; image replaces the background if it
+ is opaque. Otherwise, it uses the alpha channel to blend
+ the image with the background.
+ QtGui.QPainter.CompositionMode_Overlay The image color is mixed with the background color to
+ reflect the lightness or darkness of the background.
+ QtGui.QPainter.CompositionMode_Plus Both the alpha and color of the image and background pixels
+ are added together.
+ QtGui.QPainter.CompositionMode_Multiply The output is the image color multiplied by the background.
+ ============================================ ============================================================
+ """
+ self.paintMode = mode
+ self.update()
+
+ ## use setOpacity instead.
+ #def setAlpha(self, alpha):
+ #self.setOpacity(alpha)
+ #self.updateImage()
+
+ def setBorder(self, b):
+ self.border = fn.mkPen(b)
+ self.update()
+
+ def width(self):
+ if self.image is None:
+ return None
+ return self.image.shape[0]
+
+ def height(self):
+ if self.image is None:
+ return None
+ return self.image.shape[1]
+
+ def boundingRect(self):
+ if self.image is None:
+ return QtCore.QRectF(0., 0., 0., 0.)
+ return QtCore.QRectF(0., 0., float(self.width()), float(self.height()))
+
+ #def setClipLevel(self, level=None):
+ #self.clipLevel = level
+ #self.updateImage()
+
+ #def paint(self, p, opt, widget):
+ #pass
+ #if self.pixmap is not None:
+ #p.drawPixmap(0, 0, self.pixmap)
+ #print "paint"
+
+ def setLevels(self, levels, update=True):
+ """
+ Set image scaling levels. Can be one of:
+
+ * [blackLevel, whiteLevel]
+ * [[minRed, maxRed], [minGreen, maxGreen], [minBlue, maxBlue]]
+
+ Only the first format is compatible with lookup tables. See :func:`makeARGB `
+ for more details on how levels are applied.
+ """
+ self.levels = levels
+ if update:
+ self.updateImage()
+
+ def getLevels(self):
+ return self.levels
+ #return self.whiteLevel, self.blackLevel
+
+ def setLookupTable(self, lut, update=True):
+ """
+ Set the lookup table (numpy array) to use for this image. (see
+ :func:`makeARGB ` for more information on how this is used).
+ Optionally, lut can be a callable that accepts the current image as an
+ argument and returns the lookup table to use.
+
+ Ordinarily, this table is supplied by a :class:`HistogramLUTItem `
+ or :class:`GradientEditorItem `.
+ """
+ self.lut = lut
+ if update:
+ self.updateImage()
+
+ def setOpts(self, update=True, **kargs):
+ if 'lut' in kargs:
+ self.setLookupTable(kargs['lut'], update=update)
+ if 'levels' in kargs:
+ self.setLevels(kargs['levels'], update=update)
+ #if 'clipLevel' in kargs:
+ #self.setClipLevel(kargs['clipLevel'])
+ if 'opacity' in kargs:
+ self.setOpacity(kargs['opacity'])
+ if 'compositionMode' in kargs:
+ self.setCompositionMode(kargs['compositionMode'])
+ if 'border' in kargs:
+ self.setBorder(kargs['border'])
+ if 'removable' in kargs:
+ self.removable = kargs['removable']
+ self.menu = None
+
+ def setRect(self, rect):
+ """Scale and translate the image to fit within rect (must be a QRect or QRectF)."""
+ self.resetTransform()
+ self.translate(rect.left(), rect.top())
+ self.scale(rect.width() / self.width(), rect.height() / self.height())
+
+ def setImage(self, image=None, autoLevels=None, **kargs):
+ """
+ Update the image displayed by this item. For more information on how the image
+ is processed before displaying, see :func:`makeARGB `
+
+ ================= =========================================================================
+ **Arguments:**
+ image (numpy array) Specifies the image data. May be 2D (width, height) or
+ 3D (width, height, RGBa). The array dtype must be integer or floating
+ point of any bit depth. For 3D arrays, the third dimension must
+ be of length 3 (RGB) or 4 (RGBA).
+ autoLevels (bool) If True, this forces the image to automatically select
+ levels based on the maximum and minimum values in the data.
+ By default, this argument is true unless the levels argument is
+ given.
+ lut (numpy array) The color lookup table to use when displaying the image.
+ See :func:`setLookupTable `.
+ levels (min, max) The minimum and maximum values to use when rescaling the image
+ data. By default, this will be set to the minimum and maximum values
+ in the image. If the image array has dtype uint8, no rescaling is necessary.
+ opacity (float 0.0-1.0)
+ compositionMode see :func:`setCompositionMode `
+ border Sets the pen used when drawing the image border. Default is None.
+ ================= =========================================================================
+ """
+ prof = debug.Profiler('ImageItem.setImage', disabled=True)
+
+ gotNewData = False
+ if image is None:
+ if self.image is None:
+ return
+ else:
+ gotNewData = True
+ if self.image is None or image.shape != self.image.shape:
+ self.prepareGeometryChange()
+ self.image = image.view(np.ndarray)
+
+ prof.mark('1')
+
+ if autoLevels is None:
+ if 'levels' in kargs:
+ autoLevels = False
+ else:
+ autoLevels = True
+ if autoLevels:
+ img = self.image
+ while img.size > 2**16:
+ img = img[::2, ::2]
+ mn, mx = img.min(), img.max()
+ if mn == mx:
+ mn = 0
+ mx = 255
+ kargs['levels'] = [mn,mx]
+ prof.mark('2')
+
+ self.setOpts(update=False, **kargs)
+ prof.mark('3')
+
+ self.qimage = None
+ self.update()
+ prof.mark('4')
+
+ if gotNewData:
+ self.sigImageChanged.emit()
+
+
+ prof.finish()
+
+
+
+ def updateImage(self, *args, **kargs):
+ ## used for re-rendering qimage from self.image.
+
+ ## can we make any assumptions here that speed things up?
+ ## dtype, range, size are all the same?
+ defaults = {
+ 'autoLevels': False,
+ }
+ defaults.update(kargs)
+ return self.setImage(*args, **defaults)
+
+
+
+
+ def render(self):
+ prof = debug.Profiler('ImageItem.render', disabled=True)
+ if self.image is None:
+ return
+ if isinstance(self.lut, collections.Callable):
+ lut = self.lut(self.image)
+ else:
+ lut = self.lut
+ #print lut.shape
+ #print self.lut
+
+ argb, alpha = fn.makeARGB(self.image, lut=lut, levels=self.levels)
+ self.qimage = fn.makeQImage(argb, alpha)
+ prof.finish()
+
+
+ def paint(self, p, *args):
+ prof = debug.Profiler('ImageItem.paint', disabled=True)
+ if self.image is None:
+ return
+ if self.qimage is None:
+ self.render()
+ prof.mark('render QImage')
+ if self.paintMode is not None:
+ p.setCompositionMode(self.paintMode)
+ prof.mark('set comp mode')
+
+ p.drawImage(QtCore.QPointF(0,0), self.qimage)
+ prof.mark('p.drawImage')
+ if self.border is not None:
+ p.setPen(self.border)
+ p.drawRect(self.boundingRect())
+ prof.finish()
+
+ def save(self, fileName, *args):
+ """Save this image to file. Note that this saves the visible image (after scale/color changes), not the original data."""
+ if self.qimage is None:
+ self.render()
+ self.qimage.save(fileName, *args)
+
+ def getHistogram(self, bins=500, step=3):
+ """Returns x and y arrays containing the histogram values for the current image.
+ The step argument causes pixels to be skipped when computing the histogram to save time.
+ This method is also used when automatically computing levels.
+ """
+ if self.image is None:
+ return None,None
+ stepData = self.image[::step, ::step]
+ hist = np.histogram(stepData, bins=bins)
+ return hist[1][:-1], hist[0]
+
+ def setPxMode(self, b):
+ """
+ Set whether the item ignores transformations and draws directly to screen pixels.
+ If True, the item will not inherit any scale or rotation transformations from its
+ parent items, but its position will be transformed as usual.
+ (see GraphicsItem::ItemIgnoresTransformations in the Qt documentation)
+ """
+ self.setFlag(self.ItemIgnoresTransformations, b)
+
+ def setScaledMode(self):
+ self.setPxMode(False)
+
+ def getPixmap(self):
+ if self.qimage is None:
+ self.render()
+ if self.qimage is None:
+ return None
+ return QtGui.QPixmap.fromImage(self.qimage)
+
+ def pixelSize(self):
+ """return scene-size of a single pixel in the image"""
+ br = self.sceneBoundingRect()
+ if self.image is None:
+ return 1,1
+ return br.width()/self.width(), br.height()/self.height()
+
+ #def mousePressEvent(self, ev):
+ #if self.drawKernel is not None and ev.button() == QtCore.Qt.LeftButton:
+ #self.drawAt(ev.pos(), ev)
+ #ev.accept()
+ #else:
+ #ev.ignore()
+
+ #def mouseMoveEvent(self, ev):
+ ##print "mouse move", ev.pos()
+ #if self.drawKernel is not None:
+ #self.drawAt(ev.pos(), ev)
+
+ #def mouseReleaseEvent(self, ev):
+ #pass
+
+ def mouseDragEvent(self, ev):
+ if ev.button() != QtCore.Qt.LeftButton:
+ ev.ignore()
+ return
+ elif self.drawKernel is not None:
+ ev.accept()
+ self.drawAt(ev.pos(), ev)
+
+ def mouseClickEvent(self, ev):
+ if ev.button() == QtCore.Qt.RightButton:
+ if self.raiseContextMenu(ev):
+ ev.accept()
+ if self.drawKernel is not None and ev.button() == QtCore.Qt.LeftButton:
+ self.drawAt(ev.pos(), ev)
+
+ def raiseContextMenu(self, ev):
+ menu = self.getMenu()
+ if menu is None:
+ return False
+ menu = self.scene().addParentContextMenus(self, menu, ev)
+ pos = ev.screenPos()
+ menu.popup(QtCore.QPoint(pos.x(), pos.y()))
+ return True
+
+ def getMenu(self):
+ if self.menu is None:
+ if not self.removable:
+ return None
+ self.menu = QtGui.QMenu()
+ self.menu.setTitle("Image")
+ remAct = QtGui.QAction("Remove image", self.menu)
+ remAct.triggered.connect(self.removeClicked)
+ self.menu.addAction(remAct)
+ self.menu.remAct = remAct
+ return self.menu
+
+
+ def hoverEvent(self, ev):
+ if not ev.isExit() and self.drawKernel is not None and ev.acceptDrags(QtCore.Qt.LeftButton):
+ ev.acceptClicks(QtCore.Qt.LeftButton) ## we don't use the click, but we also don't want anyone else to use it.
+ ev.acceptClicks(QtCore.Qt.RightButton)
+ #self.box.setBrush(fn.mkBrush('w'))
+ elif not ev.isExit() and self.removable:
+ ev.acceptClicks(QtCore.Qt.RightButton) ## accept context menu clicks
+ #else:
+ #self.box.setBrush(self.brush)
+ #self.update()
+
+
+
+ def tabletEvent(self, ev):
+ print(ev.device())
+ print(ev.pointerType())
+ print(ev.pressure())
+
+ def drawAt(self, pos, ev=None):
+ pos = [int(pos.x()), int(pos.y())]
+ dk = self.drawKernel
+ kc = self.drawKernelCenter
+ sx = [0,dk.shape[0]]
+ sy = [0,dk.shape[1]]
+ tx = [pos[0] - kc[0], pos[0] - kc[0]+ dk.shape[0]]
+ ty = [pos[1] - kc[1], pos[1] - kc[1]+ dk.shape[1]]
+
+ for i in [0,1]:
+ dx1 = -min(0, tx[i])
+ dx2 = min(0, self.image.shape[0]-tx[i])
+ tx[i] += dx1+dx2
+ sx[i] += dx1+dx2
+
+ dy1 = -min(0, ty[i])
+ dy2 = min(0, self.image.shape[1]-ty[i])
+ ty[i] += dy1+dy2
+ sy[i] += dy1+dy2
+
+ ts = (slice(tx[0],tx[1]), slice(ty[0],ty[1]))
+ ss = (slice(sx[0],sx[1]), slice(sy[0],sy[1]))
+ mask = self.drawMask
+ src = dk
+
+ if isinstance(self.drawMode, collections.Callable):
+ self.drawMode(dk, self.image, mask, ss, ts, ev)
+ else:
+ src = src[ss]
+ if self.drawMode == 'set':
+ if mask is not None:
+ mask = mask[ss]
+ self.image[ts] = self.image[ts] * (1-mask) + src * mask
+ else:
+ self.image[ts] = src
+ elif self.drawMode == 'add':
+ self.image[ts] += src
+ else:
+ raise Exception("Unknown draw mode '%s'" % self.drawMode)
+ self.updateImage()
+
+ def setDrawKernel(self, kernel=None, mask=None, center=(0,0), mode='set'):
+ self.drawKernel = kernel
+ self.drawKernelCenter = center
+ self.drawMode = mode
+ self.drawMask = mask
+
+ def removeClicked(self):
+ ## Send remove event only after we have exited the menu event handler
+ self.removeTimer = QtCore.QTimer()
+ self.removeTimer.timeout.connect(lambda: self.sigRemoveRequested.emit(self))
+ self.removeTimer.start(0)
+
diff --git a/pyqtgraph/graphicsItems/InfiniteLine.py b/pyqtgraph/graphicsItems/InfiniteLine.py
new file mode 100644
index 00000000..4f0df863
--- /dev/null
+++ b/pyqtgraph/graphicsItems/InfiniteLine.py
@@ -0,0 +1,277 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.Point import Point
+from .GraphicsObject import GraphicsObject
+import pyqtgraph.functions as fn
+import numpy as np
+import weakref
+
+
+__all__ = ['InfiniteLine']
+class InfiniteLine(GraphicsObject):
+ """
+ **Bases:** :class:`GraphicsObject `
+
+ Displays a line of infinite length.
+ This line may be dragged to indicate a position in data coordinates.
+
+ =============================== ===================================================
+ **Signals**
+ sigDragged(self)
+ sigPositionChangeFinished(self)
+ sigPositionChanged(self)
+ =============================== ===================================================
+ """
+
+ sigDragged = QtCore.Signal(object)
+ sigPositionChangeFinished = QtCore.Signal(object)
+ sigPositionChanged = QtCore.Signal(object)
+
+ def __init__(self, pos=None, angle=90, pen=None, movable=False, bounds=None):
+ """
+ ============= ==================================================================
+ **Arguments**
+ pos Position of the line. This can be a QPointF or a single value for
+ vertical/horizontal lines.
+ angle Angle of line in degrees. 0 is horizontal, 90 is vertical.
+ pen Pen to use when drawing line. Can be any arguments that are valid
+ for :func:`mkPen `. Default pen is transparent
+ yellow.
+ movable If True, the line can be dragged to a new position by the user.
+ bounds Optional [min, max] bounding values. Bounds are only valid if the
+ line is vertical or horizontal.
+ ============= ==================================================================
+ """
+
+ GraphicsObject.__init__(self)
+
+ if bounds is None: ## allowed value boundaries for orthogonal lines
+ self.maxRange = [None, None]
+ else:
+ self.maxRange = bounds
+ self.moving = False
+ self.setMovable(movable)
+ self.mouseHovering = False
+ self.p = [0, 0]
+ self.setAngle(angle)
+ if pos is None:
+ pos = Point(0,0)
+ self.setPos(pos)
+
+ if pen is None:
+ pen = (200, 200, 100)
+ self.setPen(pen)
+ self.currentPen = self.pen
+ #self.setFlag(self.ItemSendsScenePositionChanges)
+
+ def setMovable(self, m):
+ """Set whether the line is movable by the user."""
+ self.movable = m
+ self.setAcceptHoverEvents(m)
+
+ def setBounds(self, bounds):
+ """Set the (minimum, maximum) allowable values when dragging."""
+ self.maxRange = bounds
+ self.setValue(self.value())
+
+ def setPen(self, pen):
+ """Set the pen for drawing the line. Allowable arguments are any that are valid
+ for :func:`mkPen `."""
+ self.pen = fn.mkPen(pen)
+ self.currentPen = self.pen
+ self.update()
+
+ def setAngle(self, angle):
+ """
+ Takes angle argument in degrees.
+ 0 is horizontal; 90 is vertical.
+
+ Note that the use of value() and setValue() changes if the line is
+ not vertical or horizontal.
+ """
+ self.angle = ((angle+45) % 180) - 45 ## -45 <= angle < 135
+ self.resetTransform()
+ self.rotate(self.angle)
+ self.update()
+
+ def setPos(self, pos):
+
+ if type(pos) in [list, tuple]:
+ newPos = pos
+ elif isinstance(pos, QtCore.QPointF):
+ newPos = [pos.x(), pos.y()]
+ else:
+ if self.angle == 90:
+ newPos = [pos, 0]
+ elif self.angle == 0:
+ newPos = [0, pos]
+ else:
+ raise Exception("Must specify 2D coordinate for non-orthogonal lines.")
+
+ ## check bounds (only works for orthogonal lines)
+ if self.angle == 90:
+ if self.maxRange[0] is not None:
+ newPos[0] = max(newPos[0], self.maxRange[0])
+ if self.maxRange[1] is not None:
+ newPos[0] = min(newPos[0], self.maxRange[1])
+ elif self.angle == 0:
+ if self.maxRange[0] is not None:
+ newPos[1] = max(newPos[1], self.maxRange[0])
+ if self.maxRange[1] is not None:
+ newPos[1] = min(newPos[1], self.maxRange[1])
+
+ if self.p != newPos:
+ self.p = newPos
+ GraphicsObject.setPos(self, Point(self.p))
+ self.update()
+ self.sigPositionChanged.emit(self)
+
+ def getXPos(self):
+ return self.p[0]
+
+ def getYPos(self):
+ return self.p[1]
+
+ def getPos(self):
+ return self.p
+
+ def value(self):
+ """Return the value of the line. Will be a single number for horizontal and
+ vertical lines, and a list of [x,y] values for diagonal lines."""
+ if self.angle%180 == 0:
+ return self.getYPos()
+ elif self.angle%180 == 90:
+ return self.getXPos()
+ else:
+ return self.getPos()
+
+ def setValue(self, v):
+ """Set the position of the line. If line is horizontal or vertical, v can be
+ a single value. Otherwise, a 2D coordinate must be specified (list, tuple and
+ QPointF are all acceptable)."""
+ self.setPos(v)
+
+ ## broken in 4.7
+ #def itemChange(self, change, val):
+ #if change in [self.ItemScenePositionHasChanged, self.ItemSceneHasChanged]:
+ #self.updateLine()
+ #print "update", change
+ #print self.getBoundingParents()
+ #else:
+ #print "ignore", change
+ #return GraphicsObject.itemChange(self, change, val)
+
+ def boundingRect(self):
+ #br = UIGraphicsItem.boundingRect(self)
+ br = self.viewRect()
+ ## add a 4-pixel radius around the line for mouse interaction.
+
+ px = self.pixelLength(direction=Point(1,0), ortho=True) ## get pixel length orthogonal to the line
+ if px is None:
+ px = 0
+ br.setBottom(-px*4)
+ br.setTop(px*4)
+ return br.normalized()
+
+ def paint(self, p, *args):
+ br = self.boundingRect()
+ p.setPen(self.currentPen)
+ p.drawLine(Point(br.right(), 0), Point(br.left(), 0))
+ #p.drawRect(self.boundingRect())
+
+ def dataBounds(self, axis, frac=1.0, orthoRange=None):
+ if axis == 0:
+ return None ## x axis should never be auto-scaled
+ else:
+ return (0,0)
+
+ #def mousePressEvent(self, ev):
+ #if self.movable and ev.button() == QtCore.Qt.LeftButton:
+ #ev.accept()
+ #self.pressDelta = self.mapToParent(ev.pos()) - QtCore.QPointF(*self.p)
+ #else:
+ #ev.ignore()
+
+ #def mouseMoveEvent(self, ev):
+ #self.setPos(self.mapToParent(ev.pos()) - self.pressDelta)
+ ##self.emit(QtCore.SIGNAL('dragged'), self)
+ #self.sigDragged.emit(self)
+ #self.hasMoved = True
+
+ #def mouseReleaseEvent(self, ev):
+ #if self.hasMoved and ev.button() == QtCore.Qt.LeftButton:
+ #self.hasMoved = False
+ ##self.emit(QtCore.SIGNAL('positionChangeFinished'), self)
+ #self.sigPositionChangeFinished.emit(self)
+
+ def mouseDragEvent(self, ev):
+ if self.movable and ev.button() == QtCore.Qt.LeftButton:
+ if ev.isStart():
+ self.moving = True
+ self.cursorOffset = self.pos() - self.mapToParent(ev.buttonDownPos())
+ self.startPosition = self.pos()
+ ev.accept()
+
+ if not self.moving:
+ return
+
+ #pressDelta = self.mapToParent(ev.buttonDownPos()) - Point(self.p)
+ self.setPos(self.cursorOffset + self.mapToParent(ev.pos()))
+ self.sigDragged.emit(self)
+ if ev.isFinish():
+ self.moving = False
+ self.sigPositionChangeFinished.emit(self)
+ #else:
+ #print ev
+
+
+ def mouseClickEvent(self, ev):
+ if self.moving and ev.button() == QtCore.Qt.RightButton:
+ ev.accept()
+ self.setPos(self.startPosition)
+ self.moving = False
+ self.sigDragged.emit(self)
+ self.sigPositionChangeFinished.emit(self)
+
+ def hoverEvent(self, ev):
+ if (not ev.isExit()) and self.movable and ev.acceptDrags(QtCore.Qt.LeftButton):
+ self.setMouseHover(True)
+ else:
+ self.setMouseHover(False)
+
+ def setMouseHover(self, hover):
+ ## Inform the item that the mouse is(not) hovering over it
+ if self.mouseHovering == hover:
+ return
+ self.mouseHovering = hover
+ if hover:
+ self.currentPen = fn.mkPen(255, 0,0)
+ else:
+ self.currentPen = self.pen
+ self.update()
+
+ #def hoverEnterEvent(self, ev):
+ #print "line hover enter"
+ #ev.ignore()
+ #self.updateHoverPen()
+
+ #def hoverMoveEvent(self, ev):
+ #print "line hover move"
+ #ev.ignore()
+ #self.updateHoverPen()
+
+ #def hoverLeaveEvent(self, ev):
+ #print "line hover leave"
+ #ev.ignore()
+ #self.updateHoverPen(False)
+
+ #def updateHoverPen(self, hover=None):
+ #if hover is None:
+ #scene = self.scene()
+ #hover = scene.claimEvent(self, QtCore.Qt.LeftButton, scene.Drag)
+
+ #if hover:
+ #self.currentPen = fn.mkPen(255, 0,0)
+ #else:
+ #self.currentPen = self.pen
+ #self.update()
+
diff --git a/pyqtgraph/graphicsItems/IsocurveItem.py b/pyqtgraph/graphicsItems/IsocurveItem.py
new file mode 100644
index 00000000..01ef57b6
--- /dev/null
+++ b/pyqtgraph/graphicsItems/IsocurveItem.py
@@ -0,0 +1,121 @@
+
+
+from .GraphicsObject import *
+import pyqtgraph.functions as fn
+from pyqtgraph.Qt import QtGui, QtCore
+
+
+class IsocurveItem(GraphicsObject):
+ """
+ **Bases:** :class:`GraphicsObject `
+
+ Item displaying an isocurve of a 2D array.To align this item correctly with an
+ ImageItem,call isocurve.setParentItem(image)
+ """
+
+
+ def __init__(self, data=None, level=0, pen='w'):
+ """
+ Create a new isocurve item.
+
+ ============= ===============================================================
+ **Arguments**
+ data A 2-dimensional ndarray. Can be initialized as None, and set
+ later using :func:`setData `
+ level The cutoff value at which to draw the isocurve.
+ pen The color of the curve item. Can be anything valid for
+ :func:`mkPen `
+ ============= ===============================================================
+ """
+ GraphicsObject.__init__(self)
+
+ self.level = level
+ self.data = None
+ self.path = None
+ self.setPen(pen)
+ self.setData(data, level)
+
+
+
+ #if data is not None and level is not None:
+ #self.updateLines(data, level)
+
+
+ def setData(self, data, level=None):
+ """
+ Set the data/image to draw isocurves for.
+
+ ============= ========================================================================
+ **Arguments**
+ data A 2-dimensional ndarray.
+ level The cutoff value at which to draw the curve. If level is not specified,
+ the previously set level is used.
+ ============= ========================================================================
+ """
+ if level is None:
+ level = self.level
+ self.level = level
+ self.data = data
+ self.path = None
+ self.prepareGeometryChange()
+ self.update()
+
+
+ def setLevel(self, level):
+ """Set the level at which the isocurve is drawn."""
+ self.level = level
+ self.path = None
+ self.update()
+
+
+ def setPen(self, *args, **kwargs):
+ """Set the pen used to draw the isocurve. Arguments can be any that are valid
+ for :func:`mkPen `"""
+ self.pen = fn.mkPen(*args, **kwargs)
+ self.update()
+
+ def setBrush(self, *args, **kwargs):
+ """Set the brush used to draw the isocurve. Arguments can be any that are valid
+ for :func:`mkBrush `"""
+ self.brush = fn.mkBrush(*args, **kwargs)
+ self.update()
+
+
+ def updateLines(self, data, level):
+ ##print "data:", data
+ ##print "level", level
+ #lines = fn.isocurve(data, level)
+ ##print len(lines)
+ #self.path = QtGui.QPainterPath()
+ #for line in lines:
+ #self.path.moveTo(*line[0])
+ #self.path.lineTo(*line[1])
+ #self.update()
+ self.setData(data, level)
+
+ def boundingRect(self):
+ if self.data is None:
+ return QtCore.QRectF()
+ if self.path is None:
+ self.generatePath()
+ return self.path.boundingRect()
+
+ def generatePath(self):
+ if self.data is None:
+ self.path = None
+ return
+ lines = fn.isocurve(self.data, self.level, connected=True, extendToEdge=True)
+ self.path = QtGui.QPainterPath()
+ for line in lines:
+ self.path.moveTo(*line[0])
+ for p in line[1:]:
+ self.path.lineTo(*p)
+
+ def paint(self, p, *args):
+ if self.data is None:
+ return
+ if self.path is None:
+ self.generatePath()
+ p.setPen(self.pen)
+ p.drawPath(self.path)
+
\ No newline at end of file
diff --git a/pyqtgraph/graphicsItems/ItemGroup.py b/pyqtgraph/graphicsItems/ItemGroup.py
new file mode 100644
index 00000000..930fdf80
--- /dev/null
+++ b/pyqtgraph/graphicsItems/ItemGroup.py
@@ -0,0 +1,23 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from .GraphicsObject import GraphicsObject
+
+__all__ = ['ItemGroup']
+class ItemGroup(GraphicsObject):
+ """
+ Replacement for QGraphicsItemGroup
+ """
+
+ def __init__(self, *args):
+ GraphicsObject.__init__(self, *args)
+ if hasattr(self, "ItemHasNoContents"):
+ self.setFlag(self.ItemHasNoContents)
+
+ def boundingRect(self):
+ return QtCore.QRectF()
+
+ def paint(self, *args):
+ pass
+
+ def addItem(self, item):
+ item.setParentItem(self)
+
diff --git a/pyqtgraph/graphicsItems/LabelItem.py b/pyqtgraph/graphicsItems/LabelItem.py
new file mode 100644
index 00000000..17301fb3
--- /dev/null
+++ b/pyqtgraph/graphicsItems/LabelItem.py
@@ -0,0 +1,140 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import pyqtgraph.functions as fn
+import pyqtgraph as pg
+from .GraphicsWidget import GraphicsWidget
+
+
+__all__ = ['LabelItem']
+
+class LabelItem(GraphicsWidget):
+ """
+ GraphicsWidget displaying text.
+ Used mainly as axis labels, titles, etc.
+
+ Note: To display text inside a scaled view (ViewBox, PlotWidget, etc) use TextItem
+ """
+
+
+ def __init__(self, text=' ', parent=None, angle=0, **args):
+ GraphicsWidget.__init__(self, parent)
+ self.item = QtGui.QGraphicsTextItem(self)
+ self.opts = {
+ 'color': None,
+ 'justify': 'center'
+ }
+ self.opts.update(args)
+ self._sizeHint = {}
+ self.setText(text)
+ self.setAngle(angle)
+
+ def setAttr(self, attr, value):
+ """Set default text properties. See setText() for accepted parameters."""
+ self.opts[attr] = value
+
+ def setText(self, text, **args):
+ """Set the text and text properties in the label. Accepts optional arguments for auto-generating
+ a CSS style string:
+
+ ==================== ==============================
+ **Style Arguments:**
+ color (str) example: 'CCFF00'
+ size (str) example: '8pt'
+ bold (bool)
+ italic (bool)
+ ==================== ==============================
+ """
+ self.text = text
+ opts = self.opts
+ for k in args:
+ opts[k] = args[k]
+
+ optlist = []
+
+ color = self.opts['color']
+ if color is None:
+ color = pg.getConfigOption('foreground')
+ color = fn.mkColor(color)
+ optlist.append('color: #' + fn.colorStr(color)[:6])
+ if 'size' in opts:
+ optlist.append('font-size: ' + opts['size'])
+ if 'bold' in opts and opts['bold'] in [True, False]:
+ optlist.append('font-weight: ' + {True:'bold', False:'normal'}[opts['bold']])
+ if 'italic' in opts and opts['italic'] in [True, False]:
+ optlist.append('font-style: ' + {True:'italic', False:'normal'}[opts['italic']])
+ full = "%s" % ('; '.join(optlist), text)
+ #print full
+ self.item.setHtml(full)
+ self.updateMin()
+ self.resizeEvent(None)
+ self.updateGeometry()
+
+ def resizeEvent(self, ev):
+ #c1 = self.boundingRect().center()
+ #c2 = self.item.mapToParent(self.item.boundingRect().center()) # + self.item.pos()
+ #dif = c1 - c2
+ #self.item.moveBy(dif.x(), dif.y())
+ #print c1, c2, dif, self.item.pos()
+ self.item.setPos(0,0)
+ bounds = self.itemRect()
+ left = self.mapFromItem(self.item, QtCore.QPointF(0,0)) - self.mapFromItem(self.item, QtCore.QPointF(1,0))
+ rect = self.rect()
+
+ if self.opts['justify'] == 'left':
+ if left.x() != 0:
+ bounds.moveLeft(rect.left())
+ if left.y() < 0:
+ bounds.moveTop(rect.top())
+ elif left.y() > 0:
+ bounds.moveBottom(rect.bottom())
+
+ elif self.opts['justify'] == 'center':
+ bounds.moveCenter(rect.center())
+ #bounds = self.itemRect()
+ #self.item.setPos(self.width()/2. - bounds.width()/2., 0)
+ elif self.opts['justify'] == 'right':
+ if left.x() != 0:
+ bounds.moveRight(rect.right())
+ if left.y() < 0:
+ bounds.moveBottom(rect.bottom())
+ elif left.y() > 0:
+ bounds.moveTop(rect.top())
+ #bounds = self.itemRect()
+ #self.item.setPos(self.width() - bounds.width(), 0)
+
+ self.item.setPos(bounds.topLeft() - self.itemRect().topLeft())
+ self.updateMin()
+
+ def setAngle(self, angle):
+ self.angle = angle
+ self.item.resetTransform()
+ self.item.rotate(angle)
+ self.updateMin()
+
+
+ def updateMin(self):
+ bounds = self.itemRect()
+ self.setMinimumWidth(bounds.width())
+ self.setMinimumHeight(bounds.height())
+
+ self._sizeHint = {
+ QtCore.Qt.MinimumSize: (bounds.width(), bounds.height()),
+ QtCore.Qt.PreferredSize: (bounds.width(), bounds.height()),
+ QtCore.Qt.MaximumSize: (-1, -1), #bounds.width()*2, bounds.height()*2),
+ QtCore.Qt.MinimumDescent: (0, 0) ##?? what is this?
+ }
+ self.updateGeometry()
+
+ def sizeHint(self, hint, constraint):
+ if hint not in self._sizeHint:
+ return QtCore.QSizeF(0, 0)
+ return QtCore.QSizeF(*self._sizeHint[hint])
+
+ def itemRect(self):
+ return self.item.mapRectToParent(self.item.boundingRect())
+
+ #def paint(self, p, *args):
+ #p.setPen(fn.mkPen('r'))
+ #p.drawRect(self.rect())
+ #p.setPen(fn.mkPen('g'))
+ #p.drawRect(self.itemRect())
+
diff --git a/pyqtgraph/graphicsItems/LegendItem.py b/pyqtgraph/graphicsItems/LegendItem.py
new file mode 100644
index 00000000..c41feb95
--- /dev/null
+++ b/pyqtgraph/graphicsItems/LegendItem.py
@@ -0,0 +1,121 @@
+from .GraphicsWidget import GraphicsWidget
+from .LabelItem import LabelItem
+from ..Qt import QtGui, QtCore
+from .. import functions as fn
+from ..Point import Point
+from .GraphicsWidgetAnchor import GraphicsWidgetAnchor
+__all__ = ['LegendItem']
+
+class LegendItem(GraphicsWidget, GraphicsWidgetAnchor):
+ """
+ Displays a legend used for describing the contents of a plot.
+ LegendItems are most commonly created by calling PlotItem.addLegend().
+
+ Note that this item should not be added directly to a PlotItem. Instead,
+ Make it a direct descendant of the PlotItem::
+
+ legend.setParentItem(plotItem)
+
+ """
+ def __init__(self, size=None, offset=None):
+ """
+ ========== ===============================================================
+ Arguments
+ size Specifies the fixed size (width, height) of the legend. If
+ this argument is omitted, the legend will autimatically resize
+ to fit its contents.
+ offset Specifies the offset position relative to the legend's parent.
+ Positive values offset from the left or top; negative values
+ offset from the right or bottom. If offset is None, the
+ legend must be anchored manually by calling anchor() or
+ positioned by calling setPos().
+ ========== ===============================================================
+
+ """
+
+
+ GraphicsWidget.__init__(self)
+ GraphicsWidgetAnchor.__init__(self)
+ self.setFlag(self.ItemIgnoresTransformations)
+ self.layout = QtGui.QGraphicsGridLayout()
+ self.setLayout(self.layout)
+ self.items = []
+ self.size = size
+ self.offset = offset
+ if size is not None:
+ self.setGeometry(QtCore.QRectF(0, 0, self.size[0], self.size[1]))
+
+ def setParentItem(self, p):
+ ret = GraphicsWidget.setParentItem(self, p)
+ if self.offset is not None:
+ offset = Point(self.offset)
+ anchorx = 1 if offset[0] <= 0 else 0
+ anchory = 1 if offset[1] <= 0 else 0
+ anchor = (anchorx, anchory)
+ self.anchor(itemPos=anchor, parentPos=anchor, offset=offset)
+ return ret
+
+ def addItem(self, item, name):
+ """
+ Add a new entry to the legend.
+
+ =========== ========================================================
+ Arguments
+ item A PlotDataItem from which the line and point style
+ of the item will be determined
+ title The title to display for this item. Simple HTML allowed.
+ =========== ========================================================
+ """
+ label = LabelItem(name)
+ sample = ItemSample(item)
+ row = len(self.items)
+ self.items.append((sample, label))
+ self.layout.addItem(sample, row, 0)
+ self.layout.addItem(label, row, 1)
+ self.updateSize()
+
+ def updateSize(self):
+ if self.size is not None:
+ return
+
+ height = 0
+ width = 0
+ #print("-------")
+ for sample, label in self.items:
+ height += max(sample.height(), label.height()) + 3
+ width = max(width, sample.width()+label.width())
+ #print(width, height)
+ #print width, height
+ self.setGeometry(0, 0, width+25, height)
+
+ def boundingRect(self):
+ return QtCore.QRectF(0, 0, self.width(), self.height())
+
+ def paint(self, p, *args):
+ p.setPen(fn.mkPen(255,255,255,100))
+ p.setBrush(fn.mkBrush(100,100,100,50))
+ p.drawRect(self.boundingRect())
+
+
+class ItemSample(GraphicsWidget):
+ def __init__(self, item):
+ GraphicsWidget.__init__(self)
+ self.item = item
+
+ def boundingRect(self):
+ return QtCore.QRectF(0, 0, 20, 20)
+
+ def paint(self, p, *args):
+ opts = self.item.opts
+
+ if opts.get('fillLevel',None) is not None and opts.get('fillBrush',None) is not None:
+ p.setBrush(fn.mkBrush(opts['fillBrush']))
+ p.setPen(fn.mkPen(None))
+ p.drawPolygon(QtGui.QPolygonF([QtCore.QPointF(2,18), QtCore.QPointF(18,2), QtCore.QPointF(18,18)]))
+
+ p.setPen(fn.mkPen(opts['pen']))
+ p.drawLine(2, 18, 18, 2)
+
+
+
+
diff --git a/pyqtgraph/graphicsItems/LinearRegionItem.py b/pyqtgraph/graphicsItems/LinearRegionItem.py
new file mode 100644
index 00000000..0b44c815
--- /dev/null
+++ b/pyqtgraph/graphicsItems/LinearRegionItem.py
@@ -0,0 +1,291 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from .UIGraphicsItem import UIGraphicsItem
+from .InfiniteLine import InfiniteLine
+import pyqtgraph.functions as fn
+import pyqtgraph.debug as debug
+
+__all__ = ['LinearRegionItem']
+
+class LinearRegionItem(UIGraphicsItem):
+ """
+ **Bases:** :class:`UIGraphicsItem `
+
+ Used for marking a horizontal or vertical region in plots.
+ The region can be dragged and is bounded by lines which can be dragged individually.
+
+ =============================== =============================================================================
+ **Signals:**
+ sigRegionChangeFinished(self) Emitted when the user has finished dragging the region (or one of its lines)
+ and when the region is changed programatically.
+ sigRegionChanged(self) Emitted while the user is dragging the region (or one of its lines)
+ and when the region is changed programatically.
+ =============================== =============================================================================
+ """
+
+ sigRegionChangeFinished = QtCore.Signal(object)
+ sigRegionChanged = QtCore.Signal(object)
+ Vertical = 0
+ Horizontal = 1
+
+ def __init__(self, values=[0,1], orientation=None, brush=None, movable=True, bounds=None):
+ """Create a new LinearRegionItem.
+
+ ============= =====================================================================
+ **Arguments**
+ values A list of the positions of the lines in the region. These are not
+ limits; limits can be set by specifying bounds.
+ orientation Options are LinearRegionItem.Vertical or LinearRegionItem.Horizontal.
+ If not specified it will be vertical.
+ brush Defines the brush that fills the region. Can be any arguments that
+ are valid for :func:`mkBrush `. Default is
+ transparent blue.
+ movable If True, the region and individual lines are movable by the user; if
+ False, they are static.
+ bounds Optional [min, max] bounding values for the region
+ ============= =====================================================================
+ """
+
+ UIGraphicsItem.__init__(self)
+ if orientation is None:
+ orientation = LinearRegionItem.Vertical
+ self.orientation = orientation
+ self.bounds = QtCore.QRectF()
+ self.blockLineSignal = False
+ self.moving = False
+ self.mouseHovering = False
+
+ if orientation == LinearRegionItem.Horizontal:
+ self.lines = [
+ InfiniteLine(QtCore.QPointF(0, values[0]), 0, movable=movable, bounds=bounds),
+ InfiniteLine(QtCore.QPointF(0, values[1]), 0, movable=movable, bounds=bounds)]
+ elif orientation == LinearRegionItem.Vertical:
+ self.lines = [
+ InfiniteLine(QtCore.QPointF(values[1], 0), 90, movable=movable, bounds=bounds),
+ InfiniteLine(QtCore.QPointF(values[0], 0), 90, movable=movable, bounds=bounds)]
+ else:
+ raise Exception('Orientation must be one of LinearRegionItem.Vertical or LinearRegionItem.Horizontal')
+
+
+ for l in self.lines:
+ l.setParentItem(self)
+ l.sigPositionChangeFinished.connect(self.lineMoveFinished)
+ l.sigPositionChanged.connect(self.lineMoved)
+
+ if brush is None:
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 255, 50))
+ self.setBrush(brush)
+
+ self.setMovable(movable)
+
+ def getRegion(self):
+ """Return the values at the edges of the region."""
+ #if self.orientation[0] == 'h':
+ #r = (self.bounds.top(), self.bounds.bottom())
+ #else:
+ #r = (self.bounds.left(), self.bounds.right())
+ r = [self.lines[0].value(), self.lines[1].value()]
+ return (min(r), max(r))
+
+ def setRegion(self, rgn):
+ """Set the values for the edges of the region.
+
+ ============= ==============================================
+ **Arguments**
+ rgn A list or tuple of the lower and upper values.
+ ============= ==============================================
+ """
+ if self.lines[0].value() == rgn[0] and self.lines[1].value() == rgn[1]:
+ return
+ self.blockLineSignal = True
+ self.lines[0].setValue(rgn[0])
+ self.blockLineSignal = False
+ self.lines[1].setValue(rgn[1])
+ #self.blockLineSignal = False
+ self.lineMoved()
+ self.lineMoveFinished()
+
+ def setBrush(self, *br, **kargs):
+ """Set the brush that fills the region. Can have any arguments that are valid
+ for :func:`mkBrush `.
+ """
+ self.brush = fn.mkBrush(*br, **kargs)
+ self.currentBrush = self.brush
+
+ def setBounds(self, bounds):
+ """Optional [min, max] bounding values for the region. To have no bounds on the
+ region use [None, None].
+ Does not affect the current position of the region unless it is outside the new bounds.
+ See :func:`setRegion ` to set the position
+ of the region."""
+ for l in self.lines:
+ l.setBounds(bounds)
+
+ def setMovable(self, m):
+ """Set lines to be movable by the user, or not. If lines are movable, they will
+ also accept HoverEvents."""
+ for l in self.lines:
+ l.setMovable(m)
+ self.movable = m
+ self.setAcceptHoverEvents(m)
+
+ def boundingRect(self):
+ br = UIGraphicsItem.boundingRect(self)
+ rng = self.getRegion()
+ if self.orientation == LinearRegionItem.Vertical:
+ br.setLeft(rng[0])
+ br.setRight(rng[1])
+ else:
+ br.setTop(rng[0])
+ br.setBottom(rng[1])
+ return br.normalized()
+
+ def paint(self, p, *args):
+ #prof = debug.Profiler('LinearRegionItem.paint')
+ UIGraphicsItem.paint(self, p, *args)
+ p.setBrush(self.currentBrush)
+ p.setPen(fn.mkPen(None))
+ p.drawRect(self.boundingRect())
+ #prof.finish()
+
+ def dataBounds(self, axis, frac=1.0, orthoRange=None):
+ if axis == self.orientation:
+ return self.getRegion()
+ else:
+ return None
+
+ def lineMoved(self):
+ if self.blockLineSignal:
+ return
+ self.prepareGeometryChange()
+ #self.emit(QtCore.SIGNAL('regionChanged'), self)
+ self.sigRegionChanged.emit(self)
+
+ def lineMoveFinished(self):
+ #self.emit(QtCore.SIGNAL('regionChangeFinished'), self)
+ self.sigRegionChangeFinished.emit(self)
+
+
+ #def updateBounds(self):
+ #vb = self.view().viewRect()
+ #vals = [self.lines[0].value(), self.lines[1].value()]
+ #if self.orientation[0] == 'h':
+ #vb.setTop(min(vals))
+ #vb.setBottom(max(vals))
+ #else:
+ #vb.setLeft(min(vals))
+ #vb.setRight(max(vals))
+ #if vb != self.bounds:
+ #self.bounds = vb
+ #self.rect.setRect(vb)
+
+ #def mousePressEvent(self, ev):
+ #if not self.movable:
+ #ev.ignore()
+ #return
+ #for l in self.lines:
+ #l.mousePressEvent(ev) ## pass event to both lines so they move together
+ ##if self.movable and ev.button() == QtCore.Qt.LeftButton:
+ ##ev.accept()
+ ##self.pressDelta = self.mapToParent(ev.pos()) - QtCore.QPointF(*self.p)
+ ##else:
+ ##ev.ignore()
+
+ #def mouseReleaseEvent(self, ev):
+ #for l in self.lines:
+ #l.mouseReleaseEvent(ev)
+
+ #def mouseMoveEvent(self, ev):
+ ##print "move", ev.pos()
+ #if not self.movable:
+ #return
+ #self.lines[0].blockSignals(True) # only want to update once
+ #for l in self.lines:
+ #l.mouseMoveEvent(ev)
+ #self.lines[0].blockSignals(False)
+ ##self.setPos(self.mapToParent(ev.pos()) - self.pressDelta)
+ ##self.emit(QtCore.SIGNAL('dragged'), self)
+
+ def mouseDragEvent(self, ev):
+ if not self.movable or int(ev.button() & QtCore.Qt.LeftButton) == 0:
+ return
+ ev.accept()
+
+ if ev.isStart():
+ bdp = ev.buttonDownPos()
+ self.cursorOffsets = [l.pos() - bdp for l in self.lines]
+ self.startPositions = [l.pos() for l in self.lines]
+ self.moving = True
+
+ if not self.moving:
+ return
+
+ #delta = ev.pos() - ev.lastPos()
+ self.lines[0].blockSignals(True) # only want to update once
+ for i, l in enumerate(self.lines):
+ l.setPos(self.cursorOffsets[i] + ev.pos())
+ #l.setPos(l.pos()+delta)
+ #l.mouseDragEvent(ev)
+ self.lines[0].blockSignals(False)
+ self.prepareGeometryChange()
+
+ if ev.isFinish():
+ self.moving = False
+ self.sigRegionChangeFinished.emit(self)
+ else:
+ self.sigRegionChanged.emit(self)
+
+ def mouseClickEvent(self, ev):
+ if self.moving and ev.button() == QtCore.Qt.RightButton:
+ ev.accept()
+ for i, l in enumerate(self.lines):
+ l.setPos(self.startPositions[i])
+ self.moving = False
+ self.sigRegionChanged.emit(self)
+ self.sigRegionChangeFinished.emit(self)
+
+
+ def hoverEvent(self, ev):
+ if (not ev.isExit()) and ev.acceptDrags(QtCore.Qt.LeftButton):
+ self.setMouseHover(True)
+ else:
+ self.setMouseHover(False)
+
+ def setMouseHover(self, hover):
+ ## Inform the item that the mouse is(not) hovering over it
+ if self.mouseHovering == hover:
+ return
+ self.mouseHovering = hover
+ if hover:
+ c = self.brush.color()
+ c.setAlpha(c.alpha() * 2)
+ self.currentBrush = fn.mkBrush(c)
+ else:
+ self.currentBrush = self.brush
+ self.update()
+
+ #def hoverEnterEvent(self, ev):
+ #print "rgn hover enter"
+ #ev.ignore()
+ #self.updateHoverBrush()
+
+ #def hoverMoveEvent(self, ev):
+ #print "rgn hover move"
+ #ev.ignore()
+ #self.updateHoverBrush()
+
+ #def hoverLeaveEvent(self, ev):
+ #print "rgn hover leave"
+ #ev.ignore()
+ #self.updateHoverBrush(False)
+
+ #def updateHoverBrush(self, hover=None):
+ #if hover is None:
+ #scene = self.scene()
+ #hover = scene.claimEvent(self, QtCore.Qt.LeftButton, scene.Drag)
+
+ #if hover:
+ #self.currentBrush = fn.mkBrush(255, 0,0,100)
+ #else:
+ #self.currentBrush = self.brush
+ #self.update()
+
diff --git a/MultiPlotItem.py b/pyqtgraph/graphicsItems/MultiPlotItem.py
similarity index 72%
rename from MultiPlotItem.py
rename to pyqtgraph/graphicsItems/MultiPlotItem.py
index 2f73c9e5..d20467a9 100644
--- a/MultiPlotItem.py
+++ b/pyqtgraph/graphicsItems/MultiPlotItem.py
@@ -6,8 +6,7 @@ Distributed under MIT/X11 license. See license.txt for more infomation.
"""
from numpy import ndarray
-from graphicsItems import *
-from PlotItem import *
+from . import GraphicsLayout
try:
from metaarray import *
@@ -16,22 +15,18 @@ except:
#raise
HAVE_METAARRAY = False
-
-class MultiPlotItem(QtGui.QGraphicsWidget):
- def __init__(self, parent=None):
- QtGui.QGraphicsWidget.__init__(self, parent)
- self.layout = QtGui.QGraphicsGridLayout()
- self.layout.setContentsMargins(1,1,1,1)
- self.setLayout(self.layout)
- self.layout.setHorizontalSpacing(0)
- self.layout.setVerticalSpacing(4)
- self.plots = []
+__all__ = ['MultiPlotItem']
+class MultiPlotItem(GraphicsLayout.GraphicsLayout):
+ """
+ Automaticaly generates a grid of plots from a multi-dimensional array
+ """
+
def plot(self, data):
#self.layout.clear()
self.plots = []
- if HAVE_METAARRAY and isinstance(data, MetaArray):
+ if HAVE_METAARRAY and (hasattr(data, 'implements') and data.implements('MetaArray')):
if data.ndim != 2:
raise Exception("MultiPlot currently only accepts 2D MetaArray.")
ic = data.infoCopy()
@@ -42,11 +37,12 @@ class MultiPlotItem(QtGui.QGraphicsWidget):
break
#print "Plotting using axis %d as columns (%d plots)" % (ax, data.shape[ax])
for i in range(data.shape[ax]):
- pi = PlotItem()
+ pi = self.addPlot()
+ self.nextRow()
sl = [slice(None)] * 2
sl[ax] = i
pi.plot(data[tuple(sl)])
- self.layout.addItem(pi, i, 0)
+ #self.layout.addItem(pi, i, 0)
self.plots.append((pi, i, 0))
title = None
units = None
@@ -67,5 +63,7 @@ class MultiPlotItem(QtGui.QGraphicsWidget):
for p in self.plots:
p[0].close()
self.plots = None
- for i in range(self.layout.count()):
- self.layout.removeAt(i)
\ No newline at end of file
+ self.clear()
+
+
+
diff --git a/pyqtgraph/graphicsItems/PlotCurveItem.py b/pyqtgraph/graphicsItems/PlotCurveItem.py
new file mode 100644
index 00000000..5314b0f2
--- /dev/null
+++ b/pyqtgraph/graphicsItems/PlotCurveItem.py
@@ -0,0 +1,514 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from scipy.fftpack import fft
+import numpy as np
+import scipy.stats
+from .GraphicsObject import GraphicsObject
+import pyqtgraph.functions as fn
+from pyqtgraph import debug
+from pyqtgraph.Point import Point
+import pyqtgraph as pg
+import struct, sys
+
+__all__ = ['PlotCurveItem']
+class PlotCurveItem(GraphicsObject):
+
+
+ """
+ Class representing a single plot curve. Instances of this class are created
+ automatically as part of PlotDataItem; these rarely need to be instantiated
+ directly.
+
+ Features:
+
+ - Fast data update
+ - FFT display mode (accessed via PlotItem context menu)
+ - Fill under curve
+ - Mouse interaction
+
+ ==================== ===============================================
+ **Signals:**
+ sigPlotChanged(self) Emitted when the data being plotted has changed
+ sigClicked(self) Emitted when the curve is clicked
+ ==================== ===============================================
+ """
+
+ sigPlotChanged = QtCore.Signal(object)
+ sigClicked = QtCore.Signal(object)
+
+ def __init__(self, *args, **kargs):
+ """
+ Forwards all arguments to :func:`setData `.
+
+ Some extra arguments are accepted as well:
+
+ ============== =======================================================
+ **Arguments:**
+ parent The parent GraphicsObject (optional)
+ clickable If True, the item will emit sigClicked when it is
+ clicked on. Defaults to False.
+ ============== =======================================================
+ """
+ GraphicsObject.__init__(self, kargs.get('parent', None))
+ self.clear()
+ self.path = None
+ self.fillPath = None
+
+
+ ## this is disastrous for performance.
+ #self.setCacheMode(QtGui.QGraphicsItem.DeviceCoordinateCache)
+
+ self.metaData = {}
+ self.opts = {
+ 'pen': fn.mkPen('w'),
+ 'shadowPen': None,
+ 'fillLevel': None,
+ 'brush': None,
+ 'stepMode': False,
+ 'name': None,
+ 'antialias': pg.getConfigOption('antialias'),
+ }
+ self.setClickable(kargs.get('clickable', False))
+ self.setData(*args, **kargs)
+
+ def implements(self, interface=None):
+ ints = ['plotData']
+ if interface is None:
+ return ints
+ return interface in ints
+
+ def setClickable(self, s):
+ """Sets whether the item responds to mouse clicks."""
+ self.clickable = s
+
+
+ def getData(self):
+ return self.xData, self.yData
+
+ def dataBounds(self, ax, frac=1.0, orthoRange=None):
+ (x, y) = self.getData()
+ if x is None or len(x) == 0:
+ return (0, 0)
+
+ if ax == 0:
+ d = x
+ d2 = y
+ elif ax == 1:
+ d = y
+ d2 = x
+
+ if orthoRange is not None:
+ mask = (d2 >= orthoRange[0]) * (d2 <= orthoRange[1])
+ d = d[mask]
+ d2 = d2[mask]
+
+
+ if frac >= 1.0:
+ return (d.min(), d.max())
+ elif frac <= 0.0:
+ raise Exception("Value for parameter 'frac' must be > 0. (got %s)" % str(frac))
+ else:
+ return (scipy.stats.scoreatpercentile(d, 50 - (frac * 50)), scipy.stats.scoreatpercentile(d, 50 + (frac * 50)))
+
+ def setPen(self, *args, **kargs):
+ """Set the pen used to draw the curve."""
+ self.opts['pen'] = fn.mkPen(*args, **kargs)
+ self.update()
+
+ def setShadowPen(self, *args, **kargs):
+ """Set the shadow pen used to draw behind tyhe primary pen.
+ This pen must have a larger width than the primary
+ pen to be visible.
+ """
+ self.opts['shadowPen'] = fn.mkPen(*args, **kargs)
+ self.update()
+
+ def setBrush(self, *args, **kargs):
+ """Set the brush used when filling the area under the curve"""
+ self.opts['brush'] = fn.mkBrush(*args, **kargs)
+ self.update()
+
+ def setFillLevel(self, level):
+ """Set the level filled to when filling under the curve"""
+ self.opts['fillLevel'] = level
+ self.fillPath = None
+ self.update()
+
+ #def setColor(self, color):
+ #self.pen.setColor(color)
+ #self.update()
+
+ #def setAlpha(self, alpha, auto):
+ #self.opts['alphaHint'] = alpha
+ #self.opts['alphaMode'] = auto
+ #self.update()
+
+ #def setSpectrumMode(self, mode):
+ #self.opts['spectrumMode'] = mode
+ #self.xDisp = self.yDisp = None
+ #self.path = None
+ #self.update()
+
+ #def setLogMode(self, mode):
+ #self.opts['logMode'] = mode
+ #self.xDisp = self.yDisp = None
+ #self.path = None
+ #self.update()
+
+ #def setPointMode(self, mode):
+ #self.opts['pointMode'] = mode
+ #self.update()
+
+
+ #def setDownsampling(self, ds):
+ #if self.opts['downsample'] != ds:
+ #self.opts['downsample'] = ds
+ #self.xDisp = self.yDisp = None
+ #self.path = None
+ #self.update()
+
+ def setData(self, *args, **kargs):
+ """
+ ============== ========================================================
+ **Arguments:**
+ x, y (numpy arrays) Data to show
+ pen Pen to use when drawing. Any single argument accepted by
+ :func:`mkPen ` is allowed.
+ shadowPen Pen for drawing behind the primary pen. Usually this
+ is used to emphasize the curve by providing a
+ high-contrast border. Any single argument accepted by
+ :func:`mkPen ` is allowed.
+ fillLevel (float or None) Fill the area 'under' the curve to
+ *fillLevel*
+ brush QBrush to use when filling. Any single argument accepted
+ by :func:`mkBrush ` is allowed.
+ antialias (bool) Whether to use antialiasing when drawing. This
+ is disabled by default because it decreases performance.
+ ============== ========================================================
+
+ If non-keyword arguments are used, they will be interpreted as
+ setData(y) for a single argument and setData(x, y) for two
+ arguments.
+
+
+ """
+ self.updateData(*args, **kargs)
+
+ def updateData(self, *args, **kargs):
+ prof = debug.Profiler('PlotCurveItem.updateData', disabled=True)
+
+ if len(args) == 1:
+ kargs['y'] = args[0]
+ elif len(args) == 2:
+ kargs['x'] = args[0]
+ kargs['y'] = args[1]
+
+ if 'y' not in kargs or kargs['y'] is None:
+ kargs['y'] = np.array([])
+ if 'x' not in kargs or kargs['x'] is None:
+ kargs['x'] = np.arange(len(kargs['y']))
+
+ for k in ['x', 'y']:
+ data = kargs[k]
+ if isinstance(data, list):
+ data = np.array(data)
+ kargs[k] = data
+ if not isinstance(data, np.ndarray) or data.ndim > 1:
+ raise Exception("Plot data must be 1D ndarray.")
+ if 'complex' in str(data.dtype):
+ raise Exception("Can not plot complex data types.")
+
+ prof.mark("data checks")
+
+ #self.setCacheMode(QtGui.QGraphicsItem.NoCache) ## Disabling and re-enabling the cache works around a bug in Qt 4.6 causing the cached results to display incorrectly
+ ## Test this bug with test_PlotWidget and zoom in on the animated plot
+ self.prepareGeometryChange()
+ self.yData = kargs['y'].view(np.ndarray)
+ self.xData = kargs['x'].view(np.ndarray)
+
+ prof.mark('copy')
+
+ if 'stepMode' in kargs:
+ self.opts['stepMode'] = kargs['stepMode']
+
+ if self.opts['stepMode'] is True:
+ if len(self.xData) != len(self.yData)+1: ## allow difference of 1 for step mode plots
+ raise Exception("len(X) must be len(Y)+1 since stepMode=True (got %s and %s)" % (str(x.shape), str(y.shape)))
+ else:
+ if self.xData.shape != self.yData.shape: ## allow difference of 1 for step mode plots
+ raise Exception("X and Y arrays must be the same shape--got %s and %s." % (str(x.shape), str(y.shape)))
+
+ self.path = None
+ self.fillPath = None
+ #self.xDisp = self.yDisp = None
+
+ if 'name' in kargs:
+ self.opts['name'] = kargs['name']
+
+ if 'pen' in kargs:
+ self.setPen(kargs['pen'])
+ if 'shadowPen' in kargs:
+ self.setShadowPen(kargs['shadowPen'])
+ if 'fillLevel' in kargs:
+ self.setFillLevel(kargs['fillLevel'])
+ if 'brush' in kargs:
+ self.setBrush(kargs['brush'])
+ if 'antialias' in kargs:
+ self.opts['antialias'] = kargs['antialias']
+
+
+ prof.mark('set')
+ self.update()
+ prof.mark('update')
+ self.sigPlotChanged.emit(self)
+ prof.mark('emit')
+ prof.finish()
+
+ def generatePath(self, x, y):
+ prof = debug.Profiler('PlotCurveItem.generatePath', disabled=True)
+ path = QtGui.QPainterPath()
+
+ ## Create all vertices in path. The method used below creates a binary format so that all
+ ## vertices can be read in at once. This binary format may change in future versions of Qt,
+ ## so the original (slower) method is left here for emergencies:
+ #path.moveTo(x[0], y[0])
+ #for i in range(1, y.shape[0]):
+ # path.lineTo(x[i], y[i])
+
+ ## Speed this up using >> operator
+ ## Format is:
+ ## numVerts(i4) 0(i4)
+ ## x(f8) y(f8) 0(i4) <-- 0 means this vertex does not connect
+ ## x(f8) y(f8) 1(i4) <-- 1 means this vertex connects to the previous vertex
+ ## ...
+ ## 0(i4)
+ ##
+ ## All values are big endian--pack using struct.pack('>d') or struct.pack('>i')
+
+ if self.opts['stepMode']:
+ ## each value in the x/y arrays generates 2 points.
+ x2 = np.empty((len(x),2), dtype=x.dtype)
+ x2[:] = x[:,np.newaxis]
+ if self.opts['fillLevel'] is None:
+ x = x2.reshape(x2.size)[1:-1]
+ y2 = np.empty((len(y),2), dtype=y.dtype)
+ y2[:] = y[:,np.newaxis]
+ y = y2.reshape(y2.size)
+ else:
+ ## If we have a fill level, add two extra points at either end
+ x = x2.reshape(x2.size)
+ y2 = np.empty((len(y)+2,2), dtype=y.dtype)
+ y2[1:-1] = y[:,np.newaxis]
+ y = y2.reshape(y2.size)[1:-1]
+ y[0] = self.opts['fillLevel']
+ y[-1] = self.opts['fillLevel']
+
+
+
+
+
+ if sys.version_info[0] == 2: ## So this is disabled for python 3... why??
+ n = x.shape[0]
+ # create empty array, pad with extra space on either end
+ arr = np.empty(n+2, dtype=[('x', '>f8'), ('y', '>f8'), ('c', '>i4')])
+ # write first two integers
+ prof.mark('allocate empty')
+ arr.data[12:20] = struct.pack('>ii', n, 0)
+ prof.mark('pack header')
+ # Fill array with vertex values
+ arr[1:-1]['x'] = x
+ arr[1:-1]['y'] = y
+ arr[1:-1]['c'] = 1
+ prof.mark('fill array')
+ # write last 0
+ lastInd = 20*(n+1)
+ arr.data[lastInd:lastInd+4] = struct.pack('>i', 0)
+ prof.mark('footer')
+ # create datastream object and stream into path
+ buf = QtCore.QByteArray(arr.data[12:lastInd+4]) # I think one unnecessary copy happens here
+ prof.mark('create buffer')
+ ds = QtCore.QDataStream(buf)
+ prof.mark('create datastream')
+ ds >> path
+ prof.mark('load')
+
+ prof.finish()
+ else:
+ path.moveTo(x[0], y[0])
+ for i in range(1, y.shape[0]):
+ path.lineTo(x[i], y[i])
+
+ return path
+
+
+ def shape(self):
+ if self.path is None:
+ try:
+ self.path = self.generatePath(*self.getData())
+ except:
+ return QtGui.QPainterPath()
+ return self.path
+
+ def boundingRect(self):
+ (x, y) = self.getData()
+ if x is None or y is None or len(x) == 0 or len(y) == 0:
+ return QtCore.QRectF()
+
+
+ if self.opts['shadowPen'] is not None:
+ lineWidth = (max(self.opts['pen'].width(), self.opts['shadowPen'].width()) + 1)
+ else:
+ lineWidth = (self.opts['pen'].width()+1)
+
+
+ pixels = self.pixelVectors()
+ if pixels == (None, None):
+ pixels = [Point(0,0), Point(0,0)]
+
+ xmin = x.min()
+ xmax = x.max()
+ ymin = y.min()
+ ymax = y.max()
+
+ if self.opts['fillLevel'] is not None:
+ ymin = min(ymin, self.opts['fillLevel'])
+ ymax = max(ymax, self.opts['fillLevel'])
+
+ xmin -= pixels[0].x() * lineWidth
+ xmax += pixels[0].x() * lineWidth
+ ymin -= abs(pixels[1].y()) * lineWidth
+ ymax += abs(pixels[1].y()) * lineWidth
+
+ return QtCore.QRectF(xmin, ymin, xmax-xmin, ymax-ymin)
+
+ def paint(self, p, opt, widget):
+ prof = debug.Profiler('PlotCurveItem.paint '+str(id(self)), disabled=True)
+ if self.xData is None:
+ return
+ #if self.opts['spectrumMode']:
+ #if self.specPath is None:
+
+ #self.specPath = self.generatePath(*self.getData())
+ #path = self.specPath
+ #else:
+ x = None
+ y = None
+ if self.path is None:
+ x,y = self.getData()
+ if x is None or len(x) == 0 or y is None or len(y) == 0:
+ return
+ self.path = self.generatePath(x,y)
+ self.fillPath = None
+
+
+ path = self.path
+ prof.mark('generate path')
+
+ if self._exportOpts is not False:
+ aa = self._exportOpts.get('antialias', True)
+ else:
+ aa = self.opts['antialias']
+
+ p.setRenderHint(p.Antialiasing, aa)
+
+
+ if self.opts['brush'] is not None and self.opts['fillLevel'] is not None:
+ if self.fillPath is None:
+ if x is None:
+ x,y = self.getData()
+ p2 = QtGui.QPainterPath(self.path)
+ p2.lineTo(x[-1], self.opts['fillLevel'])
+ p2.lineTo(x[0], self.opts['fillLevel'])
+ p2.lineTo(x[0], y[0])
+ p2.closeSubpath()
+ self.fillPath = p2
+
+ prof.mark('generate fill path')
+ p.fillPath(self.fillPath, self.opts['brush'])
+ prof.mark('draw fill path')
+
+
+ ## Copy pens and apply alpha adjustment
+ sp = QtGui.QPen(self.opts['shadowPen'])
+ cp = QtGui.QPen(self.opts['pen'])
+ #for pen in [sp, cp]:
+ #if pen is None:
+ #continue
+ #c = pen.color()
+ #c.setAlpha(c.alpha() * self.opts['alphaHint'])
+ #pen.setColor(c)
+ ##pen.setCosmetic(True)
+
+
+
+ if sp is not None and sp.style() != QtCore.Qt.NoPen:
+ p.setPen(sp)
+ p.drawPath(path)
+ p.setPen(cp)
+ p.drawPath(path)
+ prof.mark('drawPath')
+
+ #print "Render hints:", int(p.renderHints())
+ prof.finish()
+ #p.setPen(QtGui.QPen(QtGui.QColor(255,0,0)))
+ #p.drawRect(self.boundingRect())
+
+
+ def clear(self):
+ self.xData = None ## raw values
+ self.yData = None
+ self.xDisp = None ## display values (after log / fft)
+ self.yDisp = None
+ self.path = None
+ #del self.xData, self.yData, self.xDisp, self.yDisp, self.path
+
+ #def mousePressEvent(self, ev):
+ ##GraphicsObject.mousePressEvent(self, ev)
+ #if not self.clickable:
+ #ev.ignore()
+ #if ev.button() != QtCore.Qt.LeftButton:
+ #ev.ignore()
+ #self.mousePressPos = ev.pos()
+ #self.mouseMoved = False
+
+ #def mouseMoveEvent(self, ev):
+ ##GraphicsObject.mouseMoveEvent(self, ev)
+ #self.mouseMoved = True
+ ##print "move"
+
+ #def mouseReleaseEvent(self, ev):
+ ##GraphicsObject.mouseReleaseEvent(self, ev)
+ #if not self.mouseMoved:
+ #self.sigClicked.emit(self)
+
+ def mouseClickEvent(self, ev):
+ if not self.clickable or ev.button() != QtCore.Qt.LeftButton:
+ return
+ ev.accept()
+ self.sigClicked.emit(self)
+
+
+class ROIPlotItem(PlotCurveItem):
+ """Plot curve that monitors an ROI and image for changes to automatically replot."""
+ def __init__(self, roi, data, img, axes=(0,1), xVals=None, color=None):
+ self.roi = roi
+ self.roiData = data
+ self.roiImg = img
+ self.axes = axes
+ self.xVals = xVals
+ PlotCurveItem.__init__(self, self.getRoiData(), x=self.xVals, color=color)
+ #roi.connect(roi, QtCore.SIGNAL('regionChanged'), self.roiChangedEvent)
+ roi.sigRegionChanged.connect(self.roiChangedEvent)
+ #self.roiChangedEvent()
+
+ def getRoiData(self):
+ d = self.roi.getArrayRegion(self.roiData, self.roiImg, axes=self.axes)
+ if d is None:
+ return
+ while d.ndim > 1:
+ d = d.mean(axis=1)
+ return d
+
+ def roiChangedEvent(self):
+ d = self.getRoiData()
+ self.updateData(d, self.xVals)
+
diff --git a/pyqtgraph/graphicsItems/PlotDataItem.py b/pyqtgraph/graphicsItems/PlotDataItem.py
new file mode 100644
index 00000000..714210c4
--- /dev/null
+++ b/pyqtgraph/graphicsItems/PlotDataItem.py
@@ -0,0 +1,706 @@
+import pyqtgraph.metaarray as metaarray
+from pyqtgraph.Qt import QtCore
+from .GraphicsObject import GraphicsObject
+from .PlotCurveItem import PlotCurveItem
+from .ScatterPlotItem import ScatterPlotItem
+import numpy as np
+import scipy
+import pyqtgraph.functions as fn
+import pyqtgraph.debug as debug
+import pyqtgraph as pg
+
+class PlotDataItem(GraphicsObject):
+ """
+ **Bases:** :class:`GraphicsObject `
+
+ GraphicsItem for displaying plot curves, scatter plots, or both.
+ While it is possible to use :class:`PlotCurveItem ` or
+ :class:`ScatterPlotItem ` individually, this class
+ provides a unified interface to both. Inspances of :class:`PlotDataItem` are
+ usually created by plot() methods such as :func:`pyqtgraph.plot` and
+ :func:`PlotItem.plot() `.
+
+ ============================== ==============================================
+ **Signals:**
+ sigPlotChanged(self) Emitted when the data in this item is updated.
+ sigClicked(self) Emitted when the item is clicked.
+ sigPointsClicked(self, points) Emitted when a plot point is clicked
+ Sends the list of points under the mouse.
+ ============================== ==============================================
+ """
+
+ sigPlotChanged = QtCore.Signal(object)
+ sigClicked = QtCore.Signal(object)
+ sigPointsClicked = QtCore.Signal(object, object)
+
+ def __init__(self, *args, **kargs):
+ """
+ There are many different ways to create a PlotDataItem:
+
+ **Data initialization arguments:** (x,y data only)
+
+ =================================== ======================================
+ PlotDataItem(xValues, yValues) x and y values may be any sequence (including ndarray) of real numbers
+ PlotDataItem(yValues) y values only -- x will be automatically set to range(len(y))
+ PlotDataItem(x=xValues, y=yValues) x and y given by keyword arguments
+ PlotDataItem(ndarray(Nx2)) numpy array with shape (N, 2) where x=data[:,0] and y=data[:,1]
+ =================================== ======================================
+
+ **Data initialization arguments:** (x,y data AND may include spot style)
+
+ =========================== =========================================
+ PlotDataItem(recarray) numpy array with dtype=[('x', float), ('y', float), ...]
+ PlotDataItem(list-of-dicts) [{'x': x, 'y': y, ...}, ...]
+ PlotDataItem(dict-of-lists) {'x': [...], 'y': [...], ...}
+ PlotDataItem(MetaArray) 1D array of Y values with X sepecified as axis values
+ OR 2D array with a column 'y' and extra columns as needed.
+ =========================== =========================================
+
+ **Line style keyword arguments:**
+ ========== ================================================
+ pen Pen to use for drawing line between points.
+ Default is solid grey, 1px width. Use None to disable line drawing.
+ May be any single argument accepted by :func:`mkPen() `
+ shadowPen Pen for secondary line to draw behind the primary line. disabled by default.
+ May be any single argument accepted by :func:`mkPen() `
+ fillLevel Fill the area between the curve and fillLevel
+ fillBrush Fill to use when fillLevel is specified.
+ May be any single argument accepted by :func:`mkBrush() `
+ ========== ================================================
+
+ **Point style keyword arguments:** (see :func:`ScatterPlotItem.setData() ` for more information)
+
+ ============ ================================================
+ symbol Symbol to use for drawing points OR list of symbols, one per point. Default is no symbol.
+ Options are o, s, t, d, +, or any QPainterPath
+ symbolPen Outline pen for drawing points OR list of pens, one per point.
+ May be any single argument accepted by :func:`mkPen() `
+ symbolBrush Brush for filling points OR list of brushes, one per point.
+ May be any single argument accepted by :func:`mkBrush() `
+ symbolSize Diameter of symbols OR list of diameters.
+ pxMode (bool) If True, then symbolSize is specified in pixels. If False, then symbolSize is
+ specified in data coordinates.
+ ============ ================================================
+
+ **Optimization keyword arguments:**
+
+ ========== =====================================================================
+ antialias (bool) By default, antialiasing is disabled to improve performance.
+ Note that in some cases (in particluar, when pxMode=True), points
+ will be rendered antialiased even if this is set to False.
+ identical *deprecated*
+ decimate (int) sub-sample data by selecting every nth sample before plotting
+ ========== =====================================================================
+
+ **Meta-info keyword arguments:**
+
+ ========== ================================================
+ name name of dataset. This would appear in a legend
+ ========== ================================================
+ """
+ GraphicsObject.__init__(self)
+ self.setFlag(self.ItemHasNoContents)
+ self.xData = None
+ self.yData = None
+ self.xDisp = None
+ self.yDisp = None
+ #self.curves = []
+ #self.scatters = []
+ self.curve = PlotCurveItem()
+ self.scatter = ScatterPlotItem()
+ self.curve.setParentItem(self)
+ self.scatter.setParentItem(self)
+
+ self.curve.sigClicked.connect(self.curveClicked)
+ self.scatter.sigClicked.connect(self.scatterClicked)
+
+
+ #self.clear()
+ self.opts = {
+ 'fftMode': False,
+ 'logMode': [False, False],
+ 'downsample': False,
+ 'alphaHint': 1.0,
+ 'alphaMode': False,
+
+ 'pen': (200,200,200),
+ 'shadowPen': None,
+ 'fillLevel': None,
+ 'fillBrush': None,
+
+ 'symbol': None,
+ 'symbolSize': 10,
+ 'symbolPen': (200,200,200),
+ 'symbolBrush': (50, 50, 150),
+ 'pxMode': True,
+
+ 'antialias': pg.getConfigOption('antialias'),
+ 'pointMode': None,
+
+ 'data': None,
+ }
+ self.setData(*args, **kargs)
+
+ def implements(self, interface=None):
+ ints = ['plotData']
+ if interface is None:
+ return ints
+ return interface in ints
+
+ def boundingRect(self):
+ return QtCore.QRectF() ## let child items handle this
+
+ def setAlpha(self, alpha, auto):
+ if self.opts['alphaHint'] == alpha and self.opts['alphaMode'] == auto:
+ return
+ self.opts['alphaHint'] = alpha
+ self.opts['alphaMode'] = auto
+ self.setOpacity(alpha)
+ #self.update()
+
+ def setFftMode(self, mode):
+ if self.opts['fftMode'] == mode:
+ return
+ self.opts['fftMode'] = mode
+ self.xDisp = self.yDisp = None
+ self.updateItems()
+
+ def setLogMode(self, xMode, yMode):
+ if self.opts['logMode'] == [xMode, yMode]:
+ return
+ self.opts['logMode'] = [xMode, yMode]
+ self.xDisp = self.yDisp = None
+ self.updateItems()
+
+ def setPointMode(self, mode):
+ if self.opts['pointMode'] == mode:
+ return
+ self.opts['pointMode'] = mode
+ self.update()
+
+ def setPen(self, *args, **kargs):
+ """
+ | Sets the pen used to draw lines between points.
+ | *pen* can be a QPen or any argument accepted by :func:`pyqtgraph.mkPen() `
+ """
+ pen = fn.mkPen(*args, **kargs)
+ self.opts['pen'] = pen
+ #self.curve.setPen(pen)
+ #for c in self.curves:
+ #c.setPen(pen)
+ #self.update()
+ self.updateItems()
+
+ def setShadowPen(self, *args, **kargs):
+ """
+ | Sets the shadow pen used to draw lines between points (this is for enhancing contrast or
+ emphacizing data).
+ | This line is drawn behind the primary pen (see :func:`setPen() `)
+ and should generally be assigned greater width than the primary pen.
+ | *pen* can be a QPen or any argument accepted by :func:`pyqtgraph.mkPen() `
+ """
+ pen = fn.mkPen(*args, **kargs)
+ self.opts['shadowPen'] = pen
+ #for c in self.curves:
+ #c.setPen(pen)
+ #self.update()
+ self.updateItems()
+
+ def setFillBrush(self, *args, **kargs):
+ brush = fn.mkBrush(*args, **kargs)
+ if self.opts['fillBrush'] == brush:
+ return
+ self.opts['fillBrush'] = brush
+ self.updateItems()
+
+ def setBrush(self, *args, **kargs):
+ return self.setFillBrush(*args, **kargs)
+
+ def setFillLevel(self, level):
+ if self.opts['fillLevel'] == level:
+ return
+ self.opts['fillLevel'] = level
+ self.updateItems()
+
+ def setSymbol(self, symbol):
+ if self.opts['symbol'] == symbol:
+ return
+ self.opts['symbol'] = symbol
+ #self.scatter.setSymbol(symbol)
+ self.updateItems()
+
+ def setSymbolPen(self, *args, **kargs):
+ pen = fn.mkPen(*args, **kargs)
+ if self.opts['symbolPen'] == pen:
+ return
+ self.opts['symbolPen'] = pen
+ #self.scatter.setSymbolPen(pen)
+ self.updateItems()
+
+
+
+ def setSymbolBrush(self, *args, **kargs):
+ brush = fn.mkBrush(*args, **kargs)
+ if self.opts['symbolBrush'] == brush:
+ return
+ self.opts['symbolBrush'] = brush
+ #self.scatter.setSymbolBrush(brush)
+ self.updateItems()
+
+
+ def setSymbolSize(self, size):
+ if self.opts['symbolSize'] == size:
+ return
+ self.opts['symbolSize'] = size
+ #self.scatter.setSymbolSize(symbolSize)
+ self.updateItems()
+
+ def setDownsampling(self, ds):
+ if self.opts['downsample'] == ds:
+ return
+ self.opts['downsample'] = ds
+ self.xDisp = self.yDisp = None
+ self.updateItems()
+
+ def setData(self, *args, **kargs):
+ """
+ Clear any data displayed by this item and display new data.
+ See :func:`__init__() ` for details; it accepts the same arguments.
+ """
+ #self.clear()
+ prof = debug.Profiler('PlotDataItem.setData (0x%x)' % id(self), disabled=True)
+ y = None
+ x = None
+ if len(args) == 1:
+ data = args[0]
+ dt = dataType(data)
+ if dt == 'empty':
+ pass
+ elif dt == 'listOfValues':
+ y = np.array(data)
+ elif dt == 'Nx2array':
+ x = data[:,0]
+ y = data[:,1]
+ elif dt == 'recarray' or dt == 'dictOfLists':
+ if 'x' in data:
+ x = np.array(data['x'])
+ if 'y' in data:
+ y = np.array(data['y'])
+ elif dt == 'listOfDicts':
+ if 'x' in data[0]:
+ x = np.array([d.get('x',None) for d in data])
+ if 'y' in data[0]:
+ y = np.array([d.get('y',None) for d in data])
+ for k in ['data', 'symbolSize', 'symbolPen', 'symbolBrush', 'symbolShape']:
+ if k in data:
+ kargs[k] = [d.get(k, None) for d in data]
+ elif dt == 'MetaArray':
+ y = data.view(np.ndarray)
+ x = data.xvals(0).view(np.ndarray)
+ else:
+ raise Exception('Invalid data type %s' % type(data))
+
+ elif len(args) == 2:
+ seq = ('listOfValues', 'MetaArray')
+ if dataType(args[0]) not in seq or dataType(args[1]) not in seq:
+ raise Exception('When passing two unnamed arguments, both must be a list or array of values. (got %s, %s)' % (str(type(args[0])), str(type(args[1]))))
+ if not isinstance(args[0], np.ndarray):
+ x = np.array(args[0])
+ else:
+ x = args[0].view(np.ndarray)
+ if not isinstance(args[1], np.ndarray):
+ y = np.array(args[1])
+ else:
+ y = args[1].view(np.ndarray)
+
+ if 'x' in kargs:
+ x = kargs['x']
+ if 'y' in kargs:
+ y = kargs['y']
+
+ prof.mark('interpret data')
+ ## pull in all style arguments.
+ ## Use self.opts to fill in anything not present in kargs.
+
+ if 'name' in kargs:
+ self.opts['name'] = kargs['name']
+
+ ## if symbol pen/brush are given with no symbol, then assume symbol is 'o'
+
+ if 'symbol' not in kargs and ('symbolPen' in kargs or 'symbolBrush' in kargs or 'symbolSize' in kargs):
+ kargs['symbol'] = 'o'
+
+ if 'brush' in kargs:
+ kargs['fillBrush'] = kargs['brush']
+
+ for k in list(self.opts.keys()):
+ if k in kargs:
+ self.opts[k] = kargs[k]
+
+ #curveArgs = {}
+ #for k in ['pen', 'shadowPen', 'fillLevel', 'brush']:
+ #if k in kargs:
+ #self.opts[k] = kargs[k]
+ #curveArgs[k] = self.opts[k]
+
+ #scatterArgs = {}
+ #for k,v in [('symbolPen','pen'), ('symbolBrush','brush'), ('symbol','symbol')]:
+ #if k in kargs:
+ #self.opts[k] = kargs[k]
+ #scatterArgs[v] = self.opts[k]
+
+
+ if y is None:
+ return
+ if y is not None and x is None:
+ x = np.arange(len(y))
+
+ if isinstance(x, list):
+ x = np.array(x)
+ if isinstance(y, list):
+ y = np.array(y)
+
+ self.xData = x.view(np.ndarray) ## one last check to make sure there are no MetaArrays getting by
+ self.yData = y.view(np.ndarray)
+ self.xDisp = None
+ self.yDisp = None
+ prof.mark('set data')
+
+ self.updateItems()
+ prof.mark('update items')
+
+ view = self.getViewBox()
+ if view is not None:
+ view.itemBoundsChanged(self) ## inform view so it can update its range if it wants
+
+ self.sigPlotChanged.emit(self)
+ prof.mark('emit')
+ prof.finish()
+
+
+ def updateItems(self):
+ #for c in self.curves+self.scatters:
+ #if c.scene() is not None:
+ #c.scene().removeItem(c)
+
+ curveArgs = {}
+ for k,v in [('pen','pen'), ('shadowPen','shadowPen'), ('fillLevel','fillLevel'), ('fillBrush', 'brush'), ('antialias', 'antialias')]:
+ curveArgs[v] = self.opts[k]
+
+ scatterArgs = {}
+ for k,v in [('symbolPen','pen'), ('symbolBrush','brush'), ('symbol','symbol'), ('symbolSize', 'size'), ('data', 'data'), ('pxMode', 'pxMode'), ('antialias', 'antialias')]:
+ if k in self.opts:
+ scatterArgs[v] = self.opts[k]
+
+ x,y = self.getData()
+
+ if curveArgs['pen'] is not None or (curveArgs['brush'] is not None and curveArgs['fillLevel'] is not None):
+ self.curve.setData(x=x, y=y, **curveArgs)
+ self.curve.show()
+ else:
+ self.curve.hide()
+ #curve = PlotCurveItem(x=x, y=y, **curveArgs)
+ #curve.setParentItem(self)
+ #self.curves.append(curve)
+
+ if scatterArgs['symbol'] is not None:
+ self.scatter.setData(x=x, y=y, **scatterArgs)
+ self.scatter.show()
+ else:
+ self.scatter.hide()
+ #sp = ScatterPlotItem(x=x, y=y, **scatterArgs)
+ #sp.setParentItem(self)
+ #self.scatters.append(sp)
+
+
+ def getData(self):
+ if self.xData is None:
+ return (None, None)
+ if self.xDisp is None:
+ nanMask = np.isnan(self.xData) | np.isnan(self.yData) | np.isinf(self.xData) | np.isinf(self.yData)
+ if any(nanMask):
+ x = self.xData[~nanMask]
+ y = self.yData[~nanMask]
+ else:
+ x = self.xData
+ y = self.yData
+ ds = self.opts['downsample']
+ if ds > 1:
+ x = x[::ds]
+ #y = resample(y[:len(x)*ds], len(x)) ## scipy.signal.resample causes nasty ringing
+ y = y[::ds]
+ if self.opts['fftMode']:
+ f = np.fft.fft(y) / len(y)
+ y = abs(f[1:len(f)/2])
+ dt = x[-1] - x[0]
+ x = np.linspace(0, 0.5*len(x)/dt, len(y))
+ if self.opts['logMode'][0]:
+ x = np.log10(x)
+ if self.opts['logMode'][1]:
+ y = np.log10(y)
+ if any(self.opts['logMode']): ## re-check for NANs after log
+ nanMask = np.isinf(x) | np.isinf(y) | np.isnan(x) | np.isnan(y)
+ if any(nanMask):
+ x = x[~nanMask]
+ y = y[~nanMask]
+ self.xDisp = x
+ self.yDisp = y
+ #print self.yDisp.shape, self.yDisp.min(), self.yDisp.max()
+ #print self.xDisp.shape, self.xDisp.min(), self.xDisp.max()
+ return self.xDisp, self.yDisp
+
+ def dataBounds(self, ax, frac=1.0, orthoRange=None):
+ """
+ Returns the range occupied by the data (along a specific axis) in this item.
+ This method is called by ViewBox when auto-scaling.
+
+ =============== =============================================================
+ **Arguments:**
+ ax (0 or 1) the axis for which to return this item's data range
+ frac (float 0.0-1.0) Specifies what fraction of the total data
+ range to return. By default, the entire range is returned.
+ This allows the ViewBox to ignore large spikes in the data
+ when auto-scaling.
+ orthoRange ([min,max] or None) Specifies that only the data within the
+ given range (orthogonal to *ax*) should me measured when
+ returning the data range. (For example, a ViewBox might ask
+ what is the y-range of all data with x-values between min
+ and max)
+ =============== =============================================================
+ """
+ if frac <= 0.0:
+ raise Exception("Value for parameter 'frac' must be > 0. (got %s)" % str(frac))
+
+ (x, y) = self.getData()
+ if x is None or len(x) == 0:
+ return None
+
+ if ax == 0:
+ d = x
+ d2 = y
+ elif ax == 1:
+ d = y
+ d2 = x
+
+ if orthoRange is not None:
+ mask = (d2 >= orthoRange[0]) * (d2 <= orthoRange[1])
+ d = d[mask]
+ #d2 = d2[mask]
+
+ if len(d) > 0:
+ if frac >= 1.0:
+ return (np.min(d), np.max(d))
+ else:
+ return (scipy.stats.scoreatpercentile(d, 50 - (frac * 50)), scipy.stats.scoreatpercentile(d, 50 + (frac * 50)))
+ else:
+ return None
+
+
+ def clear(self):
+ #for i in self.curves+self.scatters:
+ #if i.scene() is not None:
+ #i.scene().removeItem(i)
+ #self.curves = []
+ #self.scatters = []
+ self.xData = None
+ self.yData = None
+ self.xDisp = None
+ self.yDisp = None
+ self.curve.setData([])
+ self.scatter.setData([])
+
+ def appendData(self, *args, **kargs):
+ pass
+
+ def curveClicked(self):
+ self.sigClicked.emit(self)
+
+ def scatterClicked(self, plt, points):
+ self.sigClicked.emit(self)
+ self.sigPointsClicked.emit(self, points)
+
+
+def dataType(obj):
+ if hasattr(obj, '__len__') and len(obj) == 0:
+ return 'empty'
+ if isinstance(obj, dict):
+ return 'dictOfLists'
+ elif isSequence(obj):
+ first = obj[0]
+
+ if (hasattr(obj, 'implements') and obj.implements('MetaArray')):
+ return 'MetaArray'
+ elif isinstance(obj, np.ndarray):
+ if obj.ndim == 1:
+ if obj.dtype.names is None:
+ return 'listOfValues'
+ else:
+ return 'recarray'
+ elif obj.ndim == 2 and obj.dtype.names is None and obj.shape[1] == 2:
+ return 'Nx2array'
+ else:
+ raise Exception('array shape must be (N,) or (N,2); got %s instead' % str(obj.shape))
+ elif isinstance(first, dict):
+ return 'listOfDicts'
+ else:
+ return 'listOfValues'
+
+
+def isSequence(obj):
+ return hasattr(obj, '__iter__') or isinstance(obj, np.ndarray) or (hasattr(obj, 'implements') and obj.implements('MetaArray'))
+
+
+
+#class TableData:
+ #"""
+ #Class for presenting multiple forms of tabular data through a consistent interface.
+ #May contain:
+ #- numpy record array
+ #- list-of-dicts (all dicts are _not_ required to have the same keys)
+ #- dict-of-lists
+ #- dict (single record)
+ #Note: if all the values in this record are lists, it will be interpreted as multiple records
+
+ #Data can be accessed and modified by column, by row, or by value
+ #data[columnName]
+ #data[rowId]
+ #data[columnName, rowId] = value
+ #data[columnName] = [value, value, ...]
+ #data[rowId] = {columnName: value, ...}
+ #"""
+
+ #def __init__(self, data):
+ #self.data = data
+ #if isinstance(data, np.ndarray):
+ #self.mode = 'array'
+ #elif isinstance(data, list):
+ #self.mode = 'list'
+ #elif isinstance(data, dict):
+ #types = set(map(type, data.values()))
+ ### dict may be a dict-of-lists or a single record
+ #types -= set([list, np.ndarray]) ## if dict contains any non-sequence values, it is probably a single record.
+ #if len(types) != 0:
+ #self.data = [self.data]
+ #self.mode = 'list'
+ #else:
+ #self.mode = 'dict'
+ #elif isinstance(data, TableData):
+ #self.data = data.data
+ #self.mode = data.mode
+ #else:
+ #raise TypeError(type(data))
+
+ #for fn in ['__getitem__', '__setitem__']:
+ #setattr(self, fn, getattr(self, '_TableData'+fn+self.mode))
+
+ #def originalData(self):
+ #return self.data
+
+ #def toArray(self):
+ #if self.mode == 'array':
+ #return self.data
+ #if len(self) < 1:
+ ##return np.array([]) ## need to return empty array *with correct columns*, but this is very difficult, so just return None
+ #return None
+ #rec1 = self[0]
+ #dtype = functions.suggestRecordDType(rec1)
+ ##print rec1, dtype
+ #arr = np.empty(len(self), dtype=dtype)
+ #arr[0] = tuple(rec1.values())
+ #for i in xrange(1, len(self)):
+ #arr[i] = tuple(self[i].values())
+ #return arr
+
+ #def __getitem__array(self, arg):
+ #if isinstance(arg, tuple):
+ #return self.data[arg[0]][arg[1]]
+ #else:
+ #return self.data[arg]
+
+ #def __getitem__list(self, arg):
+ #if isinstance(arg, basestring):
+ #return [d.get(arg, None) for d in self.data]
+ #elif isinstance(arg, int):
+ #return self.data[arg]
+ #elif isinstance(arg, tuple):
+ #arg = self._orderArgs(arg)
+ #return self.data[arg[0]][arg[1]]
+ #else:
+ #raise TypeError(type(arg))
+
+ #def __getitem__dict(self, arg):
+ #if isinstance(arg, basestring):
+ #return self.data[arg]
+ #elif isinstance(arg, int):
+ #return dict([(k, v[arg]) for k, v in self.data.iteritems()])
+ #elif isinstance(arg, tuple):
+ #arg = self._orderArgs(arg)
+ #return self.data[arg[1]][arg[0]]
+ #else:
+ #raise TypeError(type(arg))
+
+ #def __setitem__array(self, arg, val):
+ #if isinstance(arg, tuple):
+ #self.data[arg[0]][arg[1]] = val
+ #else:
+ #self.data[arg] = val
+
+ #def __setitem__list(self, arg, val):
+ #if isinstance(arg, basestring):
+ #if len(val) != len(self.data):
+ #raise Exception("Values (%d) and data set (%d) are not the same length." % (len(val), len(self.data)))
+ #for i, rec in enumerate(self.data):
+ #rec[arg] = val[i]
+ #elif isinstance(arg, int):
+ #self.data[arg] = val
+ #elif isinstance(arg, tuple):
+ #arg = self._orderArgs(arg)
+ #self.data[arg[0]][arg[1]] = val
+ #else:
+ #raise TypeError(type(arg))
+
+ #def __setitem__dict(self, arg, val):
+ #if isinstance(arg, basestring):
+ #if len(val) != len(self.data[arg]):
+ #raise Exception("Values (%d) and data set (%d) are not the same length." % (len(val), len(self.data[arg])))
+ #self.data[arg] = val
+ #elif isinstance(arg, int):
+ #for k in self.data:
+ #self.data[k][arg] = val[k]
+ #elif isinstance(arg, tuple):
+ #arg = self._orderArgs(arg)
+ #self.data[arg[1]][arg[0]] = val
+ #else:
+ #raise TypeError(type(arg))
+
+ #def _orderArgs(self, args):
+ ### return args in (int, str) order
+ #if isinstance(args[0], basestring):
+ #return (args[1], args[0])
+ #else:
+ #return args
+
+ #def __iter__(self):
+ #for i in xrange(len(self)):
+ #yield self[i]
+
+ #def __len__(self):
+ #if self.mode == 'array' or self.mode == 'list':
+ #return len(self.data)
+ #else:
+ #return max(map(len, self.data.values()))
+
+ #def columnNames(self):
+ #"""returns column names in no particular order"""
+ #if self.mode == 'array':
+ #return self.data.dtype.names
+ #elif self.mode == 'list':
+ #names = set()
+ #for row in self.data:
+ #names.update(row.keys())
+ #return list(names)
+ #elif self.mode == 'dict':
+ #return self.data.keys()
+
+ #def keys(self):
+ #return self.columnNames()
diff --git a/pyqtgraph/graphicsItems/PlotItem/PlotItem.py b/pyqtgraph/graphicsItems/PlotItem/PlotItem.py
new file mode 100644
index 00000000..c362ffb5
--- /dev/null
+++ b/pyqtgraph/graphicsItems/PlotItem/PlotItem.py
@@ -0,0 +1,1163 @@
+# -*- coding: utf-8 -*-
+"""
+PlotItem.py - Graphics item implementing a scalable ViewBox with plotting powers.
+Copyright 2010 Luke Campagnola
+Distributed under MIT/X11 license. See license.txt for more infomation.
+
+This class is one of the workhorses of pyqtgraph. It implements a graphics item with
+plots, labels, and scales which can be viewed inside a QGraphicsScene. If you want
+a widget that can be added to your GUI, see PlotWidget instead.
+
+This class is very heavily featured:
+ - Automatically creates and manages PlotCurveItems
+ - Fast display and update of plots
+ - Manages zoom/pan ViewBox, scale, and label elements
+ - Automatic scaling when data changes
+ - Control panel with a huge feature set including averaging, decimation,
+ display, power spectrum, svg/png export, plot linking, and more.
+"""
+from pyqtgraph.Qt import QtGui, QtCore, QtSvg, USE_PYSIDE
+import pyqtgraph.pixmaps
+
+if USE_PYSIDE:
+ from .plotConfigTemplate_pyside import *
+else:
+ from .plotConfigTemplate_pyqt import *
+
+import pyqtgraph.functions as fn
+from pyqtgraph.widgets.FileDialog import FileDialog
+import weakref
+import numpy as np
+import os
+from .. PlotDataItem import PlotDataItem
+from .. ViewBox import ViewBox
+from .. AxisItem import AxisItem
+from .. LabelItem import LabelItem
+from .. LegendItem import LegendItem
+from .. GraphicsWidget import GraphicsWidget
+from .. ButtonItem import ButtonItem
+from pyqtgraph.WidgetGroup import WidgetGroup
+
+__all__ = ['PlotItem']
+
+try:
+ from metaarray import *
+ HAVE_METAARRAY = True
+except:
+ HAVE_METAARRAY = False
+
+
+
+
+class PlotItem(GraphicsWidget):
+
+ """
+ **Bases:** :class:`GraphicsWidget `
+
+ Plot graphics item that can be added to any graphics scene. Implements axes, titles, and interactive viewbox.
+ PlotItem also provides some basic analysis functionality that may be accessed from the context menu.
+ Use :func:`plot() ` to create a new PlotDataItem and add it to the view.
+ Use :func:`addItem() ` to add any QGraphicsItem to the view.
+
+ This class wraps several methods from its internal ViewBox:
+ :func:`setXRange `,
+ :func:`setYRange `,
+ :func:`setRange `,
+ :func:`autoRange `,
+ :func:`setXLink `,
+ :func:`setYLink `,
+ :func:`setAutoPan `,
+ :func:`setAutoVisible `,
+ :func:`viewRect `,
+ :func:`viewRange `,
+ :func:`setMouseEnabled `,
+ :func:`enableAutoRange `,
+ :func:`disableAutoRange `,
+ :func:`setAspectLocked `,
+ :func:`invertY `,
+ :func:`register `,
+ :func:`unregister `
+
+ The ViewBox itself can be accessed by calling :func:`getViewBox() `
+
+ ==================== =======================================================================
+ **Signals**
+ sigYRangeChanged wrapped from :class:`ViewBox `
+ sigXRangeChanged wrapped from :class:`ViewBox `
+ sigRangeChanged wrapped from :class:`ViewBox `
+ ==================== =======================================================================
+ """
+
+ sigRangeChanged = QtCore.Signal(object, object) ## Emitted when the ViewBox range has changed
+ sigYRangeChanged = QtCore.Signal(object, object) ## Emitted when the ViewBox Y range has changed
+ sigXRangeChanged = QtCore.Signal(object, object) ## Emitted when the ViewBox X range has changed
+
+
+ lastFileDir = None
+ managers = {}
+
+ def __init__(self, parent=None, name=None, labels=None, title=None, viewBox=None, axisItems=None, enableMenu=True, **kargs):
+ """
+ Create a new PlotItem. All arguments are optional.
+ Any extra keyword arguments are passed to PlotItem.plot().
+
+ ============== ==========================================================================================
+ **Arguments**
+ *title* Title to display at the top of the item. Html is allowed.
+ *labels* A dictionary specifying the axis labels to display::
+
+ {'left': (args), 'bottom': (args), ...}
+
+ The name of each axis and the corresponding arguments are passed to
+ :func:`PlotItem.setLabel() `
+ Optionally, PlotItem my also be initialized with the keyword arguments left,
+ right, top, or bottom to achieve the same effect.
+ *name* Registers a name for this view so that others may link to it
+ *viewBox* If specified, the PlotItem will be constructed with this as its ViewBox.
+ *axisItems* Optional dictionary instructing the PlotItem to use pre-constructed items
+ for its axes. The dict keys must be axis names ('left', 'bottom', 'right', 'top')
+ and the values must be instances of AxisItem (or at least compatible with AxisItem).
+ ============== ==========================================================================================
+ """
+
+ GraphicsWidget.__init__(self, parent)
+
+ self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
+
+ ## Set up control buttons
+ path = os.path.dirname(__file__)
+ #self.autoImageFile = os.path.join(path, 'auto.png')
+ #self.lockImageFile = os.path.join(path, 'lock.png')
+ self.autoBtn = ButtonItem(pyqtgraph.pixmaps.getPixmap('auto'), 14, self)
+ self.autoBtn.mode = 'auto'
+ self.autoBtn.clicked.connect(self.autoBtnClicked)
+ #self.autoBtn.hide()
+ self.buttonsHidden = False ## whether the user has requested buttons to be hidden
+ self.mouseHovering = False
+
+ self.layout = QtGui.QGraphicsGridLayout()
+ self.layout.setContentsMargins(1,1,1,1)
+ self.setLayout(self.layout)
+ self.layout.setHorizontalSpacing(0)
+ self.layout.setVerticalSpacing(0)
+
+ if viewBox is None:
+ viewBox = ViewBox()
+ self.vb = viewBox
+ self.vb.sigStateChanged.connect(self.viewStateChanged)
+ self.setMenuEnabled(enableMenu, enableMenu) ## en/disable plotitem and viewbox menus
+
+ if name is not None:
+ self.vb.register(name)
+ self.vb.sigRangeChanged.connect(self.sigRangeChanged)
+ self.vb.sigXRangeChanged.connect(self.sigXRangeChanged)
+ self.vb.sigYRangeChanged.connect(self.sigYRangeChanged)
+
+ self.layout.addItem(self.vb, 2, 1)
+ self.alpha = 1.0
+ self.autoAlpha = True
+ self.spectrumMode = False
+
+ self.legend = None
+
+ ## Create and place axis items
+ if axisItems is None:
+ axisItems = {}
+ self.axes = {}
+ for k, pos in (('top', (1,1)), ('bottom', (3,1)), ('left', (2,0)), ('right', (2,2))):
+ axis = axisItems.get(k, AxisItem(orientation=k))
+ axis.linkToView(self.vb)
+ self.axes[k] = {'item': axis, 'pos': pos}
+ self.layout.addItem(axis, *pos)
+ axis.setZValue(-1000)
+ axis.setFlag(axis.ItemNegativeZStacksBehindParent)
+
+ self.titleLabel = LabelItem('', size='11pt')
+ self.layout.addItem(self.titleLabel, 0, 1)
+ self.setTitle(None) ## hide
+
+
+ for i in range(4):
+ self.layout.setRowPreferredHeight(i, 0)
+ self.layout.setRowMinimumHeight(i, 0)
+ self.layout.setRowSpacing(i, 0)
+ self.layout.setRowStretchFactor(i, 1)
+
+ for i in range(3):
+ self.layout.setColumnPreferredWidth(i, 0)
+ self.layout.setColumnMinimumWidth(i, 0)
+ self.layout.setColumnSpacing(i, 0)
+ self.layout.setColumnStretchFactor(i, 1)
+ self.layout.setRowStretchFactor(2, 100)
+ self.layout.setColumnStretchFactor(1, 100)
+
+
+ ## Wrap a few methods from viewBox
+ for m in [
+ 'setXRange', 'setYRange', 'setXLink', 'setYLink', 'setAutoPan', 'setAutoVisible',
+ 'setRange', 'autoRange', 'viewRect', 'viewRange', 'setMouseEnabled',
+ 'enableAutoRange', 'disableAutoRange', 'setAspectLocked', 'invertY',
+ 'register', 'unregister']: ## NOTE: If you update this list, please update the class docstring as well.
+ setattr(self, m, getattr(self.vb, m))
+
+ self.items = []
+ self.curves = []
+ self.itemMeta = weakref.WeakKeyDictionary()
+ self.dataItems = []
+ self.paramList = {}
+ self.avgCurves = {}
+
+ ### Set up context menu
+
+ w = QtGui.QWidget()
+ self.ctrl = c = Ui_Form()
+ c.setupUi(w)
+ dv = QtGui.QDoubleValidator(self)
+
+ menuItems = [
+ ('Transforms', c.transformGroup),
+ ('Downsample', c.decimateGroup),
+ ('Average', c.averageGroup),
+ ('Alpha', c.alphaGroup),
+ ('Grid', c.gridGroup),
+ ('Points', c.pointsGroup),
+ ]
+
+
+ self.ctrlMenu = QtGui.QMenu()
+
+ self.ctrlMenu.setTitle('Plot Options')
+ self.subMenus = []
+ for name, grp in menuItems:
+ sm = QtGui.QMenu(name)
+ act = QtGui.QWidgetAction(self)
+ act.setDefaultWidget(grp)
+ sm.addAction(act)
+ self.subMenus.append(sm)
+ self.ctrlMenu.addMenu(sm)
+
+ self.stateGroup = WidgetGroup()
+ for name, w in menuItems:
+ self.stateGroup.autoAdd(w)
+
+ self.fileDialog = None
+
+ c.alphaGroup.toggled.connect(self.updateAlpha)
+ c.alphaSlider.valueChanged.connect(self.updateAlpha)
+ c.autoAlphaCheck.toggled.connect(self.updateAlpha)
+
+ c.xGridCheck.toggled.connect(self.updateGrid)
+ c.yGridCheck.toggled.connect(self.updateGrid)
+ c.gridAlphaSlider.valueChanged.connect(self.updateGrid)
+
+ c.fftCheck.toggled.connect(self.updateSpectrumMode)
+ c.logXCheck.toggled.connect(self.updateLogMode)
+ c.logYCheck.toggled.connect(self.updateLogMode)
+
+ c.downsampleSpin.valueChanged.connect(self.updateDownsampling)
+
+ self.ctrl.avgParamList.itemClicked.connect(self.avgParamListClicked)
+ self.ctrl.averageGroup.toggled.connect(self.avgToggled)
+
+ self.ctrl.maxTracesCheck.toggled.connect(self.updateDecimation)
+ self.ctrl.maxTracesSpin.valueChanged.connect(self.updateDecimation)
+
+ self.hideAxis('right')
+ self.hideAxis('top')
+ self.showAxis('left')
+ self.showAxis('bottom')
+
+ if labels is None:
+ labels = {}
+ for label in list(self.axes.keys()):
+ if label in kargs:
+ labels[label] = kargs[label]
+ del kargs[label]
+ for k in labels:
+ if isinstance(labels[k], basestring):
+ labels[k] = (labels[k],)
+ self.setLabel(k, *labels[k])
+
+ if title is not None:
+ self.setTitle(title)
+
+ if len(kargs) > 0:
+ self.plot(**kargs)
+
+
+ def implements(self, interface=None):
+ return interface in ['ViewBoxWrapper']
+
+ def getViewBox(self):
+ """Return the :class:`ViewBox ` contained within."""
+ return self.vb
+
+
+
+ def setLogMode(self, x, y):
+ """
+ Set log scaling for x and y axes.
+ This informs PlotDataItems to transform logarithmically and switches
+ the axes to use log ticking.
+
+ Note that *no other items* in the scene will be affected by
+ this; there is no generic way to redisplay a GraphicsItem
+ with log coordinates.
+
+ """
+ self.ctrl.logXCheck.setChecked(x)
+ self.ctrl.logYCheck.setChecked(y)
+
+ def showGrid(self, x=None, y=None, alpha=None):
+ """
+ Show or hide the grid for either axis.
+
+ ============== =====================================
+ **Arguments:**
+ x (bool) Whether to show the X grid
+ y (bool) Whether to show the Y grid
+ alpha (0.0-1.0) Opacity of the grid
+ ============== =====================================
+ """
+ if x is None and y is None and alpha is None:
+ raise Exception("Must specify at least one of x, y, or alpha.") ## prevent people getting confused if they just call showGrid()
+
+ if x is not None:
+ self.ctrl.xGridCheck.setChecked(x)
+ if y is not None:
+ self.ctrl.yGridCheck.setChecked(y)
+ if alpha is not None:
+ v = np.clip(alpha, 0, 1)*self.ctrl.gridAlphaSlider.maximum()
+ self.ctrl.gridAlphaSlider.setValue(v)
+
+ #def paint(self, *args):
+ #prof = debug.Profiler('PlotItem.paint', disabled=True)
+ #QtGui.QGraphicsWidget.paint(self, *args)
+ #prof.finish()
+
+ ## bad idea.
+ #def __getattr__(self, attr): ## wrap ms
+ #return getattr(self.vb, attr)
+
+ def close(self):
+ #print "delete", self
+ ## Most of this crap is needed to avoid PySide trouble.
+ ## The problem seems to be whenever scene.clear() leads to deletion of widgets (either through proxies or qgraphicswidgets)
+ ## the solution is to manually remove all widgets before scene.clear() is called
+ if self.ctrlMenu is None: ## already shut down
+ return
+ self.ctrlMenu.setParent(None)
+ self.ctrlMenu = None
+
+ #self.ctrlBtn.setParent(None)
+ #self.ctrlBtn = None
+ #self.autoBtn.setParent(None)
+ #self.autoBtn = None
+
+ for k in self.axes:
+ i = self.axes[k]['item']
+ i.close()
+
+ self.axes = None
+ self.scene().removeItem(self.vb)
+ self.vb = None
+
+ ## causes invalid index errors:
+ #for i in range(self.layout.count()):
+ #self.layout.removeAt(i)
+
+ #for p in self.proxies:
+ #try:
+ #p.setWidget(None)
+ #except RuntimeError:
+ #break
+ #self.scene().removeItem(p)
+ #self.proxies = []
+
+ #self.menuAction.releaseWidget(self.menuAction.defaultWidget())
+ #self.menuAction.setParent(None)
+ #self.menuAction = None
+
+ #if self.manager is not None:
+ #self.manager.sigWidgetListChanged.disconnect(self.updatePlotList)
+ #self.manager.removeWidget(self.name)
+ #else:
+ #print "no manager"
+
+ def registerPlot(self, name): ## for backward compatibility
+ self.vb.register(name)
+
+ def updateGrid(self, *args):
+ alpha = self.ctrl.gridAlphaSlider.value()
+ x = alpha if self.ctrl.xGridCheck.isChecked() else False
+ y = alpha if self.ctrl.yGridCheck.isChecked() else False
+ self.getAxis('top').setGrid(x)
+ self.getAxis('bottom').setGrid(x)
+ self.getAxis('left').setGrid(y)
+ self.getAxis('right').setGrid(y)
+
+ def viewGeometry(self):
+ """Return the screen geometry of the viewbox"""
+ v = self.scene().views()[0]
+ b = self.vb.mapRectToScene(self.vb.boundingRect())
+ wr = v.mapFromScene(b).boundingRect()
+ pos = v.mapToGlobal(v.pos())
+ wr.adjust(pos.x(), pos.y(), pos.x(), pos.y())
+ return wr
+
+
+ def avgToggled(self, b):
+ if b:
+ self.recomputeAverages()
+ for k in self.avgCurves:
+ self.avgCurves[k][1].setVisible(b)
+
+ def avgParamListClicked(self, item):
+ name = str(item.text())
+ self.paramList[name] = (item.checkState() == QtCore.Qt.Checked)
+ self.recomputeAverages()
+
+ def recomputeAverages(self):
+ if not self.ctrl.averageGroup.isChecked():
+ return
+ for k in self.avgCurves:
+ self.removeItem(self.avgCurves[k][1])
+ self.avgCurves = {}
+ for c in self.curves:
+ self.addAvgCurve(c)
+ self.replot()
+
+ def addAvgCurve(self, curve):
+ ## Add a single curve into the pool of curves averaged together
+
+ ## If there are plot parameters, then we need to determine which to average together.
+ remKeys = []
+ addKeys = []
+ if self.ctrl.avgParamList.count() > 0:
+
+ ### First determine the key of the curve to which this new data should be averaged
+ for i in range(self.ctrl.avgParamList.count()):
+ item = self.ctrl.avgParamList.item(i)
+ if item.checkState() == QtCore.Qt.Checked:
+ remKeys.append(str(item.text()))
+ else:
+ addKeys.append(str(item.text()))
+
+ if len(remKeys) < 1: ## In this case, there would be 1 average plot for each data plot; not useful.
+ return
+
+ p = self.itemMeta.get(curve,{}).copy()
+ for k in p:
+ if type(k) is tuple:
+ p['.'.join(k)] = p[k]
+ del p[k]
+ for rk in remKeys:
+ if rk in p:
+ del p[rk]
+ for ak in addKeys:
+ if ak not in p:
+ p[ak] = None
+ key = tuple(p.items())
+
+ ### Create a new curve if needed
+ if key not in self.avgCurves:
+ plot = PlotDataItem()
+ plot.setPen(fn.mkPen([0, 200, 0]))
+ plot.setShadowPen(fn.mkPen([0, 0, 0, 100], width=3))
+ plot.setAlpha(1.0, False)
+ plot.setZValue(100)
+ self.addItem(plot, skipAverage=True)
+ self.avgCurves[key] = [0, plot]
+ self.avgCurves[key][0] += 1
+ (n, plot) = self.avgCurves[key]
+
+ ### Average data together
+ (x, y) = curve.getData()
+ if plot.yData is not None:
+ newData = plot.yData * (n-1) / float(n) + y * 1.0 / float(n)
+ plot.setData(plot.xData, newData)
+ else:
+ plot.setData(x, y)
+
+ def autoBtnClicked(self):
+ if self.autoBtn.mode == 'auto':
+ self.enableAutoRange()
+ self.autoBtn.hide()
+ else:
+ self.disableAutoRange()
+
+ def viewStateChanged(self):
+ self.updateButtons()
+
+ def enableAutoScale(self):
+ """
+ Enable auto-scaling. The plot will continuously scale to fit the boundaries of its data.
+ """
+ print("Warning: enableAutoScale is deprecated. Use enableAutoRange(axis, enable) instead.")
+ self.vb.enableAutoRange(self.vb.XYAxes)
+
+ def addItem(self, item, *args, **kargs):
+ """
+ Add a graphics item to the view box.
+ If the item has plot data (PlotDataItem, PlotCurveItem, ScatterPlotItem), it may
+ be included in analysis performed by the PlotItem.
+ """
+ self.items.append(item)
+ vbargs = {}
+ if 'ignoreBounds' in kargs:
+ vbargs['ignoreBounds'] = kargs['ignoreBounds']
+ self.vb.addItem(item, *args, **vbargs)
+ if hasattr(item, 'implements') and item.implements('plotData'):
+ self.dataItems.append(item)
+ #self.plotChanged()
+
+ params = kargs.get('params', {})
+ self.itemMeta[item] = params
+ #item.setMeta(params)
+ self.curves.append(item)
+ #self.addItem(c)
+
+ if hasattr(item, 'setLogMode'):
+ item.setLogMode(self.ctrl.logXCheck.isChecked(), self.ctrl.logYCheck.isChecked())
+
+ if isinstance(item, PlotDataItem):
+ ## configure curve for this plot
+ (alpha, auto) = self.alphaState()
+ item.setAlpha(alpha, auto)
+ item.setFftMode(self.ctrl.fftCheck.isChecked())
+ item.setDownsampling(self.downsampleMode())
+ item.setPointMode(self.pointMode())
+
+ ## Hide older plots if needed
+ self.updateDecimation()
+
+ ## Add to average if needed
+ self.updateParamList()
+ if self.ctrl.averageGroup.isChecked() and 'skipAverage' not in kargs:
+ self.addAvgCurve(item)
+
+ #c.connect(c, QtCore.SIGNAL('plotChanged'), self.plotChanged)
+ #item.sigPlotChanged.connect(self.plotChanged)
+ #self.plotChanged()
+ name = kargs.get('name', getattr(item, 'opts', {}).get('name', None))
+ if name is not None and hasattr(self, 'legend') and self.legend is not None:
+ self.legend.addItem(item, name=name)
+
+
+ def addDataItem(self, item, *args):
+ print("PlotItem.addDataItem is deprecated. Use addItem instead.")
+ self.addItem(item, *args)
+
+ def addCurve(self, c, params=None):
+ print("PlotItem.addCurve is deprecated. Use addItem instead.")
+ self.addItem(c, params)
+
+ def removeItem(self, item):
+ """
+ Remove an item from the internal ViewBox.
+ """
+ if not item in self.items:
+ return
+ self.items.remove(item)
+ if item in self.dataItems:
+ self.dataItems.remove(item)
+
+ if item.scene() is not None:
+ self.vb.removeItem(item)
+ if item in self.curves:
+ self.curves.remove(item)
+ self.updateDecimation()
+ self.updateParamList()
+ #item.connect(item, QtCore.SIGNAL('plotChanged'), self.plotChanged)
+ #item.sigPlotChanged.connect(self.plotChanged)
+
+ def clear(self):
+ """
+ Remove all items from the ViewBox.
+ """
+ for i in self.items[:]:
+ self.removeItem(i)
+ self.avgCurves = {}
+
+ def clearPlots(self):
+ for i in self.curves[:]:
+ self.removeItem(i)
+ self.avgCurves = {}
+
+
+ def plot(self, *args, **kargs):
+ """
+ Add and return a new plot.
+ See :func:`PlotDataItem.__init__ ` for data arguments
+
+ Extra allowed arguments are:
+ clear - clear all plots before displaying new data
+ params - meta-parameters to associate with this data
+ """
+
+
+ clear = kargs.get('clear', False)
+ params = kargs.get('params', None)
+
+ if clear:
+ self.clear()
+
+ item = PlotDataItem(*args, **kargs)
+
+ if params is None:
+ params = {}
+ self.addItem(item, params=params)
+
+ return item
+
+ def addLegend(self, size=None, offset=(30, 30)):
+ """
+ Create a new LegendItem and anchor it over the internal ViewBox.
+ Plots will be automatically displayed in the legend if they
+ are created with the 'name' argument.
+ """
+ self.legend = LegendItem(size, offset)
+ self.legend.setParentItem(self.vb)
+ return self.legend
+
+ def scatterPlot(self, *args, **kargs):
+ if 'pen' in kargs:
+ kargs['symbolPen'] = kargs['pen']
+ kargs['pen'] = None
+
+ if 'brush' in kargs:
+ kargs['symbolBrush'] = kargs['brush']
+ del kargs['brush']
+
+ if 'size' in kargs:
+ kargs['symbolSize'] = kargs['size']
+ del kargs['size']
+
+ return self.plot(*args, **kargs)
+
+ def replot(self):
+ self.update()
+
+ def updateParamList(self):
+ self.ctrl.avgParamList.clear()
+ ## Check to see that each parameter for each curve is present in the list
+ for c in self.curves:
+ for p in list(self.itemMeta.get(c, {}).keys()):
+ if type(p) is tuple:
+ p = '.'.join(p)
+
+ ## If the parameter is not in the list, add it.
+ matches = self.ctrl.avgParamList.findItems(p, QtCore.Qt.MatchExactly)
+ if len(matches) == 0:
+ i = QtGui.QListWidgetItem(p)
+ if p in self.paramList and self.paramList[p] is True:
+ i.setCheckState(QtCore.Qt.Checked)
+ else:
+ i.setCheckState(QtCore.Qt.Unchecked)
+ self.ctrl.avgParamList.addItem(i)
+ else:
+ i = matches[0]
+
+ self.paramList[p] = (i.checkState() == QtCore.Qt.Checked)
+
+
+ ## Qt's SVG-writing capabilities are pretty terrible.
+ def writeSvgCurves(self, fileName=None):
+ if fileName is None:
+ self.fileDialog = FileDialog()
+ if PlotItem.lastFileDir is not None:
+ self.fileDialog.setDirectory(PlotItem.lastFileDir)
+ self.fileDialog.setFileMode(QtGui.QFileDialog.AnyFile)
+ self.fileDialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
+ self.fileDialog.show()
+ self.fileDialog.fileSelected.connect(self.writeSvg)
+ return
+ #if fileName is None:
+ #fileName = QtGui.QFileDialog.getSaveFileName()
+ if isinstance(fileName, tuple):
+ raise Exception("Not implemented yet..")
+ fileName = str(fileName)
+ PlotItem.lastFileDir = os.path.dirname(fileName)
+
+ rect = self.vb.viewRect()
+ xRange = rect.left(), rect.right()
+
+ svg = ""
+ fh = open(fileName, 'w')
+
+ dx = max(rect.right(),0) - min(rect.left(),0)
+ ymn = min(rect.top(), rect.bottom())
+ ymx = max(rect.top(), rect.bottom())
+ dy = max(ymx,0) - min(ymn,0)
+ sx = 1.
+ sy = 1.
+ while dx*sx < 10:
+ sx *= 1000
+ while dy*sy < 10:
+ sy *= 1000
+ sy *= -1
+
+ #fh.write('Enables mouse interaction (panning, scaling) for this axis.
", None, QtGui.QApplication.UnicodeUTF8))
+ self.mouseCheck.setText(QtGui.QApplication.translate("Form", "Mouse Enabled", None, QtGui.QApplication.UnicodeUTF8))
+ self.visibleOnlyCheck.setToolTip(QtGui.QApplication.translate("Form", "When checked, the axis will only auto-scale to data that is visible along the orthogonal axis.
", None, QtGui.QApplication.UnicodeUTF8))
+ self.visibleOnlyCheck.setText(QtGui.QApplication.translate("Form", "Visible Data Only", None, QtGui.QApplication.UnicodeUTF8))
+ self.autoPanCheck.setToolTip(QtGui.QApplication.translate("Form", "When checked, the axis will automatically pan to center on the current data, but the scale along this axis will not change.
", None, QtGui.QApplication.UnicodeUTF8))
+ self.autoPanCheck.setText(QtGui.QApplication.translate("Form", "Auto Pan Only", None, QtGui.QApplication.UnicodeUTF8))
+
diff --git a/pyqtgraph/graphicsItems/__init__.py b/pyqtgraph/graphicsItems/__init__.py
new file mode 100644
index 00000000..8e411816
--- /dev/null
+++ b/pyqtgraph/graphicsItems/__init__.py
@@ -0,0 +1,21 @@
+### just import everything from sub-modules
+
+#import os
+
+#d = os.path.split(__file__)[0]
+#files = []
+#for f in os.listdir(d):
+ #if os.path.isdir(os.path.join(d, f)):
+ #files.append(f)
+ #elif f[-3:] == '.py' and f != '__init__.py':
+ #files.append(f[:-3])
+
+#for modName in files:
+ #mod = __import__(modName, globals(), locals(), fromlist=['*'])
+ #if hasattr(mod, '__all__'):
+ #names = mod.__all__
+ #else:
+ #names = [n for n in dir(mod) if n[0] != '_']
+ #for k in names:
+ ##print modName, k
+ #globals()[k] = getattr(mod, k)
diff --git a/graphicsWindows.py b/pyqtgraph/graphicsWindows.py
similarity index 50%
rename from graphicsWindows.py
rename to pyqtgraph/graphicsWindows.py
index 8b8e8678..6e7d6305 100644
--- a/graphicsWindows.py
+++ b/pyqtgraph/graphicsWindows.py
@@ -5,9 +5,11 @@ Copyright 2010 Luke Campagnola
Distributed under MIT/X11 license. See license.txt for more infomation.
"""
-from PyQt4 import QtCore, QtGui
-from PlotWidget import *
-from ImageView import *
+from .Qt import QtCore, QtGui
+from .widgets.PlotWidget import *
+from .imageview import *
+from .widgets.GraphicsLayoutWidget import GraphicsLayoutWidget
+from .widgets.GraphicsView import GraphicsView
QAPP = None
def mkQApp():
@@ -15,54 +17,17 @@ def mkQApp():
global QAPP
QAPP = QtGui.QApplication([])
-class GraphicsLayoutWidget(GraphicsView):
- def __init__(self):
- GraphicsView.__init__(self)
- self.items = {}
- self.currentRow = 0
- self.currentCol = 0
-
- def nextRow(self):
- """Advance to next row for automatic item placement"""
- self.currentRow += 1
- self.currentCol = 0
-
- def nextCol(self, colspan=1):
- """Advance to next column, while returning the current column number
- (generally only for internal use)"""
- self.currentCol += colspan
- return self.currentCol-colspan
-
- def addPlot(self, row=None, col=None, rowspan=1, colspan=1, **kargs):
- plot = PlotItem(**kargs)
- self.addItem(plot, row, col, rowspan, colspan)
- return plot
-
- def addItem(self, item, row=None, col=None, rowspan=1, colspan=1):
- if row not in self.items:
- self.items[row] = {}
- self.items[row][col] = item
-
- if row is None:
- row = self.currentRow
- if col is None:
- col = self.nextCol(colspan)
- self.centralLayout.addItem(item, row, col, rowspan, colspan)
-
- def getItem(self, row, col):
- return self.items[row][col]
-
class GraphicsWindow(GraphicsLayoutWidget):
- def __init__(self, title=None, size=(800,600)):
+ def __init__(self, title=None, size=(800,600), **kargs):
mkQApp()
- self.win = QtGui.QMainWindow()
- GraphicsLayoutWidget.__init__(self)
- self.win.setCentralWidget(self)
- self.win.resize(*size)
+ #self.win = QtGui.QMainWindow()
+ GraphicsLayoutWidget.__init__(self, **kargs)
+ #self.win.setCentralWidget(self)
+ self.resize(*size)
if title is not None:
- self.win.setWindowTitle(title)
- self.win.show()
+ self.setWindowTitle(title)
+ self.show()
class TabWindow(QtGui.QMainWindow):
@@ -83,19 +48,6 @@ class TabWindow(QtGui.QMainWindow):
raise NameError(attr)
-#class PlotWindow(QtGui.QMainWindow):
- #def __init__(self, title=None, **kargs):
- #mkQApp()
- #QtGui.QMainWindow.__init__(self)
- #self.cw = PlotWidget(**kargs)
- #self.setCentralWidget(self.cw)
- #for m in ['plot', 'autoRange', 'addItem', 'removeItem', 'setLabel', 'clear', 'viewRect']:
- #setattr(self, m, getattr(self.cw, m))
- #if title is not None:
- #self.setWindowTitle(title)
- #self.show()
-
-
class PlotWindow(PlotWidget):
def __init__(self, title=None, **kargs):
mkQApp()
diff --git a/ImageView.py b/pyqtgraph/imageview/ImageView.py
similarity index 62%
rename from ImageView.py
rename to pyqtgraph/imageview/ImageView.py
index 3c293964..5c6573e3 100644
--- a/ImageView.py
+++ b/pyqtgraph/imageview/ImageView.py
@@ -12,81 +12,135 @@ Widget used for displaying 2D or 3D data. Features:
- ROI plotting
- Image normalization through a variety of methods
"""
+from pyqtgraph.Qt import QtCore, QtGui, USE_PYSIDE
-from ImageViewTemplate import *
-from graphicsItems import *
-from widgets import ROI
-from PyQt4 import QtCore, QtGui
+if USE_PYSIDE:
+ from .ImageViewTemplate_pyside import *
+else:
+ from .ImageViewTemplate_pyqt import *
+
+from pyqtgraph.graphicsItems.ImageItem import *
+from pyqtgraph.graphicsItems.ROI import *
+from pyqtgraph.graphicsItems.LinearRegionItem import *
+from pyqtgraph.graphicsItems.InfiniteLine import *
+from pyqtgraph.graphicsItems.ViewBox import *
+#from widgets import ROI
import sys
#from numpy import ndarray
-import ptime
+import pyqtgraph.ptime as ptime
import numpy as np
-import debug
+import pyqtgraph.debug as debug
-from SignalProxy import proxyConnect
+from pyqtgraph.SignalProxy import SignalProxy
+
+#try:
+ #import pyqtgraph.metaarray as metaarray
+ #HAVE_METAARRAY = True
+#except:
+ #HAVE_METAARRAY = False
+
class PlotROI(ROI):
def __init__(self, size):
- ROI.__init__(self, pos=[0,0], size=size, scaleSnap=True, translateSnap=True)
+ ROI.__init__(self, pos=[0,0], size=size) #, scaleSnap=True, translateSnap=True)
self.addScaleHandle([1, 1], [0, 0])
+ self.addRotateHandle([0, 0], [0.5, 0.5])
class ImageView(QtGui.QWidget):
+ """
+ Widget used for display and analysis of image data.
+ Implements many features:
+ * Displays 2D and 3D image data. For 3D data, a z-axis
+ slider is displayed allowing the user to select which frame is displayed.
+ * Displays histogram of image data with movable region defining the dark/light levels
+ * Editable gradient provides a color lookup table
+ * Frame slider may also be moved using left/right arrow keys as well as pgup, pgdn, home, and end.
+ * Basic analysis features including:
+
+ * ROI and embedded plot for measuring image values across frames
+ * Image normalization / background subtraction
+
+ Basic Usage::
+
+ imv = pg.ImageView()
+ imv.show()
+ imv.setImage(data)
+ """
sigTimeChanged = QtCore.Signal(object, object)
+ sigProcessingChanged = QtCore.Signal(object)
- def __init__(self, parent=None, name="ImageView", *args):
+ def __init__(self, parent=None, name="ImageView", view=None, imageItem=None, *args):
+ """
+ By default, this class creates an :class:`ImageItem ` to display image data
+ and a :class:`ViewBox ` to contain the ImageItem. Custom items may be given instead
+ by specifying the *view* and/or *imageItem* arguments.
+ """
QtGui.QWidget.__init__(self, parent, *args)
self.levelMax = 4096
self.levelMin = 0
self.name = name
self.image = None
+ self.axes = {}
self.imageDisp = None
self.ui = Ui_Form()
self.ui.setupUi(self)
- self.scene = self.ui.graphicsView.sceneObj
+ self.scene = self.ui.graphicsView.scene()
self.ignoreTimeLine = False
- if 'linux' in sys.platform.lower(): ## Stupid GL bug in linux.
- self.ui.graphicsView.setViewport(QtGui.QWidget())
+ #if 'linux' in sys.platform.lower(): ## Stupid GL bug in linux.
+ # self.ui.graphicsView.setViewport(QtGui.QWidget())
- self.ui.graphicsView.enableMouse(True)
- self.ui.graphicsView.autoPixelRange = False
- self.ui.graphicsView.setAspectLocked(True)
+ #self.ui.graphicsView.enableMouse(True)
+ #self.ui.graphicsView.autoPixelRange = False
+ #self.ui.graphicsView.setAspectLocked(True)
#self.ui.graphicsView.invertY()
- self.ui.graphicsView.enableMouse()
+ #self.ui.graphicsView.enableMouse()
+ if view is None:
+ self.view = ViewBox()
+ else:
+ self.view = view
+ self.ui.graphicsView.setCentralItem(self.view)
+ self.view.setAspectLocked(True)
+ self.view.invertY()
- self.ticks = [t[0] for t in self.ui.gradientWidget.listTicks()]
- self.ticks[0].colorChangeAllowed = False
- self.ticks[1].colorChangeAllowed = False
- self.ui.gradientWidget.allowAdd = False
- self.ui.gradientWidget.setTickColor(self.ticks[1], QtGui.QColor(255,255,255))
- self.ui.gradientWidget.setOrientation('right')
+ #self.ticks = [t[0] for t in self.ui.gradientWidget.listTicks()]
+ #self.ticks[0].colorChangeAllowed = False
+ #self.ticks[1].colorChangeAllowed = False
+ #self.ui.gradientWidget.allowAdd = False
+ #self.ui.gradientWidget.setTickColor(self.ticks[1], QtGui.QColor(255,255,255))
+ #self.ui.gradientWidget.setOrientation('right')
- self.imageItem = ImageItem()
- self.scene.addItem(self.imageItem)
+ if imageItem is None:
+ self.imageItem = ImageItem()
+ else:
+ self.imageItem = imageItem
+ self.view.addItem(self.imageItem)
self.currentIndex = 0
+ self.ui.histogram.setImageItem(self.imageItem)
+
self.ui.normGroup.hide()
self.roi = PlotROI(10)
self.roi.setZValue(20)
- self.scene.addItem(self.roi)
+ self.view.addItem(self.roi)
self.roi.hide()
self.normRoi = PlotROI(10)
self.normRoi.setPen(QtGui.QPen(QtGui.QColor(255,255,0)))
self.normRoi.setZValue(20)
- self.scene.addItem(self.normRoi)
+ self.view.addItem(self.normRoi)
self.normRoi.hide()
#self.ui.roiPlot.hide()
self.roiCurve = self.ui.roiPlot.plot()
- self.timeLine = InfiniteLine(self.ui.roiPlot, 0, movable=True)
+ self.timeLine = InfiniteLine(0, movable=True)
self.timeLine.setPen(QtGui.QPen(QtGui.QColor(255, 255, 0, 200)))
self.timeLine.setZValue(1)
self.ui.roiPlot.addItem(self.timeLine)
self.ui.splitter.setSizes([self.height()-35, 35])
- self.ui.roiPlot.showScale('left', False)
+ self.ui.roiPlot.hideAxis('left')
self.keysPressed = {}
self.playTimer = QtCore.QTimer()
@@ -100,250 +154,65 @@ class ImageView(QtGui.QWidget):
#self.ui.roiPlot.addItem(l)
#self.normLines.append(l)
#l.hide()
- self.normRgn = LinearRegionItem(self.ui.roiPlot, 'vertical')
+ self.normRgn = LinearRegionItem()
self.normRgn.setZValue(0)
self.ui.roiPlot.addItem(self.normRgn)
self.normRgn.hide()
- ## wrap functions from graphics view
+ ## wrap functions from view box
for fn in ['addItem', 'removeItem']:
- setattr(self, fn, getattr(self.ui.graphicsView, fn))
+ setattr(self, fn, getattr(self.view, fn))
+
+ ## wrap functions from histogram
+ for fn in ['setHistogramRange', 'autoHistogramRange', 'getLookupTable', 'getLevels']:
+ setattr(self, fn, getattr(self.ui.histogram, fn))
- #QtCore.QObject.connect(self.ui.timeSlider, QtCore.SIGNAL('valueChanged(int)'), self.timeChanged)
- #self.timeLine.connect(self.timeLine, QtCore.SIGNAL('positionChanged'), self.timeLineChanged)
self.timeLine.sigPositionChanged.connect(self.timeLineChanged)
- #QtCore.QObject.connect(self.ui.whiteSlider, QtCore.SIGNAL('valueChanged(int)'), self.updateImage)
- #QtCore.QObject.connect(self.ui.blackSlider, QtCore.SIGNAL('valueChanged(int)'), self.updateImage)
- #QtCore.QObject.connect(self.ui.gradientWidget, QtCore.SIGNAL('gradientChanged'), self.updateImage)
- self.ui.gradientWidget.sigGradientChanged.connect(self.updateImage)
- #QtCore.QObject.connect(self.ui.roiBtn, QtCore.SIGNAL('clicked()'), self.roiClicked)
+ #self.ui.gradientWidget.sigGradientChanged.connect(self.updateImage)
self.ui.roiBtn.clicked.connect(self.roiClicked)
- #self.roi.connect(self.roi, QtCore.SIGNAL('regionChanged'), self.roiChanged)
self.roi.sigRegionChanged.connect(self.roiChanged)
- #QtCore.QObject.connect(self.ui.normBtn, QtCore.SIGNAL('toggled(bool)'), self.normToggled)
self.ui.normBtn.toggled.connect(self.normToggled)
- #QtCore.QObject.connect(self.ui.normDivideRadio, QtCore.SIGNAL('clicked()'), self.updateNorm)
- self.ui.normDivideRadio.clicked.connect(self.updateNorm)
- #QtCore.QObject.connect(self.ui.normSubtractRadio, QtCore.SIGNAL('clicked()'), self.updateNorm)
- self.ui.normSubtractRadio.clicked.connect(self.updateNorm)
- #QtCore.QObject.connect(self.ui.normOffRadio, QtCore.SIGNAL('clicked()'), self.updateNorm)
- self.ui.normOffRadio.clicked.connect(self.updateNorm)
- #QtCore.QObject.connect(self.ui.normROICheck, QtCore.SIGNAL('clicked()'), self.updateNorm)
+ self.ui.normDivideRadio.clicked.connect(self.normRadioChanged)
+ self.ui.normSubtractRadio.clicked.connect(self.normRadioChanged)
+ self.ui.normOffRadio.clicked.connect(self.normRadioChanged)
self.ui.normROICheck.clicked.connect(self.updateNorm)
- #QtCore.QObject.connect(self.ui.normFrameCheck, QtCore.SIGNAL('clicked()'), self.updateNorm)
self.ui.normFrameCheck.clicked.connect(self.updateNorm)
- #QtCore.QObject.connect(self.ui.normTimeRangeCheck, QtCore.SIGNAL('clicked()'), self.updateNorm)
self.ui.normTimeRangeCheck.clicked.connect(self.updateNorm)
- #QtCore.QObject.connect(self.playTimer, QtCore.SIGNAL('timeout()'), self.timeout)
self.playTimer.timeout.connect(self.timeout)
- ##QtCore.QObject.connect(self.ui.normStartSlider, QtCore.SIGNAL('valueChanged(int)'), self.updateNorm)
- #QtCore.QObject.connect(self.ui.normStopSlider, QtCore.SIGNAL('valueChanged(int)'), self.updateNorm)
- self.normProxy = proxyConnect(None, self.normRgn.sigRegionChanged, self.updateNorm)
- #self.normRoi.connect(self.normRoi, QtCore.SIGNAL('regionChangeFinished'), self.updateNorm)
+ self.normProxy = SignalProxy(self.normRgn.sigRegionChanged, slot=self.updateNorm)
self.normRoi.sigRegionChangeFinished.connect(self.updateNorm)
self.ui.roiPlot.registerPlot(self.name + '_ROI')
self.noRepeatKeys = [QtCore.Qt.Key_Right, QtCore.Qt.Key_Left, QtCore.Qt.Key_Up, QtCore.Qt.Key_Down, QtCore.Qt.Key_PageUp, QtCore.Qt.Key_PageDown]
+
+
+ self.roiClicked() ## initialize roi plot to correct shape / visibility
- #def __dtor__(self):
- ##print "Called ImageView sip destructor"
- #self.quit()
- #QtGui.QWidget.__dtor__(self)
+ def setImage(self, img, autoRange=True, autoLevels=True, levels=None, axes=None, xvals=None, pos=None, scale=None, transform=None):
+ """
+ Set the image to be displayed in the widget.
- def close(self):
- self.ui.roiPlot.close()
- self.ui.graphicsView.close()
- self.ui.gradientWidget.sigGradientChanged.disconnect(self.updateImage)
- self.scene.clear()
- del self.image
- del self.imageDisp
- #self.image = None
- #self.imageDisp = None
- self.setParent(None)
-
- def keyPressEvent(self, ev):
- if ev.key() == QtCore.Qt.Key_Space:
- if self.playRate == 0:
- fps = (self.getProcessedImage().shape[0]-1) / (self.tVals[-1] - self.tVals[0])
- self.play(fps)
- #print fps
- else:
- self.play(0)
- ev.accept()
- elif ev.key() == QtCore.Qt.Key_Home:
- self.setCurrentIndex(0)
- self.play(0)
- ev.accept()
- elif ev.key() == QtCore.Qt.Key_End:
- self.setCurrentIndex(self.getProcessedImage().shape[0]-1)
- self.play(0)
- ev.accept()
- elif ev.key() in self.noRepeatKeys:
- ev.accept()
- if ev.isAutoRepeat():
- return
- self.keysPressed[ev.key()] = 1
- self.evalKeyState()
- else:
- QtGui.QWidget.keyPressEvent(self, ev)
-
- def keyReleaseEvent(self, ev):
- if ev.key() in [QtCore.Qt.Key_Space, QtCore.Qt.Key_Home, QtCore.Qt.Key_End]:
- ev.accept()
- elif ev.key() in self.noRepeatKeys:
- ev.accept()
- if ev.isAutoRepeat():
- return
- try:
- del self.keysPressed[ev.key()]
- except:
- self.keysPressed = {}
- self.evalKeyState()
- else:
- QtGui.QWidget.keyReleaseEvent(self, ev)
-
-
- def evalKeyState(self):
- if len(self.keysPressed) == 1:
- key = self.keysPressed.keys()[0]
- if key == QtCore.Qt.Key_Right:
- self.play(20)
- self.jumpFrames(1)
- self.lastPlayTime = ptime.time() + 0.2 ## 2ms wait before start
- ## This happens *after* jumpFrames, since it might take longer than 2ms
- elif key == QtCore.Qt.Key_Left:
- self.play(-20)
- self.jumpFrames(-1)
- self.lastPlayTime = ptime.time() + 0.2
- elif key == QtCore.Qt.Key_Up:
- self.play(-100)
- elif key == QtCore.Qt.Key_Down:
- self.play(100)
- elif key == QtCore.Qt.Key_PageUp:
- self.play(-1000)
- elif key == QtCore.Qt.Key_PageDown:
- self.play(1000)
- else:
- self.play(0)
-
- def play(self, rate):
- #print "play:", rate
- self.playRate = rate
- if rate == 0:
- self.playTimer.stop()
- return
-
- self.lastPlayTime = ptime.time()
- if not self.playTimer.isActive():
- self.playTimer.start(16)
-
-
- def timeout(self):
- now = ptime.time()
- dt = now - self.lastPlayTime
- if dt < 0:
- return
- n = int(self.playRate * dt)
- #print n, dt
- if n != 0:
- #print n, dt, self.lastPlayTime
- self.lastPlayTime += (float(n)/self.playRate)
- if self.currentIndex+n > self.image.shape[0]:
- self.play(0)
- self.jumpFrames(n)
-
- def setCurrentIndex(self, ind):
- self.currentIndex = clip(ind, 0, self.getProcessedImage().shape[0]-1)
- self.updateImage()
- self.ignoreTimeLine = True
- self.timeLine.setValue(self.tVals[self.currentIndex])
- self.ignoreTimeLine = False
-
- def jumpFrames(self, n):
- """If this is a video, move ahead n frames"""
- if self.axes['t'] is not None:
- self.setCurrentIndex(self.currentIndex + n)
-
- def updateNorm(self):
- #for l, sl in zip(self.normLines, [self.ui.normStartSlider, self.ui.normStopSlider]):
- #if self.ui.normTimeRangeCheck.isChecked():
- #l.show()
- #else:
- #l.hide()
-
- #i, t = self.timeIndex(sl)
- #l.setPos(t)
-
- if self.ui.normTimeRangeCheck.isChecked():
- #print "show!"
- self.normRgn.show()
- else:
- self.normRgn.hide()
-
- if self.ui.normROICheck.isChecked():
- #print "show!"
- self.normRoi.show()
- else:
- self.normRoi.hide()
-
- self.imageDisp = None
- self.updateImage()
- self.roiChanged()
-
- def normToggled(self, b):
- self.ui.normGroup.setVisible(b)
- self.normRoi.setVisible(b and self.ui.normROICheck.isChecked())
- self.normRgn.setVisible(b and self.ui.normTimeRangeCheck.isChecked())
-
- def roiClicked(self):
- if self.ui.roiBtn.isChecked():
- self.roi.show()
- #self.ui.roiPlot.show()
- self.ui.roiPlot.setMouseEnabled(True, True)
- self.ui.splitter.setSizes([self.height()*0.6, self.height()*0.4])
- self.roiCurve.show()
- self.roiChanged()
- self.ui.roiPlot.showScale('left', True)
- else:
- self.roi.hide()
- self.ui.roiPlot.setMouseEnabled(False, False)
- self.ui.roiPlot.setXRange(self.tVals.min(), self.tVals.max())
- self.ui.splitter.setSizes([self.height()-35, 35])
- self.roiCurve.hide()
- self.ui.roiPlot.showScale('left', False)
-
- def roiChanged(self):
- if self.image is None:
- return
-
- image = self.getProcessedImage()
- if image.ndim == 2:
- axes = (0, 1)
- elif image.ndim == 3:
- axes = (1, 2)
- else:
- return
- data = self.roi.getArrayRegion(image.view(np.ndarray), self.imageItem, axes)
- if data is not None:
- while data.ndim > 1:
- data = data.mean(axis=1)
- self.roiCurve.setData(y=data, x=self.tVals)
- #self.ui.roiPlot.replot()
-
- def setImage(self, img, autoRange=True, autoLevels=True, levels=None, axes=None, xvals=None, pos=None, scale=None):
- """Set the image to be displayed in the widget.
- Options are:
- img: ndarray; the image to be displayed.
- autoRange: bool; whether to scale/pan the view to fit the image.
- autoLevels: bool; whether to update the white/black levels to fit the image.
- levels: (min, max); the white and black level values to use.
- axes: {'t':0, 'x':1, 'y':2, 'c':3}; Dictionary indicating the interpretation for each axis.
- This is only needed to override the default guess.
+ ============== =======================================================================
+ **Arguments:**
+ *img* (numpy array) the image to be displayed.
+ *xvals* (numpy array) 1D array of z-axis values corresponding to the third axis
+ in a 3D image. For video, this array should contain the time of each frame.
+ *autoRange* (bool) whether to scale/pan the view to fit the image.
+ *autoLevels* (bool) whether to update the white/black levels to fit the image.
+ *levels* (min, max); the white and black level values to use.
+ *axes* Dictionary indicating the interpretation for each axis.
+ This is only needed to override the default guess. Format is::
+
+ {'t':0, 'x':1, 'y':2, 'c':3};
+ ============== =======================================================================
"""
prof = debug.Profiler('ImageView.setImage', disabled=True)
+ if hasattr(img, 'implements') and img.implements('MetaArray'):
+ img = img.asarray()
+
if not isinstance(img, np.ndarray):
raise Exception("Image must be specified as ndarray.")
self.image = img
@@ -390,15 +259,16 @@ class ImageView(QtGui.QWidget):
self.imageDisp = None
+ prof.mark('3')
+
+ self.currentIndex = 0
+ self.updateImage()
if levels is None and autoLevels:
self.autoLevels()
if levels is not None: ## this does nothing since getProcessedImage sets these values again.
self.levelMax = levels[1]
self.levelMin = levels[0]
- prof.mark('3')
- self.currentIndex = 0
- self.updateImage()
if self.ui.roiBtn.isChecked():
self.roiChanged()
prof.mark('4')
@@ -429,6 +299,8 @@ class ImageView(QtGui.QWidget):
self.imageItem.scale(*scale)
if pos is not None:
self.imageItem.setPos(*pos)
+ if transform is not None:
+ self.imageItem.setTransform(transform)
prof.mark('6')
if autoRange:
@@ -436,30 +308,259 @@ class ImageView(QtGui.QWidget):
self.roiClicked()
prof.mark('7')
prof.finish()
+
+
+ def play(self, rate):
+ """Begin automatically stepping frames forward at the given rate (in fps).
+ This can also be accessed by pressing the spacebar."""
+ #print "play:", rate
+ self.playRate = rate
+ if rate == 0:
+ self.playTimer.stop()
+ return
+ self.lastPlayTime = ptime.time()
+ if not self.playTimer.isActive():
+ self.playTimer.start(16)
+
+
+
def autoLevels(self):
- image = self.getProcessedImage()
+ """Set the min/max levels automatically to match the image data."""
+ #image = self.getProcessedImage()
+ self.setLevels(self.levelMin, self.levelMax)
- #self.ui.whiteSlider.setValue(self.ui.whiteSlider.maximum())
- #self.ui.blackSlider.setValue(0)
-
- self.ui.gradientWidget.setTickValue(self.ticks[0], 0.0)
- self.ui.gradientWidget.setTickValue(self.ticks[1], 1.0)
- self.imageItem.setLevels(white=self.whiteLevel(), black=self.blackLevel())
+ #self.ui.histogram.imageChanged(autoLevel=True)
+ def setLevels(self, min, max):
+ """Set the min/max (bright and dark) levels."""
+ self.ui.histogram.setLevels(min, max)
+
def autoRange(self):
+ """Auto scale and pan the view around the image."""
image = self.getProcessedImage()
#self.ui.graphicsView.setRange(QtCore.QRectF(0, 0, image.shape[self.axes['x']], image.shape[self.axes['y']]), padding=0., lockAspect=True)
- self.ui.graphicsView.setRange(self.imageItem.sceneBoundingRect(), padding=0., lockAspect=True)
+ self.view.autoRange() ##setRange(self.imageItem.viewBoundingRect(), padding=0.)
def getProcessedImage(self):
+ """Returns the image data after it has been processed by any normalization options in use."""
if self.imageDisp is None:
image = self.normalize(self.image)
self.imageDisp = image
- self.levelMin, self.levelMax = map(float, ImageView.quickMinMax(self.imageDisp))
+ self.levelMin, self.levelMax = list(map(float, ImageView.quickMinMax(self.imageDisp)))
+ self.ui.histogram.setHistogramRange(self.levelMin, self.levelMax)
+
return self.imageDisp
+
+
+ def close(self):
+ """Closes the widget nicely, making sure to clear the graphics scene and release memory."""
+ self.ui.roiPlot.close()
+ self.ui.graphicsView.close()
+ #self.ui.gradientWidget.sigGradientChanged.disconnect(self.updateImage)
+ self.scene.clear()
+ del self.image
+ del self.imageDisp
+ self.setParent(None)
+
+ def keyPressEvent(self, ev):
+ #print ev.key()
+ if ev.key() == QtCore.Qt.Key_Space:
+ if self.playRate == 0:
+ fps = (self.getProcessedImage().shape[0]-1) / (self.tVals[-1] - self.tVals[0])
+ self.play(fps)
+ #print fps
+ else:
+ self.play(0)
+ ev.accept()
+ elif ev.key() == QtCore.Qt.Key_Home:
+ self.setCurrentIndex(0)
+ self.play(0)
+ ev.accept()
+ elif ev.key() == QtCore.Qt.Key_End:
+ self.setCurrentIndex(self.getProcessedImage().shape[0]-1)
+ self.play(0)
+ ev.accept()
+ elif ev.key() in self.noRepeatKeys:
+ ev.accept()
+ if ev.isAutoRepeat():
+ return
+ self.keysPressed[ev.key()] = 1
+ self.evalKeyState()
+ else:
+ QtGui.QWidget.keyPressEvent(self, ev)
+
+ def keyReleaseEvent(self, ev):
+ if ev.key() in [QtCore.Qt.Key_Space, QtCore.Qt.Key_Home, QtCore.Qt.Key_End]:
+ ev.accept()
+ elif ev.key() in self.noRepeatKeys:
+ ev.accept()
+ if ev.isAutoRepeat():
+ return
+ try:
+ del self.keysPressed[ev.key()]
+ except:
+ self.keysPressed = {}
+ self.evalKeyState()
+ else:
+ QtGui.QWidget.keyReleaseEvent(self, ev)
+
+
+ def evalKeyState(self):
+ if len(self.keysPressed) == 1:
+ key = list(self.keysPressed.keys())[0]
+ if key == QtCore.Qt.Key_Right:
+ self.play(20)
+ self.jumpFrames(1)
+ self.lastPlayTime = ptime.time() + 0.2 ## 2ms wait before start
+ ## This happens *after* jumpFrames, since it might take longer than 2ms
+ elif key == QtCore.Qt.Key_Left:
+ self.play(-20)
+ self.jumpFrames(-1)
+ self.lastPlayTime = ptime.time() + 0.2
+ elif key == QtCore.Qt.Key_Up:
+ self.play(-100)
+ elif key == QtCore.Qt.Key_Down:
+ self.play(100)
+ elif key == QtCore.Qt.Key_PageUp:
+ self.play(-1000)
+ elif key == QtCore.Qt.Key_PageDown:
+ self.play(1000)
+ else:
+ self.play(0)
+
+
+ def timeout(self):
+ now = ptime.time()
+ dt = now - self.lastPlayTime
+ if dt < 0:
+ return
+ n = int(self.playRate * dt)
+ #print n, dt
+ if n != 0:
+ #print n, dt, self.lastPlayTime
+ self.lastPlayTime += (float(n)/self.playRate)
+ if self.currentIndex+n > self.image.shape[0]:
+ self.play(0)
+ self.jumpFrames(n)
+
+ def setCurrentIndex(self, ind):
+ """Set the currently displayed frame index."""
+ self.currentIndex = np.clip(ind, 0, self.getProcessedImage().shape[0]-1)
+ self.updateImage()
+ self.ignoreTimeLine = True
+ self.timeLine.setValue(self.tVals[self.currentIndex])
+ self.ignoreTimeLine = False
+
+ def jumpFrames(self, n):
+ """Move video frame ahead n frames (may be negative)"""
+ if self.axes['t'] is not None:
+ self.setCurrentIndex(self.currentIndex + n)
+
+ def normRadioChanged(self):
+ self.imageDisp = None
+ self.updateImage()
+ self.roiChanged()
+ self.sigProcessingChanged.emit(self)
+
+
+ def updateNorm(self):
+ #for l, sl in zip(self.normLines, [self.ui.normStartSlider, self.ui.normStopSlider]):
+ #if self.ui.normTimeRangeCheck.isChecked():
+ #l.show()
+ #else:
+ #l.hide()
+
+ #i, t = self.timeIndex(sl)
+ #l.setPos(t)
+
+ if self.ui.normTimeRangeCheck.isChecked():
+ #print "show!"
+ self.normRgn.show()
+ else:
+ self.normRgn.hide()
+
+ if self.ui.normROICheck.isChecked():
+ #print "show!"
+ self.normRoi.show()
+ else:
+ self.normRoi.hide()
+
+ if not self.ui.normOffRadio.isChecked():
+ self.imageDisp = None
+ self.updateImage()
+ self.roiChanged()
+ self.sigProcessingChanged.emit(self)
+
+ def normToggled(self, b):
+ self.ui.normGroup.setVisible(b)
+ self.normRoi.setVisible(b and self.ui.normROICheck.isChecked())
+ self.normRgn.setVisible(b and self.ui.normTimeRangeCheck.isChecked())
+
+ def hasTimeAxis(self):
+ return 't' in self.axes and self.axes['t'] is not None
+
+ def roiClicked(self):
+ showRoiPlot = False
+ if self.ui.roiBtn.isChecked():
+ showRoiPlot = True
+ self.roi.show()
+ #self.ui.roiPlot.show()
+ self.ui.roiPlot.setMouseEnabled(True, True)
+ self.ui.splitter.setSizes([self.height()*0.6, self.height()*0.4])
+ self.roiCurve.show()
+ self.roiChanged()
+ self.ui.roiPlot.showAxis('left')
+ else:
+ self.roi.hide()
+ self.ui.roiPlot.setMouseEnabled(False, False)
+ self.roiCurve.hide()
+ self.ui.roiPlot.hideAxis('left')
+
+ if self.hasTimeAxis():
+ showRoiPlot = True
+ mn = self.tVals.min()
+ mx = self.tVals.max()
+ self.ui.roiPlot.setXRange(mn, mx, padding=0.01)
+ self.timeLine.show()
+ self.timeLine.setBounds([mn, mx])
+ self.ui.roiPlot.show()
+ if not self.ui.roiBtn.isChecked():
+ self.ui.splitter.setSizes([self.height()-35, 35])
+ else:
+ self.timeLine.hide()
+ #self.ui.roiPlot.hide()
+
+ self.ui.roiPlot.setVisible(showRoiPlot)
+
+ def roiChanged(self):
+ if self.image is None:
+ return
+
+ image = self.getProcessedImage()
+ if image.ndim == 2:
+ axes = (0, 1)
+ elif image.ndim == 3:
+ axes = (1, 2)
+ else:
+ return
+ data, coords = self.roi.getArrayRegion(image.view(np.ndarray), self.imageItem, axes, returnMappedCoords=True)
+ if data is not None:
+ while data.ndim > 1:
+ data = data.mean(axis=1)
+ if image.ndim == 3:
+ self.roiCurve.setData(y=data, x=self.tVals)
+ else:
+ while coords.ndim > 2:
+ coords = coords[:,:,0]
+ coords = coords - coords[:,0,np.newaxis]
+ xvals = (coords**2).sum(axis=0) ** 0.5
+ self.roiCurve.setData(y=data, x=xvals)
+
+ #self.ui.roiPlot.replot()
+
@staticmethod
def quickMinMax(data):
@@ -536,18 +637,18 @@ class ImageView(QtGui.QWidget):
#print "update:", image.ndim, image.max(), image.min(), self.blackLevel(), self.whiteLevel()
if self.axes['t'] is None:
#self.ui.timeSlider.hide()
- self.imageItem.updateImage(image, white=self.whiteLevel(), black=self.blackLevel())
- self.ui.roiPlot.hide()
- self.ui.roiBtn.hide()
+ self.imageItem.updateImage(image)
+ #self.ui.roiPlot.hide()
+ #self.ui.roiBtn.hide()
else:
- self.ui.roiBtn.show()
+ #self.ui.roiBtn.show()
self.ui.roiPlot.show()
#self.ui.timeSlider.show()
- self.imageItem.updateImage(image[self.currentIndex], white=self.whiteLevel(), black=self.blackLevel())
+ self.imageItem.updateImage(image[self.currentIndex])
def timeIndex(self, slider):
- """Return the time and frame index indicated by a slider"""
+ ## Return the time and frame index indicated by a slider
if self.image is None:
return (0,0)
#v = slider.value()
@@ -574,11 +675,26 @@ class ImageView(QtGui.QWidget):
#print ind
return ind, t
- def whiteLevel(self):
- return self.levelMin + (self.levelMax-self.levelMin) * self.ui.gradientWidget.tickValue(self.ticks[1])
- #return self.levelMin + (self.levelMax-self.levelMin) * self.ui.whiteSlider.value() / self.ui.whiteSlider.maximum()
+ #def whiteLevel(self):
+ #return self.levelMin + (self.levelMax-self.levelMin) * self.ui.gradientWidget.tickValue(self.ticks[1])
+ ##return self.levelMin + (self.levelMax-self.levelMin) * self.ui.whiteSlider.value() / self.ui.whiteSlider.maximum()
- def blackLevel(self):
- return self.levelMin + (self.levelMax-self.levelMin) * self.ui.gradientWidget.tickValue(self.ticks[0])
- #return self.levelMin + ((self.levelMax-self.levelMin) / self.ui.blackSlider.maximum()) * self.ui.blackSlider.value()
-
\ No newline at end of file
+ #def blackLevel(self):
+ #return self.levelMin + (self.levelMax-self.levelMin) * self.ui.gradientWidget.tickValue(self.ticks[0])
+ ##return self.levelMin + ((self.levelMax-self.levelMin) / self.ui.blackSlider.maximum()) * self.ui.blackSlider.value()
+
+ def getView(self):
+ """Return the ViewBox (or other compatible object) which displays the ImageItem"""
+ return self.view
+
+ def getImageItem(self):
+ """Return the ImageItem for this ImageView."""
+ return self.imageItem
+
+ def getRoiPlot(self):
+ """Return the ROI PlotWidget for this ImageView"""
+ return self.ui.roiPlot
+
+ def getHistogramWidget(self):
+ """Return the HistogramLUTWidget for this ImageView"""
+ return self.ui.histogram
diff --git a/pyqtgraph/imageview/ImageViewTemplate.ui b/pyqtgraph/imageview/ImageViewTemplate.ui
new file mode 100644
index 00000000..497c0c59
--- /dev/null
+++ b/pyqtgraph/imageview/ImageViewTemplate.ui
@@ -0,0 +1,252 @@
+
+
+ Form
+
+
+
+ 0
+ 0
+ 726
+ 588
+
+
+
+ Form
+
+
+
+ 0
+
+
+ 0
+
+ -
+
+
+ Qt::Vertical
+
+
+
+
+ 0
+
+
-
+
+
+ -
+
+
+ -
+
+
+
+ 0
+ 1
+
+
+
+ ROI
+
+
+ true
+
+
+
+ -
+
+
+
+ 0
+ 1
+
+
+
+ Norm
+
+
+ true
+
+
+
+
+
+
+
+
+ 0
+ 0
+
+
+
+
+ 0
+ 40
+
+
+
+
+
+ -
+
+
+ Normalization
+
+
+
+ 0
+
+
+ 0
+
+
-
+
+
+ Subtract
+
+
+
+ -
+
+
+ Divide
+
+
+ false
+
+
+
+ -
+
+
+
+ 75
+ true
+
+
+
+ Operation:
+
+
+
+ -
+
+
+
+ 75
+ true
+
+
+
+ Mean:
+
+
+
+ -
+
+
+
+ 75
+ true
+
+
+
+ Blur:
+
+
+
+ -
+
+
+ ROI
+
+
+
+ -
+
+
+ -
+
+
+ X
+
+
+ Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
+
+
+
+ -
+
+
+ Y
+
+
+ Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
+
+
+
+ -
+
+
+ -
+
+
+ T
+
+
+ Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
+
+
+
+ -
+
+
+ Off
+
+
+ true
+
+
+
+ -
+
+
+ Time range
+
+
+
+ -
+
+
+ Frame
+
+
+
+ -
+
+
+
+
+
+
+
+
+
+ PlotWidget
+ QWidget
+ pyqtgraph.widgets.PlotWidget
+ 1
+
+
+ GraphicsView
+ QGraphicsView
+ pyqtgraph.widgets.GraphicsView
+
+
+ HistogramLUTWidget
+ QGraphicsView
+ pyqtgraph.widgets.HistogramLUTWidget
+
+
+
+
+
diff --git a/ImageViewTemplate.py b/pyqtgraph/imageview/ImageViewTemplate_pyqt.py
similarity index 80%
rename from ImageViewTemplate.py
rename to pyqtgraph/imageview/ImageViewTemplate_pyqt.py
index fe283a74..e6423276 100644
--- a/ImageViewTemplate.py
+++ b/pyqtgraph/imageview/ImageViewTemplate_pyqt.py
@@ -1,9 +1,9 @@
# -*- coding: utf-8 -*-
-# Form implementation generated from reading ui file './lib/util/pyqtgraph/ImageViewTemplate.ui'
+# Form implementation generated from reading ui file './imageview/ImageViewTemplate.ui'
#
-# Created: Wed May 18 20:44:20 2011
-# by: PyQt4 UI code generator 4.8.3
+# Created: Sun Sep 9 14:41:30 2012
+# by: PyQt4 UI code generator 4.9.1
#
# WARNING! All changes made in this file will be lost!
@@ -18,57 +18,53 @@ class Ui_Form(object):
def setupUi(self, Form):
Form.setObjectName(_fromUtf8("Form"))
Form.resize(726, 588)
- self.verticalLayout = QtGui.QVBoxLayout(Form)
- self.verticalLayout.setSpacing(0)
- self.verticalLayout.setMargin(0)
- self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
+ self.gridLayout_3 = QtGui.QGridLayout(Form)
+ self.gridLayout_3.setMargin(0)
+ self.gridLayout_3.setSpacing(0)
+ self.gridLayout_3.setObjectName(_fromUtf8("gridLayout_3"))
self.splitter = QtGui.QSplitter(Form)
self.splitter.setOrientation(QtCore.Qt.Vertical)
self.splitter.setObjectName(_fromUtf8("splitter"))
self.layoutWidget = QtGui.QWidget(self.splitter)
self.layoutWidget.setObjectName(_fromUtf8("layoutWidget"))
self.gridLayout = QtGui.QGridLayout(self.layoutWidget)
- self.gridLayout.setMargin(0)
self.gridLayout.setSpacing(0)
self.gridLayout.setMargin(0)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.graphicsView = GraphicsView(self.layoutWidget)
- sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
- sizePolicy.setHorizontalStretch(10)
- sizePolicy.setVerticalStretch(10)
- sizePolicy.setHeightForWidth(self.graphicsView.sizePolicy().hasHeightForWidth())
- self.graphicsView.setSizePolicy(sizePolicy)
self.graphicsView.setObjectName(_fromUtf8("graphicsView"))
- self.gridLayout.addWidget(self.graphicsView, 1, 0, 3, 1)
+ self.gridLayout.addWidget(self.graphicsView, 0, 0, 2, 1)
+ self.histogram = HistogramLUTWidget(self.layoutWidget)
+ self.histogram.setObjectName(_fromUtf8("histogram"))
+ self.gridLayout.addWidget(self.histogram, 0, 1, 1, 2)
self.roiBtn = QtGui.QPushButton(self.layoutWidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(1)
sizePolicy.setHeightForWidth(self.roiBtn.sizePolicy().hasHeightForWidth())
self.roiBtn.setSizePolicy(sizePolicy)
- self.roiBtn.setMaximumSize(QtCore.QSize(30, 16777215))
self.roiBtn.setCheckable(True)
self.roiBtn.setObjectName(_fromUtf8("roiBtn"))
- self.gridLayout.addWidget(self.roiBtn, 3, 3, 1, 1)
- self.gradientWidget = GradientWidget(self.layoutWidget)
- sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding)
- sizePolicy.setHorizontalStretch(0)
- sizePolicy.setVerticalStretch(100)
- sizePolicy.setHeightForWidth(self.gradientWidget.sizePolicy().hasHeightForWidth())
- self.gradientWidget.setSizePolicy(sizePolicy)
- self.gradientWidget.setObjectName(_fromUtf8("gradientWidget"))
- self.gridLayout.addWidget(self.gradientWidget, 1, 3, 1, 1)
+ self.gridLayout.addWidget(self.roiBtn, 1, 1, 1, 1)
self.normBtn = QtGui.QPushButton(self.layoutWidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(1)
sizePolicy.setHeightForWidth(self.normBtn.sizePolicy().hasHeightForWidth())
self.normBtn.setSizePolicy(sizePolicy)
- self.normBtn.setMaximumSize(QtCore.QSize(30, 16777215))
self.normBtn.setCheckable(True)
self.normBtn.setObjectName(_fromUtf8("normBtn"))
- self.gridLayout.addWidget(self.normBtn, 2, 3, 1, 1)
- self.normGroup = QtGui.QGroupBox(self.layoutWidget)
+ self.gridLayout.addWidget(self.normBtn, 1, 2, 1, 1)
+ self.roiPlot = PlotWidget(self.splitter)
+ sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.roiPlot.sizePolicy().hasHeightForWidth())
+ self.roiPlot.setSizePolicy(sizePolicy)
+ self.roiPlot.setMinimumSize(QtCore.QSize(0, 40))
+ self.roiPlot.setObjectName(_fromUtf8("roiPlot"))
+ self.gridLayout_3.addWidget(self.splitter, 0, 0, 1, 1)
+ self.normGroup = QtGui.QGroupBox(Form)
self.normGroup.setObjectName(_fromUtf8("normGroup"))
self.gridLayout_2 = QtGui.QGridLayout(self.normGroup)
self.gridLayout_2.setMargin(0)
@@ -83,22 +79,22 @@ class Ui_Form(object):
self.gridLayout_2.addWidget(self.normDivideRadio, 0, 1, 1, 1)
self.label_5 = QtGui.QLabel(self.normGroup)
font = QtGui.QFont()
- font.setWeight(75)
font.setBold(True)
+ font.setWeight(75)
self.label_5.setFont(font)
self.label_5.setObjectName(_fromUtf8("label_5"))
self.gridLayout_2.addWidget(self.label_5, 0, 0, 1, 1)
self.label_3 = QtGui.QLabel(self.normGroup)
font = QtGui.QFont()
- font.setWeight(75)
font.setBold(True)
+ font.setWeight(75)
self.label_3.setFont(font)
self.label_3.setObjectName(_fromUtf8("label_3"))
self.gridLayout_2.addWidget(self.label_3, 1, 0, 1, 1)
self.label_4 = QtGui.QLabel(self.normGroup)
font = QtGui.QFont()
- font.setWeight(75)
font.setBold(True)
+ font.setWeight(75)
self.label_4.setFont(font)
self.label_4.setObjectName(_fromUtf8("label_4"))
self.gridLayout_2.addWidget(self.label_4, 2, 0, 1, 1)
@@ -136,24 +132,15 @@ class Ui_Form(object):
self.normTBlurSpin = QtGui.QDoubleSpinBox(self.normGroup)
self.normTBlurSpin.setObjectName(_fromUtf8("normTBlurSpin"))
self.gridLayout_2.addWidget(self.normTBlurSpin, 2, 6, 1, 1)
- self.gridLayout.addWidget(self.normGroup, 0, 0, 1, 4)
- self.roiPlot = PlotWidget(self.splitter)
- sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
- sizePolicy.setHorizontalStretch(0)
- sizePolicy.setVerticalStretch(0)
- sizePolicy.setHeightForWidth(self.roiPlot.sizePolicy().hasHeightForWidth())
- self.roiPlot.setSizePolicy(sizePolicy)
- self.roiPlot.setMinimumSize(QtCore.QSize(0, 40))
- self.roiPlot.setObjectName(_fromUtf8("roiPlot"))
- self.verticalLayout.addWidget(self.splitter)
+ self.gridLayout_3.addWidget(self.normGroup, 1, 0, 1, 1)
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
Form.setWindowTitle(QtGui.QApplication.translate("Form", "Form", None, QtGui.QApplication.UnicodeUTF8))
- self.roiBtn.setText(QtGui.QApplication.translate("Form", "R", None, QtGui.QApplication.UnicodeUTF8))
- self.normBtn.setText(QtGui.QApplication.translate("Form", "N", None, QtGui.QApplication.UnicodeUTF8))
+ self.roiBtn.setText(QtGui.QApplication.translate("Form", "ROI", None, QtGui.QApplication.UnicodeUTF8))
+ self.normBtn.setText(QtGui.QApplication.translate("Form", "Norm", None, QtGui.QApplication.UnicodeUTF8))
self.normGroup.setTitle(QtGui.QApplication.translate("Form", "Normalization", None, QtGui.QApplication.UnicodeUTF8))
self.normSubtractRadio.setText(QtGui.QApplication.translate("Form", "Subtract", None, QtGui.QApplication.UnicodeUTF8))
self.normDivideRadio.setText(QtGui.QApplication.translate("Form", "Divide", None, QtGui.QApplication.UnicodeUTF8))
@@ -168,6 +155,6 @@ class Ui_Form(object):
self.normTimeRangeCheck.setText(QtGui.QApplication.translate("Form", "Time range", None, QtGui.QApplication.UnicodeUTF8))
self.normFrameCheck.setText(QtGui.QApplication.translate("Form", "Frame", None, QtGui.QApplication.UnicodeUTF8))
-from GraphicsView import GraphicsView
-from pyqtgraph.GradientWidget import GradientWidget
-from PlotWidget import PlotWidget
+from pyqtgraph.widgets.GraphicsView import GraphicsView
+from pyqtgraph.widgets.PlotWidget import PlotWidget
+from pyqtgraph.widgets.HistogramLUTWidget import HistogramLUTWidget
diff --git a/pyqtgraph/imageview/ImageViewTemplate_pyside.py b/pyqtgraph/imageview/ImageViewTemplate_pyside.py
new file mode 100644
index 00000000..c17bbfe1
--- /dev/null
+++ b/pyqtgraph/imageview/ImageViewTemplate_pyside.py
@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file './imageview/ImageViewTemplate.ui'
+#
+# Created: Sun Sep 9 14:41:31 2012
+# by: pyside-uic 0.2.13 running on PySide 1.1.0
+#
+# WARNING! All changes made in this file will be lost!
+
+from PySide import QtCore, QtGui
+
+class Ui_Form(object):
+ def setupUi(self, Form):
+ Form.setObjectName("Form")
+ Form.resize(726, 588)
+ self.gridLayout_3 = QtGui.QGridLayout(Form)
+ self.gridLayout_3.setContentsMargins(0, 0, 0, 0)
+ self.gridLayout_3.setSpacing(0)
+ self.gridLayout_3.setObjectName("gridLayout_3")
+ self.splitter = QtGui.QSplitter(Form)
+ self.splitter.setOrientation(QtCore.Qt.Vertical)
+ self.splitter.setObjectName("splitter")
+ self.layoutWidget = QtGui.QWidget(self.splitter)
+ self.layoutWidget.setObjectName("layoutWidget")
+ self.gridLayout = QtGui.QGridLayout(self.layoutWidget)
+ self.gridLayout.setSpacing(0)
+ self.gridLayout.setContentsMargins(0, 0, 0, 0)
+ self.gridLayout.setObjectName("gridLayout")
+ self.graphicsView = GraphicsView(self.layoutWidget)
+ self.graphicsView.setObjectName("graphicsView")
+ self.gridLayout.addWidget(self.graphicsView, 0, 0, 2, 1)
+ self.histogram = HistogramLUTWidget(self.layoutWidget)
+ self.histogram.setObjectName("histogram")
+ self.gridLayout.addWidget(self.histogram, 0, 1, 1, 2)
+ self.roiBtn = QtGui.QPushButton(self.layoutWidget)
+ sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(1)
+ sizePolicy.setHeightForWidth(self.roiBtn.sizePolicy().hasHeightForWidth())
+ self.roiBtn.setSizePolicy(sizePolicy)
+ self.roiBtn.setCheckable(True)
+ self.roiBtn.setObjectName("roiBtn")
+ self.gridLayout.addWidget(self.roiBtn, 1, 1, 1, 1)
+ self.normBtn = QtGui.QPushButton(self.layoutWidget)
+ sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(1)
+ sizePolicy.setHeightForWidth(self.normBtn.sizePolicy().hasHeightForWidth())
+ self.normBtn.setSizePolicy(sizePolicy)
+ self.normBtn.setCheckable(True)
+ self.normBtn.setObjectName("normBtn")
+ self.gridLayout.addWidget(self.normBtn, 1, 2, 1, 1)
+ self.roiPlot = PlotWidget(self.splitter)
+ sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.roiPlot.sizePolicy().hasHeightForWidth())
+ self.roiPlot.setSizePolicy(sizePolicy)
+ self.roiPlot.setMinimumSize(QtCore.QSize(0, 40))
+ self.roiPlot.setObjectName("roiPlot")
+ self.gridLayout_3.addWidget(self.splitter, 0, 0, 1, 1)
+ self.normGroup = QtGui.QGroupBox(Form)
+ self.normGroup.setObjectName("normGroup")
+ self.gridLayout_2 = QtGui.QGridLayout(self.normGroup)
+ self.gridLayout_2.setContentsMargins(0, 0, 0, 0)
+ self.gridLayout_2.setSpacing(0)
+ self.gridLayout_2.setObjectName("gridLayout_2")
+ self.normSubtractRadio = QtGui.QRadioButton(self.normGroup)
+ self.normSubtractRadio.setObjectName("normSubtractRadio")
+ self.gridLayout_2.addWidget(self.normSubtractRadio, 0, 2, 1, 1)
+ self.normDivideRadio = QtGui.QRadioButton(self.normGroup)
+ self.normDivideRadio.setChecked(False)
+ self.normDivideRadio.setObjectName("normDivideRadio")
+ self.gridLayout_2.addWidget(self.normDivideRadio, 0, 1, 1, 1)
+ self.label_5 = QtGui.QLabel(self.normGroup)
+ font = QtGui.QFont()
+ font.setWeight(75)
+ font.setBold(True)
+ self.label_5.setFont(font)
+ self.label_5.setObjectName("label_5")
+ self.gridLayout_2.addWidget(self.label_5, 0, 0, 1, 1)
+ self.label_3 = QtGui.QLabel(self.normGroup)
+ font = QtGui.QFont()
+ font.setWeight(75)
+ font.setBold(True)
+ self.label_3.setFont(font)
+ self.label_3.setObjectName("label_3")
+ self.gridLayout_2.addWidget(self.label_3, 1, 0, 1, 1)
+ self.label_4 = QtGui.QLabel(self.normGroup)
+ font = QtGui.QFont()
+ font.setWeight(75)
+ font.setBold(True)
+ self.label_4.setFont(font)
+ self.label_4.setObjectName("label_4")
+ self.gridLayout_2.addWidget(self.label_4, 2, 0, 1, 1)
+ self.normROICheck = QtGui.QCheckBox(self.normGroup)
+ self.normROICheck.setObjectName("normROICheck")
+ self.gridLayout_2.addWidget(self.normROICheck, 1, 1, 1, 1)
+ self.normXBlurSpin = QtGui.QDoubleSpinBox(self.normGroup)
+ self.normXBlurSpin.setObjectName("normXBlurSpin")
+ self.gridLayout_2.addWidget(self.normXBlurSpin, 2, 2, 1, 1)
+ self.label_8 = QtGui.QLabel(self.normGroup)
+ self.label_8.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
+ self.label_8.setObjectName("label_8")
+ self.gridLayout_2.addWidget(self.label_8, 2, 1, 1, 1)
+ self.label_9 = QtGui.QLabel(self.normGroup)
+ self.label_9.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
+ self.label_9.setObjectName("label_9")
+ self.gridLayout_2.addWidget(self.label_9, 2, 3, 1, 1)
+ self.normYBlurSpin = QtGui.QDoubleSpinBox(self.normGroup)
+ self.normYBlurSpin.setObjectName("normYBlurSpin")
+ self.gridLayout_2.addWidget(self.normYBlurSpin, 2, 4, 1, 1)
+ self.label_10 = QtGui.QLabel(self.normGroup)
+ self.label_10.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
+ self.label_10.setObjectName("label_10")
+ self.gridLayout_2.addWidget(self.label_10, 2, 5, 1, 1)
+ self.normOffRadio = QtGui.QRadioButton(self.normGroup)
+ self.normOffRadio.setChecked(True)
+ self.normOffRadio.setObjectName("normOffRadio")
+ self.gridLayout_2.addWidget(self.normOffRadio, 0, 3, 1, 1)
+ self.normTimeRangeCheck = QtGui.QCheckBox(self.normGroup)
+ self.normTimeRangeCheck.setObjectName("normTimeRangeCheck")
+ self.gridLayout_2.addWidget(self.normTimeRangeCheck, 1, 3, 1, 1)
+ self.normFrameCheck = QtGui.QCheckBox(self.normGroup)
+ self.normFrameCheck.setObjectName("normFrameCheck")
+ self.gridLayout_2.addWidget(self.normFrameCheck, 1, 2, 1, 1)
+ self.normTBlurSpin = QtGui.QDoubleSpinBox(self.normGroup)
+ self.normTBlurSpin.setObjectName("normTBlurSpin")
+ self.gridLayout_2.addWidget(self.normTBlurSpin, 2, 6, 1, 1)
+ self.gridLayout_3.addWidget(self.normGroup, 1, 0, 1, 1)
+
+ self.retranslateUi(Form)
+ QtCore.QMetaObject.connectSlotsByName(Form)
+
+ def retranslateUi(self, Form):
+ Form.setWindowTitle(QtGui.QApplication.translate("Form", "Form", None, QtGui.QApplication.UnicodeUTF8))
+ self.roiBtn.setText(QtGui.QApplication.translate("Form", "ROI", None, QtGui.QApplication.UnicodeUTF8))
+ self.normBtn.setText(QtGui.QApplication.translate("Form", "Norm", None, QtGui.QApplication.UnicodeUTF8))
+ self.normGroup.setTitle(QtGui.QApplication.translate("Form", "Normalization", None, QtGui.QApplication.UnicodeUTF8))
+ self.normSubtractRadio.setText(QtGui.QApplication.translate("Form", "Subtract", None, QtGui.QApplication.UnicodeUTF8))
+ self.normDivideRadio.setText(QtGui.QApplication.translate("Form", "Divide", None, QtGui.QApplication.UnicodeUTF8))
+ self.label_5.setText(QtGui.QApplication.translate("Form", "Operation:", None, QtGui.QApplication.UnicodeUTF8))
+ self.label_3.setText(QtGui.QApplication.translate("Form", "Mean:", None, QtGui.QApplication.UnicodeUTF8))
+ self.label_4.setText(QtGui.QApplication.translate("Form", "Blur:", None, QtGui.QApplication.UnicodeUTF8))
+ self.normROICheck.setText(QtGui.QApplication.translate("Form", "ROI", None, QtGui.QApplication.UnicodeUTF8))
+ self.label_8.setText(QtGui.QApplication.translate("Form", "X", None, QtGui.QApplication.UnicodeUTF8))
+ self.label_9.setText(QtGui.QApplication.translate("Form", "Y", None, QtGui.QApplication.UnicodeUTF8))
+ self.label_10.setText(QtGui.QApplication.translate("Form", "T", None, QtGui.QApplication.UnicodeUTF8))
+ self.normOffRadio.setText(QtGui.QApplication.translate("Form", "Off", None, QtGui.QApplication.UnicodeUTF8))
+ self.normTimeRangeCheck.setText(QtGui.QApplication.translate("Form", "Time range", None, QtGui.QApplication.UnicodeUTF8))
+ self.normFrameCheck.setText(QtGui.QApplication.translate("Form", "Frame", None, QtGui.QApplication.UnicodeUTF8))
+
+from pyqtgraph.widgets.GraphicsView import GraphicsView
+from pyqtgraph.widgets.PlotWidget import PlotWidget
+from pyqtgraph.widgets.HistogramLUTWidget import HistogramLUTWidget
diff --git a/pyqtgraph/imageview/__init__.py b/pyqtgraph/imageview/__init__.py
new file mode 100644
index 00000000..0060e823
--- /dev/null
+++ b/pyqtgraph/imageview/__init__.py
@@ -0,0 +1,6 @@
+"""
+Widget used for display and analysis of 2D and 3D image data.
+Includes ROI plotting over time and image normalization.
+"""
+
+from .ImageView import ImageView
diff --git a/pyqtgraph/metaarray/MetaArray.py b/pyqtgraph/metaarray/MetaArray.py
new file mode 100644
index 00000000..0797c75e
--- /dev/null
+++ b/pyqtgraph/metaarray/MetaArray.py
@@ -0,0 +1,1471 @@
+# -*- coding: utf-8 -*-
+"""
+MetaArray.py - Class encapsulating ndarray with meta data
+Copyright 2010 Luke Campagnola
+Distributed under MIT/X11 license. See license.txt for more infomation.
+
+MetaArray is an array class based on numpy.ndarray that allows storage of per-axis meta data
+such as axis values, names, units, column names, etc. It also enables several
+new methods for slicing and indexing the array based on this meta data.
+More info at http://www.scipy.org/Cookbook/MetaArray
+"""
+
+import numpy as np
+import types, copy, threading, os, re
+import pickle
+from functools import reduce
+#import traceback
+
+## By default, the library will use HDF5 when writing files.
+## This can be overridden by setting USE_HDF5 = False
+USE_HDF5 = True
+try:
+ import h5py
+ HAVE_HDF5 = True
+except:
+ USE_HDF5 = False
+ HAVE_HDF5 = False
+
+
+def axis(name=None, cols=None, values=None, units=None):
+ """Convenience function for generating axis descriptions when defining MetaArrays"""
+ ax = {}
+ cNameOrder = ['name', 'units', 'title']
+ if name is not None:
+ ax['name'] = name
+ if values is not None:
+ ax['values'] = values
+ if units is not None:
+ ax['units'] = units
+ if cols is not None:
+ ax['cols'] = []
+ for c in cols:
+ if type(c) != list and type(c) != tuple:
+ c = [c]
+ col = {}
+ for i in range(0,len(c)):
+ col[cNameOrder[i]] = c[i]
+ ax['cols'].append(col)
+ return ax
+
+class sliceGenerator(object):
+ """Just a compact way to generate tuples of slice objects."""
+ def __getitem__(self, arg):
+ return arg
+ def __getslice__(self, arg):
+ return arg
+SLICER = sliceGenerator()
+
+
+class MetaArray(object):
+ """N-dimensional array with meta data such as axis titles, units, and column names.
+
+ May be initialized with a file name, a tuple representing the dimensions of the array,
+ or any arguments that could be passed on to numpy.array()
+
+ The info argument sets the metadata for the entire array. It is composed of a list
+ of axis descriptions where each axis may have a name, title, units, and a list of column
+ descriptions. An additional dict at the end of the axis list may specify parameters
+ that apply to values in the entire array.
+
+ For example:
+ A 2D array of altitude values for a topographical map might look like
+ info=[
+ {'name': 'lat', 'title': 'Lattitude'},
+ {'name': 'lon', 'title': 'Longitude'},
+ {'title': 'Altitude', 'units': 'm'}
+ ]
+ In this case, every value in the array represents the altitude in feet at the lat, lon
+ position represented by the array index. All of the following return the
+ value at lat=10, lon=5:
+ array[10, 5]
+ array['lon':5, 'lat':10]
+ array['lat':10][5]
+ Now suppose we want to combine this data with another array of equal dimensions that
+ represents the average rainfall for each location. We could easily store these as two
+ separate arrays or combine them into a 3D array with this description:
+ info=[
+ {'name': 'vals', 'cols': [
+ {'name': 'altitude', 'units': 'm'},
+ {'name': 'rainfall', 'units': 'cm/year'}
+ ]},
+ {'name': 'lat', 'title': 'Lattitude'},
+ {'name': 'lon', 'title': 'Longitude'}
+ ]
+ We can now access the altitude values with array[0] or array['altitude'], and the
+ rainfall values with array[1] or array['rainfall']. All of the following return
+ the rainfall value at lat=10, lon=5:
+ array[1, 10, 5]
+ array['lon':5, 'lat':10, 'val': 'rainfall']
+ array['rainfall', 'lon':5, 'lat':10]
+ Notice that in the second example, there is no need for an extra (4th) axis description
+ since the actual values are described (name and units) in the column info for the first axis.
+ """
+
+ version = '2'
+
+ ## Types allowed as axis or column names
+ nameTypes = [basestring, tuple]
+ @staticmethod
+ def isNameType(var):
+ return any([isinstance(var, t) for t in MetaArray.nameTypes])
+
+
+ ## methods to wrap from embedded ndarray / HDF5
+ wrapMethods = set(['__eq__', '__ne__', '__le__', '__lt__', '__ge__', '__gt__'])
+
+ def __init__(self, data=None, info=None, dtype=None, file=None, copy=False, **kwargs):
+ object.__init__(self)
+ #self._infoOwned = False
+ self._isHDF = False
+
+ if file is not None:
+ self._data = None
+ self.readFile(file, **kwargs)
+ if self._data is None:
+ raise Exception("File read failed: %s" % file)
+ else:
+ self._info = info
+ if (hasattr(data, 'implements') and data.implements('MetaArray')):
+ self._info = data._info
+ self._data = data.asarray()
+ elif isinstance(data, tuple): ## create empty array with specified shape
+ self._data = np.empty(data, dtype=dtype)
+ else:
+ self._data = np.array(data, dtype=dtype, copy=copy)
+
+ ## run sanity checks on info structure
+ self.checkInfo()
+
+ def checkInfo(self):
+ info = self._info
+ if info is None:
+ if self._data is None:
+ return
+ else:
+ self._info = [{} for i in range(self.ndim)]
+ return
+ else:
+ try:
+ info = list(info)
+ except:
+ raise Exception("Info must be a list of axis specifications")
+ if len(info) < self.ndim+1:
+ info.extend([{}]*(self.ndim+1-len(info)))
+ elif len(info) > self.ndim+1:
+ raise Exception("Info parameter must be list of length ndim+1 or less.")
+ for i in range(len(info)):
+ if not isinstance(info[i], dict):
+ if info[i] is None:
+ info[i] = {}
+ else:
+ raise Exception("Axis specification must be Dict or None")
+ if i < self.ndim and 'values' in info[i]:
+ if type(info[i]['values']) is list:
+ info[i]['values'] = np.array(info[i]['values'])
+ elif type(info[i]['values']) is not np.ndarray:
+ raise Exception("Axis values must be specified as list or ndarray")
+ if info[i]['values'].ndim != 1 or info[i]['values'].shape[0] != self.shape[i]:
+ raise Exception("Values array for axis %d has incorrect shape. (given %s, but should be %s)" % (i, str(info[i]['values'].shape), str((self.shape[i],))))
+ if i < self.ndim and 'cols' in info[i]:
+ if not isinstance(info[i]['cols'], list):
+ info[i]['cols'] = list(info[i]['cols'])
+ if len(info[i]['cols']) != self.shape[i]:
+ raise Exception('Length of column list for axis %d does not match data. (given %d, but should be %d)' % (i, len(info[i]['cols']), self.shape[i]))
+
+ def implements(self, name=None):
+ ## Rather than isinstance(obj, MetaArray) use object.implements('MetaArray')
+ if name is None:
+ return ['MetaArray']
+ else:
+ return name == 'MetaArray'
+
+ #def __array_finalize__(self,obj):
+ ### array_finalize is called every time a MetaArray is created
+ ### (whereas __new__ is not necessarily called every time)
+
+ ### obj is the object from which this array was generated (for example, when slicing or view()ing)
+
+ ## We use the getattr method to set a default if 'obj' doesn't have the 'info' attribute
+ ##print "Create new MA from object", str(type(obj))
+ ##import traceback
+ ##traceback.print_stack()
+ ##print "finalize", type(self), type(obj)
+ #if not hasattr(self, '_info'):
+ ##if isinstance(obj, MetaArray):
+ ##print " copy info:", obj._info
+ #self._info = getattr(obj, '_info', [{}]*(obj.ndim+1))
+ #self._infoOwned = False ## Do not make changes to _info until it is copied at least once
+ ##print " self info:", self._info
+
+ ## We could have checked first whether self._info was already defined:
+ ##if not hasattr(self, 'info'):
+ ## self._info = getattr(obj, 'info', {})
+
+
+ def __getitem__(self, ind):
+ #print "getitem:", ind
+
+ ## should catch scalar requests as early as possible to speed things up (?)
+
+ nInd = self._interpretIndexes(ind)
+
+ #a = np.ndarray.__getitem__(self, nInd)
+ a = self._data[nInd]
+ if len(nInd) == self.ndim:
+ if np.all([not isinstance(ind, slice) for ind in nInd]): ## no slices; we have requested a single value from the array
+ return a
+ #if type(a) != type(self._data) and not isinstance(a, np.ndarray): ## indexing returned single value
+ #return a
+
+ ## indexing returned a sub-array; generate new info array to go with it
+ #print " new MA:", type(a), a.shape
+ info = []
+ extraInfo = self._info[-1].copy()
+ for i in range(0, len(nInd)): ## iterate over all axes
+ #print " axis", i
+ if type(nInd[i]) in [slice, list] or isinstance(nInd[i], np.ndarray): ## If the axis is sliced, keep the info but chop if necessary
+ #print " slice axis", i, nInd[i]
+ #a._info[i] = self._axisSlice(i, nInd[i])
+ #print " info:", a._info[i]
+ info.append(self._axisSlice(i, nInd[i]))
+ else: ## If the axis is indexed, then move the information from that single index to the last info dictionary
+ #print "indexed:", i, nInd[i], type(nInd[i])
+ newInfo = self._axisSlice(i, nInd[i])
+ name = None
+ colName = None
+ for k in newInfo:
+ if k == 'cols':
+ if 'cols' not in extraInfo:
+ extraInfo['cols'] = []
+ extraInfo['cols'].append(newInfo[k])
+ if 'units' in newInfo[k]:
+ extraInfo['units'] = newInfo[k]['units']
+ if 'name' in newInfo[k]:
+ colName = newInfo[k]['name']
+ elif k == 'name':
+ name = newInfo[k]
+ else:
+ if k not in extraInfo:
+ extraInfo[k] = newInfo[k]
+ extraInfo[k] = newInfo[k]
+ if 'name' not in extraInfo:
+ if name is None:
+ if colName is not None:
+ extraInfo['name'] = colName
+ else:
+ if colName is not None:
+ extraInfo['name'] = str(name) + ': ' + str(colName)
+ else:
+ extraInfo['name'] = name
+
+
+ #print "Lost info:", newInfo
+ #a._info[i] = None
+ #if 'name' in newInfo:
+ #a._info[-1][newInfo['name']] = newInfo
+ info.append(extraInfo)
+
+ #self._infoOwned = False
+ #while None in a._info:
+ #a._info.remove(None)
+ return MetaArray(a, info=info)
+
+ @property
+ def ndim(self):
+ return len(self.shape) ## hdf5 objects do not have ndim property.
+
+ @property
+ def shape(self):
+ return self._data.shape
+
+ @property
+ def dtype(self):
+ return self._data.dtype
+
+ def __len__(self):
+ return len(self._data)
+
+ def __getslice__(self, *args):
+ return self.__getitem__(slice(*args))
+
+ def __setitem__(self, ind, val):
+ nInd = self._interpretIndexes(ind)
+ try:
+ self._data[nInd] = val
+ except:
+ print(self, nInd, val)
+ raise
+
+ def __getattr__(self, attr):
+ if attr in self.wrapMethods:
+ return getattr(self._data, attr)
+ else:
+ raise AttributeError(attr)
+ #return lambda *args, **kwargs: MetaArray(getattr(a.view(ndarray), attr)(*args, **kwargs)
+
+ def __eq__(self, b):
+ return self._binop('__eq__', b)
+
+ def __ne__(self, b):
+ return self._binop('__ne__', b)
+ #if isinstance(b, MetaArray):
+ #b = b.asarray()
+ #return self.asarray() != b
+
+ def __sub__(self, b):
+ return self._binop('__sub__', b)
+ #if isinstance(b, MetaArray):
+ #b = b.asarray()
+ #return MetaArray(self.asarray() - b, info=self.infoCopy())
+
+ def __add__(self, b):
+ return self._binop('__add__', b)
+
+ def __mul__(self, b):
+ return self._binop('__mul__', b)
+
+ def __div__(self, b):
+ return self._binop('__div__', b)
+
+ def _binop(self, op, b):
+ if isinstance(b, MetaArray):
+ b = b.asarray()
+ a = self.asarray()
+ c = getattr(a, op)(b)
+ if c.shape != a.shape:
+ raise Exception("Binary operators with MetaArray must return an array of the same shape (this shape is %s, result shape was %s)" % (a.shape, c.shape))
+ return MetaArray(c, info=self.infoCopy())
+
+ def asarray(self):
+ if isinstance(self._data, np.ndarray):
+ return self._data
+ else:
+ return np.array(self._data)
+
+ def __array__(self):
+ ## supports np.array(metaarray_instance)
+ return self.asarray()
+
+ def view(self, typ):
+ ## deprecated; kept for backward compatibility
+ if typ is np.ndarray:
+ return self.asarray()
+ else:
+ raise Exception('invalid view type: %s' % str(typ))
+
+ def axisValues(self, axis):
+ """Return the list of values for an axis"""
+ ax = self._interpretAxis(axis)
+ if 'values' in self._info[ax]:
+ return self._info[ax]['values']
+ else:
+ raise Exception('Array axis %s (%d) has no associated values.' % (str(axis), ax))
+
+ def xvals(self, axis):
+ """Synonym for axisValues()"""
+ return self.axisValues(axis)
+
+ def axisHasValues(self, axis):
+ ax = self._interpretAxis(axis)
+ return 'values' in self._info[ax]
+
+ def axisHasColumns(self, axis):
+ ax = self._interpretAxis(axis)
+ return 'cols' in self._info[ax]
+
+ def axisUnits(self, axis):
+ """Return the units for axis"""
+ ax = self._info[self._interpretAxis(axis)]
+ if 'units' in ax:
+ return ax['units']
+
+ def hasColumn(self, axis, col):
+ ax = self._info[self._interpretAxis(axis)]
+ if 'cols' in ax:
+ for c in ax['cols']:
+ if c['name'] == col:
+ return True
+ return False
+
+ def listColumns(self, axis=None):
+ """Return a list of column names for axis. If axis is not specified, then return a dict of {axisName: (column names), ...}."""
+ if axis is None:
+ ret = {}
+ for i in range(self.ndim):
+ if 'cols' in self._info[i]:
+ cols = [c['name'] for c in self._info[i]['cols']]
+ else:
+ cols = []
+ ret[self.axisName(i)] = cols
+ return ret
+ else:
+ axis = self._interpretAxis(axis)
+ return [c['name'] for c in self._info[axis]['cols']]
+
+ def columnName(self, axis, col):
+ ax = self._info[self._interpretAxis(axis)]
+ return ax['cols'][col]['name']
+
+ def axisName(self, n):
+ return self._info[n].get('name', n)
+
+ def columnUnits(self, axis, column):
+ """Return the units for column in axis"""
+ ax = self._info[self._interpretAxis(axis)]
+ if 'cols' in ax:
+ for c in ax['cols']:
+ if c['name'] == column:
+ return c['units']
+ raise Exception("Axis %s has no column named %s" % (str(axis), str(column)))
+ else:
+ raise Exception("Axis %s has no column definitions" % str(axis))
+
+ def rowsort(self, axis, key=0):
+ """Return this object with all records sorted along axis using key as the index to the values to compare. Does not yet modify meta info."""
+ ## make sure _info is copied locally before modifying it!
+
+ keyList = self[key]
+ order = keyList.argsort()
+ if type(axis) == int:
+ ind = [slice(None)]*axis
+ ind.append(order)
+ elif isinstance(axis, basestring):
+ ind = (slice(axis, order),)
+ return self[tuple(ind)]
+
+ def append(self, val, axis):
+ """Return this object with val appended along axis. Does not yet combine meta info."""
+ ## make sure _info is copied locally before modifying it!
+
+ s = list(self.shape)
+ axis = self._interpretAxis(axis)
+ s[axis] += 1
+ n = MetaArray(tuple(s), info=self._info, dtype=self.dtype)
+ ind = [slice(None)]*self.ndim
+ ind[axis] = slice(None,-1)
+ n[tuple(ind)] = self
+ ind[axis] = -1
+ n[tuple(ind)] = val
+ return n
+
+ def extend(self, val, axis):
+ """Return the concatenation along axis of this object and val. Does not yet combine meta info."""
+ ## make sure _info is copied locally before modifying it!
+
+ axis = self._interpretAxis(axis)
+ return MetaArray(np.concatenate(self, val, axis), info=self._info)
+
+ def infoCopy(self, axis=None):
+ """Return a deep copy of the axis meta info for this object"""
+ if axis is None:
+ return copy.deepcopy(self._info)
+ else:
+ return copy.deepcopy(self._info[self._interpretAxis(axis)])
+
+ def copy(self):
+ return MetaArray(self._data.copy(), info=self.infoCopy())
+
+
+ def _interpretIndexes(self, ind):
+ #print "interpret", ind
+ if not isinstance(ind, tuple):
+ ## a list of slices should be interpreted as a tuple of slices.
+ if isinstance(ind, list) and len(ind) > 0 and isinstance(ind[0], slice):
+ ind = tuple(ind)
+ ## everything else can just be converted to a length-1 tuple
+ else:
+ ind = (ind,)
+
+ nInd = [slice(None)]*self.ndim
+ numOk = True ## Named indices not started yet; numbered sill ok
+ for i in range(0,len(ind)):
+ (axis, index, isNamed) = self._interpretIndex(ind[i], i, numOk)
+ #try:
+ nInd[axis] = index
+ #except:
+ #print "ndim:", self.ndim
+ #print "axis:", axis
+ #print "index spec:", ind[i]
+ #print "index num:", index
+ #raise
+ if isNamed:
+ numOk = False
+ return tuple(nInd)
+
+ def _interpretAxis(self, axis):
+ if isinstance(axis, basestring) or isinstance(axis, tuple):
+ return self._getAxis(axis)
+ else:
+ return axis
+
+ def _interpretIndex(self, ind, pos, numOk):
+ #print "Interpreting index", ind, pos, numOk
+
+ ## should probably check for int first to speed things up..
+ if type(ind) is int:
+ if not numOk:
+ raise Exception("string and integer indexes may not follow named indexes")
+ #print " normal numerical index"
+ return (pos, ind, False)
+ if MetaArray.isNameType(ind):
+ if not numOk:
+ raise Exception("string and integer indexes may not follow named indexes")
+ #print " String index, column is ", self._getIndex(pos, ind)
+ return (pos, self._getIndex(pos, ind), False)
+ elif type(ind) is slice:
+ #print " Slice index"
+ if MetaArray.isNameType(ind.start) or MetaArray.isNameType(ind.stop): ## Not an actual slice!
+ #print " ..not a real slice"
+ axis = self._interpretAxis(ind.start)
+ #print " axis is", axis
+
+ ## x[Axis:Column]
+ if MetaArray.isNameType(ind.stop):
+ #print " column name, column is ", self._getIndex(axis, ind.stop)
+ index = self._getIndex(axis, ind.stop)
+
+ ## x[Axis:min:max]
+ elif (isinstance(ind.stop, float) or isinstance(ind.step, float)) and ('values' in self._info[axis]):
+ #print " axis value range"
+ if ind.stop is None:
+ mask = self.xvals(axis) < ind.step
+ elif ind.step is None:
+ mask = self.xvals(axis) >= ind.stop
+ else:
+ mask = (self.xvals(axis) >= ind.stop) * (self.xvals(axis) < ind.step)
+ ##print "mask:", mask
+ index = mask
+
+ ## x[Axis:columnIndex]
+ elif isinstance(ind.stop, int) or isinstance(ind.step, int):
+ #print " normal slice after named axis"
+ if ind.step is None:
+ index = ind.stop
+ else:
+ index = slice(ind.stop, ind.step)
+
+ ## x[Axis: [list]]
+ elif type(ind.stop) is list:
+ #print " list of indexes from named axis"
+ index = []
+ for i in ind.stop:
+ if type(i) is int:
+ index.append(i)
+ elif MetaArray.isNameType(i):
+ index.append(self._getIndex(axis, i))
+ else:
+ ## unrecognized type, try just passing on to array
+ index = ind.stop
+ break
+
+ else:
+ #print " other type.. forward on to array for handling", type(ind.stop)
+ index = ind.stop
+ #print "Axis %s (%s) : %s" % (ind.start, str(axis), str(type(index)))
+ #if type(index) is np.ndarray:
+ #print " ", index.shape
+ return (axis, index, True)
+ else:
+ #print " Looks like a real slice, passing on to array"
+ return (pos, ind, False)
+ elif type(ind) is list:
+ #print " List index., interpreting each element individually"
+ indList = [self._interpretIndex(i, pos, numOk)[1] for i in ind]
+ return (pos, indList, False)
+ else:
+ if not numOk:
+ raise Exception("string and integer indexes may not follow named indexes")
+ #print " normal numerical index"
+ return (pos, ind, False)
+
+ def _getAxis(self, name):
+ for i in range(0, len(self._info)):
+ axis = self._info[i]
+ if 'name' in axis and axis['name'] == name:
+ return i
+ raise Exception("No axis named %s.\n info=%s" % (name, self._info))
+
+ def _getIndex(self, axis, name):
+ ax = self._info[axis]
+ if ax is not None and 'cols' in ax:
+ for i in range(0, len(ax['cols'])):
+ if 'name' in ax['cols'][i] and ax['cols'][i]['name'] == name:
+ return i
+ raise Exception("Axis %d has no column named %s.\n info=%s" % (axis, name, self._info))
+
+ def _axisCopy(self, i):
+ return copy.deepcopy(self._info[i])
+
+ def _axisSlice(self, i, cols):
+ #print "axisSlice", i, cols
+ if 'cols' in self._info[i] or 'values' in self._info[i]:
+ ax = self._axisCopy(i)
+ if 'cols' in ax:
+ #print " slicing columns..", array(ax['cols']), cols
+ sl = np.array(ax['cols'])[cols]
+ if isinstance(sl, np.ndarray):
+ sl = list(sl)
+ ax['cols'] = sl
+ #print " result:", ax['cols']
+ if 'values' in ax:
+ ax['values'] = np.array(ax['values'])[cols]
+ else:
+ ax = self._info[i]
+ #print " ", ax
+ return ax
+
+ def prettyInfo(self):
+ s = ''
+ titles = []
+ maxl = 0
+ for i in range(len(self._info)-1):
+ ax = self._info[i]
+ axs = ''
+ if 'name' in ax:
+ axs += '"%s"' % str(ax['name'])
+ else:
+ axs += "%d" % i
+ if 'units' in ax:
+ axs += " (%s)" % str(ax['units'])
+ titles.append(axs)
+ if len(axs) > maxl:
+ maxl = len(axs)
+
+ for i in range(min(self.ndim, len(self._info)-1)):
+ ax = self._info[i]
+ axs = titles[i]
+ axs += '%s[%d] :' % (' ' * (maxl + 2 - len(axs)), self.shape[i])
+ if 'values' in ax:
+ v0 = ax['values'][0]
+ v1 = ax['values'][-1]
+ axs += " values: [%g ... %g] (step %g)" % (v0, v1, (v1-v0)/(self.shape[i]-1))
+ if 'cols' in ax:
+ axs += " columns: "
+ colstrs = []
+ for c in range(len(ax['cols'])):
+ col = ax['cols'][c]
+ cs = str(col.get('name', c))
+ if 'units' in col:
+ cs += " (%s)" % col['units']
+ colstrs.append(cs)
+ axs += '[' + ', '.join(colstrs) + ']'
+ s += axs + "\n"
+ s += str(self._info[-1])
+ return s
+
+ def __repr__(self):
+ return "%s\n-----------------------------------------------\n%s" % (self.view(np.ndarray).__repr__(), self.prettyInfo())
+
+ def __str__(self):
+ return self.__repr__()
+
+
+ def axisCollapsingFn(self, fn, axis=None, *args, **kargs):
+ #arr = self.view(np.ndarray)
+ fn = getattr(self._data, fn)
+ if axis is None:
+ return fn(axis, *args, **kargs)
+ else:
+ info = self.infoCopy()
+ axis = self._interpretAxis(axis)
+ info.pop(axis)
+ return MetaArray(fn(axis, *args, **kargs), info=info)
+
+ def mean(self, axis=None, *args, **kargs):
+ return self.axisCollapsingFn('mean', axis, *args, **kargs)
+
+
+ def min(self, axis=None, *args, **kargs):
+ return self.axisCollapsingFn('min', axis, *args, **kargs)
+
+ def max(self, axis=None, *args, **kargs):
+ return self.axisCollapsingFn('max', axis, *args, **kargs)
+
+ def transpose(self, *args):
+ if len(args) == 1 and hasattr(args[0], '__iter__'):
+ order = args[0]
+ else:
+ order = args
+
+ order = [self._interpretAxis(ax) for ax in order]
+ infoOrder = order + list(range(len(order), len(self._info)))
+ info = [self._info[i] for i in infoOrder]
+ order = order + list(range(len(order), self.ndim))
+
+ try:
+ if self._isHDF:
+ return MetaArray(np.array(self._data).transpose(order), info=info)
+ else:
+ return MetaArray(self._data.transpose(order), info=info)
+ except:
+ print(order)
+ raise
+
+ #### File I/O Routines
+ def readFile(self, filename, **kwargs):
+ """Load the data and meta info stored in *filename*
+ Different arguments are allowed depending on the type of file.
+ For HDF5 files:
+
+ *writable* (bool) if True, then any modifications to data in the array will be stored to disk.
+ *readAllData* (bool) if True, then all data in the array is immediately read from disk
+ and the file is closed (this is the default for files < 500MB). Otherwise, the file will
+ be left open and data will be read only as requested (this is
+ the default for files >= 500MB).
+
+
+ """
+ ## decide which read function to use
+ fd = open(filename, 'rb')
+ magic = fd.read(8)
+ if magic == '\x89HDF\r\n\x1a\n':
+ fd.close()
+ self._readHDF5(filename, **kwargs)
+ self._isHDF = True
+ else:
+ fd.seek(0)
+ meta = MetaArray._readMeta(fd)
+ if 'version' in meta:
+ ver = meta['version']
+ else:
+ ver = 1
+ rFuncName = '_readData%s' % str(ver)
+ if not hasattr(MetaArray, rFuncName):
+ raise Exception("This MetaArray library does not support array version '%s'" % ver)
+ rFunc = getattr(self, rFuncName)
+ rFunc(fd, meta, **kwargs)
+ self._isHDF = False
+
+ @staticmethod
+ def _readMeta(fd):
+ """Read meta array from the top of a file. Read lines until a blank line is reached.
+ This function should ideally work for ALL versions of MetaArray.
+ """
+ meta = ''
+ ## Read meta information until the first blank line
+ while True:
+ line = fd.readline().strip()
+ if line == '':
+ break
+ meta += line
+ ret = eval(meta)
+ #print ret
+ return ret
+
+ def _readData1(self, fd, meta, mmap=False):
+ ## Read array data from the file descriptor for MetaArray v1 files
+ ## read in axis values for any axis that specifies a length
+ frameSize = 1
+ for ax in meta['info']:
+ if 'values_len' in ax:
+ ax['values'] = np.fromstring(fd.read(ax['values_len']), dtype=ax['values_type'])
+ frameSize *= ax['values_len']
+ del ax['values_len']
+ del ax['values_type']
+ ## the remaining data is the actual array
+ if mmap:
+ subarr = np.memmap(fd, dtype=meta['type'], mode='r', shape=meta['shape'])
+ else:
+ subarr = np.fromstring(fd.read(), dtype=meta['type'])
+ subarr.shape = meta['shape']
+ self._info = meta['info']
+ self._data = subarr
+
+ def _readData2(self, fd, meta, mmap=False, subset=None):
+ ## read in axis values
+ dynAxis = None
+ frameSize = 1
+ ## read in axis values for any axis that specifies a length
+ for i in range(len(meta['info'])):
+ ax = meta['info'][i]
+ if 'values_len' in ax:
+ if ax['values_len'] == 'dynamic':
+ if dynAxis is not None:
+ raise Exception("MetaArray has more than one dynamic axis! (this is not allowed)")
+ dynAxis = i
+ else:
+ ax['values'] = np.fromstring(fd.read(ax['values_len']), dtype=ax['values_type'])
+ frameSize *= ax['values_len']
+ del ax['values_len']
+ del ax['values_type']
+
+ ## No axes are dynamic, just read the entire array in at once
+ if dynAxis is None:
+ #if rewriteDynamic is not None:
+ #raise Exception("")
+ if meta['type'] == 'object':
+ if mmap:
+ raise Exception('memmap not supported for arrays with dtype=object')
+ subarr = pickle.loads(fd.read())
+ else:
+ if mmap:
+ subarr = np.memmap(fd, dtype=meta['type'], mode='r', shape=meta['shape'])
+ else:
+ subarr = np.fromstring(fd.read(), dtype=meta['type'])
+ #subarr = subarr.view(subtype)
+ subarr.shape = meta['shape']
+ #subarr._info = meta['info']
+ ## One axis is dynamic, read in a frame at a time
+ else:
+ if mmap:
+ raise Exception('memmap not supported for non-contiguous arrays. Use rewriteContiguous() to convert.')
+ ax = meta['info'][dynAxis]
+ xVals = []
+ frames = []
+ frameShape = list(meta['shape'])
+ frameShape[dynAxis] = 1
+ frameSize = reduce(lambda a,b: a*b, frameShape)
+ n = 0
+ while True:
+ ## Extract one non-blank line
+ while True:
+ line = fd.readline()
+ if line != '\n':
+ break
+ if line == '':
+ break
+
+ ## evaluate line
+ inf = eval(line)
+
+ ## read data block
+ #print "read %d bytes as %s" % (inf['len'], meta['type'])
+ if meta['type'] == 'object':
+ data = pickle.loads(fd.read(inf['len']))
+ else:
+ data = np.fromstring(fd.read(inf['len']), dtype=meta['type'])
+
+ if data.size != frameSize * inf['numFrames']:
+ #print data.size, frameSize, inf['numFrames']
+ raise Exception("Wrong frame size in MetaArray file! (frame %d)" % n)
+
+ ## read in data block
+ shape = list(frameShape)
+ shape[dynAxis] = inf['numFrames']
+ data.shape = shape
+ if subset is not None:
+ dSlice = subset[dynAxis]
+ if dSlice.start is None:
+ dStart = 0
+ else:
+ dStart = max(0, dSlice.start - n)
+ if dSlice.stop is None:
+ dStop = data.shape[dynAxis]
+ else:
+ dStop = min(data.shape[dynAxis], dSlice.stop - n)
+ newSubset = list(subset[:])
+ newSubset[dynAxis] = slice(dStart, dStop)
+ if dStop > dStart:
+ #print n, data.shape, " => ", newSubset, data[tuple(newSubset)].shape
+ frames.append(data[tuple(newSubset)].copy())
+ else:
+ #data = data[subset].copy() ## what's this for??
+ frames.append(data)
+
+ n += inf['numFrames']
+ if 'xVals' in inf:
+ xVals.extend(inf['xVals'])
+ subarr = np.concatenate(frames, axis=dynAxis)
+ if len(xVals)> 0:
+ ax['values'] = np.array(xVals, dtype=ax['values_type'])
+ del ax['values_len']
+ del ax['values_type']
+ #subarr = subarr.view(subtype)
+ #subarr._info = meta['info']
+ self._info = meta['info']
+ self._data = subarr
+ #raise Exception() ## stress-testing
+ #return subarr
+
+ def _readHDF5(self, fileName, readAllData=None, writable=False, **kargs):
+ if 'close' in kargs and readAllData is None: ## for backward compatibility
+ readAllData = kargs['close']
+
+ if readAllData is True and writable is True:
+ raise Exception("Incompatible arguments: readAllData=True and writable=True")
+
+ if not HAVE_HDF5:
+ try:
+ assert writable==False
+ assert readAllData != False
+ self._readHDF5Remote(fileName)
+ return
+ except:
+ raise Exception("The file '%s' is HDF5-formatted, but the HDF5 library (h5py) was not found." % fileName)
+
+ ## by default, readAllData=True for files < 500MB
+ if readAllData is None:
+ size = os.stat(fileName).st_size
+ readAllData = (size < 500e6)
+
+ if writable is True:
+ mode = 'r+'
+ else:
+ mode = 'r'
+ f = h5py.File(fileName, mode)
+
+ ver = f.attrs['MetaArray']
+ if ver > MetaArray.version:
+ print("Warning: This file was written with MetaArray version %s, but you are using version %s. (Will attempt to read anyway)" % (str(ver), str(MetaArray.version)))
+ meta = MetaArray.readHDF5Meta(f['info'])
+ self._info = meta
+
+ if writable or not readAllData: ## read all data, convert to ndarray, close file
+ self._data = f['data']
+ self._openFile = f
+ else:
+ self._data = f['data'][:]
+ f.close()
+
+ def _readHDF5Remote(self, fileName):
+ ## Used to read HDF5 files via remote process.
+ ## This is needed in the case that HDF5 is not importable due to the use of python-dbg.
+ proc = getattr(MetaArray, '_hdf5Process', None)
+
+ if proc == False:
+ raise Exception('remote read failed')
+ if proc == None:
+ import pyqtgraph.multiprocess as mp
+ #print "new process"
+ proc = mp.Process(executable='/usr/bin/python')
+ proc.setProxyOptions(deferGetattr=True)
+ MetaArray._hdf5Process = proc
+ MetaArray._h5py_metaarray = proc._import('pyqtgraph.metaarray')
+ ma = MetaArray._h5py_metaarray.MetaArray(file=fileName)
+ self._data = ma.asarray()._getValue()
+ self._info = ma._info._getValue()
+ #print MetaArray._hdf5Process
+ #import inspect
+ #print MetaArray, id(MetaArray), inspect.getmodule(MetaArray)
+
+
+
+ @staticmethod
+ def mapHDF5Array(data, writable=False):
+ off = data.id.get_offset()
+ if writable:
+ mode = 'r+'
+ else:
+ mode = 'r'
+ if off is None:
+ raise Exception("This dataset uses chunked storage; it can not be memory-mapped. (store using mappable=True)")
+ return np.memmap(filename=data.file.filename, offset=off, dtype=data.dtype, shape=data.shape, mode=mode)
+
+
+
+
+ @staticmethod
+ def readHDF5Meta(root, mmap=False):
+ data = {}
+
+ ## Pull list of values from attributes and child objects
+ for k in root.attrs:
+ val = root.attrs[k]
+ if isinstance(val, basestring): ## strings need to be re-evaluated to their original types
+ try:
+ val = eval(val)
+ except:
+ raise Exception('Can not evaluate string: "%s"' % val)
+ data[k] = val
+ for k in root:
+ obj = root[k]
+ if isinstance(obj, h5py.highlevel.Group):
+ val = MetaArray.readHDF5Meta(obj)
+ elif isinstance(obj, h5py.highlevel.Dataset):
+ if mmap:
+ val = MetaArray.mapHDF5Array(obj)
+ else:
+ val = obj[:]
+ else:
+ raise Exception("Don't know what to do with type '%s'" % str(type(obj)))
+ data[k] = val
+
+ typ = root.attrs['_metaType_']
+ del data['_metaType_']
+
+ if typ == 'dict':
+ return data
+ elif typ == 'list' or typ == 'tuple':
+ d2 = [None]*len(data)
+ for k in data:
+ d2[int(k)] = data[k]
+ if typ == 'tuple':
+ d2 = tuple(d2)
+ return d2
+ else:
+ raise Exception("Don't understand metaType '%s'" % typ)
+
+
+ def write(self, fileName, **opts):
+ """Write this object to a file. The object can be restored by calling MetaArray(file=fileName)
+ opts:
+ appendAxis: the name (or index) of the appendable axis. Allows the array to grow.
+ compression: None, 'gzip' (good compression), 'lzf' (fast compression), etc.
+ chunks: bool or tuple specifying chunk shape
+ """
+
+ if USE_HDF5 and HAVE_HDF5:
+ return self.writeHDF5(fileName, **opts)
+ else:
+ return self.writeMa(fileName, **opts)
+
+ def writeMeta(self, fileName):
+ """Used to re-write meta info to the given file.
+ This feature is only available for HDF5 files."""
+ f = h5py.File(fileName, 'r+')
+ if f.attrs['MetaArray'] != MetaArray.version:
+ raise Exception("The file %s was created with a different version of MetaArray. Will not modify." % fileName)
+ del f['info']
+
+ self.writeHDF5Meta(f, 'info', self._info)
+ f.close()
+
+
+ def writeHDF5(self, fileName, **opts):
+ ## default options for writing datasets
+ dsOpts = {
+ 'compression': 'lzf',
+ 'chunks': True,
+ }
+
+ ## if there is an appendable axis, then we can guess the desired chunk shape (optimized for appending)
+ appAxis = opts.get('appendAxis', None)
+ if appAxis is not None:
+ appAxis = self._interpretAxis(appAxis)
+ cs = [min(100000, x) for x in self.shape]
+ cs[appAxis] = 1
+ dsOpts['chunks'] = tuple(cs)
+
+ ## if there are columns, then we can guess a different chunk shape
+ ## (read one column at a time)
+ else:
+ cs = [min(100000, x) for x in self.shape]
+ for i in range(self.ndim):
+ if 'cols' in self._info[i]:
+ cs[i] = 1
+ dsOpts['chunks'] = tuple(cs)
+
+ ## update options if they were passed in
+ for k in dsOpts:
+ if k in opts:
+ dsOpts[k] = opts[k]
+
+
+ ## If mappable is in options, it disables chunking/compression
+ if opts.get('mappable', False):
+ dsOpts = {
+ 'chunks': None,
+ 'compression': None
+ }
+
+
+ ## set maximum shape to allow expansion along appendAxis
+ append = False
+ if appAxis is not None:
+ maxShape = list(self.shape)
+ ax = self._interpretAxis(appAxis)
+ maxShape[ax] = None
+ if os.path.exists(fileName):
+ append = True
+ dsOpts['maxshape'] = tuple(maxShape)
+ else:
+ dsOpts['maxshape'] = None
+
+ if append:
+ f = h5py.File(fileName, 'r+')
+ if f.attrs['MetaArray'] != MetaArray.version:
+ raise Exception("The file %s was created with a different version of MetaArray. Will not modify." % fileName)
+
+ ## resize data and write in new values
+ data = f['data']
+ shape = list(data.shape)
+ shape[ax] += self.shape[ax]
+ data.resize(tuple(shape))
+ sl = [slice(None)] * len(data.shape)
+ sl[ax] = slice(-self.shape[ax], None)
+ data[tuple(sl)] = self.view(np.ndarray)
+
+ ## add axis values if they are present.
+ axInfo = f['info'][str(ax)]
+ if 'values' in axInfo:
+ v = axInfo['values']
+ v2 = self._info[ax]['values']
+ shape = list(v.shape)
+ shape[0] += v2.shape[0]
+ v.resize(shape)
+ v[-v2.shape[0]:] = v2
+ f.close()
+ else:
+ f = h5py.File(fileName, 'w')
+ f.attrs['MetaArray'] = MetaArray.version
+ #print dsOpts
+ f.create_dataset('data', data=self.view(np.ndarray), **dsOpts)
+
+ ## dsOpts is used when storing meta data whenever an array is encountered
+ ## however, 'chunks' will no longer be valid for these arrays if it specifies a chunk shape.
+ ## 'maxshape' is right-out.
+ if isinstance(dsOpts['chunks'], tuple):
+ dsOpts['chunks'] = True
+ if 'maxshape' in dsOpts:
+ del dsOpts['maxshape']
+ self.writeHDF5Meta(f, 'info', self._info, **dsOpts)
+ f.close()
+
+ def writeHDF5Meta(self, root, name, data, **dsOpts):
+ if isinstance(data, np.ndarray):
+ dsOpts['maxshape'] = (None,) + data.shape[1:]
+ root.create_dataset(name, data=data, **dsOpts)
+ elif isinstance(data, list) or isinstance(data, tuple):
+ gr = root.create_group(name)
+ if isinstance(data, list):
+ gr.attrs['_metaType_'] = 'list'
+ else:
+ gr.attrs['_metaType_'] = 'tuple'
+ #n = int(np.log10(len(data))) + 1
+ for i in range(len(data)):
+ self.writeHDF5Meta(gr, str(i), data[i], **dsOpts)
+ elif isinstance(data, dict):
+ gr = root.create_group(name)
+ gr.attrs['_metaType_'] = 'dict'
+ for k, v in data.items():
+ self.writeHDF5Meta(gr, k, v, **dsOpts)
+ elif isinstance(data, int) or isinstance(data, float) or isinstance(data, np.integer) or isinstance(data, np.floating):
+ root.attrs[name] = data
+ else:
+ try: ## strings, bools, None are stored as repr() strings
+ root.attrs[name] = repr(data)
+ except:
+ print("Can not store meta data of type '%s' in HDF5. (key is '%s')" % (str(type(data)), str(name)))
+ raise
+
+
+ def writeMa(self, fileName, appendAxis=None, newFile=False):
+ """Write an old-style .ma file"""
+ meta = {'shape':self.shape, 'type':str(self.dtype), 'info':self.infoCopy(), 'version':MetaArray.version}
+ axstrs = []
+
+ ## copy out axis values for dynamic axis if requested
+ if appendAxis is not None:
+ if MetaArray.isNameType(appendAxis):
+ appendAxis = self._interpretAxis(appendAxis)
+
+
+ ax = meta['info'][appendAxis]
+ ax['values_len'] = 'dynamic'
+ if 'values' in ax:
+ ax['values_type'] = str(ax['values'].dtype)
+ dynXVals = ax['values']
+ del ax['values']
+ else:
+ dynXVals = None
+
+ ## Generate axis data string, modify axis info so we know how to read it back in later
+ for ax in meta['info']:
+ if 'values' in ax:
+ axstrs.append(ax['values'].tostring())
+ ax['values_len'] = len(axstrs[-1])
+ ax['values_type'] = str(ax['values'].dtype)
+ del ax['values']
+
+ ## Decide whether to output the meta block for a new file
+ if not newFile:
+ ## If the file does not exist or its size is 0, then we must write the header
+ newFile = (not os.path.exists(fileName)) or (os.stat(fileName).st_size == 0)
+
+ ## write data to file
+ if appendAxis is None or newFile:
+ fd = open(fileName, 'wb')
+ fd.write(str(meta) + '\n\n')
+ for ax in axstrs:
+ fd.write(ax)
+ else:
+ fd = open(fileName, 'ab')
+
+ if self.dtype != object:
+ dataStr = self.view(np.ndarray).tostring()
+ else:
+ dataStr = pickle.dumps(self.view(np.ndarray))
+ #print self.size, len(dataStr), self.dtype
+ if appendAxis is not None:
+ frameInfo = {'len':len(dataStr), 'numFrames':self.shape[appendAxis]}
+ if dynXVals is not None:
+ frameInfo['xVals'] = list(dynXVals)
+ fd.write('\n'+str(frameInfo)+'\n')
+ fd.write(dataStr)
+ fd.close()
+
+ def writeCsv(self, fileName=None):
+ """Write 2D array to CSV file or return the string if no filename is given"""
+ if self.ndim > 2:
+ raise Exception("CSV Export is only for 2D arrays")
+ if fileName is not None:
+ file = open(fileName, 'w')
+ ret = ''
+ if 'cols' in self._info[0]:
+ s = ','.join([x['name'] for x in self._info[0]['cols']]) + '\n'
+ if fileName is not None:
+ file.write(s)
+ else:
+ ret += s
+ for row in range(0, self.shape[1]):
+ s = ','.join(["%g" % x for x in self[:, row]]) + '\n'
+ if fileName is not None:
+ file.write(s)
+ else:
+ ret += s
+ if fileName is not None:
+ file.close()
+ else:
+ return ret
+
+
+
+#class H5MetaList():
+
+
+#def rewriteContiguous(fileName, newName):
+ #"""Rewrite a dynamic array file as contiguous"""
+ #def _readData2(fd, meta, subtype, mmap):
+ ### read in axis values
+ #dynAxis = None
+ #frameSize = 1
+ ### read in axis values for any axis that specifies a length
+ #for i in range(len(meta['info'])):
+ #ax = meta['info'][i]
+ #if ax.has_key('values_len'):
+ #if ax['values_len'] == 'dynamic':
+ #if dynAxis is not None:
+ #raise Exception("MetaArray has more than one dynamic axis! (this is not allowed)")
+ #dynAxis = i
+ #else:
+ #ax['values'] = fromstring(fd.read(ax['values_len']), dtype=ax['values_type'])
+ #frameSize *= ax['values_len']
+ #del ax['values_len']
+ #del ax['values_type']
+
+ ### No axes are dynamic, just read the entire array in at once
+ #if dynAxis is None:
+ #raise Exception('Array has no dynamic axes.')
+ ### One axis is dynamic, read in a frame at a time
+ #else:
+ #if mmap:
+ #raise Exception('memmap not supported for non-contiguous arrays. Use rewriteContiguous() to convert.')
+ #ax = meta['info'][dynAxis]
+ #xVals = []
+ #frames = []
+ #frameShape = list(meta['shape'])
+ #frameShape[dynAxis] = 1
+ #frameSize = reduce(lambda a,b: a*b, frameShape)
+ #n = 0
+ #while True:
+ ### Extract one non-blank line
+ #while True:
+ #line = fd.readline()
+ #if line != '\n':
+ #break
+ #if line == '':
+ #break
+
+ ### evaluate line
+ #inf = eval(line)
+
+ ### read data block
+ ##print "read %d bytes as %s" % (inf['len'], meta['type'])
+ #if meta['type'] == 'object':
+ #data = pickle.loads(fd.read(inf['len']))
+ #else:
+ #data = fromstring(fd.read(inf['len']), dtype=meta['type'])
+
+ #if data.size != frameSize * inf['numFrames']:
+ ##print data.size, frameSize, inf['numFrames']
+ #raise Exception("Wrong frame size in MetaArray file! (frame %d)" % n)
+
+ ### read in data block
+ #shape = list(frameShape)
+ #shape[dynAxis] = inf['numFrames']
+ #data.shape = shape
+ #frames.append(data)
+
+ #n += inf['numFrames']
+ #if 'xVals' in inf:
+ #xVals.extend(inf['xVals'])
+ #subarr = np.concatenate(frames, axis=dynAxis)
+ #if len(xVals)> 0:
+ #ax['values'] = array(xVals, dtype=ax['values_type'])
+ #del ax['values_len']
+ #del ax['values_type']
+ #subarr = subarr.view(subtype)
+ #subarr._info = meta['info']
+ #return subarr
+
+
+
+
+
+if __name__ == '__main__':
+ ## Create an array with every option possible
+
+ arr = np.zeros((2, 5, 3, 5), dtype=int)
+ for i in range(arr.shape[0]):
+ for j in range(arr.shape[1]):
+ for k in range(arr.shape[2]):
+ for l in range(arr.shape[3]):
+ arr[i,j,k,l] = (i+1)*1000 + (j+1)*100 + (k+1)*10 + (l+1)
+
+ info = [
+ axis('Axis1'),
+ axis('Axis2', values=[1,2,3,4,5]),
+ axis('Axis3', cols=[
+ ('Ax3Col1'),
+ ('Ax3Col2', 'mV', 'Axis3 Column2'),
+ (('Ax3','Col3'), 'A', 'Axis3 Column3')]),
+ {'name': 'Axis4', 'values': np.array([1.1, 1.2, 1.3, 1.4, 1.5]), 'units': 's'},
+ {'extra': 'info'}
+ ]
+
+ ma = MetaArray(arr, info=info)
+
+ print("==== Original Array =======")
+ print(ma)
+ print("\n\n")
+
+ #### Tests follow:
+
+
+ #### Index/slice tests: check that all values and meta info are correct after slice
+ print("\n -- normal integer indexing\n")
+
+ print("\n ma[1]")
+ print(ma[1])
+
+ print("\n ma[1, 2:4]")
+ print(ma[1, 2:4])
+
+ print("\n ma[1, 1:5:2]")
+ print(ma[1, 1:5:2])
+
+ print("\n -- named axis indexing\n")
+
+ print("\n ma['Axis2':3]")
+ print(ma['Axis2':3])
+
+ print("\n ma['Axis2':3:5]")
+ print(ma['Axis2':3:5])
+
+ print("\n ma[1, 'Axis2':3]")
+ print(ma[1, 'Axis2':3])
+
+ print("\n ma[:, 'Axis2':3]")
+ print(ma[:, 'Axis2':3])
+
+ print("\n ma['Axis2':3, 'Axis4':0:2]")
+ print(ma['Axis2':3, 'Axis4':0:2])
+
+
+ print("\n -- column name indexing\n")
+
+ print("\n ma['Axis3':'Ax3Col1']")
+ print(ma['Axis3':'Ax3Col1'])
+
+ print("\n ma['Axis3':('Ax3','Col3')]")
+ print(ma['Axis3':('Ax3','Col3')])
+
+ print("\n ma[:, :, 'Ax3Col2']")
+ print(ma[:, :, 'Ax3Col2'])
+
+ print("\n ma[:, :, ('Ax3','Col3')]")
+ print(ma[:, :, ('Ax3','Col3')])
+
+
+ print("\n -- axis value range indexing\n")
+
+ print("\n ma['Axis2':1.5:4.5]")
+ print(ma['Axis2':1.5:4.5])
+
+ print("\n ma['Axis4':1.15:1.45]")
+ print(ma['Axis4':1.15:1.45])
+
+ print("\n ma['Axis4':1.15:1.25]")
+ print(ma['Axis4':1.15:1.25])
+
+
+
+ print("\n -- list indexing\n")
+
+ print("\n ma[:, [0,2,4]]")
+ print(ma[:, [0,2,4]])
+
+ print("\n ma['Axis4':[0,2,4]]")
+ print(ma['Axis4':[0,2,4]])
+
+ print("\n ma['Axis3':[0, ('Ax3','Col3')]]")
+ print(ma['Axis3':[0, ('Ax3','Col3')]])
+
+
+
+ print("\n -- boolean indexing\n")
+
+ print("\n ma[:, array([True, True, False, True, False])]")
+ print(ma[:, np.array([True, True, False, True, False])])
+
+ print("\n ma['Axis4':array([True, False, False, False])]")
+ print(ma['Axis4':np.array([True, False, False, False])])
+
+
+
+
+
+ #### Array operations
+ # - Concatenate
+ # - Append
+ # - Extend
+ # - Rowsort
+
+
+
+
+ #### File I/O tests
+
+ print("\n================ File I/O Tests ===================\n")
+ import tempfile
+ tf = tempfile.mktemp()
+ tf = 'test.ma'
+ # write whole array
+
+ print("\n -- write/read test")
+ ma.write(tf)
+ ma2 = MetaArray(file=tf)
+
+ #print ma2
+ print("\nArrays are equivalent:", (ma == ma2).all())
+ #print "Meta info is equivalent:", ma.infoCopy() == ma2.infoCopy()
+ os.remove(tf)
+
+ # CSV write
+
+ # append mode
+
+
+ print("\n================append test (%s)===============" % tf)
+ ma['Axis2':0:2].write(tf, appendAxis='Axis2')
+ for i in range(2,ma.shape[1]):
+ ma['Axis2':[i]].write(tf, appendAxis='Axis2')
+
+ ma2 = MetaArray(file=tf)
+
+ #print ma2
+ print("\nArrays are equivalent:", (ma == ma2).all())
+ #print "Meta info is equivalent:", ma.infoCopy() == ma2.infoCopy()
+
+ os.remove(tf)
+
+
+
+ ## memmap test
+ print("\n==========Memmap test============")
+ ma.write(tf, mappable=True)
+ ma2 = MetaArray(file=tf, mmap=True)
+ print("\nArrays are equivalent:", (ma == ma2).all())
+ os.remove(tf)
+
\ No newline at end of file
diff --git a/pyqtgraph/metaarray/__init__.py b/pyqtgraph/metaarray/__init__.py
new file mode 100644
index 00000000..a12f40d5
--- /dev/null
+++ b/pyqtgraph/metaarray/__init__.py
@@ -0,0 +1 @@
+from .MetaArray import *
diff --git a/license.txt b/pyqtgraph/metaarray/license.txt
similarity index 89%
rename from license.txt
rename to pyqtgraph/metaarray/license.txt
index 662ed4f4..7ef3e5e9 100644
--- a/license.txt
+++ b/pyqtgraph/metaarray/license.txt
@@ -1,6 +1,4 @@
-Copyright (c) 2011 University of North Carolina at Chapel Hill
-Luke Campagnola ('luke.campagnola@%s.com' % 'gmail')
-
+Copyright (c) 2010 Luke Campagnola ('luke.campagnola@%s.com' % 'gmail')
The MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
diff --git a/pyqtgraph/metaarray/readMeta.m b/pyqtgraph/metaarray/readMeta.m
new file mode 100644
index 00000000..f468a75d
--- /dev/null
+++ b/pyqtgraph/metaarray/readMeta.m
@@ -0,0 +1,86 @@
+function f = readMeta(file)
+info = hdf5info(file);
+f = readMetaRecursive(info.GroupHierarchy.Groups(1));
+end
+
+
+function f = readMetaRecursive(root)
+typ = 0;
+for i = 1:length(root.Attributes)
+ if strcmp(root.Attributes(i).Shortname, '_metaType_')
+ typ = root.Attributes(i).Value.Data;
+ break
+ end
+end
+if typ == 0
+ printf('group has no _metaType_')
+ typ = 'dict';
+end
+
+list = 0;
+if strcmp(typ, 'list') || strcmp(typ, 'tuple')
+ data = {};
+ list = 1;
+elseif strcmp(typ, 'dict')
+ data = struct();
+else
+ printf('Unrecognized meta type %s', typ);
+ data = struct();
+end
+
+for i = 1:length(root.Attributes)
+ name = root.Attributes(i).Shortname;
+ if strcmp(name, '_metaType_')
+ continue
+ end
+ val = root.Attributes(i).Value;
+ if isa(val, 'hdf5.h5string')
+ val = val.Data;
+ end
+ if list
+ ind = str2num(name)+1;
+ data{ind} = val;
+ else
+ data.(name) = val;
+ end
+end
+
+for i = 1:length(root.Datasets)
+ fullName = root.Datasets(i).Name;
+ name = stripName(fullName);
+ file = root.Datasets(i).Filename;
+ data2 = hdf5read(file, fullName);
+ if list
+ ind = str2num(name)+1;
+ data{ind} = data2;
+ else
+ data.(name) = data2;
+ end
+end
+
+for i = 1:length(root.Groups)
+ name = stripName(root.Groups(i).Name);
+ data2 = readMetaRecursive(root.Groups(i));
+ if list
+ ind = str2num(name)+1;
+ data{ind} = data2;
+ else
+ data.(name) = data2;
+ end
+end
+f = data;
+return;
+end
+
+
+function f = stripName(str)
+inds = strfind(str, '/');
+if isempty(inds)
+ f = str;
+else
+ f = str(inds(length(inds))+1:length(str));
+end
+end
+
+
+
diff --git a/pyqtgraph/multiprocess/__init__.py b/pyqtgraph/multiprocess/__init__.py
new file mode 100644
index 00000000..843b42a3
--- /dev/null
+++ b/pyqtgraph/multiprocess/__init__.py
@@ -0,0 +1,24 @@
+"""
+Multiprocessing utility library
+(parallelization done the way I like it)
+
+Luke Campagnola
+2012.06.10
+
+This library provides:
+
+ - simple mechanism for starting a new python interpreter process that can be controlled from the original process
+ (this allows, for example, displaying and manipulating plots in a remote process
+ while the parent process is free to do other work)
+ - proxy system that allows objects hosted in the remote process to be used as if they were local
+ - Qt signal connection between processes
+ - very simple in-line parallelization (fork only; does not work on windows) for number-crunching
+
+TODO:
+ allow remote processes to serve as rendering engines that pass pixmaps back to the parent process for display
+ (RemoteGraphicsView class)
+"""
+
+from .processes import *
+from .parallelizer import Parallelize, CanceledError
+from .remoteproxy import proxy
\ No newline at end of file
diff --git a/pyqtgraph/multiprocess/bootstrap.py b/pyqtgraph/multiprocess/bootstrap.py
new file mode 100644
index 00000000..e0d1c02c
--- /dev/null
+++ b/pyqtgraph/multiprocess/bootstrap.py
@@ -0,0 +1,16 @@
+"""For starting up remote processes"""
+import sys, pickle, os
+
+if __name__ == '__main__':
+ os.setpgrp() ## prevents signals (notably keyboard interrupt) being forwarded from parent to this process
+ name, port, authkey, targetStr, path = pickle.load(sys.stdin)
+ if path is not None:
+ ## rewrite sys.path without assigning a new object--no idea who already has a reference to the existing list.
+ while len(sys.path) > 0:
+ sys.path.pop()
+ sys.path.extend(path)
+ #import pyqtgraph
+ #import pyqtgraph.multiprocess.processes
+ target = pickle.loads(targetStr) ## unpickling the target should import everything we need
+ target(name, port, authkey)
+ sys.exit(0)
diff --git a/pyqtgraph/multiprocess/parallelizer.py b/pyqtgraph/multiprocess/parallelizer.py
new file mode 100644
index 00000000..0d5d6f5c
--- /dev/null
+++ b/pyqtgraph/multiprocess/parallelizer.py
@@ -0,0 +1,330 @@
+import os, sys, time, multiprocessing, re
+from processes import ForkedProcess
+from remoteproxy import ExitError
+
+class CanceledError(Exception):
+ """Raised when the progress dialog is canceled during a processing operation."""
+ pass
+
+class Parallelize(object):
+ """
+ Class for ultra-simple inline parallelization on multi-core CPUs
+
+ Example::
+
+ ## Here is the serial (single-process) task:
+
+ tasks = [1, 2, 4, 8]
+ results = []
+ for task in tasks:
+ result = processTask(task)
+ results.append(result)
+ print results
+
+
+ ## Here is the parallelized version:
+
+ tasks = [1, 2, 4, 8]
+ results = []
+ with Parallelize(tasks, workers=4, results=results) as tasker:
+ for task in tasker:
+ result = processTask(task)
+ tasker.results.append(result)
+ print results
+
+
+ The only major caveat is that *result* in the example above must be picklable,
+ since it is automatically sent via pipe back to the parent process.
+ """
+
+ def __init__(self, tasks=None, workers=None, block=True, progressDialog=None, randomReseed=True, **kwds):
+ """
+ =============== ===================================================================
+ Arguments:
+ tasks list of objects to be processed (Parallelize will determine how to
+ distribute the tasks). If unspecified, then each worker will receive
+ a single task with a unique id number.
+ workers number of worker processes or None to use number of CPUs in the
+ system
+ progressDialog optional dict of arguments for ProgressDialog
+ to update while tasks are processed
+ randomReseed If True, each forked process will reseed its random number generator
+ to ensure independent results. Works with the built-in random
+ and numpy.random.
+ kwds objects to be shared by proxy with child processes (they will
+ appear as attributes of the tasker)
+ =============== ===================================================================
+ """
+
+ ## Generate progress dialog.
+ ## Note that we want to avoid letting forked child processes play with progress dialogs..
+ self.showProgress = False
+ if progressDialog is not None:
+ self.showProgress = True
+ if isinstance(progressDialog, basestring):
+ progressDialog = {'labelText': progressDialog}
+ import pyqtgraph as pg
+ self.progressDlg = pg.ProgressDialog(**progressDialog)
+
+ if workers is None:
+ workers = self.suggestedWorkerCount()
+ if not hasattr(os, 'fork'):
+ workers = 1
+ self.workers = workers
+ if tasks is None:
+ tasks = range(workers)
+ self.tasks = list(tasks)
+ self.reseed = randomReseed
+ self.kwds = kwds.copy()
+ self.kwds['_taskStarted'] = self._taskStarted
+
+ def __enter__(self):
+ self.proc = None
+ if self.workers == 1:
+ return self.runSerial()
+ else:
+ return self.runParallel()
+
+ def __exit__(self, *exc_info):
+
+ if self.proc is not None: ## worker
+ exceptOccurred = exc_info[0] is not None ## hit an exception during processing.
+
+ try:
+ if exceptOccurred:
+ sys.excepthook(*exc_info)
+ finally:
+ #print os.getpid(), 'exit'
+ os._exit(1 if exceptOccurred else 0)
+
+ else: ## parent
+ if self.showProgress:
+ self.progressDlg.__exit__(None, None, None)
+
+ def runSerial(self):
+ if self.showProgress:
+ self.progressDlg.__enter__()
+ self.progressDlg.setMaximum(len(self.tasks))
+ self.progress = {os.getpid(): []}
+ return Tasker(self, None, self.tasks, self.kwds)
+
+
+ def runParallel(self):
+ self.childs = []
+
+ ## break up tasks into one set per worker
+ workers = self.workers
+ chunks = [[] for i in xrange(workers)]
+ i = 0
+ for i in range(len(self.tasks)):
+ chunks[i%workers].append(self.tasks[i])
+
+ ## fork and assign tasks to each worker
+ for i in range(workers):
+ proc = ForkedProcess(target=None, preProxy=self.kwds, randomReseed=self.reseed)
+ if not proc.isParent:
+ self.proc = proc
+ return Tasker(self, proc, chunks[i], proc.forkedProxies)
+ else:
+ self.childs.append(proc)
+
+ ## Keep track of the progress of each worker independently.
+ self.progress = {ch.childPid: [] for ch in self.childs}
+ ## for each child process, self.progress[pid] is a list
+ ## of task indexes. The last index is the task currently being
+ ## processed; all others are finished.
+
+
+ try:
+ if self.showProgress:
+ self.progressDlg.__enter__()
+ self.progressDlg.setMaximum(len(self.tasks))
+ ## process events from workers until all have exited.
+
+ activeChilds = self.childs[:]
+ self.exitCodes = []
+ pollInterval = 0.01
+ while len(activeChilds) > 0:
+ waitingChildren = 0
+ rem = []
+ for ch in activeChilds:
+ try:
+ n = ch.processRequests()
+ if n > 0:
+ waitingChildren += 1
+ except ExitError:
+ #print ch.childPid, 'process finished'
+ rem.append(ch)
+ if self.showProgress:
+ self.progressDlg += 1
+ #print "remove:", [ch.childPid for ch in rem]
+ for ch in rem:
+ activeChilds.remove(ch)
+ while True:
+ try:
+ pid, exitcode = os.waitpid(ch.childPid, 0)
+ self.exitCodes.append(exitcode)
+ break
+ except OSError as ex:
+ if ex.errno == 4: ## If we get this error, just try again
+ continue
+ #print "Ignored system call interruption"
+ else:
+ raise
+
+ #print [ch.childPid for ch in activeChilds]
+
+ if self.showProgress and self.progressDlg.wasCanceled():
+ for ch in activeChilds:
+ ch.kill()
+ raise CanceledError()
+
+ ## adjust polling interval--prefer to get exactly 1 event per poll cycle.
+ if waitingChildren > 1:
+ pollInterval *= 0.7
+ elif waitingChildren == 0:
+ pollInterval /= 0.7
+ pollInterval = max(min(pollInterval, 0.5), 0.0005) ## but keep it within reasonable limits
+
+ time.sleep(pollInterval)
+ finally:
+ if self.showProgress:
+ self.progressDlg.__exit__(None, None, None)
+ if len(self.exitCodes) < len(self.childs):
+ raise Exception("Parallelizer started %d processes but only received exit codes from %d." % (len(self.childs), len(self.exitCodes)))
+ for code in self.exitCodes:
+ if code != 0:
+ raise Exception("Error occurred in parallel-executed subprocess (console output may have more information).")
+ return [] ## no tasks for parent process.
+
+
+ @staticmethod
+ def suggestedWorkerCount():
+ if 'linux' in sys.platform:
+ ## I think we can do a little better here..
+ ## cpu_count does not consider that there is little extra benefit to using hyperthreaded cores.
+ try:
+ cores = {}
+ pid = None
+
+ for line in open('/proc/cpuinfo'):
+ m = re.match(r'physical id\s+:\s+(\d+)', line)
+ if m is not None:
+ pid = m.groups()[0]
+ m = re.match(r'cpu cores\s+:\s+(\d+)', line)
+ if m is not None:
+ cores[pid] = int(m.groups()[0])
+ return sum(cores.values())
+ except:
+ return multiprocessing.cpu_count()
+
+ else:
+ return multiprocessing.cpu_count()
+
+ def _taskStarted(self, pid, i, **kwds):
+ ## called remotely by tasker to indicate it has started working on task i
+ #print pid, 'reported starting task', i
+ if self.showProgress:
+ if len(self.progress[pid]) > 0:
+ self.progressDlg += 1
+ if pid == os.getpid(): ## single-worker process
+ if self.progressDlg.wasCanceled():
+ raise CanceledError()
+ self.progress[pid].append(i)
+
+
+class Tasker(object):
+ def __init__(self, parallelizer, process, tasks, kwds):
+ self.proc = process
+ self.par = parallelizer
+ self.tasks = tasks
+ for k, v in kwds.iteritems():
+ setattr(self, k, v)
+
+ def __iter__(self):
+ ## we could fix this up such that tasks are retrieved from the parent process one at a time..
+ for i, task in enumerate(self.tasks):
+ self.index = i
+ #print os.getpid(), 'starting task', i
+ self._taskStarted(os.getpid(), i, _callSync='off')
+ yield task
+ if self.proc is not None:
+ #print os.getpid(), 'no more tasks'
+ self.proc.close()
+
+ def process(self):
+ """
+ Process requests from parent.
+ Usually it is not necessary to call this unless you would like to
+ receive messages (such as exit requests) during an iteration.
+ """
+ if self.proc is not None:
+ self.proc.processRequests()
+
+ def numWorkers(self):
+ """
+ Return the number of parallel workers
+ """
+ return self.par.workers
+
+#class Parallelizer:
+ #"""
+ #Use::
+
+ #p = Parallelizer()
+ #with p(4) as i:
+ #p.finish(do_work(i))
+ #print p.results()
+
+ #"""
+ #def __init__(self):
+ #pass
+
+ #def __call__(self, n):
+ #self.replies = []
+ #self.conn = None ## indicates this is the parent process
+ #return Session(self, n)
+
+ #def finish(self, data):
+ #if self.conn is None:
+ #self.replies.append((self.i, data))
+ #else:
+ ##print "send", self.i, data
+ #self.conn.send((self.i, data))
+ #os._exit(0)
+
+ #def result(self):
+ #print self.replies
+
+#class Session:
+ #def __init__(self, par, n):
+ #self.par = par
+ #self.n = n
+
+ #def __enter__(self):
+ #self.childs = []
+ #for i in range(1, self.n):
+ #c1, c2 = multiprocessing.Pipe()
+ #pid = os.fork()
+ #if pid == 0: ## child
+ #self.par.i = i
+ #self.par.conn = c2
+ #self.childs = None
+ #c1.close()
+ #return i
+ #else:
+ #self.childs.append(c1)
+ #c2.close()
+ #self.par.i = 0
+ #return 0
+
+
+
+ #def __exit__(self, *exc_info):
+ #if exc_info[0] is not None:
+ #sys.excepthook(*exc_info)
+ #if self.childs is not None:
+ #self.par.replies.extend([conn.recv() for conn in self.childs])
+ #else:
+ #self.par.finish(None)
+
diff --git a/pyqtgraph/multiprocess/processes.py b/pyqtgraph/multiprocess/processes.py
new file mode 100644
index 00000000..a4769679
--- /dev/null
+++ b/pyqtgraph/multiprocess/processes.py
@@ -0,0 +1,337 @@
+from remoteproxy import RemoteEventHandler, ExitError, NoResultError, LocalObjectProxy, ObjectProxy
+import subprocess, atexit, os, sys, time, random, socket, signal
+import cPickle as pickle
+import multiprocessing.connection
+
+__all__ = ['Process', 'QtProcess', 'ForkedProcess', 'ExitError', 'NoResultError']
+
+class Process(RemoteEventHandler):
+ """
+ Bases: RemoteEventHandler
+
+ This class is used to spawn and control a new python interpreter.
+ It uses subprocess.Popen to start the new process and communicates with it
+ using multiprocessing.Connection objects over a network socket.
+
+ By default, the remote process will immediately enter an event-processing
+ loop that carries out requests send from the parent process.
+
+ Remote control works mainly through proxy objects::
+
+ proc = Process() ## starts process, returns handle
+ rsys = proc._import('sys') ## asks remote process to import 'sys', returns
+ ## a proxy which references the imported module
+ rsys.stdout.write('hello\n') ## This message will be printed from the remote
+ ## process. Proxy objects can usually be used
+ ## exactly as regular objects are.
+ proc.close() ## Request the remote process shut down
+
+ Requests made via proxy objects may be synchronous or asynchronous and may
+ return objects either by proxy or by value (if they are picklable). See
+ ProxyObject for more information.
+ """
+
+ def __init__(self, name=None, target=None, executable=None, copySysPath=True):
+ """
+ ============ =============================================================
+ Arguments:
+ name Optional name for this process used when printing messages
+ from the remote process.
+ target Optional function to call after starting remote process.
+ By default, this is startEventLoop(), which causes the remote
+ process to process requests from the parent process until it
+ is asked to quit. If you wish to specify a different target,
+ it must be picklable (bound methods are not).
+ copySysPath If true, copy the contents of sys.path to the remote process
+ ============ =============================================================
+
+ """
+ if target is None:
+ target = startEventLoop
+ if name is None:
+ name = str(self)
+ if executable is None:
+ executable = sys.executable
+
+ ## random authentication key
+ authkey = ''.join([chr(random.getrandbits(7)) for i in range(20)])
+
+ ## Listen for connection from remote process (and find free port number)
+ port = 10000
+ while True:
+ try:
+ l = multiprocessing.connection.Listener(('localhost', int(port)), authkey=authkey)
+ break
+ except socket.error as ex:
+ if ex.errno != 98:
+ raise
+ port += 1
+
+ ## start remote process, instruct it to run target function
+ sysPath = sys.path if copySysPath else None
+ bootstrap = os.path.abspath(os.path.join(os.path.dirname(__file__), 'bootstrap.py'))
+ self.proc = subprocess.Popen((executable, bootstrap), stdin=subprocess.PIPE)
+ targetStr = pickle.dumps(target) ## double-pickle target so that child has a chance to
+ ## set its sys.path properly before unpickling the target
+ pickle.dump((name+'_child', port, authkey, targetStr, sysPath), self.proc.stdin)
+ self.proc.stdin.close()
+
+ ## open connection for remote process
+ conn = l.accept()
+ RemoteEventHandler.__init__(self, conn, name+'_parent', pid=self.proc.pid)
+
+ atexit.register(self.join)
+
+ def join(self, timeout=10):
+ if self.proc.poll() is None:
+ self.close()
+ start = time.time()
+ while self.proc.poll() is None:
+ if timeout is not None and time.time() - start > timeout:
+ raise Exception('Timed out waiting for remote process to end.')
+ time.sleep(0.05)
+
+
+def startEventLoop(name, port, authkey):
+ conn = multiprocessing.connection.Client(('localhost', int(port)), authkey=authkey)
+ global HANDLER
+ HANDLER = RemoteEventHandler(conn, name, os.getppid())
+ while True:
+ try:
+ HANDLER.processRequests() # exception raised when the loop should exit
+ time.sleep(0.01)
+ except ExitError:
+ break
+
+
+class ForkedProcess(RemoteEventHandler):
+ """
+ ForkedProcess is a substitute for Process that uses os.fork() to generate a new process.
+ This is much faster than starting a completely new interpreter and child processes
+ automatically have a copy of the entire program state from before the fork. This
+ makes it an appealing approach when parallelizing expensive computations. (see
+ also Parallelizer)
+
+ However, fork() comes with some caveats and limitations:
+
+ - fork() is not available on Windows.
+ - It is not possible to have a QApplication in both parent and child process
+ (unless both QApplications are created _after_ the call to fork())
+ Attempts by the forked process to access Qt GUI elements created by the parent
+ will most likely cause the child to crash.
+ - Likewise, database connections are unlikely to function correctly in a forked child.
+ - Threads are not copied by fork(); the new process
+ will have only one thread that starts wherever fork() was called in the parent process.
+ - Forked processes are unceremoniously terminated when join() is called; they are not
+ given any opportunity to clean up. (This prevents them calling any cleanup code that
+ was only intended to be used by the parent process)
+ - Normally when fork()ing, open file handles are shared with the parent process,
+ which is potentially dangerous. ForkedProcess is careful to close all file handles
+ that are not explicitly needed--stdout, stderr, and a single pipe to the parent
+ process.
+
+ """
+
+ def __init__(self, name=None, target=0, preProxy=None, randomReseed=True):
+ """
+ When initializing, an optional target may be given.
+ If no target is specified, self.eventLoop will be used.
+ If None is given, no target will be called (and it will be up
+ to the caller to properly shut down the forked process)
+
+ preProxy may be a dict of values that will appear as ObjectProxy
+ in the remote process (but do not need to be sent explicitly since
+ they are available immediately before the call to fork().
+ Proxies will be availabe as self.proxies[name].
+
+ If randomReseed is True, the built-in random and numpy.random generators
+ will be reseeded in the child process.
+ """
+ self.hasJoined = False
+ if target == 0:
+ target = self.eventLoop
+ if name is None:
+ name = str(self)
+
+ conn, remoteConn = multiprocessing.Pipe()
+
+ proxyIDs = {}
+ if preProxy is not None:
+ for k, v in preProxy.iteritems():
+ proxyId = LocalObjectProxy.registerObject(v)
+ proxyIDs[k] = proxyId
+
+ pid = os.fork()
+ if pid == 0:
+ self.isParent = False
+ ## We are now in the forked process; need to be extra careful what we touch while here.
+ ## - no reading/writing file handles/sockets owned by parent process (stdout is ok)
+ ## - don't touch QtGui or QApplication at all; these are landmines.
+ ## - don't let the process call exit handlers
+
+ os.setpgrp() ## prevents signals (notably keyboard interrupt) being forwarded from parent to this process
+
+ ## close all file handles we do not want shared with parent
+ conn.close()
+ sys.stdin.close() ## otherwise we screw with interactive prompts.
+ fid = remoteConn.fileno()
+ os.closerange(3, fid)
+ os.closerange(fid+1, 4096) ## just guessing on the maximum descriptor count..
+
+ ## Override any custom exception hooks
+ def excepthook(*args):
+ import traceback
+ traceback.print_exception(*args)
+ sys.excepthook = excepthook
+
+ ## Make it harder to access QApplication instance
+ if 'PyQt4.QtGui' in sys.modules:
+ sys.modules['PyQt4.QtGui'].QApplication = None
+ sys.modules.pop('PyQt4.QtGui', None)
+ sys.modules.pop('PyQt4.QtCore', None)
+
+ ## sabotage atexit callbacks
+ atexit._exithandlers = []
+ atexit.register(lambda: os._exit(0))
+
+ if randomReseed:
+ if 'numpy.random' in sys.modules:
+ sys.modules['numpy.random'].seed(os.getpid() ^ int(time.time()*10000%10000))
+ if 'random' in sys.modules:
+ sys.modules['random'].seed(os.getpid() ^ int(time.time()*10000%10000))
+
+ RemoteEventHandler.__init__(self, remoteConn, name+'_child', pid=os.getppid())
+
+ ppid = os.getppid()
+ self.forkedProxies = {}
+ for name, proxyId in proxyIDs.iteritems():
+ self.forkedProxies[name] = ObjectProxy(ppid, proxyId=proxyId, typeStr=repr(preProxy[name]))
+
+ if target is not None:
+ target()
+
+ else:
+ self.isParent = True
+ self.childPid = pid
+ remoteConn.close()
+ RemoteEventHandler.handlers = {} ## don't want to inherit any of this from the parent.
+
+ RemoteEventHandler.__init__(self, conn, name+'_parent', pid=pid)
+ atexit.register(self.join)
+
+
+ def eventLoop(self):
+ while True:
+ try:
+ self.processRequests() # exception raised when the loop should exit
+ time.sleep(0.01)
+ except ExitError:
+ break
+ except:
+ print "Error occurred in forked event loop:"
+ sys.excepthook(*sys.exc_info())
+ sys.exit(0)
+
+ def join(self, timeout=10):
+ if self.hasJoined:
+ return
+ #os.kill(pid, 9)
+ try:
+ self.close(callSync='sync', timeout=timeout, noCleanup=True) ## ask the child process to exit and require that it return a confirmation.
+ os.waitpid(self.childPid, 0)
+ except IOError: ## probably remote process has already quit
+ pass
+ self.hasJoined = True
+
+ def kill(self):
+ """Immediately kill the forked remote process.
+ This is generally safe because forked processes are already
+ expected to _avoid_ any cleanup at exit."""
+ os.kill(self.childPid, signal.SIGKILL)
+ self.hasJoined = True
+
+
+
+##Special set of subclasses that implement a Qt event loop instead.
+
+class RemoteQtEventHandler(RemoteEventHandler):
+ def __init__(self, *args, **kwds):
+ RemoteEventHandler.__init__(self, *args, **kwds)
+
+ def startEventTimer(self):
+ from pyqtgraph.Qt import QtGui, QtCore
+ self.timer = QtCore.QTimer()
+ self.timer.timeout.connect(self.processRequests)
+ self.timer.start(10)
+
+ def processRequests(self):
+ try:
+ RemoteEventHandler.processRequests(self)
+ except ExitError:
+ from pyqtgraph.Qt import QtGui, QtCore
+ QtGui.QApplication.instance().quit()
+ self.timer.stop()
+ #raise
+
+class QtProcess(Process):
+ """
+ QtProcess is essentially the same as Process, with two major differences:
+
+ - The remote process starts by running startQtEventLoop() which creates a
+ QApplication in the remote process and uses a QTimer to trigger
+ remote event processing. This allows the remote process to have its own
+ GUI.
+ - A QTimer is also started on the parent process which polls for requests
+ from the child process. This allows Qt signals emitted within the child
+ process to invoke slots on the parent process and vice-versa.
+
+ Example::
+
+ proc = QtProcess()
+ rQtGui = proc._import('PyQt4.QtGui')
+ btn = rQtGui.QPushButton('button on child process')
+ btn.show()
+
+ def slot():
+ print 'slot invoked on parent process'
+ btn.clicked.connect(proxy(slot)) # be sure to send a proxy of the slot
+ """
+
+ def __init__(self, **kwds):
+ if 'target' not in kwds:
+ kwds['target'] = startQtEventLoop
+ Process.__init__(self, **kwds)
+ self.startEventTimer()
+
+ def startEventTimer(self):
+ from pyqtgraph.Qt import QtGui, QtCore ## avoid module-level import to keep bootstrap snappy.
+ self.timer = QtCore.QTimer()
+ app = QtGui.QApplication.instance()
+ if app is None:
+ raise Exception("Must create QApplication before starting QtProcess")
+ self.timer.timeout.connect(self.processRequests)
+ self.timer.start(10)
+
+ def processRequests(self):
+ try:
+ Process.processRequests(self)
+ except ExitError:
+ self.timer.stop()
+
+def startQtEventLoop(name, port, authkey):
+ conn = multiprocessing.connection.Client(('localhost', int(port)), authkey=authkey)
+ from pyqtgraph.Qt import QtGui, QtCore
+ #from PyQt4 import QtGui, QtCore
+ app = QtGui.QApplication.instance()
+ #print app
+ if app is None:
+ app = QtGui.QApplication([])
+ app.setQuitOnLastWindowClosed(False) ## generally we want the event loop to stay open
+ ## until it is explicitly closed by the parent process.
+
+ global HANDLER
+ HANDLER = RemoteQtEventHandler(conn, name, os.getppid())
+ HANDLER.startEventTimer()
+ app.exec_()
+
+
diff --git a/pyqtgraph/multiprocess/remoteproxy.py b/pyqtgraph/multiprocess/remoteproxy.py
new file mode 100644
index 00000000..f8da1bd7
--- /dev/null
+++ b/pyqtgraph/multiprocess/remoteproxy.py
@@ -0,0 +1,937 @@
+import os, __builtin__, time, sys, traceback, weakref
+import cPickle as pickle
+
+class ExitError(Exception):
+ pass
+
+class NoResultError(Exception):
+ pass
+
+
+class RemoteEventHandler(object):
+ """
+ This class handles communication between two processes. One instance is present on
+ each process and listens for communication from the other process. This enables
+ (amongst other things) ObjectProxy instances to look up their attributes and call
+ their methods.
+
+ This class is responsible for carrying out actions on behalf of the remote process.
+ Each instance holds one end of a Connection which allows python
+ objects to be passed between processes.
+
+ For the most common operations, see _import(), close(), and transfer()
+
+ To handle and respond to incoming requests, RemoteEventHandler requires that its
+ processRequests method is called repeatedly (this is usually handled by the Process
+ classes defined in multiprocess.processes).
+
+
+
+
+ """
+ handlers = {} ## maps {process ID : handler}. This allows unpickler to determine which process
+ ## an object proxy belongs to
+
+ def __init__(self, connection, name, pid):
+ self.conn = connection
+ self.name = name
+ self.results = {} ## reqId: (status, result); cache of request results received from the remote process
+ ## status is either 'result' or 'error'
+ ## if 'error', then result will be (exception, formatted exceprion)
+ ## where exception may be None if it could not be passed through the Connection.
+
+ self.proxies = {} ## maps {weakref(proxy): proxyId}; used to inform the remote process when a proxy has been deleted.
+
+ ## attributes that affect the behavior of the proxy.
+ ## See ObjectProxy._setProxyOptions for description
+ self.proxyOptions = {
+ 'callSync': 'sync', ## 'sync', 'async', 'off'
+ 'timeout': 10, ## float
+ 'returnType': 'auto', ## 'proxy', 'value', 'auto'
+ 'autoProxy': False, ## bool
+ 'deferGetattr': False, ## True, False
+ 'noProxyTypes': [ type(None), str, int, float, tuple, list, dict, LocalObjectProxy, ObjectProxy ],
+ }
+
+ self.nextRequestId = 0
+ self.exited = False
+
+ RemoteEventHandler.handlers[pid] = self ## register this handler as the one communicating with pid
+
+ @classmethod
+ def getHandler(cls, pid):
+ try:
+ return cls.handlers[pid]
+ except:
+ print pid, cls.handlers
+ raise
+
+ def getProxyOption(self, opt):
+ return self.proxyOptions[opt]
+
+ def setProxyOptions(self, **kwds):
+ """
+ Set the default behavior options for object proxies.
+ See ObjectProxy._setProxyOptions for more info.
+ """
+ self.proxyOptions.update(kwds)
+
+ def processRequests(self):
+ """Process all pending requests from the pipe, return
+ after no more events are immediately available. (non-blocking)
+ Returns the number of events processed.
+ """
+ if self.exited:
+ raise ExitError()
+
+ numProcessed = 0
+ while self.conn.poll():
+ try:
+ self.handleRequest()
+ numProcessed += 1
+ except ExitError:
+ self.exited = True
+ raise
+ except IOError as err:
+ if err.errno == 4: ## interrupted system call; try again
+ continue
+ else:
+ raise
+ except:
+ print "Error in process %s" % self.name
+ sys.excepthook(*sys.exc_info())
+
+ return numProcessed
+
+ def handleRequest(self):
+ """Handle a single request from the remote process.
+ Blocks until a request is available."""
+ result = None
+ try:
+ cmd, reqId, optStr = self.conn.recv() ## args, kwds are double-pickled to ensure this recv() call never fails
+ except EOFError:
+ ## remote process has shut down; end event loop
+ raise ExitError()
+ except IOError:
+ raise ExitError()
+ #print os.getpid(), "received request:", cmd, reqId
+
+
+ try:
+ if cmd == 'result' or cmd == 'error':
+ resultId = reqId
+ reqId = None ## prevents attempt to return information from this request
+ ## (this is already a return from a previous request)
+
+ opts = pickle.loads(optStr)
+ #print os.getpid(), "received request:", cmd, reqId, opts
+ returnType = opts.get('returnType', 'auto')
+
+ if cmd == 'result':
+ self.results[resultId] = ('result', opts['result'])
+ elif cmd == 'error':
+ self.results[resultId] = ('error', (opts['exception'], opts['excString']))
+ elif cmd == 'getObjAttr':
+ result = getattr(opts['obj'], opts['attr'])
+ elif cmd == 'callObj':
+ obj = opts['obj']
+ fnargs = opts['args']
+ fnkwds = opts['kwds']
+ if len(fnkwds) == 0: ## need to do this because some functions do not allow keyword arguments.
+ #print obj, fnargs
+ result = obj(*fnargs)
+ else:
+ result = obj(*fnargs, **fnkwds)
+ elif cmd == 'getObjValue':
+ result = opts['obj'] ## has already been unpickled into its local value
+ returnType = 'value'
+ elif cmd == 'transfer':
+ result = opts['obj']
+ returnType = 'proxy'
+ elif cmd == 'import':
+ name = opts['module']
+ fromlist = opts.get('fromlist', [])
+ mod = __builtin__.__import__(name, fromlist=fromlist)
+
+ if len(fromlist) == 0:
+ parts = name.lstrip('.').split('.')
+ result = mod
+ for part in parts[1:]:
+ result = getattr(result, part)
+ else:
+ result = map(mod.__getattr__, fromlist)
+
+ elif cmd == 'del':
+ LocalObjectProxy.releaseProxyId(opts['proxyId'])
+ #del self.proxiedObjects[opts['objId']]
+
+ elif cmd == 'close':
+ if reqId is not None:
+ result = True
+ returnType = 'value'
+
+ exc = None
+ except:
+ exc = sys.exc_info()
+
+
+
+ if reqId is not None:
+ if exc is None:
+ #print "returnValue:", returnValue, result
+ if returnType == 'auto':
+ result = self.autoProxy(result, self.proxyOptions['noProxyTypes'])
+ elif returnType == 'proxy':
+ result = LocalObjectProxy(result)
+
+ try:
+ self.replyResult(reqId, result)
+ except:
+ sys.excepthook(*sys.exc_info())
+ self.replyError(reqId, *sys.exc_info())
+ else:
+ self.replyError(reqId, *exc)
+
+ elif exc is not None:
+ sys.excepthook(*exc)
+
+ if cmd == 'close':
+ if opts.get('noCleanup', False) is True:
+ os._exit(0) ## exit immediately, do not pass GO, do not collect $200.
+ ## (more importantly, do not call any code that would
+ ## normally be invoked at exit)
+ else:
+ raise ExitError()
+
+
+
+ def replyResult(self, reqId, result):
+ self.send(request='result', reqId=reqId, callSync='off', opts=dict(result=result))
+
+ def replyError(self, reqId, *exc):
+ print "error:", self.name, reqId, exc[1]
+ excStr = traceback.format_exception(*exc)
+ try:
+ self.send(request='error', reqId=reqId, callSync='off', opts=dict(exception=exc[1], excString=excStr))
+ except:
+ self.send(request='error', reqId=reqId, callSync='off', opts=dict(exception=None, excString=excStr))
+
+ def send(self, request, opts=None, reqId=None, callSync='sync', timeout=10, returnType=None, **kwds):
+ """Send a request or return packet to the remote process.
+ Generally it is not necessary to call this method directly; it is for internal use.
+ (The docstring has information that is nevertheless useful to the programmer
+ as it describes the internal protocol used to communicate between processes)
+
+ ========== ====================================================================
+ Arguments:
+ request String describing the type of request being sent (see below)
+ reqId Integer uniquely linking a result back to the request that generated
+ it. (most requests leave this blank)
+ callSync 'sync': return the actual result of the request
+ 'async': return a Request object which can be used to look up the
+ result later
+ 'off': return no result
+ timeout Time in seconds to wait for a response when callSync=='sync'
+ opts Extra arguments sent to the remote process that determine the way
+ the request will be handled (see below)
+ returnType 'proxy', 'value', or 'auto'
+ ========== ====================================================================
+
+ Description of request strings and options allowed for each:
+
+ ============= ============= ========================================================
+ request option description
+ ------------- ------------- --------------------------------------------------------
+ getObjAttr Request the remote process return (proxy to) an
+ attribute of an object.
+ obj reference to object whose attribute should be
+ returned
+ attr string name of attribute to return
+ returnValue bool or 'auto' indicating whether to return a proxy or
+ the actual value.
+
+ callObj Request the remote process call a function or
+ method. If a request ID is given, then the call's
+ return value will be sent back (or information
+ about the error that occurred while running the
+ function)
+ obj the (reference to) object to call
+ args tuple of arguments to pass to callable
+ kwds dict of keyword arguments to pass to callable
+ returnValue bool or 'auto' indicating whether to return a proxy or
+ the actual value.
+
+ getObjValue Request the remote process return the value of
+ a proxied object (must be picklable)
+ obj reference to object whose value should be returned
+
+ transfer Copy an object to the remote process and request
+ it return a proxy for the new object.
+ obj The object to transfer.
+
+ import Request the remote process import new symbols
+ and return proxy(ies) to the imported objects
+ module the string name of the module to import
+ fromlist optional list of string names to import from module
+
+ del Inform the remote process that a proxy has been
+ released (thus the remote process may be able to
+ release the original object)
+ proxyId id of proxy which is no longer referenced by
+ remote host
+
+ close Instruct the remote process to stop its event loop
+ and exit. Optionally, this request may return a
+ confirmation.
+
+ result Inform the remote process that its request has
+ been processed
+ result return value of a request
+
+ error Inform the remote process that its request failed
+ exception the Exception that was raised (or None if the
+ exception could not be pickled)
+ excString string-formatted version of the exception and
+ traceback
+ ============= =====================================================================
+ """
+ #if len(kwds) > 0:
+ #print "Warning: send() ignored args:", kwds
+
+ if opts is None:
+ opts = {}
+
+ assert callSync in ['off', 'sync', 'async'], 'callSync must be one of "off", "sync", or "async"'
+ if reqId is None:
+ if callSync != 'off': ## requested return value; use the next available request ID
+ reqId = self.nextRequestId
+ self.nextRequestId += 1
+ else:
+ ## If requestId is provided, this _must_ be a response to a previously received request.
+ assert request in ['result', 'error']
+
+ if returnType is not None:
+ opts['returnType'] = returnType
+ #print "send", opts
+ ## double-pickle args to ensure that at least status and request ID get through
+ try:
+ optStr = pickle.dumps(opts)
+ except:
+ print "==== Error pickling this object: ===="
+ print opts
+ print "======================================="
+ raise
+
+ request = (request, reqId, optStr)
+ self.conn.send(request)
+
+ if callSync == 'off':
+ return
+
+ req = Request(self, reqId, description=str(request), timeout=timeout)
+ if callSync == 'async':
+ return req
+
+ if callSync == 'sync':
+ try:
+ return req.result()
+ except NoResultError:
+ return req
+
+ def close(self, callSync='off', noCleanup=False, **kwds):
+ self.send(request='close', opts=dict(noCleanup=noCleanup), callSync=callSync, **kwds)
+
+ def getResult(self, reqId):
+ ## raises NoResultError if the result is not available yet
+ #print self.results.keys(), os.getpid()
+ if reqId not in self.results:
+ #self.readPipe()
+ try:
+ self.processRequests()
+ except ExitError:
+ pass
+ if reqId not in self.results:
+ raise NoResultError()
+ status, result = self.results.pop(reqId)
+ if status == 'result':
+ return result
+ elif status == 'error':
+ #print ''.join(result)
+ exc, excStr = result
+ if exc is not None:
+ print "===== Remote process raised exception on request: ====="
+ print ''.join(excStr)
+ print "===== Local Traceback to request follows: ====="
+ raise exc
+ else:
+ print ''.join(excStr)
+ raise Exception("Error getting result. See above for exception from remote process.")
+
+ else:
+ raise Exception("Internal error.")
+
+ def _import(self, mod, **kwds):
+ """
+ Request the remote process import a module (or symbols from a module)
+ and return the proxied results. Uses built-in __import__() function, but
+ adds a bit more processing:
+
+ _import('module') => returns module
+ _import('module.submodule') => returns submodule
+ (note this differs from behavior of __import__)
+ _import('module', fromlist=[name1, name2, ...]) => returns [module.name1, module.name2, ...]
+ (this also differs from behavior of __import__)
+
+ """
+ return self.send(request='import', callSync='sync', opts=dict(module=mod), **kwds)
+
+ def getObjAttr(self, obj, attr, **kwds):
+ return self.send(request='getObjAttr', opts=dict(obj=obj, attr=attr), **kwds)
+
+ def getObjValue(self, obj, **kwds):
+ return self.send(request='getObjValue', opts=dict(obj=obj), **kwds)
+
+ def callObj(self, obj, args, kwds, **opts):
+ opts = opts.copy()
+ noProxyTypes = opts.pop('noProxyTypes', None)
+ if noProxyTypes is None:
+ noProxyTypes = self.proxyOptions['noProxyTypes']
+ autoProxy = opts.pop('autoProxy', self.proxyOptions['autoProxy'])
+
+ if autoProxy is True:
+ args = tuple([self.autoProxy(v, noProxyTypes) for v in args])
+ for k, v in kwds.iteritems():
+ opts[k] = self.autoProxy(v, noProxyTypes)
+
+ return self.send(request='callObj', opts=dict(obj=obj, args=args, kwds=kwds), **opts)
+
+ def registerProxy(self, proxy):
+ ref = weakref.ref(proxy, self.deleteProxy)
+ self.proxies[ref] = proxy._proxyId
+
+ def deleteProxy(self, ref):
+ proxyId = self.proxies.pop(ref)
+ try:
+ self.send(request='del', opts=dict(proxyId=proxyId), callSync='off')
+ except IOError: ## if remote process has closed down, there is no need to send delete requests anymore
+ pass
+
+ def transfer(self, obj, **kwds):
+ """
+ Transfer an object by value to the remote host (the object must be picklable)
+ and return a proxy for the new remote object.
+ """
+ return self.send(request='transfer', opts=dict(obj=obj), **kwds)
+
+ def autoProxy(self, obj, noProxyTypes):
+ ## Return object wrapped in LocalObjectProxy _unless_ its type is in noProxyTypes.
+ for typ in noProxyTypes:
+ if isinstance(obj, typ):
+ return obj
+ return LocalObjectProxy(obj)
+
+
+class Request(object):
+ """
+ Request objects are returned when calling an ObjectProxy in asynchronous mode
+ or if a synchronous call has timed out. Use hasResult() to ask whether
+ the result of the call has been returned yet. Use result() to get
+ the returned value.
+ """
+ def __init__(self, process, reqId, description=None, timeout=10):
+ self.proc = process
+ self.description = description
+ self.reqId = reqId
+ self.gotResult = False
+ self._result = None
+ self.timeout = timeout
+
+ def result(self, block=True, timeout=None):
+ """
+ Return the result for this request.
+
+ If block is True, wait until the result has arrived or *timeout* seconds passes.
+ If the timeout is reached, raise NoResultError. (use timeout=None to disable)
+ If block is False, raise NoResultError immediately if the result has not arrived yet.
+ """
+
+ if self.gotResult:
+ return self._result
+
+ if timeout is None:
+ timeout = self.timeout
+
+ if block:
+ start = time.time()
+ while not self.hasResult():
+ time.sleep(0.005)
+ if timeout >= 0 and time.time() - start > timeout:
+ print "Request timed out:", self.description
+ import traceback
+ traceback.print_stack()
+ raise NoResultError()
+ return self._result
+ else:
+ self._result = self.proc.getResult(self.reqId) ## raises NoResultError if result is not available yet
+ self.gotResult = True
+ return self._result
+
+ def hasResult(self):
+ """Returns True if the result for this request has arrived."""
+ try:
+ self.result(block=False)
+ except NoResultError:
+ pass
+
+ return self.gotResult
+
+class LocalObjectProxy(object):
+ """
+ Used for wrapping local objects to ensure that they are send by proxy to a remote host.
+ Note that 'proxy' is just a shorter alias for LocalObjectProxy.
+
+ For example::
+
+ data = [1,2,3,4,5]
+ remotePlot.plot(data) ## by default, lists are pickled and sent by value
+ remotePlot.plot(proxy(data)) ## force the object to be sent by proxy
+
+ """
+ nextProxyId = 0
+ proxiedObjects = {} ## maps {proxyId: object}
+
+
+ @classmethod
+ def registerObject(cls, obj):
+ ## assign it a unique ID so we can keep a reference to the local object
+
+ pid = cls.nextProxyId
+ cls.nextProxyId += 1
+ cls.proxiedObjects[pid] = obj
+ #print "register:", cls.proxiedObjects
+ return pid
+
+ @classmethod
+ def lookupProxyId(cls, pid):
+ return cls.proxiedObjects[pid]
+
+ @classmethod
+ def releaseProxyId(cls, pid):
+ del cls.proxiedObjects[pid]
+ #print "release:", cls.proxiedObjects
+
+ def __init__(self, obj, **opts):
+ """
+ Create a 'local' proxy object that, when sent to a remote host,
+ will appear as a normal ObjectProxy to *obj*.
+ Any extra keyword arguments are passed to proxy._setProxyOptions()
+ on the remote side.
+ """
+ self.processId = os.getpid()
+ #self.objectId = id(obj)
+ self.typeStr = repr(obj)
+ #self.handler = handler
+ self.obj = obj
+ self.opts = opts
+
+ def __reduce__(self):
+ ## a proxy is being pickled and sent to a remote process.
+ ## every time this happens, a new proxy will be generated in the remote process,
+ ## so we keep a new ID so we can track when each is released.
+ pid = LocalObjectProxy.registerObject(self.obj)
+ return (unpickleObjectProxy, (self.processId, pid, self.typeStr, None, self.opts))
+
+## alias
+proxy = LocalObjectProxy
+
+def unpickleObjectProxy(processId, proxyId, typeStr, attributes=None, opts=None):
+ if processId == os.getpid():
+ obj = LocalObjectProxy.lookupProxyId(proxyId)
+ if attributes is not None:
+ for attr in attributes:
+ obj = getattr(obj, attr)
+ return obj
+ else:
+ proxy = ObjectProxy(processId, proxyId=proxyId, typeStr=typeStr)
+ if opts is not None:
+ proxy._setProxyOptions(**opts)
+ return proxy
+
+class ObjectProxy(object):
+ """
+ Proxy to an object stored by the remote process. Proxies are created
+ by calling Process._import(), Process.transfer(), or by requesting/calling
+ attributes on existing proxy objects.
+
+ For the most part, this object can be used exactly as if it
+ were a local object::
+
+ rsys = proc._import('sys') # returns proxy to sys module on remote process
+ rsys.stdout # proxy to remote sys.stdout
+ rsys.stdout.write # proxy to remote sys.stdout.write
+ rsys.stdout.write('hello') # calls sys.stdout.write('hello') on remote machine
+ # and returns the result (None)
+
+ When calling a proxy to a remote function, the call can be made synchronous
+ (result of call is returned immediately), asynchronous (result is returned later),
+ or return can be disabled entirely::
+
+ ros = proc._import('os')
+
+ ## synchronous call; result is returned immediately
+ pid = ros.getpid()
+
+ ## asynchronous call
+ request = ros.getpid(_callSync='async')
+ while not request.hasResult():
+ time.sleep(0.01)
+ pid = request.result()
+
+ ## disable return when we know it isn't needed
+ rsys.stdout.write('hello', _callSync='off')
+
+ Additionally, values returned from a remote function call are automatically
+ returned either by value (must be picklable) or by proxy.
+ This behavior can be forced::
+
+ rnp = proc._import('numpy')
+ arrProxy = rnp.array([1,2,3,4], _returnType='proxy')
+ arrValue = rnp.array([1,2,3,4], _returnType='value')
+
+ The default callSync and returnType behaviors (as well as others) can be set
+ for each proxy individually using ObjectProxy._setProxyOptions() or globally using
+ proc.setProxyOptions().
+
+ """
+ def __init__(self, processId, proxyId, typeStr='', parent=None):
+ object.__init__(self)
+ ## can't set attributes directly because setattr is overridden.
+ self.__dict__['_processId'] = processId
+ self.__dict__['_typeStr'] = typeStr
+ self.__dict__['_proxyId'] = proxyId
+ self.__dict__['_attributes'] = ()
+ ## attributes that affect the behavior of the proxy.
+ ## in all cases, a value of None causes the proxy to ask
+ ## its parent event handler to make the decision
+ self.__dict__['_proxyOptions'] = {
+ 'callSync': None, ## 'sync', 'async', None
+ 'timeout': None, ## float, None
+ 'returnType': None, ## 'proxy', 'value', 'auto', None
+ 'deferGetattr': None, ## True, False, None
+ 'noProxyTypes': None, ## list of types to send by value instead of by proxy
+ }
+
+ self.__dict__['_handler'] = RemoteEventHandler.getHandler(processId)
+ self.__dict__['_handler'].registerProxy(self) ## handler will watch proxy; inform remote process when the proxy is deleted.
+
+ def _setProxyOptions(self, **kwds):
+ """
+ Change the behavior of this proxy. For all options, a value of None
+ will cause the proxy to instead use the default behavior defined
+ by its parent Process.
+
+ Options are:
+
+ ============= =============================================================
+ callSync 'sync', 'async', 'off', or None.
+ If 'async', then calling methods will return a Request object
+ which can be used to inquire later about the result of the
+ method call.
+ If 'sync', then calling a method
+ will block until the remote process has returned its result
+ or the timeout has elapsed (in this case, a Request object
+ is returned instead).
+ If 'off', then the remote process is instructed _not_ to
+ reply and the method call will return None immediately.
+ returnType 'auto', 'proxy', 'value', or None.
+ If 'proxy', then the value returned when calling a method
+ will be a proxy to the object on the remote process.
+ If 'value', then attempt to pickle the returned object and
+ send it back.
+ If 'auto', then the decision is made by consulting the
+ 'noProxyTypes' option.
+ autoProxy bool or None. If True, arguments to __call__ are
+ automatically converted to proxy unless their type is
+ listed in noProxyTypes (see below). If False, arguments
+ are left untouched. Use proxy(obj) to manually convert
+ arguments before sending.
+ timeout float or None. Length of time to wait during synchronous
+ requests before returning a Request object instead.
+ deferGetattr True, False, or None.
+ If False, all attribute requests will be sent to the remote
+ process immediately and will block until a response is
+ received (or timeout has elapsed).
+ If True, requesting an attribute from the proxy returns a
+ new proxy immediately. The remote process is _not_ contacted
+ to make this request. This is faster, but it is possible to
+ request an attribute that does not exist on the proxied
+ object. In this case, AttributeError will not be raised
+ until an attempt is made to look up the attribute on the
+ remote process.
+ noProxyTypes List of object types that should _not_ be proxied when
+ sent to the remote process.
+ ============= =============================================================
+ """
+ self._proxyOptions.update(kwds)
+
+ def _getValue(self):
+ """
+ Return the value of the proxied object
+ (the remote object must be picklable)
+ """
+ return self._handler.getObjValue(self)
+
+ def _getProxyOption(self, opt):
+ val = self._proxyOptions[opt]
+ if val is None:
+ return self._handler.getProxyOption(opt)
+ return val
+
+ def _getProxyOptions(self):
+ return {k: self._getProxyOption(k) for k in self._proxyOptions}
+
+ def __reduce__(self):
+ return (unpickleObjectProxy, (self._processId, self._proxyId, self._typeStr, self._attributes))
+
+ def __repr__(self):
+ #objRepr = self.__getattr__('__repr__')(callSync='value')
+ return "" % (self._processId, self._proxyId, self._typeStr)
+
+
+ def __getattr__(self, attr, **kwds):
+ """
+ Calls __getattr__ on the remote object and returns the attribute
+ by value or by proxy depending on the options set (see
+ ObjectProxy._setProxyOptions and RemoteEventHandler.setProxyOptions)
+
+ If the option 'deferGetattr' is True for this proxy, then a new proxy object
+ is returned _without_ asking the remote object whether the named attribute exists.
+ This can save time when making multiple chained attribute requests,
+ but may also defer a possible AttributeError until later, making
+ them more difficult to debug.
+ """
+ opts = self._getProxyOptions()
+ for k in opts:
+ if '_'+k in kwds:
+ opts[k] = kwds.pop('_'+k)
+ if opts['deferGetattr'] is True:
+ return self._deferredAttr(attr)
+ else:
+ #opts = self._getProxyOptions()
+ return self._handler.getObjAttr(self, attr, **opts)
+
+ def _deferredAttr(self, attr):
+ return DeferredObjectProxy(self, attr)
+
+ def __call__(self, *args, **kwds):
+ """
+ Attempts to call the proxied object from the remote process.
+ Accepts extra keyword arguments:
+
+ _callSync 'off', 'sync', or 'async'
+ _returnType 'value', 'proxy', or 'auto'
+
+ If the remote call raises an exception on the remote process,
+ it will be re-raised on the local process.
+
+ """
+ opts = self._getProxyOptions()
+ for k in opts:
+ if '_'+k in kwds:
+ opts[k] = kwds.pop('_'+k)
+ return self._handler.callObj(obj=self, args=args, kwds=kwds, **opts)
+
+
+ ## Explicitly proxy special methods. Is there a better way to do this??
+
+ def _getSpecialAttr(self, attr):
+ ## this just gives us an easy way to change the behavior of the special methods
+ return self._deferredAttr(attr)
+
+ def __getitem__(self, *args):
+ return self._getSpecialAttr('__getitem__')(*args)
+
+ def __setitem__(self, *args):
+ return self._getSpecialAttr('__setitem__')(*args, _callSync='off')
+
+ def __setattr__(self, *args):
+ return self._getSpecialAttr('__setattr__')(*args, _callSync='off')
+
+ def __str__(self, *args):
+ return self._getSpecialAttr('__str__')(*args, _returnType='value')
+
+ def __len__(self, *args):
+ return self._getSpecialAttr('__len__')(*args)
+
+ def __add__(self, *args):
+ return self._getSpecialAttr('__add__')(*args)
+
+ def __sub__(self, *args):
+ return self._getSpecialAttr('__sub__')(*args)
+
+ def __div__(self, *args):
+ return self._getSpecialAttr('__div__')(*args)
+
+ def __mul__(self, *args):
+ return self._getSpecialAttr('__mul__')(*args)
+
+ def __pow__(self, *args):
+ return self._getSpecialAttr('__pow__')(*args)
+
+ def __iadd__(self, *args):
+ return self._getSpecialAttr('__iadd__')(*args, _callSync='off')
+
+ def __isub__(self, *args):
+ return self._getSpecialAttr('__isub__')(*args, _callSync='off')
+
+ def __idiv__(self, *args):
+ return self._getSpecialAttr('__idiv__')(*args, _callSync='off')
+
+ def __imul__(self, *args):
+ return self._getSpecialAttr('__imul__')(*args, _callSync='off')
+
+ def __ipow__(self, *args):
+ return self._getSpecialAttr('__ipow__')(*args, _callSync='off')
+
+ def __rshift__(self, *args):
+ return self._getSpecialAttr('__rshift__')(*args)
+
+ def __lshift__(self, *args):
+ return self._getSpecialAttr('__lshift__')(*args)
+
+ def __floordiv__(self, *args):
+ return self._getSpecialAttr('__pow__')(*args)
+
+ def __irshift__(self, *args):
+ return self._getSpecialAttr('__rshift__')(*args, _callSync='off')
+
+ def __ilshift__(self, *args):
+ return self._getSpecialAttr('__lshift__')(*args, _callSync='off')
+
+ def __ifloordiv__(self, *args):
+ return self._getSpecialAttr('__pow__')(*args, _callSync='off')
+
+ def __eq__(self, *args):
+ return self._getSpecialAttr('__eq__')(*args)
+
+ def __ne__(self, *args):
+ return self._getSpecialAttr('__ne__')(*args)
+
+ def __lt__(self, *args):
+ return self._getSpecialAttr('__lt__')(*args)
+
+ def __gt__(self, *args):
+ return self._getSpecialAttr('__gt__')(*args)
+
+ def __le__(self, *args):
+ return self._getSpecialAttr('__le__')(*args)
+
+ def __ge__(self, *args):
+ return self._getSpecialAttr('__ge__')(*args)
+
+ def __and__(self, *args):
+ return self._getSpecialAttr('__and__')(*args)
+
+ def __or__(self, *args):
+ return self._getSpecialAttr('__or__')(*args)
+
+ def __xor__(self, *args):
+ return self._getSpecialAttr('__xor__')(*args)
+
+ def __iand__(self, *args):
+ return self._getSpecialAttr('__iand__')(*args, _callSync='off')
+
+ def __ior__(self, *args):
+ return self._getSpecialAttr('__ior__')(*args, _callSync='off')
+
+ def __ixor__(self, *args):
+ return self._getSpecialAttr('__ixor__')(*args, _callSync='off')
+
+ def __mod__(self, *args):
+ return self._getSpecialAttr('__mod__')(*args)
+
+ def __radd__(self, *args):
+ return self._getSpecialAttr('__radd__')(*args)
+
+ def __rsub__(self, *args):
+ return self._getSpecialAttr('__rsub__')(*args)
+
+ def __rdiv__(self, *args):
+ return self._getSpecialAttr('__rdiv__')(*args)
+
+ def __rmul__(self, *args):
+ return self._getSpecialAttr('__rmul__')(*args)
+
+ def __rpow__(self, *args):
+ return self._getSpecialAttr('__rpow__')(*args)
+
+ def __rrshift__(self, *args):
+ return self._getSpecialAttr('__rrshift__')(*args)
+
+ def __rlshift__(self, *args):
+ return self._getSpecialAttr('__rlshift__')(*args)
+
+ def __rfloordiv__(self, *args):
+ return self._getSpecialAttr('__rpow__')(*args)
+
+ def __rand__(self, *args):
+ return self._getSpecialAttr('__rand__')(*args)
+
+ def __ror__(self, *args):
+ return self._getSpecialAttr('__ror__')(*args)
+
+ def __rxor__(self, *args):
+ return self._getSpecialAttr('__ror__')(*args)
+
+ def __rmod__(self, *args):
+ return self._getSpecialAttr('__rmod__')(*args)
+
+class DeferredObjectProxy(ObjectProxy):
+ """
+ This class represents an attribute (or sub-attribute) of a proxied object.
+ It is used to speed up attribute requests. Take the following scenario::
+
+ rsys = proc._import('sys')
+ rsys.stdout.write('hello')
+
+ For this simple example, a total of 4 synchronous requests are made to
+ the remote process:
+
+ 1) import sys
+ 2) getattr(sys, 'stdout')
+ 3) getattr(stdout, 'write')
+ 4) write('hello')
+
+ This takes a lot longer than running the equivalent code locally. To
+ speed things up, we can 'defer' the two attribute lookups so they are
+ only carried out when neccessary::
+
+ rsys = proc._import('sys')
+ rsys._setProxyOptions(deferGetattr=True)
+ rsys.stdout.write('hello')
+
+ This example only makes two requests to the remote process; the two
+ attribute lookups immediately return DeferredObjectProxy instances
+ immediately without contacting the remote process. When the call
+ to write() is made, all attribute requests are processed at the same time.
+
+ Note that if the attributes requested do not exist on the remote object,
+ making the call to write() will raise an AttributeError.
+ """
+ def __init__(self, parentProxy, attribute):
+ ## can't set attributes directly because setattr is overridden.
+ for k in ['_processId', '_typeStr', '_proxyId', '_handler']:
+ self.__dict__[k] = getattr(parentProxy, k)
+ self.__dict__['_parent'] = parentProxy ## make sure parent stays alive
+ self.__dict__['_attributes'] = parentProxy._attributes + (attribute,)
+ self.__dict__['_proxyOptions'] = parentProxy._proxyOptions.copy()
+
+ def __repr__(self):
+ return ObjectProxy.__repr__(self) + '.' + '.'.join(self._attributes)
+
+ def _undefer(self):
+ """
+ Return a non-deferred ObjectProxy referencing the same object
+ """
+ return self._parent.__getattr__(self._attributes[-1], _deferGetattr=False)
+
diff --git a/pyqtgraph/numpy_fix.py b/pyqtgraph/numpy_fix.py
new file mode 100644
index 00000000..2fa8ef1f
--- /dev/null
+++ b/pyqtgraph/numpy_fix.py
@@ -0,0 +1,22 @@
+try:
+ import numpy as np
+
+ ## Wrap np.concatenate to catch and avoid a segmentation fault bug
+ ## (numpy trac issue #2084)
+ if not hasattr(np, 'concatenate_orig'):
+ np.concatenate_orig = np.concatenate
+ def concatenate(vals, *args, **kwds):
+ """Wrapper around numpy.concatenate (see pyqtgraph/numpy_fix.py)"""
+ dtypes = [getattr(v, 'dtype', None) for v in vals]
+ names = [getattr(dt, 'names', None) for dt in dtypes]
+ if len(dtypes) < 2 or all([n is None for n in names]):
+ return np.concatenate_orig(vals, *args, **kwds)
+ if any([dt != dtypes[0] for dt in dtypes[1:]]):
+ raise TypeError("Cannot concatenate structured arrays of different dtype.")
+ return np.concatenate_orig(vals, *args, **kwds)
+
+ np.concatenate = concatenate
+
+except ImportError:
+ pass
+
diff --git a/pyqtgraph/opengl/GLGraphicsItem.py b/pyqtgraph/opengl/GLGraphicsItem.py
new file mode 100644
index 00000000..9babec3a
--- /dev/null
+++ b/pyqtgraph/opengl/GLGraphicsItem.py
@@ -0,0 +1,267 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph import Transform3D
+from OpenGL.GL import *
+from OpenGL import GL
+
+GLOptions = {
+ 'opaque': {
+ GL_DEPTH_TEST: True,
+ GL_BLEND: False,
+ GL_ALPHA_TEST: False,
+ GL_CULL_FACE: False,
+ },
+ 'translucent': {
+ GL_DEPTH_TEST: True,
+ GL_BLEND: True,
+ GL_ALPHA_TEST: False,
+ GL_CULL_FACE: False,
+ 'glBlendFunc': (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA),
+ },
+ 'additive': {
+ GL_DEPTH_TEST: False,
+ GL_BLEND: True,
+ GL_ALPHA_TEST: False,
+ GL_CULL_FACE: False,
+ 'glBlendFunc': (GL_SRC_ALPHA, GL_ONE),
+ },
+}
+
+
+class GLGraphicsItem(QtCore.QObject):
+ def __init__(self, parentItem=None):
+ QtCore.QObject.__init__(self)
+ self.__parent = None
+ self.__view = None
+ self.__children = set()
+ self.__transform = Transform3D()
+ self.__visible = True
+ self.setParentItem(parentItem)
+ self.setDepthValue(0)
+ self.__glOpts = {}
+
+ def setParentItem(self, item):
+ if self.__parent is not None:
+ self.__parent.__children.remove(self)
+ if item is not None:
+ item.__children.add(self)
+ self.__parent = item
+
+ if self.__parent is not None and self.view() is not self.__parent.view():
+ if self.view() is not None:
+ self.view().removeItem(self)
+ self.__parent.view().addItem(self)
+
+ def setGLOptions(self, opts):
+ """
+ Set the OpenGL state options to use immediately before drawing this item.
+ (Note that subclasses must call setupGLState before painting for this to work)
+
+ The simplest way to invoke this method is to pass in the name of
+ a predefined set of options (see the GLOptions variable):
+
+ ============= ======================================================
+ opaque Enables depth testing and disables blending
+ translucent Enables depth testing and blending
+ Elements must be drawn sorted back-to-front for
+ translucency to work correctly.
+ additive Disables depth testing, enables blending.
+ Colors are added together, so sorting is not required.
+ ============= ======================================================
+
+ It is also possible to specify any arbitrary settings as a dictionary.
+ This may consist of {'functionName': (args...)} pairs where functionName must
+ be a callable attribute of OpenGL.GL, or {GL_STATE_VAR: bool} pairs
+ which will be interpreted as calls to glEnable or glDisable(GL_STATE_VAR).
+
+ For example::
+
+ {
+ GL_ALPHA_TEST: True,
+ GL_CULL_FACE: False,
+ 'glBlendFunc': (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA),
+ }
+
+
+ """
+ if isinstance(opts, basestring):
+ opts = GLOptions[opts]
+ self.__glOpts = opts.copy()
+ self.update()
+
+ def updateGLOptions(self, opts):
+ """
+ Modify the OpenGL state options to use immediately before drawing this item.
+ *opts* must be a dictionary as specified by setGLOptions.
+ Values may also be None, in which case the key will be ignored.
+ """
+ self.__glOpts.update(opts)
+
+
+ def parentItem(self):
+ return self.__parent
+
+ def childItems(self):
+ return list(self.__children)
+
+ def _setView(self, v):
+ self.__view = v
+
+ def view(self):
+ return self.__view
+
+ def setDepthValue(self, value):
+ """
+ Sets the depth value of this item. Default is 0.
+ This controls the order in which items are drawn--those with a greater depth value will be drawn later.
+ Items with negative depth values are drawn before their parent.
+ (This is analogous to QGraphicsItem.zValue)
+ The depthValue does NOT affect the position of the item or the values it imparts to the GL depth buffer.
+ '"""
+ self.__depthValue = value
+
+ def depthValue(self):
+ """Return the depth value of this item. See setDepthValue for mode information."""
+ return self.__depthValue
+
+ def setTransform(self, tr):
+ self.__transform = Transform3D(tr)
+ self.update()
+
+ def resetTransform(self):
+ self.__transform.setToIdentity()
+ self.update()
+
+ def applyTransform(self, tr, local):
+ """
+ Multiply this object's transform by *tr*.
+ If local is True, then *tr* is multiplied on the right of the current transform:
+ newTransform = transform * tr
+ If local is False, then *tr* is instead multiplied on the left:
+ newTransform = tr * transform
+ """
+ if local:
+ self.setTransform(self.transform() * tr)
+ else:
+ self.setTransform(tr * self.transform())
+
+ def transform(self):
+ return self.__transform
+
+ def viewTransform(self):
+ tr = self.__transform
+ p = self
+ while True:
+ p = p.parentItem()
+ if p is None:
+ break
+ tr = p.transform() * tr
+ return Transform3D(tr)
+
+ def translate(self, dx, dy, dz, local=False):
+ """
+ Translate the object by (*dx*, *dy*, *dz*) in its parent's coordinate system.
+ If *local* is True, then translation takes place in local coordinates.
+ """
+ tr = Transform3D()
+ tr.translate(dx, dy, dz)
+ self.applyTransform(tr, local=local)
+
+ def rotate(self, angle, x, y, z, local=False):
+ """
+ Rotate the object around the axis specified by (x,y,z).
+ *angle* is in degrees.
+
+ """
+ tr = Transform3D()
+ tr.rotate(angle, x, y, z)
+ self.applyTransform(tr, local=local)
+
+ def scale(self, x, y, z, local=True):
+ """
+ Scale the object by (*dx*, *dy*, *dz*) in its local coordinate system.
+ If *local* is False, then scale takes place in the parent's coordinates.
+ """
+ tr = Transform3D()
+ tr.scale(x, y, z)
+ self.applyTransform(tr, local=local)
+
+
+ def hide(self):
+ self.setVisible(False)
+
+ def show(self):
+ self.setVisible(True)
+
+ def setVisible(self, vis):
+ self.__visible = vis
+ self.update()
+
+ def visible(self):
+ return self.__visible
+
+
+ def initializeGL(self):
+ """
+ Called after an item is added to a GLViewWidget.
+ The widget's GL context is made current before this method is called.
+ (So this would be an appropriate time to generate lists, upload textures, etc.)
+ """
+ pass
+
+ def setupGLState(self):
+ """
+ This method is responsible for preparing the GL state options needed to render
+ this item (blending, depth testing, etc). The method is called immediately before painting the item.
+ """
+ for k,v in self.__glOpts.items():
+ if v is None:
+ continue
+ if isinstance(k, basestring):
+ func = getattr(GL, k)
+ func(*v)
+ else:
+ if v is True:
+ glEnable(k)
+ else:
+ glDisable(k)
+
+ def paint(self):
+ """
+ Called by the GLViewWidget to draw this item.
+ It is the responsibility of the item to set up its own modelview matrix,
+ but the caller will take care of pushing/popping.
+ """
+ self.setupGLState()
+
+ def update(self):
+ v = self.view()
+ if v is None:
+ return
+ v.updateGL()
+
+ def mapToParent(self, point):
+ tr = self.transform()
+ if tr is None:
+ return point
+ return tr.map(point)
+
+ def mapFromParent(self, point):
+ tr = self.transform()
+ if tr is None:
+ return point
+ return tr.inverted()[0].map(point)
+
+ def mapToView(self, point):
+ tr = self.viewTransform()
+ if tr is None:
+ return point
+ return tr.map(point)
+
+ def mapFromView(self, point):
+ tr = self.viewTransform()
+ if tr is None:
+ return point
+ return tr.inverted()[0].map(point)
+
+
+
\ No newline at end of file
diff --git a/pyqtgraph/opengl/GLViewWidget.py b/pyqtgraph/opengl/GLViewWidget.py
new file mode 100644
index 00000000..d1c1d090
--- /dev/null
+++ b/pyqtgraph/opengl/GLViewWidget.py
@@ -0,0 +1,289 @@
+from pyqtgraph.Qt import QtCore, QtGui, QtOpenGL
+from OpenGL.GL import *
+import numpy as np
+from pyqtgraph import Vector
+##Vector = QtGui.QVector3D
+
+class GLViewWidget(QtOpenGL.QGLWidget):
+ """
+ Basic widget for displaying 3D data
+ - Rotation/scale controls
+ - Axis/grid display
+ - Export options
+
+ """
+
+ ShareWidget = None
+
+ def __init__(self, parent=None):
+ if GLViewWidget.ShareWidget is None:
+ ## create a dummy widget to allow sharing objects (textures, shaders, etc) between views
+ GLViewWidget.ShareWidget = QtOpenGL.QGLWidget()
+
+ QtOpenGL.QGLWidget.__init__(self, parent, GLViewWidget.ShareWidget)
+
+ self.setFocusPolicy(QtCore.Qt.ClickFocus)
+
+ self.opts = {
+ 'center': Vector(0,0,0), ## will always appear at the center of the widget
+ 'distance': 10.0, ## distance of camera from center
+ 'fov': 60, ## horizontal field of view in degrees
+ 'elevation': 30, ## camera's angle of elevation in degrees
+ 'azimuth': 45, ## camera's azimuthal angle in degrees
+ ## (rotation around z-axis 0 points along x-axis)
+ }
+ self.items = []
+ self.noRepeatKeys = [QtCore.Qt.Key_Right, QtCore.Qt.Key_Left, QtCore.Qt.Key_Up, QtCore.Qt.Key_Down, QtCore.Qt.Key_PageUp, QtCore.Qt.Key_PageDown]
+ self.keysPressed = {}
+ self.keyTimer = QtCore.QTimer()
+ self.keyTimer.timeout.connect(self.evalKeyState)
+
+ self.makeCurrent()
+
+ def addItem(self, item):
+ self.items.append(item)
+ if hasattr(item, 'initializeGL'):
+ self.makeCurrent()
+ try:
+ item.initializeGL()
+ except:
+ self.checkOpenGLVersion('Error while adding item %s to GLViewWidget.' % str(item))
+
+ item._setView(self)
+ #print "set view", item, self, item.view()
+ self.update()
+
+ def removeItem(self, item):
+ self.items.remove(item)
+ item._setView(None)
+ self.update()
+
+
+ def initializeGL(self):
+ glClearColor(0.0, 0.0, 0.0, 0.0)
+ self.resizeGL(self.width(), self.height())
+
+ def resizeGL(self, w, h):
+ glViewport(0, 0, w, h)
+ #self.update()
+
+ def setProjection(self):
+ ## Create the projection matrix
+ glMatrixMode(GL_PROJECTION)
+ glLoadIdentity()
+ w = self.width()
+ h = self.height()
+ dist = self.opts['distance']
+ fov = self.opts['fov']
+
+ nearClip = dist * 0.001
+ farClip = dist * 1000.
+
+ r = nearClip * np.tan(fov * 0.5 * np.pi / 180.)
+ t = r * h / w
+ glFrustum( -r, r, -t, t, nearClip, farClip)
+
+ def setModelview(self):
+ glMatrixMode(GL_MODELVIEW)
+ glLoadIdentity()
+ glTranslatef( 0.0, 0.0, -self.opts['distance'])
+ glRotatef(self.opts['elevation']-90, 1, 0, 0)
+ glRotatef(self.opts['azimuth']+90, 0, 0, -1)
+ center = self.opts['center']
+ glTranslatef(-center.x(), -center.y(), -center.z())
+
+
+ def paintGL(self):
+ self.setProjection()
+ self.setModelview()
+ glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT )
+ self.drawItemTree()
+
+ def drawItemTree(self, item=None):
+ if item is None:
+ items = [x for x in self.items if x.parentItem() is None]
+ else:
+ items = item.childItems()
+ items.append(item)
+ items.sort(lambda a,b: cmp(a.depthValue(), b.depthValue()))
+ for i in items:
+ if not i.visible():
+ continue
+ if i is item:
+ try:
+ glPushAttrib(GL_ALL_ATTRIB_BITS)
+ i.paint()
+ except:
+ import pyqtgraph.debug
+ pyqtgraph.debug.printExc()
+ msg = "Error while drawing item %s." % str(item)
+ ver = glGetString(GL_VERSION)
+ if ver is not None:
+ ver = ver.split()[0]
+ if int(ver.split('.')[0]) < 2:
+ print(msg + " The original exception is printed above; however, pyqtgraph requires OpenGL version 2.0 or greater for many of its 3D features and your OpenGL version is %s. Installing updated display drivers may resolve this issue." % ver)
+ else:
+ print(msg)
+
+ finally:
+ glPopAttrib()
+ else:
+ glMatrixMode(GL_MODELVIEW)
+ glPushMatrix()
+ try:
+ tr = i.transform()
+ a = np.array(tr.copyDataTo()).reshape((4,4))
+ glMultMatrixf(a.transpose())
+ self.drawItemTree(i)
+ finally:
+ glMatrixMode(GL_MODELVIEW)
+ glPopMatrix()
+
+ def setCameraPosition(self, pos=None, distance=None, elevation=None, azimuth=None):
+ if distance is not None:
+ self.opts['distance'] = distance
+ if elevation is not None:
+ self.opts['elevation'] = elevation
+ if azimuth is not None:
+ self.opts['azimuth'] = azimuth
+ self.update()
+
+
+
+ def cameraPosition(self):
+ """Return current position of camera based on center, dist, elevation, and azimuth"""
+ center = self.opts['center']
+ dist = self.opts['distance']
+ elev = self.opts['elevation'] * np.pi/180.
+ azim = self.opts['azimuth'] * np.pi/180.
+
+ pos = Vector(
+ center.x() + dist * np.cos(elev) * np.cos(azim),
+ center.y() + dist * np.cos(elev) * np.sin(azim),
+ center.z() + dist * np.sin(elev)
+ )
+
+ return pos
+
+ def orbit(self, azim, elev):
+ """Orbits the camera around the center position. *azim* and *elev* are given in degrees."""
+ self.opts['azimuth'] += azim
+ self.opts['elevation'] = np.clip(self.opts['elevation'] + elev, -90, 90)
+ self.update()
+
+ def pan(self, dx, dy, dz, relative=False):
+ """
+ Moves the center (look-at) position while holding the camera in place.
+
+ If relative=True, then the coordinates are interpreted such that x
+ if in the global xy plane and points to the right side of the view, y is
+ in the global xy plane and orthogonal to x, and z points in the global z
+ direction. Distances are scaled roughly such that a value of 1.0 moves
+ by one pixel on screen.
+
+ """
+ if not relative:
+ self.opts['center'] += QtGui.QVector3D(dx, dy, dz)
+ else:
+ cPos = self.cameraPosition()
+ cVec = self.opts['center'] - cPos
+ dist = cVec.length() ## distance from camera to center
+ xDist = dist * 2. * np.tan(0.5 * self.opts['fov'] * np.pi / 180.) ## approx. width of view at distance of center point
+ xScale = xDist / self.width()
+ zVec = QtGui.QVector3D(0,0,1)
+ xVec = QtGui.QVector3D.crossProduct(zVec, cVec).normalized()
+ yVec = QtGui.QVector3D.crossProduct(xVec, zVec).normalized()
+ self.opts['center'] = self.opts['center'] + xVec * xScale * dx + yVec * xScale * dy + zVec * xScale * dz
+ self.update()
+
+ def pixelSize(self, pos):
+ """
+ Return the approximate size of a screen pixel at the location pos
+ Pos may be a Vector or an (N,3) array of locations
+ """
+ cam = self.cameraPosition()
+ if isinstance(pos, np.ndarray):
+ cam = np.array(cam).reshape((1,)*(pos.ndim-1)+(3,))
+ dist = ((pos-cam)**2).sum(axis=-1)**0.5
+ else:
+ dist = (pos-cam).length()
+ xDist = dist * 2. * np.tan(0.5 * self.opts['fov'] * np.pi / 180.)
+ return xDist / self.width()
+
+ def mousePressEvent(self, ev):
+ self.mousePos = ev.pos()
+
+ def mouseMoveEvent(self, ev):
+ diff = ev.pos() - self.mousePos
+ self.mousePos = ev.pos()
+
+ if ev.buttons() == QtCore.Qt.LeftButton:
+ self.orbit(-diff.x(), diff.y())
+ #print self.opts['azimuth'], self.opts['elevation']
+ elif ev.buttons() == QtCore.Qt.MidButton:
+ if (ev.modifiers() & QtCore.Qt.ControlModifier):
+ self.pan(diff.x(), 0, diff.y(), relative=True)
+ else:
+ self.pan(diff.x(), diff.y(), 0, relative=True)
+
+ def mouseReleaseEvent(self, ev):
+ pass
+
+ def wheelEvent(self, ev):
+ if (ev.modifiers() & QtCore.Qt.ControlModifier):
+ self.opts['fov'] *= 0.999**ev.delta()
+ else:
+ self.opts['distance'] *= 0.999**ev.delta()
+ self.update()
+
+ def keyPressEvent(self, ev):
+ if ev.key() in self.noRepeatKeys:
+ ev.accept()
+ if ev.isAutoRepeat():
+ return
+ self.keysPressed[ev.key()] = 1
+ self.evalKeyState()
+
+ def keyReleaseEvent(self, ev):
+ if ev.key() in self.noRepeatKeys:
+ ev.accept()
+ if ev.isAutoRepeat():
+ return
+ try:
+ del self.keysPressed[ev.key()]
+ except:
+ self.keysPressed = {}
+ self.evalKeyState()
+
+ def evalKeyState(self):
+ speed = 2.0
+ if len(self.keysPressed) > 0:
+ for key in self.keysPressed:
+ if key == QtCore.Qt.Key_Right:
+ self.orbit(azim=-speed, elev=0)
+ elif key == QtCore.Qt.Key_Left:
+ self.orbit(azim=speed, elev=0)
+ elif key == QtCore.Qt.Key_Up:
+ self.orbit(azim=0, elev=-speed)
+ elif key == QtCore.Qt.Key_Down:
+ self.orbit(azim=0, elev=speed)
+ elif key == QtCore.Qt.Key_PageUp:
+ pass
+ elif key == QtCore.Qt.Key_PageDown:
+ pass
+ self.keyTimer.start(16)
+ else:
+ self.keyTimer.stop()
+
+ def checkOpenGLVersion(self, msg):
+ ## Only to be called from within exception handler.
+ ver = glGetString(GL_VERSION).split()[0]
+ if int(ver.split('.')[0]) < 2:
+ import pyqtgraph.debug
+ pyqtgraph.debug.printExc()
+ raise Exception(msg + " The original exception is printed above; however, pyqtgraph requires OpenGL version 2.0 or greater for many of its 3D features and your OpenGL version is %s. Installing updated display drivers may resolve this issue." % ver)
+ else:
+ raise
+
+
+
\ No newline at end of file
diff --git a/pyqtgraph/opengl/MeshData.py b/pyqtgraph/opengl/MeshData.py
new file mode 100644
index 00000000..3e5938d1
--- /dev/null
+++ b/pyqtgraph/opengl/MeshData.py
@@ -0,0 +1,493 @@
+from pyqtgraph.Qt import QtGui
+import pyqtgraph.functions as fn
+import numpy as np
+
+class MeshData(object):
+ """
+ Class for storing and operating on 3D mesh data. May contain:
+
+ - list of vertex locations
+ - list of edges
+ - list of triangles
+ - colors per vertex, edge, or tri
+ - normals per vertex or tri
+
+ This class handles conversion between the standard [list of vertexes, list of faces]
+ format (suitable for use with glDrawElements) and 'indexed' [list of vertexes] format
+ (suitable for use with glDrawArrays). It will automatically compute face normal
+ vectors as well as averaged vertex normal vectors.
+
+ The class attempts to be as efficient as possible in caching conversion results and
+ avoiding unnecessary conversions.
+ """
+
+ def __init__(self, vertexes=None, faces=None, edges=None, vertexColors=None, faceColors=None):
+ """
+ ============= =====================================================
+ Arguments
+ vertexes (Nv, 3) array of vertex coordinates.
+ If faces is not specified, then this will instead be
+ interpreted as (Nf, 3, 3) array of coordinates.
+ faces (Nf, 3) array of indexes into the vertex array.
+ edges [not available yet]
+ vertexColors (Nv, 4) array of vertex colors.
+ If faces is not specified, then this will instead be
+ interpreted as (Nf, 3, 4) array of colors.
+ faceColors (Nf, 4) array of face colors.
+ ============= =====================================================
+
+ All arguments are optional.
+ """
+ self._vertexes = None # (Nv,3) array of vertex coordinates
+ self._vertexesIndexedByFaces = None # (Nf, 3, 3) array of vertex coordinates
+ self._vertexesIndexedByEdges = None # (Ne, 2, 3) array of vertex coordinates
+
+ ## mappings between vertexes, faces, and edges
+ self._faces = None # Nx3 array of indexes into self._vertexes specifying three vertexes for each face
+ self._edges = None
+ self._vertexFaces = None ## maps vertex ID to a list of face IDs (inverse mapping of _faces)
+ self._vertexEdges = None ## maps vertex ID to a list of edge IDs (inverse mapping of _edges)
+
+ ## Per-vertex data
+ self._vertexNormals = None # (Nv, 3) array of normals, one per vertex
+ self._vertexNormalsIndexedByFaces = None # (Nf, 3, 3) array of normals
+ self._vertexColors = None # (Nv, 3) array of colors
+ self._vertexColorsIndexedByFaces = None # (Nf, 3, 4) array of colors
+ self._vertexColorsIndexedByEdges = None # (Nf, 2, 4) array of colors
+
+ ## Per-face data
+ self._faceNormals = None # (Nf, 3) array of face normals
+ self._faceNormalsIndexedByFaces = None # (Nf, 3, 3) array of face normals
+ self._faceColors = None # (Nf, 4) array of face colors
+ self._faceColorsIndexedByFaces = None # (Nf, 3, 4) array of face colors
+ self._faceColorsIndexedByEdges = None # (Ne, 2, 4) array of face colors
+
+ ## Per-edge data
+ self._edgeColors = None # (Ne, 4) array of edge colors
+ self._edgeColorsIndexedByEdges = None # (Ne, 2, 4) array of edge colors
+ #self._meshColor = (1, 1, 1, 0.1) # default color to use if no face/edge/vertex colors are given
+
+
+
+ if vertexes is not None:
+ if faces is None:
+ self.setVertexes(vertexes, indexed='faces')
+ if vertexColors is not None:
+ self.setVertexColors(vertexColors, indexed='faces')
+ if faceColors is not None:
+ self.setFaceColors(faceColors, indexed='faces')
+ else:
+ self.setVertexes(vertexes)
+ self.setFaces(faces)
+ if vertexColors is not None:
+ self.setVertexColors(vertexColors)
+ if faceColors is not None:
+ self.setFaceColors(faceColors)
+
+ #self.setFaces(vertexes=vertexes, faces=faces, vertexColors=vertexColors, faceColors=faceColors)
+
+
+ #def setFaces(self, vertexes=None, faces=None, vertexColors=None, faceColors=None):
+ #"""
+ #Set the faces in this data set.
+ #Data may be provided either as an Nx3x3 array of floats (9 float coordinate values per face)::
+
+ #faces = [ [(x, y, z), (x, y, z), (x, y, z)], ... ]
+
+ #or as an Nx3 array of ints (vertex integers) AND an Mx3 array of floats (3 float coordinate values per vertex)::
+
+ #faces = [ (p1, p2, p3), ... ]
+ #vertexes = [ (x, y, z), ... ]
+
+ #"""
+ #if not isinstance(vertexes, np.ndarray):
+ #vertexes = np.array(vertexes)
+ #if vertexes.dtype != np.float:
+ #vertexes = vertexes.astype(float)
+ #if faces is None:
+ #self._setIndexedFaces(vertexes, vertexColors, faceColors)
+ #else:
+ #self._setUnindexedFaces(faces, vertexes, vertexColors, faceColors)
+ ##print self.vertexes().shape
+ ##print self.faces().shape
+
+
+ #def setMeshColor(self, color):
+ #"""Set the color of the entire mesh. This removes any per-face or per-vertex colors."""
+ #color = fn.Color(color)
+ #self._meshColor = color.glColor()
+ #self._vertexColors = None
+ #self._faceColors = None
+
+
+ #def __iter__(self):
+ #"""Iterate over all faces, yielding a list of three tuples [(position, normal, color), ...] for each face."""
+ #vnorms = self.vertexNormals()
+ #vcolors = self.vertexColors()
+ #for i in range(self._faces.shape[0]):
+ #face = []
+ #for j in [0,1,2]:
+ #vind = self._faces[i,j]
+ #pos = self._vertexes[vind]
+ #norm = vnorms[vind]
+ #if vcolors is None:
+ #color = self._meshColor
+ #else:
+ #color = vcolors[vind]
+ #face.append((pos, norm, color))
+ #yield face
+
+ #def __len__(self):
+ #return len(self._faces)
+
+ def faces(self):
+ """Return an array (Nf, 3) of vertex indexes, three per triangular face in the mesh."""
+ return self._faces
+
+ def setFaces(self, faces):
+ """Set the (Nf, 3) array of faces. Each rown in the array contains
+ three indexes into the vertex array, specifying the three corners
+ of a triangular face."""
+ self._faces = faces
+ self._vertexFaces = None
+ self._vertexesIndexedByFaces = None
+ self.resetNormals()
+ self._vertexColorsIndexedByFaces = None
+ self._faceColorsIndexedByFaces = None
+
+
+
+ def vertexes(self, indexed=None):
+ """Return an array (N,3) of the positions of vertexes in the mesh.
+ By default, each unique vertex appears only once in the array.
+ If indexed is 'faces', then the array will instead contain three vertexes
+ per face in the mesh (and a single vertex may appear more than once in the array)."""
+ if indexed is None:
+ if self._vertexes is None and self._vertexesIndexedByFaces is not None:
+ self._computeUnindexedVertexes()
+ return self._vertexes
+ elif indexed == 'faces':
+ if self._vertexesIndexedByFaces is None and self._vertexes is not None:
+ self._vertexesIndexedByFaces = self._vertexes[self.faces()]
+ return self._vertexesIndexedByFaces
+ else:
+ raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+
+ def setVertexes(self, verts=None, indexed=None, resetNormals=True):
+ """
+ Set the array (Nv, 3) of vertex coordinates.
+ If indexed=='faces', then the data must have shape (Nf, 3, 3) and is
+ assumed to be already indexed as a list of faces.
+ This will cause any pre-existing normal vectors to be cleared
+ unless resetNormals=False.
+ """
+ if indexed is None:
+ if verts is not None:
+ self._vertexes = verts
+ self._vertexesIndexedByFaces = None
+ elif indexed=='faces':
+ self._vertexes = None
+ if verts is not None:
+ self._vertexesIndexedByFaces = verts
+ else:
+ raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+
+ if resetNormals:
+ self.resetNormals()
+
+ def resetNormals(self):
+ self._vertexNormals = None
+ self._vertexNormalsIndexedByFaces = None
+ self._faceNormals = None
+ self._faceNormalsIndexedByFaces = None
+
+
+ def hasFaceIndexedData(self):
+ """Return True if this object already has vertex positions indexed by face"""
+ return self._vertexesIndexedByFaces is not None
+
+ def hasEdgeIndexedData(self):
+ return self._vertexesIndexedByEdges is not None
+
+ def hasVertexColor(self):
+ """Return True if this data set has vertex color information"""
+ for v in (self._vertexColors, self._vertexColorsIndexedByFaces, self._vertexColorsIndexedByEdges):
+ if v is not None:
+ return True
+ return False
+
+ def hasFaceColor(self):
+ """Return True if this data set has face color information"""
+ for v in (self._faceColors, self._faceColorsIndexedByFaces, self._faceColorsIndexedByEdges):
+ if v is not None:
+ return True
+ return False
+
+
+ def faceNormals(self, indexed=None):
+ """
+ Return an array (Nf, 3) of normal vectors for each face.
+ If indexed='faces', then instead return an indexed array
+ (Nf, 3, 3) (this is just the same array with each vector
+ copied three times).
+ """
+ if self._faceNormals is None:
+ v = self.vertexes(indexed='faces')
+ self._faceNormals = np.cross(v[:,1]-v[:,0], v[:,2]-v[:,0])
+
+
+ if indexed is None:
+ return self._faceNormals
+ elif indexed == 'faces':
+ if self._faceNormalsIndexedByFaces is None:
+ norms = np.empty((self._faceNormals.shape[0], 3, 3))
+ norms[:] = self._faceNormals[:,np.newaxis,:]
+ self._faceNormalsIndexedByFaces = norms
+ return self._faceNormalsIndexedByFaces
+ else:
+ raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+
+ def vertexNormals(self, indexed=None):
+ """
+ Return an array of normal vectors.
+ By default, the array will be (N, 3) with one entry per unique vertex in the mesh.
+ If indexed is 'faces', then the array will contain three normal vectors per face
+ (and some vertexes may be repeated).
+ """
+ if self._vertexNormals is None:
+ faceNorms = self.faceNormals()
+ vertFaces = self.vertexFaces()
+ self._vertexNormals = np.empty(self._vertexes.shape, dtype=float)
+ for vindex in xrange(self._vertexes.shape[0]):
+ norms = faceNorms[vertFaces[vindex]] ## get all face normals
+ norm = norms.sum(axis=0) ## sum normals
+ norm /= (norm**2).sum()**0.5 ## and re-normalize
+ self._vertexNormals[vindex] = norm
+
+ if indexed is None:
+ return self._vertexNormals
+ elif indexed == 'faces':
+ return self._vertexNormals[self.faces()]
+ else:
+ raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+
+ def vertexColors(self, indexed=None):
+ """
+ Return an array (Nv, 4) of vertex colors.
+ If indexed=='faces', then instead return an indexed array
+ (Nf, 3, 4).
+ """
+ if indexed is None:
+ return self._vertexColors
+ elif indexed == 'faces':
+ if self._vertexColorsIndexedByFaces is None:
+ self._vertexColorsIndexedByFaces = self._vertexColors[self.faces()]
+ return self._vertexColorsIndexedByFaces
+ else:
+ raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+
+ def setVertexColors(self, colors, indexed=None):
+ """
+ Set the vertex color array (Nv, 4).
+ If indexed=='faces', then the array will be interpreted
+ as indexed and should have shape (Nf, 3, 4)
+ """
+ if indexed is None:
+ self._vertexColors = colors
+ self._vertexColorsIndexedByFaces = None
+ elif indexed == 'faces':
+ self._vertexColors = None
+ self._vertexColorsIndexedByFaces = colors
+ else:
+ raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+
+ def faceColors(self, indexed=None):
+ """
+ Return an array (Nf, 4) of face colors.
+ If indexed=='faces', then instead return an indexed array
+ (Nf, 3, 4) (note this is just the same array with each color
+ repeated three times).
+ """
+ if indexed is None:
+ return self._faceColors
+ elif indexed == 'faces':
+ if self._faceColorsIndexedByFaces is None and self._faceColors is not None:
+ Nf = self._faceColors.shape[0]
+ self._faceColorsIndexedByFaces = np.empty((Nf, 3, 4), dtype=self._faceColors.dtype)
+ self._faceColorsIndexedByFaces[:] = self._faceColors.reshape(Nf, 1, 4)
+ return self._faceColorsIndexedByFaces
+ else:
+ raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+
+ def setFaceColors(self, colors, indexed=None):
+ """
+ Set the face color array (Nf, 4).
+ If indexed=='faces', then the array will be interpreted
+ as indexed and should have shape (Nf, 3, 4)
+ """
+ if indexed is None:
+ self._faceColors = colors
+ self._faceColorsIndexedByFaces = None
+ elif indexed == 'faces':
+ self._faceColors = None
+ self._faceColorsIndexedByFaces = colors
+ else:
+ raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+
+ def faceCount(self):
+ """
+ Return the number of faces in the mesh.
+ """
+ if self._faces is not None:
+ return self._faces.shape[0]
+ elif self._vertexesIndexedByFaces is not None:
+ return self._vertexesIndexedByFaces.shape[0]
+
+ def edgeColors(self):
+ return self._edgeColors
+
+ #def _setIndexedFaces(self, faces, vertexColors=None, faceColors=None):
+ #self._vertexesIndexedByFaces = faces
+ #self._vertexColorsIndexedByFaces = vertexColors
+ #self._faceColorsIndexedByFaces = faceColors
+
+ def _computeUnindexedVertexes(self):
+ ## Given (Nv, 3, 3) array of vertexes-indexed-by-face, convert backward to unindexed vertexes
+ ## This is done by collapsing into a list of 'unique' vertexes (difference < 1e-14)
+
+ ## I think generally this should be discouraged..
+
+ faces = self._vertexesIndexedByFaces
+ verts = {} ## used to remember the index of each vertex position
+ self._faces = np.empty(faces.shape[:2], dtype=np.uint)
+ self._vertexes = []
+ self._vertexFaces = []
+ self._faceNormals = None
+ self._vertexNormals = None
+ for i in xrange(faces.shape[0]):
+ face = faces[i]
+ inds = []
+ for j in range(face.shape[0]):
+ pt = face[j]
+ pt2 = tuple([round(x*1e14) for x in pt]) ## quantize to be sure that nearly-identical points will be merged
+ index = verts.get(pt2, None)
+ if index is None:
+ #self._vertexes.append(QtGui.QVector3D(*pt))
+ self._vertexes.append(pt)
+ self._vertexFaces.append([])
+ index = len(self._vertexes)-1
+ verts[pt2] = index
+ self._vertexFaces[index].append(i) # keep track of which vertexes belong to which faces
+ self._faces[i,j] = index
+ self._vertexes = np.array(self._vertexes, dtype=float)
+
+ #def _setUnindexedFaces(self, faces, vertexes, vertexColors=None, faceColors=None):
+ #self._vertexes = vertexes #[QtGui.QVector3D(*v) for v in vertexes]
+ #self._faces = faces.astype(np.uint)
+ #self._edges = None
+ #self._vertexFaces = None
+ #self._faceNormals = None
+ #self._vertexNormals = None
+ #self._vertexColors = vertexColors
+ #self._faceColors = faceColors
+
+ def vertexFaces(self):
+ """
+ Return list mapping each vertex index to a list of face indexes that use the vertex.
+ """
+ if self._vertexFaces is None:
+ self._vertexFaces = [None] * len(self.vertexes())
+ for i in xrange(self._faces.shape[0]):
+ face = self._faces[i]
+ for ind in face:
+ if self._vertexFaces[ind] is None:
+ self._vertexFaces[ind] = [] ## need a unique/empty list to fill
+ self._vertexFaces[ind].append(i)
+ return self._vertexFaces
+
+ #def reverseNormals(self):
+ #"""
+ #Reverses the direction of all normal vectors.
+ #"""
+ #pass
+
+ #def generateEdgesFromFaces(self):
+ #"""
+ #Generate a set of edges by listing all the edges of faces and removing any duplicates.
+ #Useful for displaying wireframe meshes.
+ #"""
+ #pass
+
+ def save(self):
+ """Serialize this mesh to a string appropriate for disk storage"""
+ import pickle
+ if self._faces is not None:
+ names = ['_vertexes', '_faces']
+ else:
+ names = ['_vertexesIndexedByFaces']
+
+ if self._vertexColors is not None:
+ names.append('_vertexColors')
+ elif self._vertexColorsIndexedByFaces is not None:
+ names.append('_vertexColorsIndexedByFaces')
+
+ if self._faceColors is not None:
+ names.append('_faceColors')
+ elif self._faceColorsIndexedByFaces is not None:
+ names.append('_faceColorsIndexedByFaces')
+
+ state = {n:getattr(self, n) for n in names}
+ return pickle.dumps(state)
+
+ def restore(self, state):
+ """Restore the state of a mesh previously saved using save()"""
+ import pickle
+ state = pickle.loads(state)
+ for k in state:
+ if isinstance(state[k], list):
+ if isinstance(state[k][0], QtGui.QVector3D):
+ state[k] = [[v.x(), v.y(), v.z()] for v in state[k]]
+ state[k] = np.array(state[k])
+ setattr(self, k, state[k])
+
+
+
+ @staticmethod
+ def sphere(rows, cols, radius=1.0, offset=True):
+ """
+ Return a MeshData instance with vertexes and faces computed
+ for a spherical surface.
+ """
+ verts = np.empty((rows+1, cols, 3), dtype=float)
+
+ ## compute vertexes
+ phi = (np.arange(rows+1) * np.pi / rows).reshape(rows+1, 1)
+ s = radius * np.sin(phi)
+ verts[...,2] = radius * np.cos(phi)
+ th = ((np.arange(cols) * 2 * np.pi / cols).reshape(1, cols))
+ if offset:
+ th = th + ((np.pi / cols) * np.arange(rows+1).reshape(rows+1,1)) ## rotate each row by 1/2 column
+ verts[...,0] = s * np.cos(th)
+ verts[...,1] = s * np.sin(th)
+ verts = verts.reshape((rows+1)*cols, 3)[cols-1:-(cols-1)] ## remove redundant vertexes from top and bottom
+
+ ## compute faces
+ faces = np.empty((rows*cols*2, 3), dtype=np.uint)
+ rowtemplate1 = ((np.arange(cols).reshape(cols, 1) + np.array([[0, 1, 0]])) % cols) + np.array([[0, 0, cols]])
+ rowtemplate2 = ((np.arange(cols).reshape(cols, 1) + np.array([[0, 1, 1]])) % cols) + np.array([[cols, 0, cols]])
+ for row in range(rows):
+ start = row * cols * 2
+ faces[start:start+cols] = rowtemplate1 + row * cols
+ faces[start+cols:start+(cols*2)] = rowtemplate2 + row * cols
+ faces = faces[cols:-cols] ## cut off zero-area triangles at top and bottom
+
+ ## adjust for redundant vertexes that were removed from top and bottom
+ vmin = cols-1
+ faces[facesvmax] = vmax
+
+ return MeshData(vertexes=verts, faces=faces)
+
+
\ No newline at end of file
diff --git a/pyqtgraph/opengl/__init__.py b/pyqtgraph/opengl/__init__.py
new file mode 100644
index 00000000..199c372c
--- /dev/null
+++ b/pyqtgraph/opengl/__init__.py
@@ -0,0 +1,30 @@
+from .GLViewWidget import GLViewWidget
+
+from pyqtgraph import importAll
+#import os
+#def importAll(path):
+ #d = os.path.join(os.path.split(__file__)[0], path)
+ #files = []
+ #for f in os.listdir(d):
+ #if os.path.isdir(os.path.join(d, f)) and f != '__pycache__':
+ #files.append(f)
+ #elif f[-3:] == '.py' and f != '__init__.py':
+ #files.append(f[:-3])
+
+ #for modName in files:
+ #mod = __import__(path+"."+modName, globals(), locals(), fromlist=['*'])
+ #if hasattr(mod, '__all__'):
+ #names = mod.__all__
+ #else:
+ #names = [n for n in dir(mod) if n[0] != '_']
+ #for k in names:
+ #if hasattr(mod, k):
+ #globals()[k] = getattr(mod, k)
+
+importAll('items', globals(), locals())
+\
+from MeshData import MeshData
+## for backward compatibility:
+#MeshData.MeshData = MeshData ## breaks autodoc.
+
+import shaders
diff --git a/pyqtgraph/opengl/glInfo.py b/pyqtgraph/opengl/glInfo.py
new file mode 100644
index 00000000..95f59630
--- /dev/null
+++ b/pyqtgraph/opengl/glInfo.py
@@ -0,0 +1,16 @@
+from pyqtgraph.Qt import QtCore, QtGui, QtOpenGL
+from OpenGL.GL import *
+app = QtGui.QApplication([])
+
+class GLTest(QtOpenGL.QGLWidget):
+ def __init__(self):
+ QtOpenGL.QGLWidget.__init__(self)
+ self.makeCurrent()
+ print "GL version:", glGetString(GL_VERSION)
+ print "MAX_TEXTURE_SIZE:", glGetIntegerv(GL_MAX_TEXTURE_SIZE)
+ print "MAX_3D_TEXTURE_SIZE:", glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE)
+ print "Extensions:", glGetString(GL_EXTENSIONS)
+
+GLTest()
+
+
diff --git a/pyqtgraph/opengl/items/GLAxisItem.py b/pyqtgraph/opengl/items/GLAxisItem.py
new file mode 100644
index 00000000..1586d70a
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLAxisItem.py
@@ -0,0 +1,58 @@
+from OpenGL.GL import *
+from .. GLGraphicsItem import GLGraphicsItem
+from pyqtgraph import QtGui
+
+__all__ = ['GLAxisItem']
+
+class GLAxisItem(GLGraphicsItem):
+ """
+ **Bases:** :class:`GLGraphicsItem `
+
+ Displays three lines indicating origin and orientation of local coordinate system.
+
+ """
+
+ def __init__(self, size=None):
+ GLGraphicsItem.__init__(self)
+ if size is None:
+ size = QtGui.QVector3D(1,1,1)
+ self.setSize(size=size)
+
+ def setSize(self, x=None, y=None, z=None, size=None):
+ """
+ Set the size of the axes (in its local coordinate system; this does not affect the transform)
+ Arguments can be x,y,z or size=QVector3D().
+ """
+ if size is not None:
+ x = size.x()
+ y = size.y()
+ z = size.z()
+ self.__size = [x,y,z]
+ self.update()
+
+ def size(self):
+ return self.__size[:]
+
+
+ def paint(self):
+
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+ glEnable( GL_BLEND )
+ glEnable( GL_ALPHA_TEST )
+ glEnable( GL_POINT_SMOOTH )
+ #glDisable( GL_DEPTH_TEST )
+ glBegin( GL_LINES )
+
+ x,y,z = self.size()
+ glColor4f(0, 1, 0, .6) # z is green
+ glVertex3f(0, 0, 0)
+ glVertex3f(0, 0, z)
+
+ glColor4f(1, 1, 0, .6) # y is yellow
+ glVertex3f(0, 0, 0)
+ glVertex3f(0, y, 0)
+
+ glColor4f(0, 0, 1, .6) # x is blue
+ glVertex3f(0, 0, 0)
+ glVertex3f(x, 0, 0)
+ glEnd()
diff --git a/pyqtgraph/opengl/items/GLBoxItem.py b/pyqtgraph/opengl/items/GLBoxItem.py
new file mode 100644
index 00000000..af888e91
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLBoxItem.py
@@ -0,0 +1,85 @@
+from OpenGL.GL import *
+from .. GLGraphicsItem import GLGraphicsItem
+from pyqtgraph.Qt import QtGui
+import pyqtgraph as pg
+
+__all__ = ['GLBoxItem']
+
+class GLBoxItem(GLGraphicsItem):
+ """
+ **Bases:** :class:`GLGraphicsItem `
+
+ Displays a wire-frame box.
+ """
+ def __init__(self, size=None, color=None):
+ GLGraphicsItem.__init__(self)
+ if size is None:
+ size = QtGui.QVector3D(1,1,1)
+ self.setSize(size=size)
+ if color is None:
+ color = (255,255,255,80)
+ self.setColor(color)
+
+ def setSize(self, x=None, y=None, z=None, size=None):
+ """
+ Set the size of the box (in its local coordinate system; this does not affect the transform)
+ Arguments can be x,y,z or size=QVector3D().
+ """
+ if size is not None:
+ x = size.x()
+ y = size.y()
+ z = size.z()
+ self.__size = [x,y,z]
+ self.update()
+
+ def size(self):
+ return self.__size[:]
+
+ def setColor(self, *args):
+ """Set the color of the box. Arguments are the same as those accepted by functions.mkColor()"""
+ self.__color = pg.Color(*args)
+
+ def color(self):
+ return self.__color
+
+ def paint(self):
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+ glEnable( GL_BLEND )
+ glEnable( GL_ALPHA_TEST )
+ #glAlphaFunc( GL_ALWAYS,0.5 )
+ glEnable( GL_POINT_SMOOTH )
+ glDisable( GL_DEPTH_TEST )
+ glBegin( GL_LINES )
+
+ glColor4f(*self.color().glColor())
+ x,y,z = self.size()
+ glVertex3f(0, 0, 0)
+ glVertex3f(0, 0, z)
+ glVertex3f(x, 0, 0)
+ glVertex3f(x, 0, z)
+ glVertex3f(0, y, 0)
+ glVertex3f(0, y, z)
+ glVertex3f(x, y, 0)
+ glVertex3f(x, y, z)
+
+ glVertex3f(0, 0, 0)
+ glVertex3f(0, y, 0)
+ glVertex3f(x, 0, 0)
+ glVertex3f(x, y, 0)
+ glVertex3f(0, 0, z)
+ glVertex3f(0, y, z)
+ glVertex3f(x, 0, z)
+ glVertex3f(x, y, z)
+
+ glVertex3f(0, 0, 0)
+ glVertex3f(x, 0, 0)
+ glVertex3f(0, y, 0)
+ glVertex3f(x, y, 0)
+ glVertex3f(0, 0, z)
+ glVertex3f(x, 0, z)
+ glVertex3f(0, y, z)
+ glVertex3f(x, y, z)
+
+ glEnd()
+
+
\ No newline at end of file
diff --git a/pyqtgraph/opengl/items/GLGridItem.py b/pyqtgraph/opengl/items/GLGridItem.py
new file mode 100644
index 00000000..630b2aba
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLGridItem.py
@@ -0,0 +1,55 @@
+from OpenGL.GL import *
+from .. GLGraphicsItem import GLGraphicsItem
+from pyqtgraph import QtGui
+
+__all__ = ['GLGridItem']
+
+class GLGridItem(GLGraphicsItem):
+ """
+ **Bases:** :class:`GLGraphicsItem `
+
+ Displays a wire-grame grid.
+ """
+
+ def __init__(self, size=None, color=None, glOptions='translucent'):
+ GLGraphicsItem.__init__(self)
+ self.setGLOptions(glOptions)
+ if size is None:
+ size = QtGui.QVector3D(1,1,1)
+ self.setSize(size=size)
+
+ def setSize(self, x=None, y=None, z=None, size=None):
+ """
+ Set the size of the axes (in its local coordinate system; this does not affect the transform)
+ Arguments can be x,y,z or size=QVector3D().
+ """
+ if size is not None:
+ x = size.x()
+ y = size.y()
+ z = size.z()
+ self.__size = [x,y,z]
+ self.update()
+
+ def size(self):
+ return self.__size[:]
+
+
+ def paint(self):
+ self.setupGLState()
+ #glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+ #glEnable( GL_BLEND )
+ #glEnable( GL_ALPHA_TEST )
+ glEnable( GL_POINT_SMOOTH )
+ #glDisable( GL_DEPTH_TEST )
+ glBegin( GL_LINES )
+
+ x,y,z = self.size()
+ glColor4f(1, 1, 1, .3)
+ for x in range(-10, 11):
+ glVertex3f(x, -10, 0)
+ glVertex3f(x, 10, 0)
+ for y in range(-10, 11):
+ glVertex3f(-10, y, 0)
+ glVertex3f( 10, y, 0)
+
+ glEnd()
diff --git a/pyqtgraph/opengl/items/GLImageItem.py b/pyqtgraph/opengl/items/GLImageItem.py
new file mode 100644
index 00000000..b292a7b7
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLImageItem.py
@@ -0,0 +1,87 @@
+from OpenGL.GL import *
+from .. GLGraphicsItem import GLGraphicsItem
+from pyqtgraph.Qt import QtGui
+import numpy as np
+
+__all__ = ['GLImageItem']
+
+class GLImageItem(GLGraphicsItem):
+ """
+ **Bases:** :class:`GLGraphicsItem `
+
+ Displays image data as a textured quad.
+ """
+
+
+ def __init__(self, data, smooth=False):
+ """
+
+ ============== =======================================================================================
+ **Arguments:**
+ data Volume data to be rendered. *Must* be 3D numpy array (x, y, RGBA) with dtype=ubyte.
+ (See functions.makeRGBA)
+ smooth (bool) If True, the volume slices are rendered with linear interpolation
+ ============== =======================================================================================
+ """
+
+ self.smooth = smooth
+ self.data = data
+ GLGraphicsItem.__init__(self)
+
+ def initializeGL(self):
+ glEnable(GL_TEXTURE_2D)
+ self.texture = glGenTextures(1)
+ glBindTexture(GL_TEXTURE_2D, self.texture)
+ if self.smooth:
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+ else:
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER)
+ #glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_BORDER)
+ shape = self.data.shape
+
+ ## Test texture dimensions first
+ glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, shape[0], shape[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, None)
+ if glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH) == 0:
+ raise Exception("OpenGL failed to create 2D texture (%dx%d); too large for this hardware." % shape[:2])
+
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, shape[0], shape[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, self.data.transpose((1,0,2)))
+ glDisable(GL_TEXTURE_2D)
+
+ #self.lists = {}
+ #for ax in [0,1,2]:
+ #for d in [-1, 1]:
+ #l = glGenLists(1)
+ #self.lists[(ax,d)] = l
+ #glNewList(l, GL_COMPILE)
+ #self.drawVolume(ax, d)
+ #glEndList()
+
+
+ def paint(self):
+
+ glEnable(GL_TEXTURE_2D)
+ glBindTexture(GL_TEXTURE_2D, self.texture)
+
+ glEnable(GL_DEPTH_TEST)
+ #glDisable(GL_CULL_FACE)
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+ glEnable( GL_BLEND )
+ glEnable( GL_ALPHA_TEST )
+ glColor4f(1,1,1,1)
+
+ glBegin(GL_QUADS)
+ glTexCoord2f(0,0)
+ glVertex3f(0,0,0)
+ glTexCoord2f(1,0)
+ glVertex3f(self.data.shape[0], 0, 0)
+ glTexCoord2f(1,1)
+ glVertex3f(self.data.shape[0], self.data.shape[1], 0)
+ glTexCoord2f(0,1)
+ glVertex3f(0, self.data.shape[1], 0)
+ glEnd()
+ glDisable(GL_TEXTURE_3D)
+
diff --git a/pyqtgraph/opengl/items/GLLinePlotItem.py b/pyqtgraph/opengl/items/GLLinePlotItem.py
new file mode 100644
index 00000000..ef747d17
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLLinePlotItem.py
@@ -0,0 +1,81 @@
+from OpenGL.GL import *
+from OpenGL.arrays import vbo
+from .. GLGraphicsItem import GLGraphicsItem
+from .. import shaders
+from pyqtgraph import QtGui
+import numpy as np
+
+__all__ = ['GLLinePlotItem']
+
+class GLLinePlotItem(GLGraphicsItem):
+ """Draws line plots in 3D."""
+
+ def __init__(self, **kwds):
+ GLGraphicsItem.__init__(self)
+ glopts = kwds.pop('glOptions', 'additive')
+ self.setGLOptions(glopts)
+ self.pos = None
+ self.width = 1.
+ self.color = (1.0,1.0,1.0,1.0)
+ self.setData(**kwds)
+
+ def setData(self, **kwds):
+ """
+ Update the data displayed by this item. All arguments are optional;
+ for example it is allowed to update spot positions while leaving
+ colors unchanged, etc.
+
+ ==================== ==================================================
+ Arguments:
+ ------------------------------------------------------------------------
+ pos (N,3) array of floats specifying point locations.
+ color tuple of floats (0.0-1.0) specifying
+ a color for the entire item.
+ width float specifying line width
+ ==================== ==================================================
+ """
+ args = ['pos', 'color', 'width', 'connected']
+ for k in kwds.keys():
+ if k not in args:
+ raise Exception('Invalid keyword argument: %s (allowed arguments are %s)' % (k, str(args)))
+
+ for arg in args:
+ if arg in kwds:
+ setattr(self, arg, kwds[arg])
+ #self.vbo.pop(arg, None)
+ self.update()
+
+ def initializeGL(self):
+ pass
+
+ #def setupGLState(self):
+ #"""Prepare OpenGL state for drawing. This function is called immediately before painting."""
+ ##glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ## requires z-sorting to render properly.
+ #glBlendFunc(GL_SRC_ALPHA, GL_ONE)
+ #glEnable( GL_BLEND )
+ #glEnable( GL_ALPHA_TEST )
+ #glDisable( GL_DEPTH_TEST )
+
+ ##glEnable( GL_POINT_SMOOTH )
+
+ ##glHint(GL_POINT_SMOOTH_HINT, GL_NICEST)
+ ##glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, (0, 0, -1e-3))
+ ##glPointParameterfv(GL_POINT_SIZE_MAX, (65500,))
+ ##glPointParameterfv(GL_POINT_SIZE_MIN, (0,))
+
+ def paint(self):
+ if self.pos is None:
+ return
+ self.setupGLState()
+
+ glEnableClientState(GL_VERTEX_ARRAY)
+ try:
+ glVertexPointerf(self.pos)
+ glColor4f(*self.color)
+
+ glPointSize(self.width)
+ glDrawArrays(GL_LINE_STRIP, 0, self.pos.size / self.pos.shape[-1])
+ finally:
+ glDisableClientState(GL_VERTEX_ARRAY)
+
+
diff --git a/pyqtgraph/opengl/items/GLMeshItem.py b/pyqtgraph/opengl/items/GLMeshItem.py
new file mode 100644
index 00000000..4222c96b
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLMeshItem.py
@@ -0,0 +1,182 @@
+from OpenGL.GL import *
+from .. GLGraphicsItem import GLGraphicsItem
+from .. MeshData import MeshData
+from pyqtgraph.Qt import QtGui
+import pyqtgraph as pg
+from .. import shaders
+import numpy as np
+
+
+
+__all__ = ['GLMeshItem']
+
+class GLMeshItem(GLGraphicsItem):
+ """
+ **Bases:** :class:`GLGraphicsItem `
+
+ Displays a 3D triangle mesh.
+ """
+ def __init__(self, **kwds):
+ """
+ ============== =====================================================
+ Arguments
+ meshdata MeshData object from which to determine geometry for
+ this item.
+ color Default color used if no vertex or face colors are
+ specified.
+ shader Name of shader program to use (None for no shader)
+ smooth If True, normal vectors are computed for each vertex
+ and interpolated within each face.
+ computeNormals If False, then computation of normal vectors is
+ disabled. This can provide a performance boost for
+ meshes that do not make use of normals.
+ ============== =====================================================
+ """
+ self.opts = {
+ 'meshdata': None,
+ 'color': (1., 1., 1., 1.),
+ 'shader': None,
+ 'smooth': True,
+ 'computeNormals': True,
+ }
+
+ GLGraphicsItem.__init__(self)
+ glopts = kwds.pop('glOptions', 'opaque')
+ self.setGLOptions(glopts)
+ shader = kwds.pop('shader', None)
+ self.setShader(shader)
+
+ self.setMeshData(**kwds)
+
+ ## storage for data compiled from MeshData object
+ self.vertexes = None
+ self.normals = None
+ self.colors = None
+ self.faces = None
+
+ def setShader(self, shader):
+ """Set the shader used when rendering faces in the mesh. (see the GL shaders example)"""
+ self.opts['shader'] = shader
+ self.update()
+
+ def shader(self):
+ return shaders.getShaderProgram(self.opts['shader'])
+
+ def setColor(self, c):
+ """Set the default color to use when no vertex or face colors are specified."""
+ self.opts['color'] = c
+ self.update()
+
+ def setMeshData(self, **kwds):
+ """
+ Set mesh data for this item. This can be invoked two ways:
+
+ 1. Specify *meshdata* argument with a new MeshData object
+ 2. Specify keyword arguments to be passed to MeshData(..) to create a new instance.
+ """
+ md = kwds.get('meshdata', None)
+ if md is None:
+ opts = {}
+ for k in ['vertexes', 'faces', 'edges', 'vertexColors', 'faceColors']:
+ try:
+ opts[k] = kwds.pop(k)
+ except KeyError:
+ pass
+ md = MeshData(**opts)
+
+ self.opts['meshdata'] = md
+ self.opts.update(kwds)
+ self.meshDataChanged()
+ self.update()
+
+
+ def meshDataChanged(self):
+ """
+ This method must be called to inform the item that the MeshData object
+ has been altered.
+ """
+
+ self.vertexes = None
+ self.faces = None
+ self.normals = None
+ self.colors = None
+ self.update()
+
+ def parseMeshData(self):
+ ## interpret vertex / normal data before drawing
+ ## This can:
+ ## - automatically generate normals if they were not specified
+ ## - pull vertexes/noormals/faces from MeshData if that was specified
+
+ if self.vertexes is not None and self.normals is not None:
+ return
+ #if self.opts['normals'] is None:
+ #if self.opts['meshdata'] is None:
+ #self.opts['meshdata'] = MeshData(vertexes=self.opts['vertexes'], faces=self.opts['faces'])
+ if self.opts['meshdata'] is not None:
+ md = self.opts['meshdata']
+ if self.opts['smooth'] and not md.hasFaceIndexedData():
+ self.vertexes = md.vertexes()
+ if self.opts['computeNormals']:
+ self.normals = md.vertexNormals()
+ self.faces = md.faces()
+ if md.hasVertexColor():
+ self.colors = md.vertexColors()
+ if md.hasFaceColor():
+ self.colors = md.faceColors()
+ else:
+ self.vertexes = md.vertexes(indexed='faces')
+ if self.opts['computeNormals']:
+ if self.opts['smooth']:
+ self.normals = md.vertexNormals(indexed='faces')
+ else:
+ self.normals = md.faceNormals(indexed='faces')
+ self.faces = None
+ if md.hasVertexColor():
+ self.colors = md.vertexColors(indexed='faces')
+ elif md.hasFaceColor():
+ self.colors = md.faceColors(indexed='faces')
+
+ return
+
+ def paint(self):
+ self.setupGLState()
+
+ self.parseMeshData()
+
+ with self.shader():
+ verts = self.vertexes
+ norms = self.normals
+ color = self.colors
+ faces = self.faces
+ if verts is None:
+ return
+ glEnableClientState(GL_VERTEX_ARRAY)
+ try:
+ glVertexPointerf(verts)
+
+ if self.colors is None:
+ color = self.opts['color']
+ if isinstance(color, QtGui.QColor):
+ glColor4f(*pg.glColor(color))
+ else:
+ glColor4f(*color)
+ else:
+ glEnableClientState(GL_COLOR_ARRAY)
+ glColorPointerf(color)
+
+
+ if norms is not None:
+ glEnableClientState(GL_NORMAL_ARRAY)
+ glNormalPointerf(norms)
+
+ if faces is None:
+ glDrawArrays(GL_TRIANGLES, 0, np.product(verts.shape[:-1]))
+ else:
+ faces = faces.astype(np.uint).flatten()
+ glDrawElements(GL_TRIANGLES, faces.shape[0], GL_UNSIGNED_INT, faces)
+ finally:
+ glDisableClientState(GL_NORMAL_ARRAY)
+ glDisableClientState(GL_VERTEX_ARRAY)
+ glDisableClientState(GL_COLOR_ARRAY)
+
diff --git a/pyqtgraph/opengl/items/GLScatterPlotItem.py b/pyqtgraph/opengl/items/GLScatterPlotItem.py
new file mode 100644
index 00000000..e9bbde64
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLScatterPlotItem.py
@@ -0,0 +1,183 @@
+from OpenGL.GL import *
+from OpenGL.arrays import vbo
+from .. GLGraphicsItem import GLGraphicsItem
+from .. import shaders
+from pyqtgraph import QtGui
+import numpy as np
+
+__all__ = ['GLScatterPlotItem']
+
+class GLScatterPlotItem(GLGraphicsItem):
+ """Draws points at a list of 3D positions."""
+
+ def __init__(self, **kwds):
+ GLGraphicsItem.__init__(self)
+ glopts = kwds.pop('glOptions', 'additive')
+ self.setGLOptions(glopts)
+ self.pos = []
+ self.size = 10
+ self.color = [1.0,1.0,1.0,0.5]
+ self.pxMode = True
+ #self.vbo = {} ## VBO does not appear to improve performance very much.
+ self.setData(**kwds)
+
+ def setData(self, **kwds):
+ """
+ Update the data displayed by this item. All arguments are optional;
+ for example it is allowed to update spot positions while leaving
+ colors unchanged, etc.
+
+ ==================== ==================================================
+ Arguments:
+ ------------------------------------------------------------------------
+ pos (N,3) array of floats specifying point locations.
+ color (N,4) array of floats (0.0-1.0) specifying
+ spot colors OR a tuple of floats specifying
+ a single color for all spots.
+ size (N,) array of floats specifying spot sizes or
+ a single value to apply to all spots.
+ pxMode If True, spot sizes are expressed in pixels.
+ Otherwise, they are expressed in item coordinates.
+ ==================== ==================================================
+ """
+ args = ['pos', 'color', 'size', 'pxMode']
+ for k in kwds.keys():
+ if k not in args:
+ raise Exception('Invalid keyword argument: %s (allowed arguments are %s)' % (k, str(args)))
+
+ args.remove('pxMode')
+ for arg in args:
+ if arg in kwds:
+ setattr(self, arg, kwds[arg])
+ #self.vbo.pop(arg, None)
+
+ self.pxMode = kwds.get('pxMode', self.pxMode)
+ self.update()
+
+ def initializeGL(self):
+
+ ## Generate texture for rendering points
+ w = 64
+ def fn(x,y):
+ r = ((x-w/2.)**2 + (y-w/2.)**2) ** 0.5
+ return 200 * (w/2. - np.clip(r, w/2.-1.0, w/2.))
+ pData = np.empty((w, w, 4))
+ pData[:] = 255
+ pData[:,:,3] = np.fromfunction(fn, pData.shape[:2])
+ #print pData.shape, pData.min(), pData.max()
+ pData = pData.astype(np.ubyte)
+
+ self.pointTexture = glGenTextures(1)
+ glActiveTexture(GL_TEXTURE0)
+ glEnable(GL_TEXTURE_2D)
+ glBindTexture(GL_TEXTURE_2D, self.pointTexture)
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pData.shape[0], pData.shape[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, pData)
+
+ self.shader = shaders.getShaderProgram('pointSprite')
+
+ #def getVBO(self, name):
+ #if name not in self.vbo:
+ #self.vbo[name] = vbo.VBO(getattr(self, name).astype('f'))
+ #return self.vbo[name]
+
+ #def setupGLState(self):
+ #"""Prepare OpenGL state for drawing. This function is called immediately before painting."""
+ ##glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ## requires z-sorting to render properly.
+ #glBlendFunc(GL_SRC_ALPHA, GL_ONE)
+ #glEnable( GL_BLEND )
+ #glEnable( GL_ALPHA_TEST )
+ #glDisable( GL_DEPTH_TEST )
+
+ ##glEnable( GL_POINT_SMOOTH )
+
+ ##glHint(GL_POINT_SMOOTH_HINT, GL_NICEST)
+ ##glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, (0, 0, -1e-3))
+ ##glPointParameterfv(GL_POINT_SIZE_MAX, (65500,))
+ ##glPointParameterfv(GL_POINT_SIZE_MIN, (0,))
+
+ def paint(self):
+ self.setupGLState()
+
+ glEnable(GL_POINT_SPRITE)
+
+ glActiveTexture(GL_TEXTURE0)
+ glEnable( GL_TEXTURE_2D )
+ glBindTexture(GL_TEXTURE_2D, self.pointTexture)
+
+ glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)
+ #glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE) ## use texture color exactly
+ #glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) ## texture modulates current color
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+ glEnable(GL_PROGRAM_POINT_SIZE)
+
+
+ with self.shader:
+ #glUniform1i(self.shader.uniform('texture'), 0) ## inform the shader which texture to use
+ glEnableClientState(GL_VERTEX_ARRAY)
+ try:
+ pos = self.pos
+ #if pos.ndim > 2:
+ #pos = pos.reshape((reduce(lambda a,b: a*b, pos.shape[:-1]), pos.shape[-1]))
+ glVertexPointerf(pos)
+
+ if isinstance(self.color, np.ndarray):
+ glEnableClientState(GL_COLOR_ARRAY)
+ glColorPointerf(self.color)
+ else:
+ if isinstance(self.color, QtGui.QColor):
+ glColor4f(*fn.glColor(self.color))
+ else:
+ glColor4f(*self.color)
+
+ if not self.pxMode or isinstance(self.size, np.ndarray):
+ glEnableClientState(GL_NORMAL_ARRAY)
+ norm = np.empty(pos.shape)
+ if self.pxMode:
+ norm[...,0] = self.size
+ else:
+ gpos = self.mapToView(pos.transpose()).transpose()
+ pxSize = self.view().pixelSize(gpos)
+ norm[...,0] = self.size / pxSize
+
+ glNormalPointerf(norm)
+ else:
+ glNormal3f(self.size, 0, 0) ## vertex shader uses norm.x to determine point size
+ #glPointSize(self.size)
+ glDrawArrays(GL_POINTS, 0, pos.size / pos.shape[-1])
+ finally:
+ glDisableClientState(GL_NORMAL_ARRAY)
+ glDisableClientState(GL_VERTEX_ARRAY)
+ glDisableClientState(GL_COLOR_ARRAY)
+ #posVBO.unbind()
+
+ #for i in range(len(self.pos)):
+ #pos = self.pos[i]
+
+ #if isinstance(self.color, np.ndarray):
+ #color = self.color[i]
+ #else:
+ #color = self.color
+ #if isinstance(self.color, QtGui.QColor):
+ #color = fn.glColor(self.color)
+
+ #if isinstance(self.size, np.ndarray):
+ #size = self.size[i]
+ #else:
+ #size = self.size
+
+ #pxSize = self.view().pixelSize(QtGui.QVector3D(*pos))
+
+ #glPointSize(size / pxSize)
+ #glBegin( GL_POINTS )
+ #glColor4f(*color) # x is blue
+ ##glNormal3f(size, 0, 0)
+ #glVertex3f(*pos)
+ #glEnd()
+
+
+
+
+
diff --git a/pyqtgraph/opengl/items/GLSurfacePlotItem.py b/pyqtgraph/opengl/items/GLSurfacePlotItem.py
new file mode 100644
index 00000000..69080fad
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLSurfacePlotItem.py
@@ -0,0 +1,139 @@
+from OpenGL.GL import *
+from GLMeshItem import GLMeshItem
+from .. MeshData import MeshData
+from pyqtgraph.Qt import QtGui
+import pyqtgraph as pg
+import numpy as np
+
+
+
+__all__ = ['GLSurfacePlotItem']
+
+class GLSurfacePlotItem(GLMeshItem):
+ """
+ **Bases:** :class:`GLMeshItem `
+
+ Displays a surface plot on a regular x,y grid
+ """
+ def __init__(self, x=None, y=None, z=None, colors=None, **kwds):
+ """
+ The x, y, z, and colors arguments are passed to setData().
+ All other keyword arguments are passed to GLMeshItem.__init__().
+ """
+
+ self._x = None
+ self._y = None
+ self._z = None
+ self._color = None
+ self._vertexes = None
+ self._meshdata = MeshData()
+ GLMeshItem.__init__(self, meshdata=self._meshdata, **kwds)
+
+ self.setData(x, y, z, colors)
+
+
+
+ def setData(self, x=None, y=None, z=None, colors=None):
+ """
+ Update the data in this surface plot.
+
+ ========== =====================================================================
+ Arguments
+ x,y 1D arrays of values specifying the x,y positions of vertexes in the
+ grid. If these are omitted, then the values will be assumed to be
+ integers.
+ z 2D array of height values for each grid vertex.
+ colors (width, height, 4) array of vertex colors.
+ ========== =====================================================================
+
+ All arguments are optional.
+
+ Note that if vertex positions are updated, the normal vectors for each triangle must
+ be recomputed. This is somewhat expensive if the surface was initialized with smooth=False
+ and very expensive if smooth=True. For faster performance, initialize with
+ computeNormals=False and use per-vertex colors or a normal-independent shader program.
+ """
+ if x is not None:
+ if self._x is None or len(x) != len(self._x):
+ self._vertexes = None
+ self._x = x
+
+ if y is not None:
+ if self._y is None or len(y) != len(self._y):
+ self._vertexes = None
+ self._y = y
+
+ if z is not None:
+ #if self._x is None:
+ #self._x = np.arange(z.shape[0])
+ #self._vertexes = None
+ #if self._y is None:
+ #self._y = np.arange(z.shape[1])
+ #self._vertexes = None
+
+ if self._x is not None and z.shape[0] != len(self._x):
+ raise Exception('Z values must have shape (len(x), len(y))')
+ if self._y is not None and z.shape[1] != len(self._y):
+ raise Exception('Z values must have shape (len(x), len(y))')
+ self._z = z
+ if self._vertexes is not None and self._z.shape != self._vertexes.shape[:2]:
+ self._vertexes = None
+
+ if colors is not None:
+ self._colors = colors
+ self._meshdata.setVertexColors(colors)
+
+ if self._z is None:
+ return
+
+ updateMesh = False
+ newVertexes = False
+
+ ## Generate vertex and face array
+ if self._vertexes is None:
+ newVertexes = True
+ self._vertexes = np.empty((self._z.shape[0], self._z.shape[1], 3), dtype=float)
+ self.generateFaces()
+ self._meshdata.setFaces(self._faces)
+ updateMesh = True
+
+ ## Copy x, y, z data into vertex array
+ if newVertexes or x is not None:
+ if x is None:
+ if self._x is None:
+ x = np.arange(self._z.shape[0])
+ else:
+ x = self._x
+ self._vertexes[:, :, 0] = x.reshape(len(x), 1)
+ updateMesh = True
+
+ if newVertexes or y is not None:
+ if y is None:
+ if self._y is None:
+ y = np.arange(self._z.shape[1])
+ else:
+ y = self._y
+ self._vertexes[:, :, 1] = y.reshape(1, len(y))
+ updateMesh = True
+
+ if newVertexes or z is not None:
+ self._vertexes[...,2] = self._z
+ updateMesh = True
+
+ ## Update MeshData
+ if updateMesh:
+ self._meshdata.setVertexes(self._vertexes.reshape(self._vertexes.shape[0]*self._vertexes.shape[1], 3))
+ self.meshDataChanged()
+
+
+ def generateFaces(self):
+ cols = self._z.shape[0]-1
+ rows = self._z.shape[1]-1
+ faces = np.empty((cols*rows*2, 3), dtype=np.uint)
+ rowtemplate1 = np.arange(cols).reshape(cols, 1) + np.array([[0, 1, cols+1]])
+ rowtemplate2 = np.arange(cols).reshape(cols, 1) + np.array([[cols+1, 1, cols+2]])
+ for row in range(rows):
+ start = row * cols * 2
+ faces[start:start+cols] = rowtemplate1 + row * (cols+1)
+ faces[start+cols:start+(cols*2)] = rowtemplate2 + row * (cols+1)
+ self._faces = faces
\ No newline at end of file
diff --git a/pyqtgraph/opengl/items/GLVolumeItem.py b/pyqtgraph/opengl/items/GLVolumeItem.py
new file mode 100644
index 00000000..4980239d
--- /dev/null
+++ b/pyqtgraph/opengl/items/GLVolumeItem.py
@@ -0,0 +1,213 @@
+from OpenGL.GL import *
+from .. GLGraphicsItem import GLGraphicsItem
+from pyqtgraph.Qt import QtGui
+import numpy as np
+
+__all__ = ['GLVolumeItem']
+
+class GLVolumeItem(GLGraphicsItem):
+ """
+ **Bases:** :class:`GLGraphicsItem `
+
+ Displays volumetric data.
+ """
+
+
+ def __init__(self, data, sliceDensity=1, smooth=True, glOptions='translucent'):
+ """
+ ============== =======================================================================================
+ **Arguments:**
+ data Volume data to be rendered. *Must* be 4D numpy array (x, y, z, RGBA) with dtype=ubyte.
+ sliceDensity Density of slices to render through the volume. A value of 1 means one slice per voxel.
+ smooth (bool) If True, the volume slices are rendered with linear interpolation
+ ============== =======================================================================================
+ """
+
+ self.sliceDensity = sliceDensity
+ self.smooth = smooth
+ self.data = data
+ GLGraphicsItem.__init__(self)
+ self.setGLOptions(glOptions)
+
+ def initializeGL(self):
+ glEnable(GL_TEXTURE_3D)
+ self.texture = glGenTextures(1)
+ glBindTexture(GL_TEXTURE_3D, self.texture)
+ if self.smooth:
+ glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+ glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+ else:
+ glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+ glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+ glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER)
+ glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER)
+ glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_BORDER)
+ shape = self.data.shape
+
+ ## Test texture dimensions first
+ glTexImage3D(GL_PROXY_TEXTURE_3D, 0, GL_RGBA, shape[0], shape[1], shape[2], 0, GL_RGBA, GL_UNSIGNED_BYTE, None)
+ if glGetTexLevelParameteriv(GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_WIDTH) == 0:
+ raise Exception("OpenGL failed to create 3D texture (%dx%dx%d); too large for this hardware." % shape[:3])
+
+ glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, shape[0], shape[1], shape[2], 0, GL_RGBA, GL_UNSIGNED_BYTE, self.data.transpose((2,1,0,3)))
+ glDisable(GL_TEXTURE_3D)
+
+ self.lists = {}
+ for ax in [0,1,2]:
+ for d in [-1, 1]:
+ l = glGenLists(1)
+ self.lists[(ax,d)] = l
+ glNewList(l, GL_COMPILE)
+ self.drawVolume(ax, d)
+ glEndList()
+
+
+ def paint(self):
+ self.setupGLState()
+
+ glEnable(GL_TEXTURE_3D)
+ glBindTexture(GL_TEXTURE_3D, self.texture)
+
+ #glEnable(GL_DEPTH_TEST)
+ #glDisable(GL_CULL_FACE)
+ #glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+ #glEnable( GL_BLEND )
+ #glEnable( GL_ALPHA_TEST )
+ glColor4f(1,1,1,1)
+
+ view = self.view()
+ center = QtGui.QVector3D(*[x/2. for x in self.data.shape[:3]])
+ cam = self.mapFromParent(view.cameraPosition()) - center
+ #print "center", center, "cam", view.cameraPosition(), self.mapFromParent(view.cameraPosition()), "diff", cam
+ cam = np.array([cam.x(), cam.y(), cam.z()])
+ ax = np.argmax(abs(cam))
+ d = 1 if cam[ax] > 0 else -1
+ glCallList(self.lists[(ax,d)]) ## draw axes
+ glDisable(GL_TEXTURE_3D)
+
+ def drawVolume(self, ax, d):
+ N = 5
+
+ imax = [0,1,2]
+ imax.remove(ax)
+
+ tp = [[0,0,0],[0,0,0],[0,0,0],[0,0,0]]
+ vp = [[0,0,0],[0,0,0],[0,0,0],[0,0,0]]
+ nudge = [0.5/x for x in self.data.shape]
+ tp[0][imax[0]] = 0+nudge[imax[0]]
+ tp[0][imax[1]] = 0+nudge[imax[1]]
+ tp[1][imax[0]] = 1-nudge[imax[0]]
+ tp[1][imax[1]] = 0+nudge[imax[1]]
+ tp[2][imax[0]] = 1-nudge[imax[0]]
+ tp[2][imax[1]] = 1-nudge[imax[1]]
+ tp[3][imax[0]] = 0+nudge[imax[0]]
+ tp[3][imax[1]] = 1-nudge[imax[1]]
+
+ vp[0][imax[0]] = 0
+ vp[0][imax[1]] = 0
+ vp[1][imax[0]] = self.data.shape[imax[0]]
+ vp[1][imax[1]] = 0
+ vp[2][imax[0]] = self.data.shape[imax[0]]
+ vp[2][imax[1]] = self.data.shape[imax[1]]
+ vp[3][imax[0]] = 0
+ vp[3][imax[1]] = self.data.shape[imax[1]]
+ slices = self.data.shape[ax] * self.sliceDensity
+ r = list(range(slices))
+ if d == -1:
+ r = r[::-1]
+
+ glBegin(GL_QUADS)
+ tzVals = np.linspace(nudge[ax], 1.0-nudge[ax], slices)
+ vzVals = np.linspace(0, self.data.shape[ax], slices)
+ for i in r:
+ z = tzVals[i]
+ w = vzVals[i]
+
+ tp[0][ax] = z
+ tp[1][ax] = z
+ tp[2][ax] = z
+ tp[3][ax] = z
+
+ vp[0][ax] = w
+ vp[1][ax] = w
+ vp[2][ax] = w
+ vp[3][ax] = w
+
+
+ glTexCoord3f(*tp[0])
+ glVertex3f(*vp[0])
+ glTexCoord3f(*tp[1])
+ glVertex3f(*vp[1])
+ glTexCoord3f(*tp[2])
+ glVertex3f(*vp[2])
+ glTexCoord3f(*tp[3])
+ glVertex3f(*vp[3])
+ glEnd()
+
+
+
+
+
+
+
+
+
+ ## Interesting idea:
+ ## remove projection/modelview matrixes, recreate in texture coords.
+ ## it _sorta_ works, but needs tweaking.
+ #mvm = glGetDoublev(GL_MODELVIEW_MATRIX)
+ #pm = glGetDoublev(GL_PROJECTION_MATRIX)
+ #m = QtGui.QMatrix4x4(mvm.flatten()).inverted()[0]
+ #p = QtGui.QMatrix4x4(pm.flatten()).inverted()[0]
+
+ #glMatrixMode(GL_PROJECTION)
+ #glPushMatrix()
+ #glLoadIdentity()
+ #N=1
+ #glOrtho(-N,N,-N,N,-100,100)
+
+ #glMatrixMode(GL_MODELVIEW)
+ #glLoadIdentity()
+
+
+ #glMatrixMode(GL_TEXTURE)
+ #glLoadIdentity()
+ #glMultMatrixf(m.copyDataTo())
+
+ #view = self.view()
+ #w = view.width()
+ #h = view.height()
+ #dist = view.opts['distance']
+ #fov = view.opts['fov']
+ #nearClip = dist * .1
+ #farClip = dist * 5.
+ #r = nearClip * np.tan(fov)
+ #t = r * h / w
+
+ #p = QtGui.QMatrix4x4()
+ #p.frustum( -r, r, -t, t, nearClip, farClip)
+ #glMultMatrixf(p.inverted()[0].copyDataTo())
+
+
+ #glBegin(GL_QUADS)
+
+ #M=1
+ #for i in range(500):
+ #z = i/500.
+ #w = -i/500.
+ #glTexCoord3f(-M, -M, z)
+ #glVertex3f(-N, -N, w)
+ #glTexCoord3f(M, -M, z)
+ #glVertex3f(N, -N, w)
+ #glTexCoord3f(M, M, z)
+ #glVertex3f(N, N, w)
+ #glTexCoord3f(-M, M, z)
+ #glVertex3f(-N, N, w)
+ #glEnd()
+ #glDisable(GL_TEXTURE_3D)
+
+ #glMatrixMode(GL_PROJECTION)
+ #glPopMatrix()
+
+
+
diff --git a/pyqtgraph/opengl/items/__init__.py b/pyqtgraph/opengl/items/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/pyqtgraph/opengl/shaders.py b/pyqtgraph/opengl/shaders.py
new file mode 100644
index 00000000..b1652850
--- /dev/null
+++ b/pyqtgraph/opengl/shaders.py
@@ -0,0 +1,393 @@
+from OpenGL.GL import *
+from OpenGL.GL import shaders
+import re
+
+## For centralizing and managing vertex/fragment shader programs.
+
+def initShaders():
+ global Shaders
+ Shaders = [
+ ShaderProgram(None, []),
+
+ ## increases fragment alpha as the normal turns orthogonal to the view
+ ## this is useful for viewing shells that enclose a volume (such as isosurfaces)
+ ShaderProgram('balloon', [
+ VertexShader("""
+ varying vec3 normal;
+ void main() {
+ // compute here for use in fragment shader
+ normal = normalize(gl_NormalMatrix * gl_Normal);
+ gl_FrontColor = gl_Color;
+ gl_BackColor = gl_Color;
+ gl_Position = ftransform();
+ }
+ """),
+ FragmentShader("""
+ varying vec3 normal;
+ void main() {
+ vec4 color = gl_Color;
+ color.w = min(color.w + 2.0 * color.w * pow(normal.x*normal.x + normal.y*normal.y, 5.0), 1.0);
+ gl_FragColor = color;
+ }
+ """)
+ ]),
+
+ ## colors fragments based on face normals relative to view
+ ## This means that the colors will change depending on how the view is rotated
+ ShaderProgram('viewNormalColor', [
+ VertexShader("""
+ varying vec3 normal;
+ void main() {
+ // compute here for use in fragment shader
+ normal = normalize(gl_NormalMatrix * gl_Normal);
+ gl_FrontColor = gl_Color;
+ gl_BackColor = gl_Color;
+ gl_Position = ftransform();
+ }
+ """),
+ FragmentShader("""
+ varying vec3 normal;
+ void main() {
+ vec4 color = gl_Color;
+ color.x = (normal.x + 1.0) * 0.5;
+ color.y = (normal.y + 1.0) * 0.5;
+ color.z = (normal.z + 1.0) * 0.5;
+ gl_FragColor = color;
+ }
+ """)
+ ]),
+
+ ## colors fragments based on absolute face normals.
+ ShaderProgram('normalColor', [
+ VertexShader("""
+ varying vec3 normal;
+ void main() {
+ // compute here for use in fragment shader
+ normal = normalize(gl_Normal);
+ gl_FrontColor = gl_Color;
+ gl_BackColor = gl_Color;
+ gl_Position = ftransform();
+ }
+ """),
+ FragmentShader("""
+ varying vec3 normal;
+ void main() {
+ vec4 color = gl_Color;
+ color.x = (normal.x + 1.0) * 0.5;
+ color.y = (normal.y + 1.0) * 0.5;
+ color.z = (normal.z + 1.0) * 0.5;
+ gl_FragColor = color;
+ }
+ """)
+ ]),
+
+ ## very simple simulation of lighting.
+ ## The light source position is always relative to the camera.
+ ShaderProgram('shaded', [
+ VertexShader("""
+ varying vec3 normal;
+ void main() {
+ // compute here for use in fragment shader
+ normal = normalize(gl_NormalMatrix * gl_Normal);
+ gl_FrontColor = gl_Color;
+ gl_BackColor = gl_Color;
+ gl_Position = ftransform();
+ }
+ """),
+ FragmentShader("""
+ varying vec3 normal;
+ void main() {
+ float p = dot(normal, normalize(vec3(1.0, -1.0, -1.0)));
+ p = p < 0. ? 0. : p * 0.8;
+ vec4 color = gl_Color;
+ color.x = color.x * (0.2 + p);
+ color.y = color.y * (0.2 + p);
+ color.z = color.z * (0.2 + p);
+ gl_FragColor = color;
+ }
+ """)
+ ]),
+
+ ## colors get brighter near edges of object
+ ShaderProgram('edgeHilight', [
+ VertexShader("""
+ varying vec3 normal;
+ void main() {
+ // compute here for use in fragment shader
+ normal = normalize(gl_NormalMatrix * gl_Normal);
+ gl_FrontColor = gl_Color;
+ gl_BackColor = gl_Color;
+ gl_Position = ftransform();
+ }
+ """),
+ FragmentShader("""
+ varying vec3 normal;
+ void main() {
+ vec4 color = gl_Color;
+ float s = pow(normal.x*normal.x + normal.y*normal.y, 2.0);
+ color.x = color.x + s * (1.0-color.x);
+ color.y = color.y + s * (1.0-color.y);
+ color.z = color.z + s * (1.0-color.z);
+ gl_FragColor = color;
+ }
+ """)
+ ]),
+
+ ## colors fragments by z-value.
+ ## This is useful for coloring surface plots by height.
+ ## This shader uses a uniform called "colorMap" to determine how to map the colors:
+ ## red = pow(z * colorMap[0] + colorMap[1], colorMap[2])
+ ## green = pow(z * colorMap[3] + colorMap[4], colorMap[5])
+ ## blue = pow(z * colorMap[6] + colorMap[7], colorMap[8])
+ ## (set the values like this: shader['uniformMap'] = array([...])
+ ShaderProgram('heightColor', [
+ VertexShader("""
+ varying vec4 pos;
+ void main() {
+ gl_FrontColor = gl_Color;
+ gl_BackColor = gl_Color;
+ pos = gl_Vertex;
+ gl_Position = ftransform();
+ }
+ """),
+ FragmentShader("""
+ uniform float colorMap[9];
+ varying vec4 pos;
+ //out vec4 gl_FragColor; // only needed for later glsl versions
+ //in vec4 gl_Color;
+ void main() {
+ vec4 color = gl_Color;
+ color.x = colorMap[0] * (pos.z + colorMap[1]);
+ if (colorMap[2] != 1.0)
+ color.x = pow(color.x, colorMap[2]);
+ color.x = color.x < 0. ? 0. : (color.x > 1. ? 1. : color.x);
+
+ color.y = colorMap[3] * (pos.z + colorMap[4]);
+ if (colorMap[5] != 1.0)
+ color.y = pow(color.y, colorMap[5]);
+ color.y = color.y < 0. ? 0. : (color.y > 1. ? 1. : color.y);
+
+ color.z = colorMap[6] * (pos.z + colorMap[7]);
+ if (colorMap[8] != 1.0)
+ color.z = pow(color.z, colorMap[8]);
+ color.z = color.z < 0. ? 0. : (color.z > 1. ? 1. : color.z);
+
+ color.w = 1.0;
+ gl_FragColor = color;
+ }
+ """),
+ ], uniforms={'colorMap': [1, 1, 1, 1, 0.5, 1, 1, 0, 1]}),
+ ShaderProgram('pointSprite', [ ## allows specifying point size using normal.x
+ ## See:
+ ##
+ ## http://stackoverflow.com/questions/9609423/applying-part-of-a-texture-sprite-sheet-texture-map-to-a-point-sprite-in-ios
+ ## http://stackoverflow.com/questions/3497068/textured-points-in-opengl-es-2-0
+ ##
+ ##
+ VertexShader("""
+ void main() {
+ gl_FrontColor=gl_Color;
+ gl_PointSize = gl_Normal.x;
+ gl_Position = ftransform();
+ }
+ """),
+ #FragmentShader("""
+ ##version 120
+ #uniform sampler2D texture;
+ #void main ( )
+ #{
+ #gl_FragColor = texture2D(texture, gl_PointCoord) * gl_Color;
+ #}
+ #""")
+ ]),
+ ]
+
+
+CompiledShaderPrograms = {}
+
+def getShaderProgram(name):
+ return ShaderProgram.names[name]
+
+class Shader(object):
+ def __init__(self, shaderType, code):
+ self.shaderType = shaderType
+ self.code = code
+ self.compiled = None
+
+ def shader(self):
+ if self.compiled is None:
+ try:
+ self.compiled = shaders.compileShader(self.code, self.shaderType)
+ except RuntimeError as exc:
+ ## Format compile errors a bit more nicely
+ if len(exc.args) == 3:
+ err, code, typ = exc.args
+ if not err.startswith('Shader compile failure'):
+ raise
+ code = code[0].split('\n')
+ err, c, msgs = err.partition(':')
+ err = err + '\n'
+ msgs = msgs.split('\n')
+ errNums = [()] * len(code)
+ for i, msg in enumerate(msgs):
+ msg = msg.strip()
+ if msg == '':
+ continue
+ m = re.match(r'(\d+\:)?\d+\((\d+)\)', msg)
+ if m is not None:
+ line = int(m.groups()[1])
+ errNums[line-1] = errNums[line-1] + (str(i+1),)
+ #code[line-1] = '%d\t%s' % (i+1, code[line-1])
+ err = err + "%d %s\n" % (i+1, msg)
+ errNums = [','.join(n) for n in errNums]
+ maxlen = max(map(len, errNums))
+ code = [errNums[i] + " "*(maxlen-len(errNums[i])) + line for i, line in enumerate(code)]
+ err = err + '\n'.join(code)
+ raise Exception(err)
+ else:
+ raise
+ return self.compiled
+
+class VertexShader(Shader):
+ def __init__(self, code):
+ Shader.__init__(self, GL_VERTEX_SHADER, code)
+
+class FragmentShader(Shader):
+ def __init__(self, code):
+ Shader.__init__(self, GL_FRAGMENT_SHADER, code)
+
+
+
+
+class ShaderProgram(object):
+ names = {}
+
+ def __init__(self, name, shaders, uniforms=None):
+ self.name = name
+ ShaderProgram.names[name] = self
+ self.shaders = shaders
+ self.prog = None
+ self.blockData = {}
+ self.uniformData = {}
+
+ ## parse extra options from the shader definition
+ if uniforms is not None:
+ for k,v in uniforms.items():
+ self[k] = v
+
+ def setBlockData(self, blockName, data):
+ if data is None:
+ del self.blockData[blockName]
+ else:
+ self.blockData[blockName] = data
+
+ def setUniformData(self, uniformName, data):
+ if data is None:
+ del self.uniformData[uniformName]
+ else:
+ self.uniformData[uniformName] = data
+
+ def __setitem__(self, item, val):
+ self.setUniformData(item, val)
+
+ def __delitem__(self, item):
+ self.setUniformData(item, None)
+
+ def program(self):
+ if self.prog is None:
+ try:
+ compiled = [s.shader() for s in self.shaders] ## compile all shaders
+ self.prog = shaders.compileProgram(*compiled) ## compile program
+ except:
+ self.prog = -1
+ raise
+ return self.prog
+
+ def __enter__(self):
+ if len(self.shaders) > 0 and self.program() != -1:
+ glUseProgram(self.program())
+
+ try:
+ ## load uniform values into program
+ for uniformName, data in self.uniformData.items():
+ loc = self.uniform(uniformName)
+ if loc == -1:
+ raise Exception('Could not find uniform variable "%s"' % uniformName)
+ glUniform1fv(loc, len(data), data)
+
+ ### bind buffer data to program blocks
+ #if len(self.blockData) > 0:
+ #bindPoint = 1
+ #for blockName, data in self.blockData.items():
+ ### Program should have a uniform block declared:
+ ###
+ ### layout (std140) uniform blockName {
+ ### vec4 diffuse;
+ ### };
+
+ ### pick any-old binding point. (there are a limited number of these per-program
+ #bindPoint = 1
+
+ ### get the block index for a uniform variable in the shader
+ #blockIndex = glGetUniformBlockIndex(self.program(), blockName)
+
+ ### give the shader block a binding point
+ #glUniformBlockBinding(self.program(), blockIndex, bindPoint)
+
+ ### create a buffer
+ #buf = glGenBuffers(1)
+ #glBindBuffer(GL_UNIFORM_BUFFER, buf)
+ #glBufferData(GL_UNIFORM_BUFFER, size, data, GL_DYNAMIC_DRAW)
+ ### also possible to use glBufferSubData to fill parts of the buffer
+
+ ### bind buffer to the same binding point
+ #glBindBufferBase(GL_UNIFORM_BUFFER, bindPoint, buf)
+ except:
+ glUseProgram(0)
+ raise
+
+
+
+ def __exit__(self, *args):
+ if len(self.shaders) > 0:
+ glUseProgram(0)
+
+ def uniform(self, name):
+ """Return the location integer for a uniform variable in this program"""
+ return glGetUniformLocation(self.program(), name)
+
+ #def uniformBlockInfo(self, blockName):
+ #blockIndex = glGetUniformBlockIndex(self.program(), blockName)
+ #count = glGetActiveUniformBlockiv(self.program(), blockIndex, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS)
+ #indices = []
+ #for i in range(count):
+ #indices.append(glGetActiveUniformBlockiv(self.program(), blockIndex, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES))
+
+class HeightColorShader(ShaderProgram):
+ def __enter__(self):
+ ## Program should have a uniform block declared:
+ ##
+ ## layout (std140) uniform blockName {
+ ## vec4 diffuse;
+ ## vec4 ambient;
+ ## };
+
+ ## pick any-old binding point. (there are a limited number of these per-program
+ bindPoint = 1
+
+ ## get the block index for a uniform variable in the shader
+ blockIndex = glGetUniformBlockIndex(self.program(), "blockName")
+
+ ## give the shader block a binding point
+ glUniformBlockBinding(self.program(), blockIndex, bindPoint)
+
+ ## create a buffer
+ buf = glGenBuffers(1)
+ glBindBuffer(GL_UNIFORM_BUFFER, buf)
+ glBufferData(GL_UNIFORM_BUFFER, size, data, GL_DYNAMIC_DRAW)
+ ## also possible to use glBufferSubData to fill parts of the buffer
+
+ ## bind buffer to the same binding point
+ glBindBufferBase(GL_UNIFORM_BUFFER, bindPoint, buf)
+
+initShaders()
\ No newline at end of file
diff --git a/pyqtgraph/parametertree/Parameter.py b/pyqtgraph/parametertree/Parameter.py
new file mode 100644
index 00000000..c8ed4902
--- /dev/null
+++ b/pyqtgraph/parametertree/Parameter.py
@@ -0,0 +1,680 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import os, weakref, re
+from pyqtgraph.pgcollections import OrderedDict
+from .ParameterItem import ParameterItem
+
+PARAM_TYPES = {}
+PARAM_NAMES = {}
+
+def registerParameterType(name, cls, override=False):
+ global PARAM_TYPES
+ if name in PARAM_TYPES and not override:
+ raise Exception("Parameter type '%s' already exists (use override=True to replace)" % name)
+ PARAM_TYPES[name] = cls
+ PARAM_NAMES[cls] = name
+
+
+
+class Parameter(QtCore.QObject):
+ """
+ A Parameter is the basic unit of data in a parameter tree. Each parameter has
+ a name, a type, a value, and several other properties that modify the behavior of the
+ Parameter. Parameters may have parent / child / sibling relationships to construct
+ organized hierarchies. Parameters generally do not have any inherent GUI or visual
+ interpretation; instead they manage ParameterItem instances which take care of
+ display and user interaction.
+
+ Note: It is fairly uncommon to use the Parameter class directly; mostly you
+ will use subclasses which provide specialized type and data handling. The static
+ pethod Parameter.create(...) is an easy way to generate instances of these subclasses.
+
+ For more Parameter types, see ParameterTree.parameterTypes module.
+
+ =================================== =========================================================
+ **Signals:**
+ sigStateChanged(self, change, info) Emitted when anything changes about this parameter at
+ all.
+ The second argument is a string indicating what changed
+ ('value', 'childAdded', etc..)
+ The third argument can be any extra information about
+ the change
+ sigTreeStateChanged(self, changes) Emitted when any child in the tree changes state
+ (but only if monitorChildren() is called)
+ the format of *changes* is [(param, change, info), ...]
+ sigValueChanged(self, value) Emitted when value is finished changing
+ sigValueChanging(self, value) Emitted immediately for all value changes,
+ including during editing.
+ sigChildAdded(self, child, index) Emitted when a child is added
+ sigChildRemoved(self, child) Emitted when a child is removed
+ sigParentChanged(self, parent) Emitted when this parameter's parent has changed
+ sigLimitsChanged(self, limits) Emitted when this parameter's limits have changed
+ sigDefaultChanged(self, default) Emitted when this parameter's default value has changed
+ sigNameChanged(self, name) Emitted when this parameter's name has changed
+ sigOptionsChanged(self, opts) Emitted when any of this parameter's options have changed
+ =================================== =========================================================
+ """
+ ## name, type, limits, etc.
+ ## can also carry UI hints (slider vs spinbox, etc.)
+
+ sigValueChanged = QtCore.Signal(object, object) ## self, value emitted when value is finished being edited
+ sigValueChanging = QtCore.Signal(object, object) ## self, value emitted as value is being edited
+
+ sigChildAdded = QtCore.Signal(object, object, object) ## self, child, index
+ sigChildRemoved = QtCore.Signal(object, object) ## self, child
+ sigParentChanged = QtCore.Signal(object, object) ## self, parent
+ sigLimitsChanged = QtCore.Signal(object, object) ## self, limits
+ sigDefaultChanged = QtCore.Signal(object, object) ## self, default
+ sigNameChanged = QtCore.Signal(object, object) ## self, name
+ sigOptionsChanged = QtCore.Signal(object, object) ## self, {opt:val, ...}
+
+ ## Emitted when anything changes about this parameter at all.
+ ## The second argument is a string indicating what changed ('value', 'childAdded', etc..)
+ ## The third argument can be any extra information about the change
+ sigStateChanged = QtCore.Signal(object, object, object) ## self, change, info
+
+ ## emitted when any child in the tree changes state
+ ## (but only if monitorChildren() is called)
+ sigTreeStateChanged = QtCore.Signal(object, object) # self, changes
+ # changes = [(param, change, info), ...]
+
+ # bad planning.
+ #def __new__(cls, *args, **opts):
+ #try:
+ #cls = PARAM_TYPES[opts['type']]
+ #except KeyError:
+ #pass
+ #return QtCore.QObject.__new__(cls, *args, **opts)
+
+ @staticmethod
+ def create(**opts):
+ """
+ Create a new Parameter (or subclass) instance using opts['type'] to select the
+ appropriate class.
+
+ Use registerParameterType() to add new class types.
+ """
+ typ = opts.get('type', None)
+ if typ is None:
+ cls = Parameter
+ else:
+ cls = PARAM_TYPES[opts['type']]
+ return cls(**opts)
+
+ def __init__(self, **opts):
+ QtCore.QObject.__init__(self)
+
+ self.opts = {
+ 'type': None,
+ 'readonly': False,
+ 'visible': True,
+ 'enabled': True,
+ 'renamable': False,
+ 'removable': False,
+ 'strictNaming': False, # forces name to be usable as a python variable
+ #'limits': None, ## This is a bad plan--each parameter type may have a different data type for limits.
+ }
+ self.opts.update(opts)
+
+ self.childs = []
+ self.names = {} ## map name:child
+ self.items = weakref.WeakKeyDictionary() ## keeps track of tree items representing this parameter
+ self._parent = None
+ self.treeStateChanges = [] ## cache of tree state changes to be delivered on next emit
+ self.blockTreeChangeEmit = 0
+ #self.monitoringChildren = False ## prevent calling monitorChildren more than once
+
+ if 'value' not in self.opts:
+ self.opts['value'] = None
+
+ if 'name' not in self.opts or not isinstance(self.opts['name'], basestring):
+ raise Exception("Parameter must have a string name specified in opts.")
+ self.setName(opts['name'])
+
+ self.addChildren(self.opts.get('children', []))
+
+ if 'value' in self.opts and 'default' not in self.opts:
+ self.opts['default'] = self.opts['value']
+
+ ## Connect all state changed signals to the general sigStateChanged
+ self.sigValueChanged.connect(lambda param, data: self.emitStateChanged('value', data))
+ self.sigChildAdded.connect(lambda param, *data: self.emitStateChanged('childAdded', data))
+ self.sigChildRemoved.connect(lambda param, data: self.emitStateChanged('childRemoved', data))
+ self.sigParentChanged.connect(lambda param, data: self.emitStateChanged('parent', data))
+ self.sigLimitsChanged.connect(lambda param, data: self.emitStateChanged('limits', data))
+ self.sigDefaultChanged.connect(lambda param, data: self.emitStateChanged('default', data))
+ self.sigNameChanged.connect(lambda param, data: self.emitStateChanged('name', data))
+ self.sigOptionsChanged.connect(lambda param, data: self.emitStateChanged('options', data))
+
+ #self.watchParam(self) ## emit treechange signals if our own state changes
+
+ def name(self):
+ return self.opts['name']
+
+ def setName(self, name):
+ """Attempt to change the name of this parameter; return the actual name.
+ (The parameter may reject the name change or automatically pick a different name)"""
+ if self.opts['strictNaming']:
+ if len(name) < 1 or re.search(r'\W', name) or re.match(r'\d', name[0]):
+ raise Exception("Parameter name '%s' is invalid. (Must contain only alphanumeric and underscore characters and may not start with a number)" % name)
+ parent = self.parent()
+ if parent is not None:
+ name = parent._renameChild(self, name) ## first ask parent if it's ok to rename
+ if self.opts['name'] != name:
+ self.opts['name'] = name
+ self.sigNameChanged.emit(self, name)
+ return name
+
+ def type(self):
+ return self.opts['type']
+
+ def isType(self, typ):
+ """
+ Return True if this parameter type matches the name *typ*.
+ This can occur either of two ways:
+
+ - If self.type() == *typ*
+ - If this parameter's class is registered with the name *typ*
+ """
+ if self.type() == typ:
+ return True
+ global PARAM_TYPES
+ cls = PARAM_TYPES.get(typ, None)
+ if cls is None:
+ raise Exception("Type name '%s' is not registered." % str(typ))
+ return self.__class__ is cls
+
+ def childPath(self, child):
+ """
+ Return the path of parameter names from self to child.
+ If child is not a (grand)child of self, return None.
+ """
+ path = []
+ while child is not self:
+ path.insert(0, child.name())
+ child = child.parent()
+ if child is None:
+ return None
+ return path
+
+ def setValue(self, value, blockSignal=None):
+ ## return the actual value that was set
+ ## (this may be different from the value that was requested)
+ try:
+ if blockSignal is not None:
+ self.sigValueChanged.disconnect(blockSignal)
+ if self.opts['value'] == value:
+ return value
+ self.opts['value'] = value
+ self.sigValueChanged.emit(self, value)
+ finally:
+ if blockSignal is not None:
+ self.sigValueChanged.connect(blockSignal)
+
+ return value
+
+ def value(self):
+ return self.opts['value']
+
+ def getValues(self):
+ """Return a tree of all values that are children of this parameter"""
+ vals = OrderedDict()
+ for ch in self:
+ vals[ch.name()] = (ch.value(), ch.getValues())
+ return vals
+
+ def saveState(self):
+ """
+ Return a structure representing the entire state of the parameter tree.
+ The tree state may be restored from this structure using restoreState()
+ """
+ state = self.opts.copy()
+ state['children'] = OrderedDict([(ch.name(), ch.saveState()) for ch in self])
+ if state['type'] is None:
+ global PARAM_NAMES
+ state['type'] = PARAM_NAMES.get(type(self), None)
+ return state
+
+ def restoreState(self, state, recursive=True, addChildren=True, removeChildren=True, blockSignals=True):
+ """
+ Restore the state of this parameter and its children from a structure generated using saveState()
+ If recursive is True, then attempt to restore the state of child parameters as well.
+ If addChildren is True, then any children which are referenced in the state object will be
+ created if they do not already exist.
+ If removeChildren is True, then any children which are not referenced in the state object will
+ be removed.
+ If blockSignals is True, no signals will be emitted until the tree has been completely restored.
+ This prevents signal handlers from responding to a partially-rebuilt network.
+ """
+ childState = state.get('children', [])
+
+ ## list of children may be stored either as list or dict.
+ if isinstance(childState, dict):
+ childState = childState.values()
+
+
+ if blockSignals:
+ self.blockTreeChangeSignal()
+
+ try:
+ self.setOpts(**state)
+
+ if not recursive:
+ return
+
+ ptr = 0 ## pointer to first child that has not been restored yet
+ foundChilds = set()
+ #print "==============", self.name()
+
+ for ch in childState:
+ name = ch['name']
+ typ = ch['type']
+ #print('child: %s, %s' % (self.name()+'.'+name, typ))
+
+ ## First, see if there is already a child with this name and type
+ gotChild = False
+ for i, ch2 in enumerate(self.childs[ptr:]):
+ #print " ", ch2.name(), ch2.type()
+ if ch2.name() != name or not ch2.isType(typ):
+ continue
+ gotChild = True
+ #print " found it"
+ if i != 0: ## move parameter to next position
+ #self.removeChild(ch2)
+ self.insertChild(ptr, ch2)
+ #print " moved to position", ptr
+ ch2.restoreState(ch, recursive=recursive, addChildren=addChildren, removeChildren=removeChildren)
+ foundChilds.add(ch2)
+
+ break
+
+ if not gotChild:
+ if not addChildren:
+ #print " ignored child"
+ continue
+ #print " created new"
+ ch2 = Parameter.create(**ch)
+ self.insertChild(ptr, ch2)
+ foundChilds.add(ch2)
+
+ ptr += 1
+
+ if removeChildren:
+ for ch in self.childs[:]:
+ if ch not in foundChilds:
+ #print " remove:", ch
+ self.removeChild(ch)
+ finally:
+ if blockSignals:
+ self.unblockTreeChangeSignal()
+
+
+
+ def defaultValue(self):
+ """Return the default value for this parameter."""
+ return self.opts['default']
+
+ def setDefault(self, val):
+ """Set the default value for this parameter."""
+ if self.opts['default'] == val:
+ return
+ self.opts['default'] = val
+ self.sigDefaultChanged.emit(self, val)
+
+ def setToDefault(self):
+ """Set this parameter's value to the default."""
+ if self.hasDefault():
+ self.setValue(self.defaultValue())
+
+ def hasDefault(self):
+ """Returns True if this parameter has a default value."""
+ return 'default' in self.opts
+
+ def valueIsDefault(self):
+ """Returns True if this parameter's value is equal to the default value."""
+ return self.value() == self.defaultValue()
+
+ def setLimits(self, limits):
+ """Set limits on the acceptable values for this parameter.
+ The format of limits depends on the type of the parameter and
+ some parameters do not make use of limits at all."""
+ if 'limits' in self.opts and self.opts['limits'] == limits:
+ return
+ self.opts['limits'] = limits
+ self.sigLimitsChanged.emit(self, limits)
+ return limits
+
+ def writable(self):
+ """
+ Returns True if this parameter's value can be changed by the user.
+ Note that the value of the parameter can *always* be changed by
+ calling setValue().
+ """
+ return not self.opts.get('readonly', False)
+
+ def setWritable(self, writable=True):
+ self.setOpts(readonly=not writable)
+
+ def setReadonly(self, readonly=True):
+ self.setOpts(readonly=readonly)
+
+ def setOpts(self, **opts):
+ """
+ Set any arbitrary options on this parameter.
+ The exact behavior of this function will depend on the parameter type, but
+ most parameters will accept a common set of options: value, name, limits,
+ default, readonly, removable, renamable, visible, and enabled.
+ """
+ changed = OrderedDict()
+ for k in opts:
+ if k == 'value':
+ self.setValue(opts[k])
+ elif k == 'name':
+ self.setName(opts[k])
+ elif k == 'limits':
+ self.setLimits(opts[k])
+ elif k == 'default':
+ self.setDefault(opts[k])
+ elif k not in self.opts or self.opts[k] != opts[k]:
+ self.opts[k] = opts[k]
+ changed[k] = opts[k]
+
+ if len(changed) > 0:
+ self.sigOptionsChanged.emit(self, changed)
+
+ def emitStateChanged(self, changeDesc, data):
+ ## Emits stateChanged signal and
+ ## requests emission of new treeStateChanged signal
+ self.sigStateChanged.emit(self, changeDesc, data)
+ #self.treeStateChanged(self, changeDesc, data)
+ self.treeStateChanges.append((self, changeDesc, data))
+ self.emitTreeChanges()
+
+ def makeTreeItem(self, depth):
+ """Return a TreeWidgetItem suitable for displaying/controlling the content of this parameter.
+ Most subclasses will want to override this function.
+ """
+ if hasattr(self, 'itemClass'):
+ #print "Param:", self, "Make item from itemClass:", self.itemClass
+ return self.itemClass(self, depth)
+ else:
+ return ParameterItem(self, depth=depth)
+
+
+ def addChild(self, child):
+ """Add another parameter to the end of this parameter's child list."""
+ return self.insertChild(len(self.childs), child)
+
+ def addChildren(self, children):
+ ## If children was specified as dict, then assume keys are the names.
+ if isinstance(children, dict):
+ ch2 = []
+ for name, opts in children.items():
+ if isinstance(opts, dict) and 'name' not in opts:
+ opts = opts.copy()
+ opts['name'] = name
+ ch2.append(opts)
+ children = ch2
+
+ for chOpts in children:
+ #print self, "Add child:", type(chOpts), id(chOpts)
+ self.addChild(chOpts)
+
+
+ def insertChild(self, pos, child):
+ """
+ Insert a new child at pos.
+ If pos is a Parameter, then insert at the position of that Parameter.
+ If child is a dict, then a parameter is constructed as Parameter(\*\*child)
+ """
+ if isinstance(child, dict):
+ child = Parameter.create(**child)
+
+ name = child.name()
+ if name in self.names and child is not self.names[name]:
+ if child.opts.get('autoIncrementName', False):
+ name = self.incrementName(name)
+ child.setName(name)
+ else:
+ raise Exception("Already have child named %s" % str(name))
+ if isinstance(pos, Parameter):
+ pos = self.childs.index(pos)
+
+ with self.treeChangeBlocker():
+ if child.parent() is not None:
+ child.remove()
+
+ self.names[name] = child
+ self.childs.insert(pos, child)
+
+ child.parentChanged(self)
+ self.sigChildAdded.emit(self, child, pos)
+ child.sigTreeStateChanged.connect(self.treeStateChanged)
+ return child
+
+ def removeChild(self, child):
+ """Remove a child parameter."""
+ name = child.name()
+ if name not in self.names or self.names[name] is not child:
+ raise Exception("Parameter %s is not my child; can't remove." % str(child))
+ del self.names[name]
+ self.childs.pop(self.childs.index(child))
+ child.parentChanged(None)
+ self.sigChildRemoved.emit(self, child)
+ try:
+ child.sigTreeStateChanged.disconnect(self.treeStateChanged)
+ except TypeError: ## already disconnected
+ pass
+
+ def clearChildren(self):
+ """Remove all child parameters."""
+ for ch in self.childs[:]:
+ self.removeChild(ch)
+
+ def children(self):
+ """Return a list of this parameter's children."""
+ ## warning -- this overrides QObject.children
+ return self.childs[:]
+
+ def hasChildren(self):
+ return len(self.childs) > 0
+
+ def parentChanged(self, parent):
+ """This method is called when the parameter's parent has changed.
+ It may be useful to extend this method in subclasses."""
+ self._parent = parent
+ self.sigParentChanged.emit(self, parent)
+
+ def parent(self):
+ """Return the parent of this parameter."""
+ return self._parent
+
+ def remove(self):
+ """Remove this parameter from its parent's child list"""
+ parent = self.parent()
+ if parent is None:
+ raise Exception("Cannot remove; no parent.")
+ parent.removeChild(self)
+
+ def incrementName(self, name):
+ ## return an unused name by adding a number to the name given
+ base, num = re.match('(.*)(\d*)', name).groups()
+ numLen = len(num)
+ if numLen == 0:
+ num = 2
+ numLen = 1
+ else:
+ num = int(num)
+ while True:
+ newName = base + ("%%0%dd"%numLen) % num
+ if newName not in self.names:
+ return newName
+ num += 1
+
+ def __iter__(self):
+ for ch in self.childs:
+ yield ch
+
+ def __getitem__(self, names):
+ """Get the value of a child parameter. The name may also be a tuple giving
+ the path to a sub-parameter::
+
+ value = param[('child', 'grandchild')]
+ """
+ if not isinstance(names, tuple):
+ names = (names,)
+ return self.param(*names).value()
+
+ def __setitem__(self, names, value):
+ """Set the value of a child parameter. The name may also be a tuple giving
+ the path to a sub-parameter::
+
+ param[('child', 'grandchild')] = value
+ """
+ if isinstance(names, basestring):
+ names = (names,)
+ return self.param(*names).setValue(value)
+
+ def param(self, *names):
+ """Return a child parameter.
+ Accepts the name of the child or a tuple (path, to, child)"""
+ try:
+ param = self.names[names[0]]
+ except KeyError:
+ raise Exception("Parameter %s has no child named %s" % (self.name(), names[0]))
+
+ if len(names) > 1:
+ return param.param(*names[1:])
+ else:
+ return param
+
+ def __repr__(self):
+ return "<%s '%s' at 0x%x>" % (self.__class__.__name__, self.name(), id(self))
+
+ def __getattr__(self, attr):
+ ## Leaving this undocumented because I might like to remove it in the future..
+ #print type(self), attr
+ if 'names' not in self.__dict__:
+ raise AttributeError(attr)
+ if attr in self.names:
+ return self.param(attr)
+ else:
+ raise AttributeError(attr)
+
+ def _renameChild(self, child, name):
+ ## Only to be called from Parameter.rename
+ if name in self.names:
+ return child.name()
+ self.names[name] = child
+ del self.names[child.name()]
+ return name
+
+ def registerItem(self, item):
+ self.items[item] = None
+
+ def hide(self):
+ """Hide this parameter. It and its children will no longer be visible in any ParameterTree
+ widgets it is connected to."""
+ self.show(False)
+
+ def show(self, s=True):
+ """Show this parameter. """
+ self.opts['visible'] = s
+ self.sigOptionsChanged.emit(self, {'visible': s})
+
+
+ #def monitorChildren(self):
+ #if self.monitoringChildren:
+ #raise Exception("Already monitoring children.")
+ #self.watchParam(self)
+ #self.monitoringChildren = True
+
+ #def watchParam(self, param):
+ #param.sigChildAdded.connect(self.grandchildAdded)
+ #param.sigChildRemoved.connect(self.grandchildRemoved)
+ #param.sigStateChanged.connect(self.grandchildChanged)
+ #for ch in param:
+ #self.watchParam(ch)
+
+ #def unwatchParam(self, param):
+ #param.sigChildAdded.disconnect(self.grandchildAdded)
+ #param.sigChildRemoved.disconnect(self.grandchildRemoved)
+ #param.sigStateChanged.disconnect(self.grandchildChanged)
+ #for ch in param:
+ #self.unwatchParam(ch)
+
+ #def grandchildAdded(self, parent, child):
+ #self.watchParam(child)
+
+ #def grandchildRemoved(self, parent, child):
+ #self.unwatchParam(child)
+
+ #def grandchildChanged(self, param, change, data):
+ ##self.sigTreeStateChanged.emit(self, param, change, data)
+ #self.emitTreeChange((param, change, data))
+
+ def treeChangeBlocker(self):
+ """
+ Return an object that can be used to temporarily block and accumulate
+ sigTreeStateChanged signals. This is meant to be used when numerous changes are
+ about to be made to the tree and only one change signal should be
+ emitted at the end.
+
+ Example::
+
+ with param.treeChangeBlocker():
+ param.addChild(...)
+ param.removeChild(...)
+ param.setValue(...)
+ """
+ return SignalBlocker(self.blockTreeChangeSignal, self.unblockTreeChangeSignal)
+
+ def blockTreeChangeSignal(self):
+ """
+ Used to temporarily block and accumulate tree change signals.
+ *You must remember to unblock*, so it is advisable to use treeChangeBlocker() instead.
+ """
+ self.blockTreeChangeEmit += 1
+
+ def unblockTreeChangeSignal(self):
+ """Unblocks enission of sigTreeStateChanged and flushes the changes out through a single signal."""
+ self.blockTreeChangeEmit -= 1
+ self.emitTreeChanges()
+
+
+ def treeStateChanged(self, param, changes):
+ """
+ Called when the state of any sub-parameter has changed.
+
+ ========== ================================================================
+ Arguments:
+ param The immediate child whose tree state has changed.
+ note that the change may have originated from a grandchild.
+ changes List of tuples describing all changes that have been made
+ in this event: (param, changeDescr, data)
+ ========== ================================================================
+
+ This function can be extended to react to tree state changes.
+ """
+ self.treeStateChanges.extend(changes)
+ self.emitTreeChanges()
+
+ def emitTreeChanges(self):
+ if self.blockTreeChangeEmit == 0:
+ changes = self.treeStateChanges
+ self.treeStateChanges = []
+ self.sigTreeStateChanged.emit(self, changes)
+
+
+class SignalBlocker(object):
+ def __init__(self, enterFn, exitFn):
+ self.enterFn = enterFn
+ self.exitFn = exitFn
+
+ def __enter__(self):
+ self.enterFn()
+
+ def __exit__(self, exc_type, exc_value, tb):
+ self.exitFn()
+
+
+
diff --git a/pyqtgraph/parametertree/ParameterItem.py b/pyqtgraph/parametertree/ParameterItem.py
new file mode 100644
index 00000000..376e900d
--- /dev/null
+++ b/pyqtgraph/parametertree/ParameterItem.py
@@ -0,0 +1,159 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import os, weakref, re
+
+class ParameterItem(QtGui.QTreeWidgetItem):
+ """
+ Abstract ParameterTree item.
+ Used to represent the state of a Parameter from within a ParameterTree.
+
+ - Sets first column of item to name
+ - generates context menu if item is renamable or removable
+ - handles child added / removed events
+ - provides virtual functions for handling changes from parameter
+
+ For more ParameterItem types, see ParameterTree.parameterTypes module.
+ """
+
+ def __init__(self, param, depth=0):
+ QtGui.QTreeWidgetItem.__init__(self, [param.name(), ''])
+
+ self.param = param
+ self.param.registerItem(self) ## let parameter know this item is connected to it (for debugging)
+ self.depth = depth
+
+ param.sigValueChanged.connect(self.valueChanged)
+ param.sigChildAdded.connect(self.childAdded)
+ param.sigChildRemoved.connect(self.childRemoved)
+ param.sigNameChanged.connect(self.nameChanged)
+ param.sigLimitsChanged.connect(self.limitsChanged)
+ param.sigDefaultChanged.connect(self.defaultChanged)
+ param.sigOptionsChanged.connect(self.optsChanged)
+ param.sigParentChanged.connect(self.parentChanged)
+
+
+ opts = param.opts
+
+ ## Generate context menu for renaming/removing parameter
+ self.contextMenu = QtGui.QMenu()
+ self.contextMenu.addSeparator()
+ flags = QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
+ if opts.get('renamable', False):
+ flags |= QtCore.Qt.ItemIsEditable
+ self.contextMenu.addAction('Rename').triggered.connect(self.editName)
+ if opts.get('removable', False):
+ self.contextMenu.addAction("Remove").triggered.connect(self.requestRemove)
+
+ ## handle movable / dropEnabled options
+ if opts.get('movable', False):
+ flags |= QtCore.Qt.ItemIsDragEnabled
+ if opts.get('dropEnabled', False):
+ flags |= QtCore.Qt.ItemIsDropEnabled
+ self.setFlags(flags)
+
+ ## flag used internally during name editing
+ self.ignoreNameColumnChange = False
+
+
+ def valueChanged(self, param, val):
+ ## called when the parameter's value has changed
+ pass
+
+ def isFocusable(self):
+ """Return True if this item should be included in the tab-focus order"""
+ return False
+
+ def setFocus(self):
+ """Give input focus to this item.
+ Can be reimplemented to display editor widgets, etc.
+ """
+ pass
+
+ def focusNext(self, forward=True):
+ """Give focus to the next (or previous) focusable item in the parameter tree"""
+ self.treeWidget().focusNext(self, forward=forward)
+
+
+ def treeWidgetChanged(self):
+ """Called when this item is added or removed from a tree.
+ Expansion, visibility, and column widgets must all be configured AFTER
+ the item is added to a tree, not during __init__.
+ """
+ self.setHidden(not self.param.opts.get('visible', True))
+ self.setExpanded(self.param.opts.get('expanded', True))
+
+ def childAdded(self, param, child, pos):
+ item = child.makeTreeItem(depth=self.depth+1)
+ self.insertChild(pos, item)
+ item.treeWidgetChanged()
+
+ for i, ch in enumerate(child):
+ item.childAdded(child, ch, i)
+
+ def childRemoved(self, param, child):
+ for i in range(self.childCount()):
+ item = self.child(i)
+ if item.param is child:
+ self.takeChild(i)
+ break
+
+ def parentChanged(self, param, parent):
+ ## called when the parameter's parent has changed.
+ pass
+
+ def contextMenuEvent(self, ev):
+ if not self.param.opts.get('removable', False) and not self.param.opts.get('renamable', False):
+ return
+
+ self.contextMenu.popup(ev.globalPos())
+
+ def columnChangedEvent(self, col):
+ """Called when the text in a column has been edited.
+ By default, we only use changes to column 0 to rename the parameter.
+ """
+ if col == 0:
+ if self.ignoreNameColumnChange:
+ return
+ try:
+ newName = self.param.setName(str(self.text(col)))
+ except:
+ self.setText(0, self.param.name())
+ raise
+
+ try:
+ self.ignoreNameColumnChange = True
+ self.nameChanged(self, newName) ## If the parameter rejects the name change, we need to set it back.
+ finally:
+ self.ignoreNameColumnChange = False
+
+ def nameChanged(self, param, name):
+ ## called when the parameter's name has changed.
+ self.setText(0, name)
+
+ def limitsChanged(self, param, limits):
+ """Called when the parameter's limits have changed"""
+ pass
+
+ def defaultChanged(self, param, default):
+ """Called when the parameter's default value has changed"""
+ pass
+
+ def optsChanged(self, param, opts):
+ """Called when any options are changed that are not
+ name, value, default, or limits"""
+ #print opts
+ if 'visible' in opts:
+ self.setHidden(not opts['visible'])
+
+ def editName(self):
+ self.treeWidget().editItem(self, 0)
+
+ def selected(self, sel):
+ """Called when this item has been selected (sel=True) OR deselected (sel=False)"""
+ pass
+
+ def requestRemove(self):
+ ## called when remove is selected from the context menu.
+ ## we need to delay removal until the action is complete
+ ## since destroying the menu in mid-action will cause a crash.
+ QtCore.QTimer.singleShot(0, self.param.remove)
+
diff --git a/pyqtgraph/parametertree/ParameterTree.py b/pyqtgraph/parametertree/ParameterTree.py
new file mode 100644
index 00000000..e57430ea
--- /dev/null
+++ b/pyqtgraph/parametertree/ParameterTree.py
@@ -0,0 +1,118 @@
+from pyqtgraph.Qt import QtCore, QtGui
+from pyqtgraph.widgets.TreeWidget import TreeWidget
+import os, weakref, re
+#import functions as fn
+
+
+
+class ParameterTree(TreeWidget):
+ """Widget used to display or control data from a ParameterSet"""
+
+ def __init__(self, parent=None, showHeader=True):
+ TreeWidget.__init__(self, parent)
+ self.setVerticalScrollMode(self.ScrollPerPixel)
+ self.setHorizontalScrollMode(self.ScrollPerPixel)
+ self.setAnimated(False)
+ self.setColumnCount(2)
+ self.setHeaderLabels(["Parameter", "Value"])
+ self.setAlternatingRowColors(True)
+ self.paramSet = None
+ self.header().setResizeMode(QtGui.QHeaderView.ResizeToContents)
+ self.setHeaderHidden(not showHeader)
+ self.itemChanged.connect(self.itemChangedEvent)
+ self.lastSel = None
+ self.setRootIsDecorated(False)
+
+ def setParameters(self, param, showTop=True):
+ self.clear()
+ self.addParameters(param, showTop=showTop)
+
+ def addParameters(self, param, root=None, depth=0, showTop=True):
+ item = param.makeTreeItem(depth=depth)
+ if root is None:
+ root = self.invisibleRootItem()
+ ## Hide top-level item
+ if not showTop:
+ item.setText(0, '')
+ item.setSizeHint(0, QtCore.QSize(1,1))
+ item.setSizeHint(1, QtCore.QSize(1,1))
+ depth -= 1
+ root.addChild(item)
+ item.treeWidgetChanged()
+
+ for ch in param:
+ self.addParameters(ch, root=item, depth=depth+1)
+
+ def clear(self):
+ self.invisibleRootItem().takeChildren()
+
+
+ def focusNext(self, item, forward=True):
+ ## Give input focus to the next (or previous) item after 'item'
+ while True:
+ parent = item.parent()
+ if parent is None:
+ return
+ nextItem = self.nextFocusableChild(parent, item, forward=forward)
+ if nextItem is not None:
+ nextItem.setFocus()
+ self.setCurrentItem(nextItem)
+ return
+ item = parent
+
+ def focusPrevious(self, item):
+ self.focusNext(item, forward=False)
+
+ def nextFocusableChild(self, root, startItem=None, forward=True):
+ if startItem is None:
+ if forward:
+ index = 0
+ else:
+ index = root.childCount()-1
+ else:
+ if forward:
+ index = root.indexOfChild(startItem) + 1
+ else:
+ index = root.indexOfChild(startItem) - 1
+
+ if forward:
+ inds = list(range(index, root.childCount()))
+ else:
+ inds = list(range(index, -1, -1))
+
+ for i in inds:
+ item = root.child(i)
+ if hasattr(item, 'isFocusable') and item.isFocusable():
+ return item
+ else:
+ item = self.nextFocusableChild(item, forward=forward)
+ if item is not None:
+ return item
+ return None
+
+ def contextMenuEvent(self, ev):
+ item = self.currentItem()
+ if hasattr(item, 'contextMenuEvent'):
+ item.contextMenuEvent(ev)
+
+ def itemChangedEvent(self, item, col):
+ if hasattr(item, 'columnChangedEvent'):
+ item.columnChangedEvent(col)
+
+ def selectionChanged(self, *args):
+ sel = self.selectedItems()
+ if len(sel) != 1:
+ sel = None
+ if self.lastSel is not None:
+ self.lastSel.selected(False)
+ if sel is None:
+ self.lastSel = None
+ return
+ self.lastSel = sel[0]
+ if hasattr(sel[0], 'selected'):
+ sel[0].selected(True)
+ return TreeWidget.selectionChanged(self, *args)
+
+ def wheelEvent(self, ev):
+ self.clearSelection()
+ return TreeWidget.wheelEvent(self, ev)
diff --git a/pyqtgraph/parametertree/__init__.py b/pyqtgraph/parametertree/__init__.py
new file mode 100644
index 00000000..acdb7a37
--- /dev/null
+++ b/pyqtgraph/parametertree/__init__.py
@@ -0,0 +1,5 @@
+from .Parameter import Parameter, registerParameterType
+from .ParameterTree import ParameterTree
+from .ParameterItem import ParameterItem
+
+from . import parameterTypes as types
\ No newline at end of file
diff --git a/pyqtgraph/parametertree/parameterTypes.py b/pyqtgraph/parametertree/parameterTypes.py
new file mode 100644
index 00000000..3aab5a6d
--- /dev/null
+++ b/pyqtgraph/parametertree/parameterTypes.py
@@ -0,0 +1,616 @@
+from pyqtgraph.Qt import QtCore, QtGui
+from pyqtgraph.python2_3 import asUnicode
+from .Parameter import Parameter, registerParameterType
+from .ParameterItem import ParameterItem
+from pyqtgraph.widgets.SpinBox import SpinBox
+from pyqtgraph.widgets.ColorButton import ColorButton
+import pyqtgraph as pg
+import pyqtgraph.pixmaps as pixmaps
+import os
+from pyqtgraph.pgcollections import OrderedDict
+
+class WidgetParameterItem(ParameterItem):
+ """
+ ParameterTree item with:
+
+ - label in second column for displaying value
+ - simple widget for editing value (displayed instead of label when item is selected)
+ - button that resets value to default
+ - provides SpinBox, CheckBox, LineEdit, and ColorButton types
+
+ This class can be subclassed by overriding makeWidget() to provide a custom widget.
+ """
+ def __init__(self, param, depth):
+ ParameterItem.__init__(self, param, depth)
+
+ self.hideWidget = True ## hide edit widget, replace with label when not selected
+ ## set this to False to keep the editor widget always visible
+
+
+ ## build widget into column 1 with a display label and default button.
+ w = self.makeWidget()
+ self.widget = w
+ self.eventProxy = EventProxy(w, self.widgetEventFilter)
+
+ opts = self.param.opts
+ if 'tip' in opts:
+ w.setToolTip(opts['tip'])
+
+ self.defaultBtn = QtGui.QPushButton()
+ self.defaultBtn.setFixedWidth(20)
+ self.defaultBtn.setFixedHeight(20)
+ modDir = os.path.dirname(__file__)
+ self.defaultBtn.setIcon(QtGui.QIcon(pixmaps.getPixmap('default')))
+ self.defaultBtn.clicked.connect(self.defaultClicked)
+
+ self.displayLabel = QtGui.QLabel()
+
+ layout = QtGui.QHBoxLayout()
+ layout.setContentsMargins(0, 0, 0, 0)
+ layout.setSpacing(2)
+ layout.addWidget(w)
+ layout.addWidget(self.displayLabel)
+ layout.addWidget(self.defaultBtn)
+ self.layoutWidget = QtGui.QWidget()
+ self.layoutWidget.setLayout(layout)
+
+ if w.sigChanged is not None:
+ w.sigChanged.connect(self.widgetValueChanged)
+
+ if hasattr(w, 'sigChanging'):
+ w.sigChanging.connect(self.widgetValueChanging)
+
+ ## update value shown in widget.
+ self.valueChanged(self, opts['value'], force=True)
+
+
+ def makeWidget(self):
+ """
+ Return a single widget that should be placed in the second tree column.
+ The widget must be given three attributes:
+
+ ========== ============================================================
+ sigChanged a signal that is emitted when the widget's value is changed
+ value a function that returns the value
+ setValue a function that sets the value
+ ========== ============================================================
+
+ This is a good function to override in subclasses.
+ """
+ opts = self.param.opts
+ t = opts['type']
+ if t == 'int':
+ defs = {
+ 'value': 0, 'min': None, 'max': None, 'int': True,
+ 'step': 1.0, 'minStep': 1.0, 'dec': False,
+ 'siPrefix': False, 'suffix': ''
+ }
+ defs.update(opts)
+ if 'limits' in opts:
+ defs['bounds'] = opts['limits']
+ w = SpinBox()
+ w.setOpts(**defs)
+ w.sigChanged = w.sigValueChanged
+ w.sigChanging = w.sigValueChanging
+ elif t == 'float':
+ defs = {
+ 'value': 0, 'min': None, 'max': None,
+ 'step': 1.0, 'dec': False,
+ 'siPrefix': False, 'suffix': ''
+ }
+ defs.update(opts)
+ if 'limits' in opts:
+ defs['bounds'] = opts['limits']
+ w = SpinBox()
+ w.setOpts(**defs)
+ w.sigChanged = w.sigValueChanged
+ w.sigChanging = w.sigValueChanging
+ elif t == 'bool':
+ w = QtGui.QCheckBox()
+ w.sigChanged = w.toggled
+ w.value = w.isChecked
+ w.setValue = w.setChecked
+ self.hideWidget = False
+ elif t == 'str':
+ w = QtGui.QLineEdit()
+ w.sigChanged = w.editingFinished
+ w.value = lambda: asUnicode(w.text())
+ w.setValue = lambda v: w.setText(asUnicode(v))
+ w.sigChanging = w.textChanged
+ elif t == 'color':
+ w = ColorButton()
+ w.sigChanged = w.sigColorChanged
+ w.sigChanging = w.sigColorChanging
+ w.value = w.color
+ w.setValue = w.setColor
+ self.hideWidget = False
+ w.setFlat(True)
+ else:
+ raise Exception("Unknown type '%s'" % asUnicode(t))
+ return w
+
+ def widgetEventFilter(self, obj, ev):
+ ## filter widget's events
+ ## catch TAB to change focus
+ ## catch focusOut to hide editor
+ if ev.type() == ev.KeyPress:
+ if ev.key() == QtCore.Qt.Key_Tab:
+ self.focusNext(forward=True)
+ return True ## don't let anyone else see this event
+ elif ev.key() == QtCore.Qt.Key_Backtab:
+ self.focusNext(forward=False)
+ return True ## don't let anyone else see this event
+
+ #elif ev.type() == ev.FocusOut:
+ #self.hideEditor()
+ return False
+
+ def setFocus(self):
+ self.showEditor()
+
+ def isFocusable(self):
+ return self.param.writable()
+
+ def valueChanged(self, param, val, force=False):
+ ## called when the parameter's value has changed
+ ParameterItem.valueChanged(self, param, val)
+ self.widget.sigChanged.disconnect(self.widgetValueChanged)
+ try:
+ if force or val != self.widget.value():
+ self.widget.setValue(val)
+ self.updateDisplayLabel(val) ## always make sure label is updated, even if values match!
+ finally:
+ self.widget.sigChanged.connect(self.widgetValueChanged)
+ self.updateDefaultBtn()
+
+ def updateDefaultBtn(self):
+ ## enable/disable default btn
+ self.defaultBtn.setEnabled(not self.param.valueIsDefault() and self.param.writable())
+
+ def updateDisplayLabel(self, value=None):
+ """Update the display label to reflect the value of the parameter."""
+ if value is None:
+ value = self.param.value()
+ opts = self.param.opts
+ if isinstance(self.widget, QtGui.QAbstractSpinBox):
+ text = asUnicode(self.widget.lineEdit().text())
+ elif isinstance(self.widget, QtGui.QComboBox):
+ text = self.widget.currentText()
+ else:
+ text = asUnicode(value)
+ self.displayLabel.setText(text)
+
+ def widgetValueChanged(self):
+ ## called when the widget's value has been changed by the user
+ val = self.widget.value()
+ newVal = self.param.setValue(val)
+
+ def widgetValueChanging(self):
+ """
+ Called when the widget's value is changing, but not finalized.
+ For example: editing text before pressing enter or changing focus.
+ """
+ pass
+
+ def selected(self, sel):
+ """Called when this item has been selected (sel=True) OR deselected (sel=False)"""
+ ParameterItem.selected(self, sel)
+
+ if self.widget is None:
+ return
+ if sel and self.param.writable():
+ self.showEditor()
+ elif self.hideWidget:
+ self.hideEditor()
+
+ def showEditor(self):
+ self.widget.show()
+ self.displayLabel.hide()
+ self.widget.setFocus(QtCore.Qt.OtherFocusReason)
+
+ def hideEditor(self):
+ self.widget.hide()
+ self.displayLabel.show()
+
+ def limitsChanged(self, param, limits):
+ """Called when the parameter's limits have changed"""
+ ParameterItem.limitsChanged(self, param, limits)
+
+ t = self.param.opts['type']
+ if t == 'int' or t == 'float':
+ self.widget.setOpts(bounds=limits)
+ else:
+ return ## don't know what to do with any other types..
+
+ def defaultChanged(self, param, value):
+ self.updateDefaultBtn()
+
+ def treeWidgetChanged(self):
+ """Called when this item is added or removed from a tree."""
+ ParameterItem.treeWidgetChanged(self)
+
+ ## add all widgets for this item into the tree
+ if self.widget is not None:
+ tree = self.treeWidget()
+ if tree is None:
+ return
+ tree.setItemWidget(self, 1, self.layoutWidget)
+ self.displayLabel.hide()
+ self.selected(False)
+
+ def defaultClicked(self):
+ self.param.setToDefault()
+
+ def optsChanged(self, param, opts):
+ """Called when any options are changed that are not
+ name, value, default, or limits"""
+ #print "opts changed:", opts
+ ParameterItem.optsChanged(self, param, opts)
+
+ if 'readonly' in opts:
+ self.updateDefaultBtn()
+
+ ## If widget is a SpinBox, pass options straight through
+ if isinstance(self.widget, SpinBox):
+ if 'units' in opts and 'suffix' not in opts:
+ opts['suffix'] = opts['units']
+ self.widget.setOpts(**opts)
+ self.updateDisplayLabel()
+
+class EventProxy(QtCore.QObject):
+ def __init__(self, qobj, callback):
+ QtCore.QObject.__init__(self)
+ self.callback = callback
+ qobj.installEventFilter(self)
+
+ def eventFilter(self, obj, ev):
+ return self.callback(obj, ev)
+
+
+
+
+class SimpleParameter(Parameter):
+ itemClass = WidgetParameterItem
+
+ def __init__(self, *args, **kargs):
+ Parameter.__init__(self, *args, **kargs)
+
+ ## override a few methods for color parameters
+ if self.opts['type'] == 'color':
+ self.value = self.colorValue
+ self.saveState = self.saveColorState
+
+ def colorValue(self):
+ return pg.mkColor(Parameter.value(self))
+
+ def saveColorState(self):
+ state = Parameter.saveState(self)
+ state['value'] = pg.colorTuple(self.value())
+ return state
+
+
+registerParameterType('int', SimpleParameter, override=True)
+registerParameterType('float', SimpleParameter, override=True)
+registerParameterType('bool', SimpleParameter, override=True)
+registerParameterType('str', SimpleParameter, override=True)
+registerParameterType('color', SimpleParameter, override=True)
+
+
+
+
+class GroupParameterItem(ParameterItem):
+ """
+ Group parameters are used mainly as a generic parent item that holds (and groups!) a set
+ of child parameters. It also provides a simple mechanism for displaying a button or combo
+ that can be used to add new parameters to the group.
+ """
+ def __init__(self, param, depth):
+ ParameterItem.__init__(self, param, depth)
+ self.updateDepth(depth)
+
+ self.addItem = None
+ if 'addText' in param.opts:
+ addText = param.opts['addText']
+ if 'addList' in param.opts:
+ self.addWidget = QtGui.QComboBox()
+ self.addWidget.setSizeAdjustPolicy(QtGui.QComboBox.AdjustToContents)
+ self.updateAddList()
+ self.addWidget.currentIndexChanged.connect(self.addChanged)
+ else:
+ self.addWidget = QtGui.QPushButton(addText)
+ self.addWidget.clicked.connect(self.addClicked)
+ w = QtGui.QWidget()
+ l = QtGui.QHBoxLayout()
+ l.setContentsMargins(0,0,0,0)
+ w.setLayout(l)
+ l.addWidget(self.addWidget)
+ l.addStretch()
+ #l.addItem(QtGui.QSpacerItem(200, 10, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum))
+ self.addWidgetBox = w
+ self.addItem = QtGui.QTreeWidgetItem([])
+ self.addItem.setFlags(QtCore.Qt.ItemIsEnabled)
+ ParameterItem.addChild(self, self.addItem)
+
+ def updateDepth(self, depth):
+ ## Change item's appearance based on its depth in the tree
+ ## This allows highest-level groups to be displayed more prominently.
+ if depth == 0:
+ for c in [0,1]:
+ self.setBackground(c, QtGui.QBrush(QtGui.QColor(100,100,100)))
+ self.setForeground(c, QtGui.QBrush(QtGui.QColor(220,220,255)))
+ font = self.font(c)
+ font.setBold(True)
+ font.setPointSize(font.pointSize()+1)
+ self.setFont(c, font)
+ self.setSizeHint(0, QtCore.QSize(0, 25))
+ else:
+ for c in [0,1]:
+ self.setBackground(c, QtGui.QBrush(QtGui.QColor(220,220,220)))
+ font = self.font(c)
+ font.setBold(True)
+ #font.setPointSize(font.pointSize()+1)
+ self.setFont(c, font)
+ self.setSizeHint(0, QtCore.QSize(0, 20))
+
+ def addClicked(self):
+ """Called when "add new" button is clicked
+ The parameter MUST have an 'addNew' method defined.
+ """
+ self.param.addNew()
+
+ def addChanged(self):
+ """Called when "add new" combo is changed
+ The parameter MUST have an 'addNew' method defined.
+ """
+ if self.addWidget.currentIndex() == 0:
+ return
+ typ = asUnicode(self.addWidget.currentText())
+ self.param.addNew(typ)
+ self.addWidget.setCurrentIndex(0)
+
+ def treeWidgetChanged(self):
+ ParameterItem.treeWidgetChanged(self)
+ self.treeWidget().setFirstItemColumnSpanned(self, True)
+ if self.addItem is not None:
+ self.treeWidget().setItemWidget(self.addItem, 0, self.addWidgetBox)
+ self.treeWidget().setFirstItemColumnSpanned(self.addItem, True)
+
+ def addChild(self, child): ## make sure added childs are actually inserted before add btn
+ if self.addItem is not None:
+ ParameterItem.insertChild(self, self.childCount()-1, child)
+ else:
+ ParameterItem.addChild(self, child)
+
+ def optsChanged(self, param, changed):
+ if 'addList' in changed:
+ self.updateAddList()
+
+ def updateAddList(self):
+ self.addWidget.blockSignals(True)
+ try:
+ self.addWidget.clear()
+ self.addWidget.addItem(self.param.opts['addText'])
+ for t in self.param.opts['addList']:
+ self.addWidget.addItem(t)
+ finally:
+ self.addWidget.blockSignals(False)
+
+class GroupParameter(Parameter):
+ """
+ Group parameters are used mainly as a generic parent item that holds (and groups!) a set
+ of child parameters.
+
+ It also provides a simple mechanism for displaying a button or combo
+ that can be used to add new parameters to the group. To enable this, the group
+ must be initialized with the 'addText' option (the text will be displayed on
+ a button which, when clicked, will cause addNew() to be called). If the 'addList'
+ option is specified as well, then a dropdown-list of addable items will be displayed
+ instead of a button.
+ """
+ itemClass = GroupParameterItem
+
+ def addNew(self, typ=None):
+ """
+ This method is called when the user has requested to add a new item to the group.
+ """
+ raise Exception("Must override this function in subclass.")
+
+ def setAddList(self, vals):
+ """Change the list of options available for the user to add to the group."""
+ self.setOpts(addList=vals)
+
+
+
+registerParameterType('group', GroupParameter, override=True)
+
+
+
+
+
+class ListParameterItem(WidgetParameterItem):
+ """
+ WidgetParameterItem subclass providing comboBox that lets the user select from a list of options.
+
+ """
+ def __init__(self, param, depth):
+ self.targetValue = None
+ WidgetParameterItem.__init__(self, param, depth)
+
+
+ def makeWidget(self):
+ opts = self.param.opts
+ t = opts['type']
+ w = QtGui.QComboBox()
+ w.setMaximumHeight(20) ## set to match height of spin box and line edit
+ w.sigChanged = w.currentIndexChanged
+ w.value = self.value
+ w.setValue = self.setValue
+ self.widget = w ## needs to be set before limits are changed
+ self.limitsChanged(self.param, self.param.opts['limits'])
+ if len(self.forward) > 0:
+ self.setValue(self.param.value())
+ return w
+
+ def value(self):
+ #vals = self.param.opts['limits']
+ key = asUnicode(self.widget.currentText())
+ #if isinstance(vals, dict):
+ #return vals[key]
+ #else:
+ #return key
+ #print key, self.forward
+
+ return self.forward.get(key, None)
+
+ def setValue(self, val):
+ #vals = self.param.opts['limits']
+ #if isinstance(vals, dict):
+ #key = None
+ #for k,v in vals.iteritems():
+ #if v == val:
+ #key = k
+ #if key is None:
+ #raise Exception("Value '%s' not allowed." % val)
+ #else:
+ #key = unicode(val)
+ self.targetValue = val
+ if val not in self.reverse:
+ self.widget.setCurrentIndex(0)
+ else:
+ key = self.reverse[val]
+ ind = self.widget.findText(key)
+ self.widget.setCurrentIndex(ind)
+
+ def limitsChanged(self, param, limits):
+ # set up forward / reverse mappings for name:value
+
+ if len(limits) == 0:
+ limits = [''] ## Can never have an empty list--there is always at least a singhe blank item.
+
+ self.forward, self.reverse = ListParameter.mapping(limits)
+ try:
+ self.widget.blockSignals(True)
+ val = self.targetValue #asUnicode(self.widget.currentText())
+
+ self.widget.clear()
+ for k in self.forward:
+ self.widget.addItem(k)
+ if k == val:
+ self.widget.setCurrentIndex(self.widget.count()-1)
+ self.updateDisplayLabel()
+ finally:
+ self.widget.blockSignals(False)
+
+
+
+class ListParameter(Parameter):
+ itemClass = ListParameterItem
+
+ def __init__(self, **opts):
+ self.forward = OrderedDict() ## name: value
+ self.reverse = OrderedDict() ## value: name
+
+ ## Parameter uses 'limits' option to define the set of allowed values
+ if 'values' in opts:
+ opts['limits'] = opts['values']
+ if opts.get('limits', None) is None:
+ opts['limits'] = []
+ Parameter.__init__(self, **opts)
+ self.setLimits(opts['limits'])
+
+ def setLimits(self, limits):
+ self.forward, self.reverse = self.mapping(limits)
+
+ Parameter.setLimits(self, limits)
+ #print self.name(), self.value(), limits
+ if self.value() not in self.reverse and len(self.reverse) > 0:
+ self.setValue(list(self.reverse.keys())[0])
+
+ @staticmethod
+ def mapping(limits):
+ ## Return forward and reverse mapping dictionaries given a limit specification
+ forward = OrderedDict() ## name: value
+ reverse = OrderedDict() ## value: name
+ if isinstance(limits, dict):
+ for k, v in limits.items():
+ forward[k] = v
+ reverse[v] = k
+ else:
+ for v in limits:
+ n = asUnicode(v)
+ forward[n] = v
+ reverse[v] = n
+ return forward, reverse
+
+registerParameterType('list', ListParameter, override=True)
+
+
+
+class ActionParameterItem(ParameterItem):
+ def __init__(self, param, depth):
+ ParameterItem.__init__(self, param, depth)
+ self.layoutWidget = QtGui.QWidget()
+ self.layout = QtGui.QHBoxLayout()
+ self.layoutWidget.setLayout(self.layout)
+ self.button = QtGui.QPushButton(param.name())
+ #self.layout.addSpacing(100)
+ self.layout.addWidget(self.button)
+ self.layout.addStretch()
+ self.button.clicked.connect(self.buttonClicked)
+ param.sigNameChanged.connect(self.paramRenamed)
+ self.setText(0, '')
+
+ def treeWidgetChanged(self):
+ ParameterItem.treeWidgetChanged(self)
+ tree = self.treeWidget()
+ if tree is None:
+ return
+
+ tree.setFirstItemColumnSpanned(self, True)
+ tree.setItemWidget(self, 0, self.layoutWidget)
+
+ def paramRenamed(self, param, name):
+ self.button.setText(name)
+
+ def buttonClicked(self):
+ self.param.activate()
+
+class ActionParameter(Parameter):
+ """Used for displaying a button within the tree."""
+ itemClass = ActionParameterItem
+ sigActivated = QtCore.Signal(object)
+
+ def activate(self):
+ self.sigActivated.emit(self)
+ self.emitStateChanged('activated', None)
+
+registerParameterType('action', ActionParameter, override=True)
+
+
+
+class TextParameterItem(WidgetParameterItem):
+ def __init__(self, param, depth):
+ WidgetParameterItem.__init__(self, param, depth)
+ self.subItem = QtGui.QTreeWidgetItem()
+ self.addChild(self.subItem)
+
+ def treeWidgetChanged(self):
+ self.treeWidget().setFirstItemColumnSpanned(self.subItem, True)
+ self.treeWidget().setItemWidget(self.subItem, 0, self.textBox)
+ self.setExpanded(True)
+
+ def makeWidget(self):
+ self.textBox = QtGui.QTextEdit()
+ self.textBox.setMaximumHeight(100)
+ self.textBox.value = lambda: str(self.textBox.toPlainText())
+ self.textBox.setValue = self.textBox.setPlainText
+ self.textBox.sigChanged = self.textBox.textChanged
+ return self.textBox
+
+class TextParameter(Parameter):
+ """Editable string; displayed as large text box in the tree."""
+ itemClass = TextParameterItem
+
+
+
+registerParameterType('text', TextParameter, override=True)
diff --git a/pyqtgraph/pgcollections.py b/pyqtgraph/pgcollections.py
new file mode 100644
index 00000000..b0198526
--- /dev/null
+++ b/pyqtgraph/pgcollections.py
@@ -0,0 +1,543 @@
+# -*- coding: utf-8 -*-
+"""
+advancedTypes.py - Basic data structures not included with python
+Copyright 2010 Luke Campagnola
+Distributed under MIT/X11 license. See license.txt for more infomation.
+
+Includes:
+ - OrderedDict - Dictionary which preserves the order of its elements
+ - BiDict, ReverseDict - Bi-directional dictionaries
+ - ThreadsafeDict, ThreadsafeList - Self-mutexed data structures
+"""
+
+import threading, sys, copy, collections
+#from debug import *
+
+try:
+ from collections import OrderedDict
+except:
+ # Deprecated; this class is now present in Python 2.7 as collections.OrderedDict
+ # Only keeping this around for python2.6 support.
+ class OrderedDict(dict):
+ """extends dict so that elements are iterated in the order that they were added.
+ Since this class can not be instantiated with regular dict notation, it instead uses
+ a list of tuples:
+ od = OrderedDict([(key1, value1), (key2, value2), ...])
+ items set using __setattr__ are added to the end of the key list.
+ """
+
+ def __init__(self, data=None):
+ self.order = []
+ if data is not None:
+ for i in data:
+ self[i[0]] = i[1]
+
+ def __setitem__(self, k, v):
+ if not self.has_key(k):
+ self.order.append(k)
+ dict.__setitem__(self, k, v)
+
+ def __delitem__(self, k):
+ self.order.remove(k)
+ dict.__delitem__(self, k)
+
+ def keys(self):
+ return self.order[:]
+
+ def items(self):
+ it = []
+ for k in self.keys():
+ it.append((k, self[k]))
+ return it
+
+ def values(self):
+ return [self[k] for k in self.order]
+
+ def remove(self, key):
+ del self[key]
+ #self.order.remove(key)
+
+ def __iter__(self):
+ for k in self.order:
+ yield k
+
+ def update(self, data):
+ """Works like dict.update, but accepts list-of-tuples as well as dict."""
+ if isinstance(data, dict):
+ for k, v in data.iteritems():
+ self[k] = v
+ else:
+ for k,v in data:
+ self[k] = v
+
+ def copy(self):
+ return OrderedDict(self.items())
+
+ def itervalues(self):
+ for k in self.order:
+ yield self[k]
+
+ def iteritems(self):
+ for k in self.order:
+ yield (k, self[k])
+
+ def __deepcopy__(self, memo):
+ return OrderedDict([(k, copy.deepcopy(v, memo)) for k, v in self.iteritems()])
+
+
+
+class ReverseDict(dict):
+ """extends dict so that reverse lookups are possible by requesting the key as a list of length 1:
+ d = BiDict({'x': 1, 'y': 2})
+ d['x']
+ 1
+ d[[2]]
+ 'y'
+ """
+ def __init__(self, data=None):
+ if data is None:
+ data = {}
+ self.reverse = {}
+ for k in data:
+ self.reverse[data[k]] = k
+ dict.__init__(self, data)
+
+ def __getitem__(self, item):
+ if type(item) is list:
+ return self.reverse[item[0]]
+ else:
+ return dict.__getitem__(self, item)
+
+ def __setitem__(self, item, value):
+ self.reverse[value] = item
+ dict.__setitem__(self, item, value)
+
+ def __deepcopy__(self, memo):
+ raise Exception("deepcopy not implemented")
+
+
+class BiDict(dict):
+ """extends dict so that reverse lookups are possible by adding each reverse combination to the dict.
+ This only works if all values and keys are unique."""
+ def __init__(self, data=None):
+ if data is None:
+ data = {}
+ dict.__init__(self)
+ for k in data:
+ self[data[k]] = k
+
+ def __setitem__(self, item, value):
+ dict.__setitem__(self, item, value)
+ dict.__setitem__(self, value, item)
+
+ def __deepcopy__(self, memo):
+ raise Exception("deepcopy not implemented")
+
+class ThreadsafeDict(dict):
+ """Extends dict so that getitem, setitem, and contains are all thread-safe.
+ Also adds lock/unlock functions for extended exclusive operations
+ Converts all sub-dicts and lists to threadsafe as well.
+ """
+
+ def __init__(self, *args, **kwargs):
+ self.mutex = threading.RLock()
+ dict.__init__(self, *args, **kwargs)
+ for k in self:
+ if type(self[k]) is dict:
+ self[k] = ThreadsafeDict(self[k])
+
+ def __getitem__(self, attr):
+ self.lock()
+ try:
+ val = dict.__getitem__(self, attr)
+ finally:
+ self.unlock()
+ return val
+
+ def __setitem__(self, attr, val):
+ if type(val) is dict:
+ val = ThreadsafeDict(val)
+ self.lock()
+ try:
+ dict.__setitem__(self, attr, val)
+ finally:
+ self.unlock()
+
+ def __contains__(self, attr):
+ self.lock()
+ try:
+ val = dict.__contains__(self, attr)
+ finally:
+ self.unlock()
+ return val
+
+ def __len__(self):
+ self.lock()
+ try:
+ val = dict.__len__(self)
+ finally:
+ self.unlock()
+ return val
+
+ def clear(self):
+ self.lock()
+ try:
+ dict.clear(self)
+ finally:
+ self.unlock()
+
+ def lock(self):
+ self.mutex.acquire()
+
+ def unlock(self):
+ self.mutex.release()
+
+ def __deepcopy__(self, memo):
+ raise Exception("deepcopy not implemented")
+
+class ThreadsafeList(list):
+ """Extends list so that getitem, setitem, and contains are all thread-safe.
+ Also adds lock/unlock functions for extended exclusive operations
+ Converts all sub-lists and dicts to threadsafe as well.
+ """
+
+ def __init__(self, *args, **kwargs):
+ self.mutex = threading.RLock()
+ list.__init__(self, *args, **kwargs)
+ for k in self:
+ self[k] = mkThreadsafe(self[k])
+
+ def __getitem__(self, attr):
+ self.lock()
+ try:
+ val = list.__getitem__(self, attr)
+ finally:
+ self.unlock()
+ return val
+
+ def __setitem__(self, attr, val):
+ val = makeThreadsafe(val)
+ self.lock()
+ try:
+ list.__setitem__(self, attr, val)
+ finally:
+ self.unlock()
+
+ def __contains__(self, attr):
+ self.lock()
+ try:
+ val = list.__contains__(self, attr)
+ finally:
+ self.unlock()
+ return val
+
+ def __len__(self):
+ self.lock()
+ try:
+ val = list.__len__(self)
+ finally:
+ self.unlock()
+ return val
+
+ def lock(self):
+ self.mutex.acquire()
+
+ def unlock(self):
+ self.mutex.release()
+
+ def __deepcopy__(self, memo):
+ raise Exception("deepcopy not implemented")
+
+
+def makeThreadsafe(obj):
+ if type(obj) is dict:
+ return ThreadsafeDict(obj)
+ elif type(obj) is list:
+ return ThreadsafeList(obj)
+ elif type(obj) in [str, int, float, bool, tuple]:
+ return obj
+ else:
+ raise Exception("Not sure how to make object of type %s thread-safe" % str(type(obj)))
+
+
+class Locker(object):
+ def __init__(self, lock):
+ self.lock = lock
+ self.lock.acquire()
+ def __del__(self):
+ try:
+ self.lock.release()
+ except:
+ pass
+
+class CaselessDict(OrderedDict):
+ """Case-insensitive dict. Values can be set and retrieved using keys of any case.
+ Note that when iterating, the original case is returned for each key."""
+ def __init__(self, *args):
+ OrderedDict.__init__(self, {}) ## requirement for the empty {} here seems to be a python bug?
+ self.keyMap = OrderedDict([(k.lower(), k) for k in OrderedDict.keys(self)])
+ if len(args) == 0:
+ return
+ elif len(args) == 1 and isinstance(args[0], dict):
+ for k in args[0]:
+ self[k] = args[0][k]
+ else:
+ raise Exception("CaselessDict may only be instantiated with a single dict.")
+
+ #def keys(self):
+ #return self.keyMap.values()
+
+ def __setitem__(self, key, val):
+ kl = key.lower()
+ if kl in self.keyMap:
+ OrderedDict.__setitem__(self, self.keyMap[kl], val)
+ else:
+ OrderedDict.__setitem__(self, key, val)
+ self.keyMap[kl] = key
+
+ def __getitem__(self, key):
+ kl = key.lower()
+ if kl not in self.keyMap:
+ raise KeyError(key)
+ return OrderedDict.__getitem__(self, self.keyMap[kl])
+
+ def __contains__(self, key):
+ return key.lower() in self.keyMap
+
+ def update(self, d):
+ for k, v in d.iteritems():
+ self[k] = v
+
+ def copy(self):
+ return CaselessDict(OrderedDict.copy(self))
+
+ def __delitem__(self, key):
+ kl = key.lower()
+ if kl not in self.keyMap:
+ raise KeyError(key)
+ OrderedDict.__delitem__(self, self.keyMap[kl])
+ del self.keyMap[kl]
+
+ def __deepcopy__(self, memo):
+ raise Exception("deepcopy not implemented")
+
+ def clear(self):
+ OrderedDict.clear(self)
+ self.keyMap.clear()
+
+
+
+class ProtectedDict(dict):
+ """
+ A class allowing read-only 'view' of a dict.
+ The object can be treated like a normal dict, but will never modify the original dict it points to.
+ Any values accessed from the dict will also be read-only.
+ """
+ def __init__(self, data):
+ self._data_ = data
+
+ ## List of methods to directly wrap from _data_
+ wrapMethods = ['_cmp_', '__contains__', '__eq__', '__format__', '__ge__', '__gt__', '__le__', '__len__', '__lt__', '__ne__', '__reduce__', '__reduce_ex__', '__repr__', '__str__', 'count', 'has_key', 'iterkeys', 'keys', ]
+
+ ## List of methods which wrap from _data_ but return protected results
+ protectMethods = ['__getitem__', '__iter__', 'get', 'items', 'values']
+
+ ## List of methods to disable
+ disableMethods = ['__delitem__', '__setitem__', 'clear', 'pop', 'popitem', 'setdefault', 'update']
+
+
+ ## Template methods
+ def wrapMethod(methodName):
+ return lambda self, *a, **k: getattr(self._data_, methodName)(*a, **k)
+
+ def protectMethod(methodName):
+ return lambda self, *a, **k: protect(getattr(self._data_, methodName)(*a, **k))
+
+ def error(self, *args, **kargs):
+ raise Exception("Can not modify read-only list.")
+
+
+ ## Directly (and explicitly) wrap some methods from _data_
+ ## Many of these methods can not be intercepted using __getattribute__, so they
+ ## must be implemented explicitly
+ for methodName in wrapMethods:
+ locals()[methodName] = wrapMethod(methodName)
+
+ ## Wrap some methods from _data_ with the results converted to protected objects
+ for methodName in protectMethods:
+ locals()[methodName] = protectMethod(methodName)
+
+ ## Disable any methods that could change data in the list
+ for methodName in disableMethods:
+ locals()[methodName] = error
+
+
+ ## Add a few extra methods.
+ def copy(self):
+ raise Exception("It is not safe to copy protected dicts! (instead try deepcopy, but be careful.)")
+
+ def itervalues(self):
+ for v in self._data_.itervalues():
+ yield protect(v)
+
+ def iteritems(self):
+ for k, v in self._data_.iteritems():
+ yield (k, protect(v))
+
+ def deepcopy(self):
+ return copy.deepcopy(self._data_)
+
+ def __deepcopy__(self, memo):
+ return copy.deepcopy(self._data_, memo)
+
+
+
+class ProtectedList(collections.Sequence):
+ """
+ A class allowing read-only 'view' of a list or dict.
+ The object can be treated like a normal list, but will never modify the original list it points to.
+ Any values accessed from the list will also be read-only.
+
+ Note: It would be nice if we could inherit from list or tuple so that isinstance checks would work.
+ However, doing this causes tuple(obj) to return unprotected results (importantly, this means
+ unpacking into function arguments will also fail)
+ """
+ def __init__(self, data):
+ self._data_ = data
+ #self.__mro__ = (ProtectedList, object)
+
+ ## List of methods to directly wrap from _data_
+ wrapMethods = ['__contains__', '__eq__', '__format__', '__ge__', '__gt__', '__le__', '__len__', '__lt__', '__ne__', '__reduce__', '__reduce_ex__', '__repr__', '__str__', 'count', 'index']
+
+ ## List of methods which wrap from _data_ but return protected results
+ protectMethods = ['__getitem__', '__getslice__', '__mul__', '__reversed__', '__rmul__']
+
+ ## List of methods to disable
+ disableMethods = ['__delitem__', '__delslice__', '__iadd__', '__imul__', '__setitem__', '__setslice__', 'append', 'extend', 'insert', 'pop', 'remove', 'reverse', 'sort']
+
+
+ ## Template methods
+ def wrapMethod(methodName):
+ return lambda self, *a, **k: getattr(self._data_, methodName)(*a, **k)
+
+ def protectMethod(methodName):
+ return lambda self, *a, **k: protect(getattr(self._data_, methodName)(*a, **k))
+
+ def error(self, *args, **kargs):
+ raise Exception("Can not modify read-only list.")
+
+
+ ## Directly (and explicitly) wrap some methods from _data_
+ ## Many of these methods can not be intercepted using __getattribute__, so they
+ ## must be implemented explicitly
+ for methodName in wrapMethods:
+ locals()[methodName] = wrapMethod(methodName)
+
+ ## Wrap some methods from _data_ with the results converted to protected objects
+ for methodName in protectMethods:
+ locals()[methodName] = protectMethod(methodName)
+
+ ## Disable any methods that could change data in the list
+ for methodName in disableMethods:
+ locals()[methodName] = error
+
+
+ ## Add a few extra methods.
+ def __iter__(self):
+ for item in self._data_:
+ yield protect(item)
+
+
+ def __add__(self, op):
+ if isinstance(op, ProtectedList):
+ return protect(self._data_.__add__(op._data_))
+ elif isinstance(op, list):
+ return protect(self._data_.__add__(op))
+ else:
+ raise TypeError("Argument must be a list.")
+
+ def __radd__(self, op):
+ if isinstance(op, ProtectedList):
+ return protect(op._data_.__add__(self._data_))
+ elif isinstance(op, list):
+ return protect(op.__add__(self._data_))
+ else:
+ raise TypeError("Argument must be a list.")
+
+ def deepcopy(self):
+ return copy.deepcopy(self._data_)
+
+ def __deepcopy__(self, memo):
+ return copy.deepcopy(self._data_, memo)
+
+ def poop(self):
+ raise Exception("This is a list. It does not poop.")
+
+
+class ProtectedTuple(collections.Sequence):
+ """
+ A class allowing read-only 'view' of a tuple.
+ The object can be treated like a normal tuple, but its contents will be returned as protected objects.
+
+ Note: It would be nice if we could inherit from list or tuple so that isinstance checks would work.
+ However, doing this causes tuple(obj) to return unprotected results (importantly, this means
+ unpacking into function arguments will also fail)
+ """
+ def __init__(self, data):
+ self._data_ = data
+
+ ## List of methods to directly wrap from _data_
+ wrapMethods = ['__contains__', '__eq__', '__format__', '__ge__', '__getnewargs__', '__gt__', '__hash__', '__le__', '__len__', '__lt__', '__ne__', '__reduce__', '__reduce_ex__', '__repr__', '__str__', 'count', 'index']
+
+ ## List of methods which wrap from _data_ but return protected results
+ protectMethods = ['__getitem__', '__getslice__', '__iter__', '__add__', '__mul__', '__reversed__', '__rmul__']
+
+
+ ## Template methods
+ def wrapMethod(methodName):
+ return lambda self, *a, **k: getattr(self._data_, methodName)(*a, **k)
+
+ def protectMethod(methodName):
+ return lambda self, *a, **k: protect(getattr(self._data_, methodName)(*a, **k))
+
+
+ ## Directly (and explicitly) wrap some methods from _data_
+ ## Many of these methods can not be intercepted using __getattribute__, so they
+ ## must be implemented explicitly
+ for methodName in wrapMethods:
+ locals()[methodName] = wrapMethod(methodName)
+
+ ## Wrap some methods from _data_ with the results converted to protected objects
+ for methodName in protectMethods:
+ locals()[methodName] = protectMethod(methodName)
+
+
+ ## Add a few extra methods.
+ def deepcopy(self):
+ return copy.deepcopy(self._data_)
+
+ def __deepcopy__(self, memo):
+ return copy.deepcopy(self._data_, memo)
+
+
+
+def protect(obj):
+ if isinstance(obj, dict):
+ return ProtectedDict(obj)
+ elif isinstance(obj, list):
+ return ProtectedList(obj)
+ elif isinstance(obj, tuple):
+ return ProtectedTuple(obj)
+ else:
+ return obj
+
+
+if __name__ == '__main__':
+ d = {'x': 1, 'y': [1,2], 'z': ({'a': 2, 'b': [3,4], 'c': (5,6)}, 1, 2)}
+ dp = protect(d)
+
+ l = [1, 'x', ['a', 'b'], ('c', 'd'), {'x': 1, 'y': 2}]
+ lp = protect(l)
+
+ t = (1, 'x', ['a', 'b'], ('c', 'd'), {'x': 1, 'y': 2})
+ tp = protect(t)
\ No newline at end of file
diff --git a/pyqtgraph/pixmaps/__init__.py b/pyqtgraph/pixmaps/__init__.py
new file mode 100644
index 00000000..42bd3276
--- /dev/null
+++ b/pyqtgraph/pixmaps/__init__.py
@@ -0,0 +1,26 @@
+"""
+Allows easy loading of pixmaps used in UI elements.
+Provides support for frozen environments as well.
+"""
+
+import os, sys, pickle
+from ..functions import makeQImage
+from ..Qt import QtGui
+if sys.version_info[0] == 2:
+ from . import pixmapData_2 as pixmapData
+else:
+ from . import pixmapData_3 as pixmapData
+
+
+def getPixmap(name):
+ """
+ Return a QPixmap corresponding to the image file with the given name.
+ (eg. getPixmap('auto') loads pyqtgraph/pixmaps/auto.png)
+ """
+ key = name+'.png'
+ data = pixmapData.pixmapData[key]
+ if isinstance(data, basestring) or isinstance(data, bytes):
+ pixmapData.pixmapData[key] = pickle.loads(data)
+ arr = pixmapData.pixmapData[key]
+ return QtGui.QPixmap(makeQImage(arr, alpha=True))
+
diff --git a/pyqtgraph/pixmaps/auto.png b/pyqtgraph/pixmaps/auto.png
new file mode 100644
index 00000000..a27ff4f8
Binary files /dev/null and b/pyqtgraph/pixmaps/auto.png differ
diff --git a/pyqtgraph/pixmaps/compile.py b/pyqtgraph/pixmaps/compile.py
new file mode 100644
index 00000000..ae07d487
--- /dev/null
+++ b/pyqtgraph/pixmaps/compile.py
@@ -0,0 +1,19 @@
+import numpy as np
+from PyQt4 import QtGui
+import os, pickle, sys
+
+path = os.path.abspath(os.path.split(__file__)[0])
+pixmaps = {}
+for f in os.listdir(path):
+ if not f.endswith('.png'):
+ continue
+ print(f)
+ img = QtGui.QImage(os.path.join(path, f))
+ ptr = img.bits()
+ ptr.setsize(img.byteCount())
+ arr = np.asarray(ptr).reshape(img.height(), img.width(), 4).transpose(1,0,2)
+ pixmaps[f] = pickle.dumps(arr)
+ver = sys.version_info[0]
+fh = open(os.path.join(path, 'pixmapData_%d.py' %ver), 'w')
+fh.write("import numpy as np; pixmapData=%s" % repr(pixmaps))
+
diff --git a/pyqtgraph/pixmaps/ctrl.png b/pyqtgraph/pixmaps/ctrl.png
new file mode 100644
index 00000000..c8dc96e4
Binary files /dev/null and b/pyqtgraph/pixmaps/ctrl.png differ
diff --git a/pyqtgraph/pixmaps/default.png b/pyqtgraph/pixmaps/default.png
new file mode 100644
index 00000000..f1239421
Binary files /dev/null and b/pyqtgraph/pixmaps/default.png differ
diff --git a/pyqtgraph/pixmaps/icons.svg b/pyqtgraph/pixmaps/icons.svg
new file mode 100644
index 00000000..cfdfeba4
--- /dev/null
+++ b/pyqtgraph/pixmaps/icons.svg
@@ -0,0 +1,135 @@
+
+
+
+
diff --git a/pyqtgraph/pixmaps/lock.png b/pyqtgraph/pixmaps/lock.png
new file mode 100644
index 00000000..3f85dde0
Binary files /dev/null and b/pyqtgraph/pixmaps/lock.png differ
diff --git a/pyqtgraph/pixmaps/pixmapData_2.py b/pyqtgraph/pixmaps/pixmapData_2.py
new file mode 100644
index 00000000..7813b6a6
--- /dev/null
+++ b/pyqtgraph/pixmaps/pixmapData_2.py
@@ -0,0 +1 @@
+import numpy as np; pixmapData={'lock.png': "cnumpy.core.multiarray\n_reconstruct\np0\n(cnumpy\nndarray\np1\n(I0\ntp2\nS'b'\np3\ntp4\nRp5\n(I1\n(I32\nI32\nI4\ntp6\ncnumpy\ndtype\np7\n(S'u1'\np8\nI0\nI1\ntp9\nRp10\n(I3\nS'|'\np11\nNNNI-1\nI-1\nI0\ntp12\nbI00\nS'\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xad\\xad\\xad\\x19\\xa8\\xa8\\xa8\\x8d\\xa9\\xa9\\xa9\\xc1\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xaa\\xaa\\xaa\\xc2\\xa9\\xa9\\xa9\\x8e\\xad\\xad\\xad\\x19\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xa8\\xa8\\xa8X\\xa9\\xa9\\xa9\\xed\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xed\\xa8\\xa8\\xa8X\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff)))\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff)))\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff\\x03\\x03\\x03\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x03\\x03\\x03\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff)))\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff)))\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x0c\\x0c\\x0c\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xd2\\xd2\\xd2\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe1\\xe1\\xe1\\xff{{{\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x0e\\x0e\\x0e\\xff***\\xff+++\\xff+++\\xff\\xaf\\xaf\\xaf\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe2\\xe2\\xe2\\xff\\x10\\x10\\x10\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x1e\\x1e\\x1e\\xff\\x93\\x93\\x93\\xff\\xc6\\xc6\\xc6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xffaaa\\xff\\xdc\\xdc\\xdc\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\\\\\\\\\\\\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe2\\xe2\\xe2\\xff\\xbb\\xbb\\xbb\\xff\\x9f\\x9f\\x9f\\xff\\x9f\\x9f\\x9f\\xff\\x9f\\x9f\\x9f\\xff\\xd7\\xd7\\xd7\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x1c\\x1c\\x1c\\xff\\xda\\xda\\xda\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x91\\x91\\x91\\xff\\x0f\\x0f\\x0f\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb4\\xb4\\xb4\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x87\\x87\\x87\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x98\\x98\\x98\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb4\\xb4\\xb4\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xba\\xba\\xba\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x19\\x19\\x19\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb4\\xb4\\xb4\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x08\\x08\\x08\\xff\\xe2\\xe2\\xe2\\xff\\xe6\\xe6\\xe6\\xff\\xcc\\xcc\\xcc\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb4\\xb4\\xb4\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x08\\x08\\x08\\xff\\xe2\\xe2\\xe2\\xff\\xe6\\xe6\\xe6\\xff\\xcc\\xcc\\xcc\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb4\\xb4\\xb4\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xba\\xba\\xba\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x19\\x19\\x19\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb4\\xb4\\xb4\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x85\\x85\\x85\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x98\\x98\\x98\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb4\\xb4\\xb4\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x19\\x19\\x19\\xff\\xd9\\xd9\\xd9\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x91\\x91\\x91\\xff\\x0f\\x0f\\x0f\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb4\\xb4\\xb4\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xffZZZ\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe2\\xe2\\xe2\\xff\\xbc\\xbc\\xbc\\xff\\x9f\\x9f\\x9f\\xff\\x9f\\x9f\\x9f\\xff\\x9f\\x9f\\x9f\\xff\\xd7\\xd7\\xd7\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xffaaa\\xff\\xdc\\xdc\\xdc\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x1e\\x1e\\x1e\\xff\\x93\\x93\\x93\\xff\\xc6\\xc6\\xc6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\x1d\\x1d\\x1d\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x0e\\x0e\\x0e\\xff***\\xff+++\\xff+++\\xff\\xaf\\xaf\\xaf\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe2\\xe2\\xe2\\xff\\x10\\x10\\x10\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xd2\\xd2\\xd2\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe6\\xe6\\xe6\\xff\\xe1\\xe1\\xe1\\xff{{{\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x16\\x16\\x16\\xff\\x0c\\x0c\\x0c\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff)))\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff)))\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff\\x03\\x03\\x03\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x03\\x03\\x03\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\x88\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff)))\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff)))\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaa\\x15\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\x88\\xaa\\xaa\\xaa\\x15\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00'\np13\ntp14\nb.", 'default.png': 'cnumpy.core.multiarray\n_reconstruct\np0\n(cnumpy\nndarray\np1\n(I0\ntp2\nS\'b\'\np3\ntp4\nRp5\n(I1\n(I16\nI16\nI4\ntp6\ncnumpy\ndtype\np7\n(S\'u1\'\np8\nI0\nI1\ntp9\nRp10\n(I3\nS\'|\'\np11\nNNNI-1\nI-1\nI0\ntp12\nbI00\nS\'\\x00\\x7f\\xa6\\x1b\\x0c\\x8a\\xad\\xdc\\r\\x91\\xb0\\xf3\\r\\x91\\xb0\\xf3\\r\\x91\\xb0\\xf4\\r\\x91\\xb1\\xf4\\r\\x90\\xb0\\xf4\\x05\\x85\\xa9\\xef\\x00\\x7f\\xa6<\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6!\\x1d\\x9c\\xb9\\xf5g\\xd9\\xf1\\xffi\\xd9\\xf3\\xffd\\xd1\\xee\\xff]\\xcb\\xeb\\xff@\\xbb\\xe3\\xff\\x16\\x9c\\xc2\\xf8\\x00\\x7f\\xa6\\xb4\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6U\\\'\\xac\\xc5\\xf9i\\xd9\\xf3\\xffc\\xd3\\xef\\xff\\\\\\xcf\\xeb\\xffP\\xc8\\xe6\\xff\\x17\\x9f\\xc4\\xfd\\x00\\x7f\\xa6\\xfc\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x02\\x83\\xa8lH\\xc5\\xdd\\xfah\\xdc\\xf3\\xffc\\xd4\\xef\\xffV\\xce\\xe9\\xffN\\xcf\\xe7\\xff&\\xaa\\xca\\xfd\\x00\\x7f\\xa6\\xff\\x03\\x81\\xc7\\x01\\x04\\x8d\\xda\\x01\\t\\x94\\xd9\\x01\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6"$\\xa9\\xc4\\xf7g\\xdf\\xf5\\xfff\\xdb\\xf3\\xffU\\xcd\\xeb\\xff\\x16\\xb3\\xda\\xff.\\xc9\\xe1\\xff(\\xb2\\xd0\\xfe\\x01\\x7f\\xa6\\xff\\x04\\x84\\xc9\\x05\\t\\x94\\xd9\\x06\\x10\\x9c\\xd7\\x01\\x16\\xa2\\xd6\\x01\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x02\\x83\\xa9\\x81T\\xd3\\xeb\\xffg\\xe5\\xf7\\xffe\\xda\\xf3\\xff!\\xaa\\xde\\xff\\x11\\x9d\\xc3\\xfe\\x11\\xba\\xd7\\xff \\xb9\\xd5\\xfe\\x00\\x7f\\xa6\\xff\\x16u\\x8d\\x03\\x14\\x84\\xae\\x05\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x10\\x92\\xb4\\xc0d\\xde\\xf3\\xffg\\xe5\\xf7\\xff_\\xcc\\xef\\xff\\x0e\\x9c\\xd5\\xff\\rx\\x95\\xf6\\x0e\\x89\\xab\\xf4\\x18\\xb2\\xd1\\xfc\\x00\\x7f\\xa6\\xff\\xff\\xff\\xff\\x00\\x1a~\\x91\\x01\\x1d\\xa5\\xce\\x01\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x005\\xa9\\xc3\\xefq\\xec\\xf9\\xffg\\xe5\\xf7\\xff>\\xb7\\xe8\\xff\\x14\\x96\\xc8\\xfe\\x02}\\xa3\\xb1\\x00\\x7f\\xa6Q\\x03\\x82\\xa9\\xe8\\x00\\x7f\\xa6\\xe9\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6\\x11\\x1c\\x98\\xb8\\x04%\\xb5\\xd3\\x01\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00D\\xad\\xc8\\xf3r\\xec\\xf9\\xffg\\xe5\\xf7\\xff:\\xb7\\xe8\\xff\\x19\\x90\\xc5\\xfe\\x03{\\xa0\\xa6\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6*\\x00\\x7f\\xa6*\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6\\x98\\x0f\\x8f\\xb1\\x13&\\xb5\\xd3\\x04.\\xc0\\xd1\\x01\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x19\\x93\\xb7\\xc6i\\xdf\\xf4\\xffg\\xe5\\xf7\\xffT\\xc8\\xee\\xff\\x06\\x88\\xcd\\xff\\x08g\\x85\\xf7\\x00\\x7f\\xa6\\x15\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6\\x1b\\x01\\x80\\xa7\\xeb\\x1d\\xa3\\xca\\x16#\\xb2\\xd4\\n*\\xbb\\xd2\\x04.\\xbc\\xd7\\x01\\xff\\xff\\xff\\x00\\x01\\x81\\xa7\\x88Y\\xd1\\xee\\xffg\\xe5\\xf7\\xfff\\xd9\\xf3\\xff\\\'\\xa2\\xe2\\xff\\x05e\\x99\\xf9\\x06~\\xa5\\xf3\\x01\\x81\\xa8\\x9c\\x01\\x80\\xa8\\x9f\\x04\\x85\\xad\\xef\\x08\\x8f\\xb9\\x92\\x17\\xa4\\xd6*\\x1e\\xac\\xd5\\x1a$\\xb3\\xd3\\x0c\\x19\\xa7\\xd5\\x02\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6+!\\xa3\\xc8\\xf5i\\xe0\\xf5\\xffe\\xd9\\xf3\\xff\\\\\\xca\\xee\\xff\\x1f\\x9c\\xe0\\xfa\\x03\\x84\\xca\\xd6\\x07\\x8b\\xc5\\xca\\x06\\x88\\xc1\\xb8\\x08\\x8e\\xd0l\\x0b\\x96\\xd8I\\x11\\x9e\\xd74\\x17\\xa5\\xd6 \\xab\\xd7\\x0b\\x17\\xa2\\xdc\\x01\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x01\\x80\\xa8~?\\xb9\\xe0\\xf9h\\xda\\xf3\\xff_\\xcc\\xef\\xffV\\xc1\\xec\\xfd3\\xa7\\xe3\\xe3\\x1a\\x96\\xde\\xae\\x04\\x8b\\xdb\\x89\\x00\\x89\\xdao\\x05\\x8f\\xd9T\\x0b\\x96\\xd8<\\x11\\x9b\\xd7\\x1d\\x18\\x95\\xc9\\x0c\\x00\\x80\\xd5\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6\\x04\\x03\\x83\\xaa\\xcd5\\xa2\\xc9\\xf9[\\xc6\\xea\\xffU\\xc1\\xec\\xffH\\xb4\\xe8\\xf39\\xa8\\xe4\\xc5\\x0b\\x8f\\xdc\\x9f\\x00\\x89\\xda{\\x00\\x89\\xda_\\x07\\x87\\xc4I\\x05|\\xa5s\\x05m\\xa3\\x02\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x00\\x7f\\xa6\\x06\\x01\\x7f\\xa6\\x89\\x12x\\x9e\\xf63\\x88\\xae\\xfe6\\x93\\xc3\\xfe4\\x9d\\xd6\\xdf\\x08\\x82\\xc7\\xb8\\x03k\\xa2\\xab\\x04k\\x97\\xa8\\x02w\\x9e\\xeb\\x00\\x7f\\xa6j\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\x00\\x7f\\xa67\\x00~\\xa5\\x95\\x03v\\x9c\\xd4\\x03h\\x8c\\xfa\\x02i\\x8e\\xf9\\x01x\\x9f\\xcc\\x00\\x7f\\xa6\\x92\\x00\\x7f\\xa63\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\'\np13\ntp14\nb.', 'ctrl.png': "cnumpy.core.multiarray\n_reconstruct\np0\n(cnumpy\nndarray\np1\n(I0\ntp2\nS'b'\np3\ntp4\nRp5\n(I1\n(I32\nI32\nI4\ntp6\ncnumpy\ndtype\np7\n(S'u1'\np8\nI0\nI1\ntp9\nRp10\n(I3\nS'|'\np11\nNNNI-1\nI-1\nI0\ntp12\nbI00\nS'\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xad\\xad\\xad\\x19\\xa8\\xa8\\xa8\\x8d\\xa9\\xa9\\xa9\\xc1\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xaa\\xaa\\xaa\\xc2\\xa9\\xa9\\xa9\\x8e\\xad\\xad\\xad\\x19\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xa8\\xa8\\xa8X\\xa9\\xa9\\xa9\\xed\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xed\\xa8\\xa8\\xa8X\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff)))\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff)))\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff\\x03\\x03\\x03\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x03\\x03\\x03\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff)))\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff555\\xffPPP\\xff\\x13\\x13\\x13\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff)))\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x01\\x01\\x01\\xff\\xb2\\xb2\\xb2\\xff\\xe3\\xe3\\xe3\\xff\\xd9\\xd9\\xd9\\xff]]]\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x13\\x13\\x13\\xff\\xbb\\xbb\\xbb\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xffFFF\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x13\\x13\\x13\\xff\\xbb\\xbb\\xbb\\xff\\xe3\\xe3\\xe3\\xff\\xc4\\xc4\\xc4\\xff\\x06\\x06\\x06\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff```\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff:::\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff666\\xff\\xaf\\xaf\\xaf\\xff\\x10\\x10\\x10\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9b\\x9b\\x9b\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff@@@\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xffSSS\\xff\\xe3\\xe3\\xe3\\xff\\xb7\\xb7\\xb7\\xff\\x10\\x10\\x10\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x04\\x04\\x04\\xff\\xd5\\xd5\\xd5\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xffXXX\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x17\\x17\\x17\\xff\\xdb\\xdb\\xdb\\xff\\xe3\\xe3\\xe3\\xff\\xb7\\xb7\\xb7\\xff[[[\\xff\\x97\\x97\\x97\\xff\\xd4\\xd4\\xd4\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff```\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xffHHH\\xff\\xc6\\xc6\\xc6\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x07\\x07\\x07\\xff;;;\\xffAAA\\xff\\\\\\\\\\\\\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xda\\xda\\xda\\xff;;;\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xff\\xe3\\xe3\\xe3\\xff\\xc7\\xc7\\xc7\\xffZZZ\\xff~~~\\xff\\xd9\\xd9\\xd9\\xff\\x10\\x10\\x10\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xff\\xe3\\xe3\\xe3\\xffXXX\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xb0\\xb0\\xb0\\xfffff\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xdd\\xdd\\xdd\\xffyyy\\xff\\x00\\x00\\x00\\xff\\x06\\x06\\x06\\xff\\xcd\\xcd\\xcd\\xfffff\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff@@@\\xff\\xda\\xda\\xda\\xff\\xaf\\xaf\\xaf\\xff\\xcd\\xcd\\xcd\\xff\\xd7\\xd7\\xd7\\xff\\x10\\x10\\x10\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff)))\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x12\\x12\\x12\\xffiii\\xffccc\\xff\\x0e\\x0e\\x0e\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff)))\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff\\x03\\x03\\x03\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x03\\x03\\x03\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\x88\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff)))\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff)))\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaa\\x15\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\x88\\xaa\\xaa\\xaa\\x15\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00'\np13\ntp14\nb.", 'auto.png': "cnumpy.core.multiarray\n_reconstruct\np0\n(cnumpy\nndarray\np1\n(I0\ntp2\nS'b'\np3\ntp4\nRp5\n(I1\n(I32\nI32\nI4\ntp6\ncnumpy\ndtype\np7\n(S'u1'\np8\nI0\nI1\ntp9\nRp10\n(I3\nS'|'\np11\nNNNI-1\nI-1\nI0\ntp12\nbI00\nS'\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xad\\xad\\xad\\x19\\xa8\\xa8\\xa8\\x8d\\xa9\\xa9\\xa9\\xc1\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xaa\\xaa\\xaa\\xc2\\xa9\\xa9\\xa9\\x8e\\xad\\xad\\xad\\x19\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xa8\\xa8\\xa8X\\xa9\\xa9\\xa9\\xed\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xed\\xa8\\xa8\\xa8X\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff)))\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff)))\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff\\x03\\x03\\x03\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x19\\x19\\x19\\xff\\x03\\x03\\x03\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff)))\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x04\\x04\\x04\\xffHHH\\xff\\xa4\\xa4\\xa4\\xff\\xe5\\xe5\\xe5\\xff\\x00\\x00\\x00\\xff)))\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff \\xffyyy\\xff\\xd1\\xd1\\xd1\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x06\\x06\\x06\\xffPPP\\xff\\xab\\xab\\xab\\xff\\xe6\\xe6\\xe6\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff&&&\\xff\\x82\\x82\\x82\\xff\\xd6\\xd6\\xd6\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\t\\t\\t\\xffWWW\\xff\\xb2\\xb2\\xb2\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe5\\xe5\\xe5\\xff\\xa8\\xa8\\xa8\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff---\\xff\\x89\\x89\\x89\\xff\\xda\\xda\\xda\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xc1\\xc1\\xc1\\xfflll\\xff\\x18\\x18\\x18\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\r\\r\\r\\xff^^^\\xff\\xba\\xba\\xba\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xda\\xda\\xda\\xff...\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff555\\xff\\x90\\x90\\x90\\xff\\xde\\xde\\xde\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe2\\xe2\\xe2\\xff\\xe3\\xe3\\xe3\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd2\\xd2\\xd2\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff;;;\\xff\\xc1\\xc1\\xc1\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xb7\\xb7\\xb7\\xffbbb\\xff\\x12\\x12\\x12\\xff\\xcb\\xcb\\xcb\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd2\\xd2\\xd2\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xffmmm\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xcd\\xcd\\xcd\\xffyyy\\xff$$$\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xcb\\xcb\\xcb\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd2\\xd2\\xd2\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xffmmm\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe3\\xe3\\xe3\\xff\\x91\\x91\\x91\\xff<<<\\xff\\x01\\x01\\x01\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xcb\\xcb\\xcb\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd2\\xd2\\xd2\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xffmmm\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xc3\\xc3\\xc3\\xfflll\\xff\\x18\\x18\\x18\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xcb\\xcb\\xcb\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd2\\xd2\\xd2\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xffmmm\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe4\\xe4\\xe4\\xff\\xa6\\xa6\\xa6\\xffOOO\\xff\\x07\\x07\\x07\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\xcb\\xcb\\xcb\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd2\\xd2\\xd2\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff555\\xff\\xb4\\xb4\\xb4\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd9\\xd9\\xd9\\xff\\x8a\\x8a\\x8a\\xff333\\xff\\xcb\\xcb\\xcb\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd2\\xd2\\xd2\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff+++\\xff\\x88\\x88\\x88\\xff\\xda\\xda\\xda\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xd2\\xd2\\xd2\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\n\\n\\n\\xff[[[\\xff\\xb8\\xb8\\xb8\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xdc\\xdc\\xdc\\xffAAA\\xff\\x02\\x02\\x02\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff...\\xff\\x8c\\x8c\\x8c\\xff\\xdc\\xdc\\xdc\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xcc\\xcc\\xcc\\xffsss\\xff\\x1a\\x1a\\x1a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x0c\\x0c\\x0c\\xff___\\xff\\xbc\\xbc\\xbc\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe5\\xe5\\xe5\\xff\\xa5\\xa5\\xa5\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff222\\xff\\x8f\\x8f\\x8f\\xff\\xde\\xde\\xde\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x9a\\x9a\\x9a\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x0e\\x0e\\x0e\\xffccc\\xff\\xc0\\xc0\\xc0\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x9a\\x9a\\x9a\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff555\\xff\\x94\\x94\\x94\\xff\\xe0\\xe0\\xe0\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\xe7\\xe7\\xe7\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff)))\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x10\\x10\\x10\\xfffff\\xff\\xc4\\xc4\\xc4\\xff\\xe7\\xe7\\xe7\\xff\\x00\\x00\\x00\\xff)))\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff\\x03\\x03\\x03\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff:::\\xff\\x03\\x03\\x03\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\x88\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\x88\\x88\\x88\\xff)))\\xff\\x05\\x05\\x05\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x00\\x00\\x00\\xff\\x05\\x05\\x05\\xff)))\\xff\\x88\\x88\\x88\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaa\\x15\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa6\\xa6\\xa6\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\x9a\\x9a\\x9a\\xff\\xa6\\xa6\\xa6\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaaW\\xa9\\xa9\\xa9\\xeb\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xeb\\xaa\\xaa\\xaaW\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xaa\\xaa\\xaa\\x15\\xa9\\xa9\\xa9\\x88\\xa9\\xa9\\xa9\\xbd\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xff\\xa9\\xa9\\xa9\\xf1\\xa9\\xa9\\xa9\\xbe\\xa9\\xa9\\xa9\\x88\\xaa\\xaa\\xaa\\x15\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00\\xff\\xff\\xff\\x00'\np13\ntp14\nb."}
\ No newline at end of file
diff --git a/pyqtgraph/pixmaps/pixmapData_3.py b/pyqtgraph/pixmaps/pixmapData_3.py
new file mode 100644
index 00000000..bb512029
--- /dev/null
+++ b/pyqtgraph/pixmaps/pixmapData_3.py
@@ -0,0 +1 @@
+import numpy as np; pixmapData={'lock.png': b'\x80\x03cnumpy.core.multiarray\n_reconstruct\nq\x00cnumpy\nndarray\nq\x01K\x00\x85q\x02C\x01bq\x03\x87q\x04Rq\x05(K\x01K K K\x04\x87q\x06cnumpy\ndtype\nq\x07X\x02\x00\x00\x00u1q\x08K\x00K\x01\x87q\tRq\n(K\x03X\x01\x00\x00\x00|q\x0bNNNJ\xff\xff\xff\xffJ\xff\xff\xff\xffK\x00tq\x0cb\x89B\x00\x10\x00\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xad\xad\xad\x19\xa8\xa8\xa8\x8d\xa9\xa9\xa9\xc1\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xaa\xaa\xaa\xc2\xa9\xa9\xa9\x8e\xad\xad\xad\x19\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xa8\xa8\xa8X\xa9\xa9\xa9\xed\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xed\xa8\xa8\xa8X\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xaa\xaa\xaaW\xff\xff\xff\x00\xaa\xaa\xaa\x15\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff)))\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff)))\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaa\x15\xa9\xa9\xa9\x88\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff\x03\x03\x03\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x03\x03\x03\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\x88\xa9\xa9\xa9\xbe\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff)))\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff)))\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xbe\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x0c\x0c\x0c\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xd2\xd2\xd2\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe1\xe1\xe1\xff{{{\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x0e\x0e\x0e\xff***\xff+++\xff+++\xff\xaf\xaf\xaf\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe2\xe2\xe2\xff\x10\x10\x10\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x1e\x1e\x1e\xff\x93\x93\x93\xff\xc6\xc6\xc6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xffaaa\xff\xdc\xdc\xdc\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\\\\\\\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe2\xe2\xe2\xff\xbb\xbb\xbb\xff\x9f\x9f\x9f\xff\x9f\x9f\x9f\xff\x9f\x9f\x9f\xff\xd7\xd7\xd7\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x1c\x1c\x1c\xff\xda\xda\xda\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x91\x91\x91\xff\x0f\x0f\x0f\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb4\xb4\xb4\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x87\x87\x87\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x98\x98\x98\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb4\xb4\xb4\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\xba\xba\xba\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x19\x19\x19\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb4\xb4\xb4\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x08\x08\x08\xff\xe2\xe2\xe2\xff\xe6\xe6\xe6\xff\xcc\xcc\xcc\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb4\xb4\xb4\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x08\x08\x08\xff\xe2\xe2\xe2\xff\xe6\xe6\xe6\xff\xcc\xcc\xcc\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb4\xb4\xb4\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\xba\xba\xba\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x19\x19\x19\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb4\xb4\xb4\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x85\x85\x85\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x98\x98\x98\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb4\xb4\xb4\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x19\x19\x19\xff\xd9\xd9\xd9\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x91\x91\x91\xff\x0f\x0f\x0f\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb4\xb4\xb4\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xffZZZ\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe2\xe2\xe2\xff\xbc\xbc\xbc\xff\x9f\x9f\x9f\xff\x9f\x9f\x9f\xff\x9f\x9f\x9f\xff\xd7\xd7\xd7\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xffaaa\xff\xdc\xdc\xdc\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x1e\x1e\x1e\xff\x93\x93\x93\xff\xc6\xc6\xc6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\x1d\x1d\x1d\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x0e\x0e\x0e\xff***\xff+++\xff+++\xff\xaf\xaf\xaf\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe2\xe2\xe2\xff\x10\x10\x10\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xd2\xd2\xd2\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe6\xe6\xe6\xff\xe1\xe1\xe1\xff{{{\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x16\x16\x16\xff\x0c\x0c\x0c\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xbd\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff)))\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff)))\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xbd\xa9\xa9\xa9\x88\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff\x03\x03\x03\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x03\x03\x03\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\x88\xaa\xaa\xaa\x15\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff)))\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff)))\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaa\x15\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xaa\xaa\xaaW\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaaW\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaa\x15\xa9\xa9\xa9\x88\xa9\xa9\xa9\xbd\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xbe\xa9\xa9\xa9\x88\xaa\xaa\xaa\x15\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00q\rtq\x0eb.', 'default.png': b'\x80\x03cnumpy.core.multiarray\n_reconstruct\nq\x00cnumpy\nndarray\nq\x01K\x00\x85q\x02C\x01bq\x03\x87q\x04Rq\x05(K\x01K\x10K\x10K\x04\x87q\x06cnumpy\ndtype\nq\x07X\x02\x00\x00\x00u1q\x08K\x00K\x01\x87q\tRq\n(K\x03X\x01\x00\x00\x00|q\x0bNNNJ\xff\xff\xff\xffJ\xff\xff\xff\xffK\x00tq\x0cb\x89B\x00\x04\x00\x00\x00\x7f\xa6\x1b\x0c\x8a\xad\xdc\r\x91\xb0\xf3\r\x91\xb0\xf3\r\x91\xb0\xf4\r\x91\xb1\xf4\r\x90\xb0\xf4\x05\x85\xa9\xef\x00\x7f\xa6<\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\x00\x7f\xa6!\x1d\x9c\xb9\xf5g\xd9\xf1\xffi\xd9\xf3\xffd\xd1\xee\xff]\xcb\xeb\xff@\xbb\xe3\xff\x16\x9c\xc2\xf8\x00\x7f\xa6\xb4\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\x00\x7f\xa6U\'\xac\xc5\xf9i\xd9\xf3\xffc\xd3\xef\xff\\\xcf\xeb\xffP\xc8\xe6\xff\x17\x9f\xc4\xfd\x00\x7f\xa6\xfc\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\x02\x83\xa8lH\xc5\xdd\xfah\xdc\xf3\xffc\xd4\xef\xffV\xce\xe9\xffN\xcf\xe7\xff&\xaa\xca\xfd\x00\x7f\xa6\xff\x03\x81\xc7\x01\x04\x8d\xda\x01\t\x94\xd9\x01\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\x00\x7f\xa6"$\xa9\xc4\xf7g\xdf\xf5\xfff\xdb\xf3\xffU\xcd\xeb\xff\x16\xb3\xda\xff.\xc9\xe1\xff(\xb2\xd0\xfe\x01\x7f\xa6\xff\x04\x84\xc9\x05\t\x94\xd9\x06\x10\x9c\xd7\x01\x16\xa2\xd6\x01\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\x02\x83\xa9\x81T\xd3\xeb\xffg\xe5\xf7\xffe\xda\xf3\xff!\xaa\xde\xff\x11\x9d\xc3\xfe\x11\xba\xd7\xff \xb9\xd5\xfe\x00\x7f\xa6\xff\x16u\x8d\x03\x14\x84\xae\x05\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\x10\x92\xb4\xc0d\xde\xf3\xffg\xe5\xf7\xff_\xcc\xef\xff\x0e\x9c\xd5\xff\rx\x95\xf6\x0e\x89\xab\xf4\x18\xb2\xd1\xfc\x00\x7f\xa6\xff\xff\xff\xff\x00\x1a~\x91\x01\x1d\xa5\xce\x01\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x005\xa9\xc3\xefq\xec\xf9\xffg\xe5\xf7\xff>\xb7\xe8\xff\x14\x96\xc8\xfe\x02}\xa3\xb1\x00\x7f\xa6Q\x03\x82\xa9\xe8\x00\x7f\xa6\xe9\xff\xff\xff\x00\x00\x7f\xa6\x11\x1c\x98\xb8\x04%\xb5\xd3\x01\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00D\xad\xc8\xf3r\xec\xf9\xffg\xe5\xf7\xff:\xb7\xe8\xff\x19\x90\xc5\xfe\x03{\xa0\xa6\xff\xff\xff\x00\x00\x7f\xa6*\x00\x7f\xa6*\xff\xff\xff\x00\x00\x7f\xa6\x98\x0f\x8f\xb1\x13&\xb5\xd3\x04.\xc0\xd1\x01\xff\xff\xff\x00\xff\xff\xff\x00\x19\x93\xb7\xc6i\xdf\xf4\xffg\xe5\xf7\xffT\xc8\xee\xff\x06\x88\xcd\xff\x08g\x85\xf7\x00\x7f\xa6\x15\xff\xff\xff\x00\xff\xff\xff\x00\x00\x7f\xa6\x1b\x01\x80\xa7\xeb\x1d\xa3\xca\x16#\xb2\xd4\n*\xbb\xd2\x04.\xbc\xd7\x01\xff\xff\xff\x00\x01\x81\xa7\x88Y\xd1\xee\xffg\xe5\xf7\xfff\xd9\xf3\xff\'\xa2\xe2\xff\x05e\x99\xf9\x06~\xa5\xf3\x01\x81\xa8\x9c\x01\x80\xa8\x9f\x04\x85\xad\xef\x08\x8f\xb9\x92\x17\xa4\xd6*\x1e\xac\xd5\x1a$\xb3\xd3\x0c\x19\xa7\xd5\x02\xff\xff\xff\x00\x00\x7f\xa6+!\xa3\xc8\xf5i\xe0\xf5\xffe\xd9\xf3\xff\\\xca\xee\xff\x1f\x9c\xe0\xfa\x03\x84\xca\xd6\x07\x8b\xc5\xca\x06\x88\xc1\xb8\x08\x8e\xd0l\x0b\x96\xd8I\x11\x9e\xd74\x17\xa5\xd6 \xab\xd7\x0b\x17\xa2\xdc\x01\xff\xff\xff\x00\xff\xff\xff\x00\x01\x80\xa8~?\xb9\xe0\xf9h\xda\xf3\xff_\xcc\xef\xffV\xc1\xec\xfd3\xa7\xe3\xe3\x1a\x96\xde\xae\x04\x8b\xdb\x89\x00\x89\xdao\x05\x8f\xd9T\x0b\x96\xd8<\x11\x9b\xd7\x1d\x18\x95\xc9\x0c\x00\x80\xd5\x00\xff\xff\xff\x00\xff\xff\xff\x00\x00\x7f\xa6\x04\x03\x83\xaa\xcd5\xa2\xc9\xf9[\xc6\xea\xffU\xc1\xec\xffH\xb4\xe8\xf39\xa8\xe4\xc5\x0b\x8f\xdc\x9f\x00\x89\xda{\x00\x89\xda_\x07\x87\xc4I\x05|\xa5s\x05m\xa3\x02\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\x00\x7f\xa6\x06\x01\x7f\xa6\x89\x12x\x9e\xf63\x88\xae\xfe6\x93\xc3\xfe4\x9d\xd6\xdf\x08\x82\xc7\xb8\x03k\xa2\xab\x04k\x97\xa8\x02w\x9e\xeb\x00\x7f\xa6j\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\x00\x7f\xa67\x00~\xa5\x95\x03v\x9c\xd4\x03h\x8c\xfa\x02i\x8e\xf9\x01x\x9f\xcc\x00\x7f\xa6\x92\x00\x7f\xa63\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00q\rtq\x0eb.', 'ctrl.png': b'\x80\x03cnumpy.core.multiarray\n_reconstruct\nq\x00cnumpy\nndarray\nq\x01K\x00\x85q\x02C\x01bq\x03\x87q\x04Rq\x05(K\x01K K K\x04\x87q\x06cnumpy\ndtype\nq\x07X\x02\x00\x00\x00u1q\x08K\x00K\x01\x87q\tRq\n(K\x03X\x01\x00\x00\x00|q\x0bNNNJ\xff\xff\xff\xffJ\xff\xff\xff\xffK\x00tq\x0cb\x89B\x00\x10\x00\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xad\xad\xad\x19\xa8\xa8\xa8\x8d\xa9\xa9\xa9\xc1\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xaa\xaa\xaa\xc2\xa9\xa9\xa9\x8e\xad\xad\xad\x19\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xa8\xa8\xa8X\xa9\xa9\xa9\xed\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xed\xa8\xa8\xa8X\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xaa\xaa\xaaW\xff\xff\xff\x00\xaa\xaa\xaa\x15\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff)))\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff)))\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaa\x15\xa9\xa9\xa9\x88\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff\x03\x03\x03\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x03\x03\x03\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\x88\xa9\xa9\xa9\xbe\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff)))\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff555\xffPPP\xff\x13\x13\x13\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff)))\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xbe\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x01\x01\x01\xff\xb2\xb2\xb2\xff\xe3\xe3\xe3\xff\xd9\xd9\xd9\xff]]]\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x13\x13\x13\xff\xbb\xbb\xbb\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xffFFF\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x13\x13\x13\xff\xbb\xbb\xbb\xff\xe3\xe3\xe3\xff\xc4\xc4\xc4\xff\x06\x06\x06\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff```\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff:::\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff666\xff\xaf\xaf\xaf\xff\x10\x10\x10\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9b\x9b\x9b\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff@@@\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xffSSS\xff\xe3\xe3\xe3\xff\xb7\xb7\xb7\xff\x10\x10\x10\xff\x00\x00\x00\xff\x00\x00\x00\xff\x04\x04\x04\xff\xd5\xd5\xd5\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xffXXX\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x17\x17\x17\xff\xdb\xdb\xdb\xff\xe3\xe3\xe3\xff\xb7\xb7\xb7\xff[[[\xff\x97\x97\x97\xff\xd4\xd4\xd4\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff```\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xffHHH\xff\xc6\xc6\xc6\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x07\x07\x07\xff;;;\xffAAA\xff\\\\\\\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xda\xda\xda\xff;;;\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xff\xe3\xe3\xe3\xff\xc7\xc7\xc7\xffZZZ\xff~~~\xff\xd9\xd9\xd9\xff\x10\x10\x10\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xff\xe3\xe3\xe3\xffXXX\xff\x00\x00\x00\xff\x00\x00\x00\xff\xb0\xb0\xb0\xfffff\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xdd\xdd\xdd\xffyyy\xff\x00\x00\x00\xff\x06\x06\x06\xff\xcd\xcd\xcd\xfffff\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff@@@\xff\xda\xda\xda\xff\xaf\xaf\xaf\xff\xcd\xcd\xcd\xff\xd7\xd7\xd7\xff\x10\x10\x10\xff\x00\x00\x00\xff\x05\x05\x05\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xbd\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff)))\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x12\x12\x12\xffiii\xffccc\xff\x0e\x0e\x0e\xff\x00\x00\x00\xff\x00\x00\x00\xff)))\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xbd\xa9\xa9\xa9\x88\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff\x03\x03\x03\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x03\x03\x03\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\x88\xaa\xaa\xaa\x15\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff)))\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff)))\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaa\x15\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xaa\xaa\xaaW\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaaW\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaa\x15\xa9\xa9\xa9\x88\xa9\xa9\xa9\xbd\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xbe\xa9\xa9\xa9\x88\xaa\xaa\xaa\x15\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00q\rtq\x0eb.', 'auto.png': b'\x80\x03cnumpy.core.multiarray\n_reconstruct\nq\x00cnumpy\nndarray\nq\x01K\x00\x85q\x02C\x01bq\x03\x87q\x04Rq\x05(K\x01K K K\x04\x87q\x06cnumpy\ndtype\nq\x07X\x02\x00\x00\x00u1q\x08K\x00K\x01\x87q\tRq\n(K\x03X\x01\x00\x00\x00|q\x0bNNNJ\xff\xff\xff\xffJ\xff\xff\xff\xffK\x00tq\x0cb\x89B\x00\x10\x00\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xad\xad\xad\x19\xa8\xa8\xa8\x8d\xa9\xa9\xa9\xc1\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xaa\xaa\xaa\xc2\xa9\xa9\xa9\x8e\xad\xad\xad\x19\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xa8\xa8\xa8X\xa9\xa9\xa9\xed\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xed\xa8\xa8\xa8X\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xaa\xaa\xaaW\xff\xff\xff\x00\xaa\xaa\xaa\x15\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff)))\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff)))\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaa\x15\xa9\xa9\xa9\x88\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff\x03\x03\x03\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x19\x19\x19\xff\x03\x03\x03\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\x88\xa9\xa9\xa9\xbe\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff)))\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x04\x04\x04\xffHHH\xff\xa4\xa4\xa4\xff\xe5\xe5\xe5\xff\x00\x00\x00\xff)))\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xbe\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff \xffyyy\xff\xd1\xd1\xd1\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\x00\x00\x00\xff\x05\x05\x05\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x06\x06\x06\xffPPP\xff\xab\xab\xab\xff\xe6\xe6\xe6\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff&&&\xff\x82\x82\x82\xff\xd6\xd6\xd6\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\t\t\t\xffWWW\xff\xb2\xb2\xb2\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe5\xe5\xe5\xff\xa8\xa8\xa8\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff---\xff\x89\x89\x89\xff\xda\xda\xda\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xc1\xc1\xc1\xfflll\xff\x18\x18\x18\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\r\r\r\xff^^^\xff\xba\xba\xba\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xda\xda\xda\xff...\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff555\xff\x90\x90\x90\xff\xde\xde\xde\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe2\xe2\xe2\xff\xe3\xe3\xe3\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd2\xd2\xd2\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff;;;\xff\xc1\xc1\xc1\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xb7\xb7\xb7\xffbbb\xff\x12\x12\x12\xff\xcb\xcb\xcb\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd2\xd2\xd2\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xffmmm\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xcd\xcd\xcd\xffyyy\xff$$$\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xcb\xcb\xcb\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd2\xd2\xd2\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xffmmm\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe3\xe3\xe3\xff\x91\x91\x91\xff<<<\xff\x01\x01\x01\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xcb\xcb\xcb\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd2\xd2\xd2\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xffmmm\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xc3\xc3\xc3\xfflll\xff\x18\x18\x18\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xcb\xcb\xcb\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd2\xd2\xd2\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xffmmm\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe4\xe4\xe4\xff\xa6\xa6\xa6\xffOOO\xff\x07\x07\x07\xff\x00\x00\x00\xff\x00\x00\x00\xff\xcb\xcb\xcb\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd2\xd2\xd2\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff555\xff\xb4\xb4\xb4\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd9\xd9\xd9\xff\x8a\x8a\x8a\xff333\xff\xcb\xcb\xcb\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd2\xd2\xd2\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff+++\xff\x88\x88\x88\xff\xda\xda\xda\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xd2\xd2\xd2\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\n\n\n\xff[[[\xff\xb8\xb8\xb8\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xdc\xdc\xdc\xffAAA\xff\x02\x02\x02\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff...\xff\x8c\x8c\x8c\xff\xdc\xdc\xdc\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xcc\xcc\xcc\xffsss\xff\x1a\x1a\x1a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x0c\x0c\x0c\xff___\xff\xbc\xbc\xbc\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe5\xe5\xe5\xff\xa5\xa5\xa5\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff222\xff\x8f\x8f\x8f\xff\xde\xde\xde\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x9a\x9a\x9a\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x0e\x0e\x0e\xffccc\xff\xc0\xc0\xc0\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\x00\x00\x00\xff\x00\x00\x00\xff\x9a\x9a\x9a\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff555\xff\x94\x94\x94\xff\xe0\xe0\xe0\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\xe7\xe7\xe7\xff\x00\x00\x00\xff\x05\x05\x05\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xbd\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff)))\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x10\x10\x10\xfffff\xff\xc4\xc4\xc4\xff\xe7\xe7\xe7\xff\x00\x00\x00\xff)))\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xbd\xa9\xa9\xa9\x88\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff\x03\x03\x03\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff:::\xff\x03\x03\x03\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\x88\xaa\xaa\xaa\x15\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\x88\x88\x88\xff)))\xff\x05\x05\x05\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\x05\x05\x05\xff)))\xff\x88\x88\x88\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaa\x15\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa6\xa6\xa6\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\x9a\x9a\x9a\xff\xa6\xa6\xa6\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xaa\xaa\xaaW\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaaW\xa9\xa9\xa9\xeb\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xeb\xaa\xaa\xaaW\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00\xaa\xaa\xaa\x15\xa9\xa9\xa9\x88\xa9\xa9\xa9\xbd\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xff\xa9\xa9\xa9\xf1\xa9\xa9\xa9\xbe\xa9\xa9\xa9\x88\xaa\xaa\xaa\x15\xff\xff\xff\x00\xff\xff\xff\x00\xff\xff\xff\x00q\rtq\x0eb.'}
\ No newline at end of file
diff --git a/ptime.py b/pyqtgraph/ptime.py
similarity index 100%
rename from ptime.py
rename to pyqtgraph/ptime.py
diff --git a/pyqtgraph/python2_3.py b/pyqtgraph/python2_3.py
new file mode 100644
index 00000000..2182d3a1
--- /dev/null
+++ b/pyqtgraph/python2_3.py
@@ -0,0 +1,60 @@
+"""
+Helper functions which smooth out the differences between python 2 and 3.
+"""
+import sys
+
+def asUnicode(x):
+ if sys.version_info[0] == 2:
+ if isinstance(x, unicode):
+ return x
+ elif isinstance(x, str):
+ return x.decode('UTF-8')
+ else:
+ return unicode(x)
+ else:
+ return str(x)
+
+def cmpToKey(mycmp):
+ 'Convert a cmp= function into a key= function'
+ class K(object):
+ def __init__(self, obj, *args):
+ self.obj = obj
+ def __lt__(self, other):
+ return mycmp(self.obj, other.obj) < 0
+ def __gt__(self, other):
+ return mycmp(self.obj, other.obj) > 0
+ def __eq__(self, other):
+ return mycmp(self.obj, other.obj) == 0
+ def __le__(self, other):
+ return mycmp(self.obj, other.obj) <= 0
+ def __ge__(self, other):
+ return mycmp(self.obj, other.obj) >= 0
+ def __ne__(self, other):
+ return mycmp(self.obj, other.obj) != 0
+ return K
+
+def sortList(l, cmpFunc):
+ if sys.version_info[0] == 2:
+ l.sort(cmpFunc)
+ else:
+ l.sort(key=cmpToKey(cmpFunc))
+
+if sys.version_info[0] == 3:
+ import builtins
+ builtins.basestring = str
+ #builtins.asUnicode = asUnicode
+ #builtins.sortList = sortList
+ basestring = str
+ def cmp(a,b):
+ if a>b:
+ return 1
+ elif b > a:
+ return -1
+ else:
+ return 0
+ builtins.cmp = cmp
+ builtins.xrange = range
+#else: ## don't use __builtin__ -- this confuses things like pyshell and ActiveState's lazy import recipe
+ #import __builtin__
+ #__builtin__.asUnicode = asUnicode
+ #__builtin__.sortList = sortList
diff --git a/pyqtgraph/rebuildUi.py b/pyqtgraph/rebuildUi.py
new file mode 100644
index 00000000..92d5991a
--- /dev/null
+++ b/pyqtgraph/rebuildUi.py
@@ -0,0 +1,23 @@
+import os, sys
+## Search the package tree for all .ui files, compile each to
+## a .py for pyqt and pyside
+
+pyqtuic = 'pyuic4'
+pysideuic = 'pyside-uic'
+
+for path, sd, files in os.walk('.'):
+ for f in files:
+ base, ext = os.path.splitext(f)
+ if ext != '.ui':
+ continue
+ ui = os.path.join(path, f)
+
+ py = os.path.join(path, base + '_pyqt.py')
+ if os.stat(ui).st_mtime > os.stat(py).st_mtime:
+ os.system('%s %s > %s' % (pyqtuic, ui, py))
+ print(py)
+
+ py = os.path.join(path, base + '_pyside.py')
+ if os.stat(ui).st_mtime > os.stat(py).st_mtime:
+ os.system('%s %s > %s' % (pysideuic, ui, py))
+ print(py)
diff --git a/pyqtgraph/reload.py b/pyqtgraph/reload.py
new file mode 100644
index 00000000..b9459073
--- /dev/null
+++ b/pyqtgraph/reload.py
@@ -0,0 +1,516 @@
+# -*- coding: utf-8 -*-
+"""
+Magic Reload Library
+Luke Campagnola 2010
+
+Python reload function that actually works (the way you expect it to)
+ - No re-importing necessary
+ - Modules can be reloaded in any order
+ - Replaces functions and methods with their updated code
+ - Changes instances to use updated classes
+ - Automatically decides which modules to update by comparing file modification times
+
+Does NOT:
+ - re-initialize exting instances, even if __init__ changes
+ - update references to any module-level objects
+ ie, this does not reload correctly:
+ from module import someObject
+ print someObject
+ ..but you can use this instead: (this works even for the builtin reload)
+ import module
+ print module.someObject
+"""
+
+
+import inspect, os, sys, gc, traceback
+try:
+ import __builtin__ as builtins
+except ImportError:
+ import builtins
+from .debug import printExc
+
+def reloadAll(prefix=None, debug=False):
+ """Automatically reload everything whose __file__ begins with prefix.
+ - Skips reload if the file has not been updated (if .pyc is newer than .py)
+ - if prefix is None, checks all loaded modules
+ """
+ failed = []
+ changed = []
+ for modName, mod in list(sys.modules.items()): ## don't use iteritems; size may change during reload
+ if not inspect.ismodule(mod):
+ continue
+ if modName == '__main__':
+ continue
+
+ ## Ignore if the file name does not start with prefix
+ if not hasattr(mod, '__file__') or os.path.splitext(mod.__file__)[1] not in ['.py', '.pyc']:
+ continue
+ if prefix is not None and mod.__file__[:len(prefix)] != prefix:
+ continue
+
+ ## ignore if the .pyc is newer than the .py (or if there is no pyc or py)
+ py = os.path.splitext(mod.__file__)[0] + '.py'
+ pyc = py + 'c'
+ if py not in changed and os.path.isfile(pyc) and os.path.isfile(py) and os.stat(pyc).st_mtime >= os.stat(py).st_mtime:
+ #if debug:
+ #print "Ignoring module %s; unchanged" % str(mod)
+ continue
+ changed.append(py) ## keep track of which modules have changed to insure that duplicate-import modules get reloaded.
+
+ try:
+ reload(mod, debug=debug)
+ except:
+ printExc("Error while reloading module %s, skipping\n" % mod)
+ failed.append(mod.__name__)
+
+ if len(failed) > 0:
+ raise Exception("Some modules failed to reload: %s" % ', '.join(failed))
+
+def reload(module, debug=False, lists=False, dicts=False):
+ """Replacement for the builtin reload function:
+ - Reloads the module as usual
+ - Updates all old functions and class methods to use the new code
+ - Updates all instances of each modified class to use the new class
+ - Can update lists and dicts, but this is disabled by default
+ - Requires that class and function names have not changed
+ """
+ if debug:
+ print("Reloading %s" % str(module))
+
+ ## make a copy of the old module dictionary, reload, then grab the new module dictionary for comparison
+ oldDict = module.__dict__.copy()
+ builtins.reload(module)
+ newDict = module.__dict__
+
+ ## Allow modules access to the old dictionary after they reload
+ if hasattr(module, '__reload__'):
+ module.__reload__(oldDict)
+
+ ## compare old and new elements from each dict; update where appropriate
+ for k in oldDict:
+ old = oldDict[k]
+ new = newDict.get(k, None)
+ if old is new or new is None:
+ continue
+
+ if inspect.isclass(old):
+ if debug:
+ print(" Updating class %s.%s (0x%x -> 0x%x)" % (module.__name__, k, id(old), id(new)))
+ updateClass(old, new, debug)
+
+ elif inspect.isfunction(old):
+ depth = updateFunction(old, new, debug)
+ if debug:
+ extra = ""
+ if depth > 0:
+ extra = " (and %d previous versions)" % depth
+ print(" Updating function %s.%s%s" % (module.__name__, k, extra))
+ elif lists and isinstance(old, list):
+ l = old.len()
+ old.extend(new)
+ for i in range(l):
+ old.pop(0)
+ elif dicts and isinstance(old, dict):
+ old.update(new)
+ for k in old:
+ if k not in new:
+ del old[k]
+
+
+
+## For functions:
+## 1) update the code and defaults to new versions.
+## 2) keep a reference to the previous version so ALL versions get updated for every reload
+def updateFunction(old, new, debug, depth=0, visited=None):
+ #if debug and depth > 0:
+ #print " -> also updating previous version", old, " -> ", new
+
+ old.__code__ = new.__code__
+ old.__defaults__ = new.__defaults__
+
+ if visited is None:
+ visited = []
+ if old in visited:
+ return
+ visited.append(old)
+
+ ## finally, update any previous versions still hanging around..
+ if hasattr(old, '__previous_reload_version__'):
+ maxDepth = updateFunction(old.__previous_reload_version__, new, debug, depth=depth+1, visited=visited)
+ else:
+ maxDepth = depth
+
+ ## We need to keep a pointer to the previous version so we remember to update BOTH
+ ## when the next reload comes around.
+ if depth == 0:
+ new.__previous_reload_version__ = old
+ return maxDepth
+
+
+
+## For classes:
+## 1) find all instances of the old class and set instance.__class__ to the new class
+## 2) update all old class methods to use code from the new class methods
+def updateClass(old, new, debug):
+
+ ## Track town all instances and subclasses of old
+ refs = gc.get_referrers(old)
+ for ref in refs:
+ try:
+ if isinstance(ref, old) and ref.__class__ is old:
+ ref.__class__ = new
+ if debug:
+ print(" Changed class for %s" % safeStr(ref))
+ elif inspect.isclass(ref) and issubclass(ref, old) and old in ref.__bases__:
+ ind = ref.__bases__.index(old)
+
+ ## Does not work:
+ #ref.__bases__ = ref.__bases__[:ind] + (new,) + ref.__bases__[ind+1:]
+ ## reason: Even though we change the code on methods, they remain bound
+ ## to their old classes (changing im_class is not allowed). Instead,
+ ## we have to update the __bases__ such that this class will be allowed
+ ## as an argument to older methods.
+
+ ## This seems to work. Is there any reason not to?
+ ## Note that every time we reload, the class hierarchy becomes more complex.
+ ## (and I presume this may slow things down?)
+ ref.__bases__ = ref.__bases__[:ind] + (new,old) + ref.__bases__[ind+1:]
+ if debug:
+ print(" Changed superclass for %s" % safeStr(ref))
+ #else:
+ #if debug:
+ #print " Ignoring reference", type(ref)
+ except:
+ print("Error updating reference (%s) for class change (%s -> %s)" % (safeStr(ref), safeStr(old), safeStr(new)))
+ raise
+
+ ## update all class methods to use new code.
+ ## Generally this is not needed since instances already know about the new class,
+ ## but it fixes a few specific cases (pyqt signals, for one)
+ for attr in dir(old):
+ oa = getattr(old, attr)
+ if inspect.ismethod(oa):
+ try:
+ na = getattr(new, attr)
+ except AttributeError:
+ if debug:
+ print(" Skipping method update for %s; new class does not have this attribute" % attr)
+ continue
+
+ if hasattr(oa, 'im_func') and hasattr(na, 'im_func') and oa.__func__ is not na.__func__:
+ depth = updateFunction(oa.__func__, na.__func__, debug)
+ #oa.im_class = new ## bind old method to new class ## not allowed
+ if debug:
+ extra = ""
+ if depth > 0:
+ extra = " (and %d previous versions)" % depth
+ print(" Updating method %s%s" % (attr, extra))
+
+ ## And copy in new functions that didn't exist previously
+ for attr in dir(new):
+ if not hasattr(old, attr):
+ if debug:
+ print(" Adding missing attribute %s" % attr)
+ setattr(old, attr, getattr(new, attr))
+
+ ## finally, update any previous versions still hanging around..
+ if hasattr(old, '__previous_reload_version__'):
+ updateClass(old.__previous_reload_version__, new, debug)
+
+
+## It is possible to build classes for which str(obj) just causes an exception.
+## Avoid thusly:
+def safeStr(obj):
+ try:
+ s = str(obj)
+ except:
+ try:
+ s = repr(obj)
+ except:
+ s = "" % (safeStr(type(obj)), id(obj))
+ return s
+
+
+
+
+
+## Tests:
+# write modules to disk, import, then re-write and run again
+if __name__ == '__main__':
+ doQtTest = True
+ try:
+ from PyQt4 import QtCore
+ if not hasattr(QtCore, 'Signal'):
+ QtCore.Signal = QtCore.pyqtSignal
+ #app = QtGui.QApplication([])
+ class Btn(QtCore.QObject):
+ sig = QtCore.Signal()
+ def emit(self):
+ self.sig.emit()
+ btn = Btn()
+ except:
+ raise
+ print("Error; skipping Qt tests")
+ doQtTest = False
+
+
+
+ import os
+ if not os.path.isdir('test1'):
+ os.mkdir('test1')
+ open('test1/__init__.py', 'w')
+ modFile1 = "test1/test1.py"
+ modCode1 = """
+import sys
+class A(object):
+ def __init__(self, msg):
+ object.__init__(self)
+ self.msg = msg
+ def fn(self, pfx = ""):
+ print pfx+"A class:", self.__class__, id(self.__class__)
+ print pfx+" %%s: %d" %% self.msg
+
+class B(A):
+ def fn(self, pfx=""):
+ print pfx+"B class:", self.__class__, id(self.__class__)
+ print pfx+" %%s: %d" %% self.msg
+ print pfx+" calling superclass.. (%%s)" %% id(A)
+ A.fn(self, " ")
+"""
+
+ modFile2 = "test2.py"
+ modCode2 = """
+from test1.test1 import A
+from test1.test1 import B
+
+a1 = A("ax1")
+b1 = B("bx1")
+class C(A):
+ def __init__(self, msg):
+ #print "| C init:"
+ #print "| C.__bases__ = ", map(id, C.__bases__)
+ #print "| A:", id(A)
+ #print "| A.__init__ = ", id(A.__init__.im_func), id(A.__init__.im_func.__code__), id(A.__init__.im_class)
+ A.__init__(self, msg + "(init from C)")
+
+def fn():
+ print "fn: %s"
+"""
+
+ open(modFile1, 'w').write(modCode1%(1,1))
+ open(modFile2, 'w').write(modCode2%"message 1")
+ import test1.test1 as test1
+ import test2
+ print("Test 1 originals:")
+ A1 = test1.A
+ B1 = test1.B
+ a1 = test1.A("a1")
+ b1 = test1.B("b1")
+ a1.fn()
+ b1.fn()
+ #print "function IDs a1 bound method: %d a1 func: %d a1 class: %d b1 func: %d b1 class: %d" % (id(a1.fn), id(a1.fn.im_func), id(a1.fn.im_class), id(b1.fn.im_func), id(b1.fn.im_class))
+
+
+ from test2 import fn, C
+
+ if doQtTest:
+ print("Button test before:")
+ btn.sig.connect(fn)
+ btn.sig.connect(a1.fn)
+ btn.emit()
+ #btn.sig.emit()
+ print("")
+
+ #print "a1.fn referrers:", sys.getrefcount(a1.fn.im_func), gc.get_referrers(a1.fn.im_func)
+
+
+ print("Test2 before reload:")
+
+ fn()
+ oldfn = fn
+ test2.a1.fn()
+ test2.b1.fn()
+ c1 = test2.C('c1')
+ c1.fn()
+
+ os.remove(modFile1+'c')
+ open(modFile1, 'w').write(modCode1%(2,2))
+ print("\n----RELOAD test1-----\n")
+ reloadAll(os.path.abspath(__file__)[:10], debug=True)
+
+
+ print("Subclass test:")
+ c2 = test2.C('c2')
+ c2.fn()
+
+
+ os.remove(modFile2+'c')
+ open(modFile2, 'w').write(modCode2%"message 2")
+ print("\n----RELOAD test2-----\n")
+ reloadAll(os.path.abspath(__file__)[:10], debug=True)
+
+ if doQtTest:
+ print("Button test after:")
+ btn.emit()
+ #btn.sig.emit()
+
+ #print "a1.fn referrers:", sys.getrefcount(a1.fn.im_func), gc.get_referrers(a1.fn.im_func)
+
+ print("Test2 after reload:")
+ fn()
+ test2.a1.fn()
+ test2.b1.fn()
+
+ print("\n==> Test 1 Old instances:")
+ a1.fn()
+ b1.fn()
+ c1.fn()
+ #print "function IDs a1 bound method: %d a1 func: %d a1 class: %d b1 func: %d b1 class: %d" % (id(a1.fn), id(a1.fn.im_func), id(a1.fn.im_class), id(b1.fn.im_func), id(b1.fn.im_class))
+
+ print("\n==> Test 1 New instances:")
+ a2 = test1.A("a2")
+ b2 = test1.B("b2")
+ a2.fn()
+ b2.fn()
+ c2 = test2.C('c2')
+ c2.fn()
+ #print "function IDs a1 bound method: %d a1 func: %d a1 class: %d b1 func: %d b1 class: %d" % (id(a1.fn), id(a1.fn.im_func), id(a1.fn.im_class), id(b1.fn.im_func), id(b1.fn.im_class))
+
+
+
+
+ os.remove(modFile1+'c')
+ os.remove(modFile2+'c')
+ open(modFile1, 'w').write(modCode1%(3,3))
+ open(modFile2, 'w').write(modCode2%"message 3")
+
+ print("\n----RELOAD-----\n")
+ reloadAll(os.path.abspath(__file__)[:10], debug=True)
+
+ if doQtTest:
+ print("Button test after:")
+ btn.emit()
+ #btn.sig.emit()
+
+ #print "a1.fn referrers:", sys.getrefcount(a1.fn.im_func), gc.get_referrers(a1.fn.im_func)
+
+ print("Test2 after reload:")
+ fn()
+ test2.a1.fn()
+ test2.b1.fn()
+
+ print("\n==> Test 1 Old instances:")
+ a1.fn()
+ b1.fn()
+ print("function IDs a1 bound method: %d a1 func: %d a1 class: %d b1 func: %d b1 class: %d" % (id(a1.fn), id(a1.fn.__func__), id(a1.fn.__self__.__class__), id(b1.fn.__func__), id(b1.fn.__self__.__class__)))
+
+ print("\n==> Test 1 New instances:")
+ a2 = test1.A("a2")
+ b2 = test1.B("b2")
+ a2.fn()
+ b2.fn()
+ print("function IDs a1 bound method: %d a1 func: %d a1 class: %d b1 func: %d b1 class: %d" % (id(a1.fn), id(a1.fn.__func__), id(a1.fn.__self__.__class__), id(b1.fn.__func__), id(b1.fn.__self__.__class__)))
+
+
+ os.remove(modFile1)
+ os.remove(modFile2)
+ os.remove(modFile1+'c')
+ os.remove(modFile2+'c')
+ os.system('rm -r test1')
+
+
+
+
+
+
+
+
+#
+# Failure graveyard ahead:
+#
+
+
+"""Reload Importer:
+Hooks into import system to
+1) keep a record of module dependencies as they are imported
+2) make sure modules are always reloaded in correct order
+3) update old classes and functions to use reloaded code"""
+
+#import imp, sys
+
+## python's import hook mechanism doesn't work since we need to be
+## informed every time there is an import statement, not just for new imports
+#class ReloadImporter:
+ #def __init__(self):
+ #self.depth = 0
+
+ #def find_module(self, name, path):
+ #print " "*self.depth + "find: ", name, path
+ ##if name == 'PyQt4' and path is None:
+ ##print "PyQt4 -> PySide"
+ ##self.modData = imp.find_module('PySide')
+ ##return self
+ ##return None ## return none to allow the import to proceed normally; return self to intercept with load_module
+ #self.modData = imp.find_module(name, path)
+ #self.depth += 1
+ ##sys.path_importer_cache = {}
+ #return self
+
+ #def load_module(self, name):
+ #mod = imp.load_module(name, *self.modData)
+ #self.depth -= 1
+ #print " "*self.depth + "load: ", name
+ #return mod
+
+#def pathHook(path):
+ #print "path hook:", path
+ #raise ImportError
+#sys.path_hooks.append(pathHook)
+
+#sys.meta_path.append(ReloadImporter())
+
+
+### replace __import__ with a wrapper that tracks module dependencies
+#modDeps = {}
+#reloadModule = None
+#origImport = __builtins__.__import__
+#def _import(name, globals=None, locals=None, fromlist=None, level=-1, stack=[]):
+ ### Note that stack behaves as a static variable.
+ ##print " "*len(importStack) + "import %s" % args[0]
+ #stack.append(set())
+ #mod = origImport(name, globals, locals, fromlist, level)
+ #deps = stack.pop()
+ #if len(stack) > 0:
+ #stack[-1].add(mod)
+ #elif reloadModule is not None: ## If this is the top level import AND we're inside a module reload
+ #modDeps[reloadModule].add(mod)
+
+ #if mod in modDeps:
+ #modDeps[mod] |= deps
+ #else:
+ #modDeps[mod] = deps
+
+
+ #return mod
+
+#__builtins__.__import__ = _import
+
+### replace
+#origReload = __builtins__.reload
+#def _reload(mod):
+ #reloadModule = mod
+ #ret = origReload(mod)
+ #reloadModule = None
+ #return ret
+#__builtins__.reload = _reload
+
+
+#def reload(mod, visited=None):
+ #if visited is None:
+ #visited = set()
+ #if mod in visited:
+ #return
+ #visited.add(mod)
+ #for dep in modDeps.get(mod, []):
+ #reload(dep, visited)
+ #__builtins__.reload(mod)
diff --git a/pyqtgraph/units.py b/pyqtgraph/units.py
new file mode 100644
index 00000000..6b7f3099
--- /dev/null
+++ b/pyqtgraph/units.py
@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+## Very simple unit support:
+## - creates variable names like 'mV' and 'kHz'
+## - the value assigned to the variable corresponds to the scale prefix
+## (mV = 0.001)
+## - the actual units are purely cosmetic for making code clearer:
+##
+## x = 20*pA is identical to x = 20*1e-12
+
+## No unicode variable names (μ,Ω) allowed until python 3
+
+SI_PREFIXES = 'yzafpnum kMGTPEZY'
+UNITS = 'm,s,g,W,J,V,A,F,T,Hz,Ohm,S,N,C,px,b,B'.split(',')
+allUnits = {}
+
+def addUnit(p, n):
+ g = globals()
+ v = 1000**n
+ for u in UNITS:
+ g[p+u] = v
+ allUnits[p+u] = v
+
+for p in SI_PREFIXES:
+ if p == ' ':
+ p = ''
+ n = 0
+ elif p == 'u':
+ n = -2
+ else:
+ n = SI_PREFIXES.index(p) - 8
+
+ addUnit(p, n)
+
+cm = 0.01
+
+
+
+
+
+
+def evalUnits(unitStr):
+ """
+ Evaluate a unit string into ([numerators,...], [denominators,...])
+ Examples:
+ N m/s^2 => ([N, m], [s, s])
+ A*s / V => ([A, s], [V,])
+ """
+ pass
+
+def formatUnits(units):
+ """
+ Format a unit specification ([numerators,...], [denominators,...])
+ into a string (this is the inverse of evalUnits)
+ """
+ pass
+
+def simplify(units):
+ """
+ Cancel units that appear in both numerator and denominator, then attempt to replace
+ groups of units with single units where possible (ie, J/s => W)
+ """
+ pass
+
+
\ No newline at end of file
diff --git a/pyqtgraph/widgets/BusyCursor.py b/pyqtgraph/widgets/BusyCursor.py
new file mode 100644
index 00000000..b013dda0
--- /dev/null
+++ b/pyqtgraph/widgets/BusyCursor.py
@@ -0,0 +1,24 @@
+from pyqtgraph.Qt import QtGui, QtCore
+
+__all__ = ['BusyCursor']
+
+class BusyCursor(object):
+ """Class for displaying a busy mouse cursor during long operations.
+ Usage::
+
+ with pyqtgraph.BusyCursor():
+ doLongOperation()
+
+ May be nested.
+ """
+ active = []
+
+ def __enter__(self):
+ QtGui.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
+ BusyCursor.active.append(self)
+
+ def __exit__(self, *args):
+ BusyCursor.active.pop(-1)
+ if len(BusyCursor.active) == 0:
+ QtGui.QApplication.restoreOverrideCursor()
+
\ No newline at end of file
diff --git a/pyqtgraph/widgets/CheckTable.py b/pyqtgraph/widgets/CheckTable.py
new file mode 100644
index 00000000..dd33fd75
--- /dev/null
+++ b/pyqtgraph/widgets/CheckTable.py
@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+from . import VerticalLabel
+
+__all__ = ['CheckTable']
+
+class CheckTable(QtGui.QWidget):
+
+ sigStateChanged = QtCore.Signal(object, object, object) # (row, col, state)
+
+ def __init__(self, columns):
+ QtGui.QWidget.__init__(self)
+ self.layout = QtGui.QGridLayout()
+ self.layout.setSpacing(0)
+ self.setLayout(self.layout)
+ self.headers = []
+ self.columns = columns
+ col = 1
+ for c in columns:
+ label = VerticalLabel.VerticalLabel(c, orientation='vertical')
+ self.headers.append(label)
+ self.layout.addWidget(label, 0, col)
+ col += 1
+
+ self.rowNames = []
+ self.rowWidgets = []
+ self.oldRows = {} ## remember settings from removed rows; reapply if they reappear.
+
+
+ def updateRows(self, rows):
+ for r in self.rowNames[:]:
+ if r not in rows:
+ self.removeRow(r)
+ for r in rows:
+ if r not in self.rowNames:
+ self.addRow(r)
+
+ def addRow(self, name):
+ label = QtGui.QLabel(name)
+ row = len(self.rowNames)+1
+ self.layout.addWidget(label, row, 0)
+ checks = []
+ col = 1
+ for c in self.columns:
+ check = QtGui.QCheckBox('')
+ check.col = c
+ check.row = name
+ self.layout.addWidget(check, row, col)
+ checks.append(check)
+ if name in self.oldRows:
+ check.setChecked(self.oldRows[name][col])
+ col += 1
+ #QtCore.QObject.connect(check, QtCore.SIGNAL('stateChanged(int)'), self.checkChanged)
+ check.stateChanged.connect(self.checkChanged)
+ self.rowNames.append(name)
+ self.rowWidgets.append([label] + checks)
+
+ def removeRow(self, name):
+ row = self.rowNames.index(name)
+ self.oldRows[name] = self.saveState()['rows'][row] ## save for later
+ self.rowNames.pop(row)
+ for w in self.rowWidgets[row]:
+ w.setParent(None)
+ #QtCore.QObject.disconnect(w, QtCore.SIGNAL('stateChanged(int)'), self.checkChanged)
+ if isinstance(w, QtGui.QCheckBox):
+ w.stateChanged.disconnect(self.checkChanged)
+ self.rowWidgets.pop(row)
+ for i in range(row, len(self.rowNames)):
+ widgets = self.rowWidgets[i]
+ for j in range(len(widgets)):
+ widgets[j].setParent(None)
+ self.layout.addWidget(widgets[j], i+1, j)
+
+ def checkChanged(self, state):
+ check = QtCore.QObject.sender(self)
+ #self.emit(QtCore.SIGNAL('stateChanged'), check.row, check.col, state)
+ self.sigStateChanged.emit(check.row, check.col, state)
+
+ def saveState(self):
+ rows = []
+ for i in range(len(self.rowNames)):
+ row = [self.rowNames[i]] + [c.isChecked() for c in self.rowWidgets[i][1:]]
+ rows.append(row)
+ return {'cols': self.columns, 'rows': rows}
+
+ def restoreState(self, state):
+ rows = [r[0] for r in state['rows']]
+ self.updateRows(rows)
+ for r in state['rows']:
+ rowNum = self.rowNames.index(r[0])
+ for i in range(1, len(r)):
+ self.rowWidgets[rowNum][i].setChecked(r[i])
+
diff --git a/ColorButton.py b/pyqtgraph/widgets/ColorButton.py
similarity index 70%
rename from ColorButton.py
rename to pyqtgraph/widgets/ColorButton.py
index cc967c3b..fafe2ae7 100644
--- a/ColorButton.py
+++ b/pyqtgraph/widgets/ColorButton.py
@@ -1,11 +1,21 @@
# -*- coding: utf-8 -*-
-from PyQt4 import QtGui, QtCore
-if not hasattr(QtCore, 'Signal'):
- QtCore.Signal = QtCore.pyqtSignal
-import functions
+from pyqtgraph.Qt import QtGui, QtCore
+import pyqtgraph.functions as functions
+
+__all__ = ['ColorButton']
class ColorButton(QtGui.QPushButton):
+ """
+ **Bases:** QtGui.QPushButton
+ Button displaying a color and allowing the user to select a new color.
+
+ ====================== ============================================================
+ **Signals**:
+ sigColorChanging(self) emitted whenever a new color is picked in the color dialog
+ sigColorChanged(self) emitted when the selected color is accepted (user clicks OK)
+ ====================== ============================================================
+ """
sigColorChanging = QtCore.Signal(object) ## emitted whenever a new color is picked in the color dialog
sigColorChanged = QtCore.Signal(object) ## emitted when the selected color is accepted (user clicks OK)
@@ -27,11 +37,18 @@ class ColorButton(QtGui.QPushButton):
def paintEvent(self, ev):
QtGui.QPushButton.paintEvent(self, ev)
p = QtGui.QPainter(self)
+ rect = self.rect().adjusted(6, 6, -6, -6)
+ ## draw white base, then texture for indicating transparency, then actual color
+ p.setBrush(functions.mkBrush('w'))
+ p.drawRect(rect)
+ p.setBrush(QtGui.QBrush(QtCore.Qt.DiagCrossPattern))
+ p.drawRect(rect)
p.setBrush(functions.mkBrush(self._color))
- p.drawRect(self.rect().adjusted(5, 5, -5, -5))
+ p.drawRect(rect)
p.end()
def setColor(self, color, finished=True):
+ """Sets the button's color and emits both sigColorChanged and sigColorChanging."""
self._color = functions.mkColor(color)
if finished:
self.sigColorChanged.emit(self)
@@ -66,18 +83,3 @@ class ColorButton(QtGui.QPushButton):
def widgetGroupInterface(self):
return (self.sigColorChanged, ColorButton.saveState, ColorButton.restoreState)
-if __name__ == '__main__':
- app = QtGui.QApplication([])
- win = QtGui.QMainWindow()
- btn = ColorButton()
- win.setCentralWidget(btn)
- win.show()
-
- def change(btn):
- print "change", btn.color()
- def done(btn):
- print "done", btn.color()
-
- btn.sigColorChanging.connect(change)
- btn.sigColorChanged.connect(done)
-
\ No newline at end of file
diff --git a/pyqtgraph/widgets/ComboBox.py b/pyqtgraph/widgets/ComboBox.py
new file mode 100644
index 00000000..1884648c
--- /dev/null
+++ b/pyqtgraph/widgets/ComboBox.py
@@ -0,0 +1,41 @@
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.SignalProxy import SignalProxy
+
+
+class ComboBox(QtGui.QComboBox):
+ """Extends QComboBox to add extra functionality.
+ - updateList() - updates the items in the comboBox while blocking signals, remembers and resets to the previous values if it's still in the list
+ """
+
+
+ def __init__(self, parent=None, items=None, default=None):
+ QtGui.QComboBox.__init__(self, parent)
+
+ #self.value = default
+
+ if items is not None:
+ self.addItems(items)
+ if default is not None:
+ self.setValue(default)
+
+ def setValue(self, value):
+ ind = self.findText(value)
+ if ind == -1:
+ return
+ #self.value = value
+ self.setCurrentIndex(ind)
+
+ def updateList(self, items):
+ prevVal = str(self.currentText())
+ try:
+ self.blockSignals(True)
+ self.clear()
+ self.addItems(items)
+ self.setValue(prevVal)
+
+ finally:
+ self.blockSignals(False)
+
+ if str(self.currentText()) != prevVal:
+ self.currentIndexChanged.emit(self.currentIndex())
+
\ No newline at end of file
diff --git a/pyqtgraph/widgets/DataTreeWidget.py b/pyqtgraph/widgets/DataTreeWidget.py
new file mode 100644
index 00000000..a6b5cac8
--- /dev/null
+++ b/pyqtgraph/widgets/DataTreeWidget.py
@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.pgcollections import OrderedDict
+import types, traceback
+import numpy as np
+
+try:
+ import metaarray
+ HAVE_METAARRAY = True
+except:
+ HAVE_METAARRAY = False
+
+__all__ = ['DataTreeWidget']
+
+class DataTreeWidget(QtGui.QTreeWidget):
+ """
+ Widget for displaying hierarchical python data structures
+ (eg, nested dicts, lists, and arrays)
+ """
+
+
+ def __init__(self, parent=None, data=None):
+ QtGui.QTreeWidget.__init__(self, parent)
+ self.setVerticalScrollMode(self.ScrollPerPixel)
+ self.setData(data)
+ self.setColumnCount(3)
+ self.setHeaderLabels(['key / index', 'type', 'value'])
+
+ def setData(self, data, hideRoot=False):
+ """data should be a dictionary."""
+ self.clear()
+ self.buildTree(data, self.invisibleRootItem(), hideRoot=hideRoot)
+ #node = self.mkNode('', data)
+ #while node.childCount() > 0:
+ #c = node.child(0)
+ #node.removeChild(c)
+ #self.invisibleRootItem().addChild(c)
+ self.expandToDepth(3)
+ self.resizeColumnToContents(0)
+
+ def buildTree(self, data, parent, name='', hideRoot=False):
+ if hideRoot:
+ node = parent
+ else:
+ typeStr = type(data).__name__
+ if typeStr == 'instance':
+ typeStr += ": " + data.__class__.__name__
+ node = QtGui.QTreeWidgetItem([name, typeStr, ""])
+ parent.addChild(node)
+
+ if isinstance(data, types.TracebackType): ## convert traceback to a list of strings
+ data = list(map(str.strip, traceback.format_list(traceback.extract_tb(data))))
+ elif HAVE_METAARRAY and (hasattr(data, 'implements') and data.implements('MetaArray')):
+ data = {
+ 'data': data.view(np.ndarray),
+ 'meta': data.infoCopy()
+ }
+
+ if isinstance(data, dict):
+ for k in data:
+ self.buildTree(data[k], node, str(k))
+ elif isinstance(data, list) or isinstance(data, tuple):
+ for i in range(len(data)):
+ self.buildTree(data[i], node, str(i))
+ else:
+ node.setText(2, str(data))
+
+
+ #def mkNode(self, name, v):
+ #if type(v) is list and len(v) > 0 and isinstance(v[0], dict):
+ #inds = map(unicode, range(len(v)))
+ #v = OrderedDict(zip(inds, v))
+ #if isinstance(v, dict):
+ ##print "\nadd tree", k, v
+ #node = QtGui.QTreeWidgetItem([name])
+ #for k in v:
+ #newNode = self.mkNode(k, v[k])
+ #node.addChild(newNode)
+ #else:
+ ##print "\nadd value", k, str(v)
+ #node = QtGui.QTreeWidgetItem([unicode(name), unicode(v)])
+ #return node
+
diff --git a/pyqtgraph/widgets/FeedbackButton.py b/pyqtgraph/widgets/FeedbackButton.py
new file mode 100644
index 00000000..f788f4b6
--- /dev/null
+++ b/pyqtgraph/widgets/FeedbackButton.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtCore, QtGui
+
+__all__ = ['FeedbackButton']
+
+class FeedbackButton(QtGui.QPushButton):
+ """
+ QPushButton which flashes success/failure indication for slow or asynchronous procedures.
+ """
+
+
+ ### For thread-safetyness
+ sigCallSuccess = QtCore.Signal(object, object, object)
+ sigCallFailure = QtCore.Signal(object, object, object)
+ sigCallProcess = QtCore.Signal(object, object, object)
+ sigReset = QtCore.Signal()
+
+ def __init__(self, *args):
+ QtGui.QPushButton.__init__(self, *args)
+ self.origStyle = None
+ self.origText = self.text()
+ self.origStyle = self.styleSheet()
+ self.origTip = self.toolTip()
+ self.limitedTime = True
+
+
+ #self.textTimer = QtCore.QTimer()
+ #self.tipTimer = QtCore.QTimer()
+ #self.textTimer.timeout.connect(self.setText)
+ #self.tipTimer.timeout.connect(self.setToolTip)
+
+ self.sigCallSuccess.connect(self.success)
+ self.sigCallFailure.connect(self.failure)
+ self.sigCallProcess.connect(self.processing)
+ self.sigReset.connect(self.reset)
+
+
+ def feedback(self, success, message=None, tip="", limitedTime=True):
+ """Calls success() or failure(). If you want the message to be displayed until the user takes an action, set limitedTime to False. Then call self.reset() after the desired action.Threadsafe."""
+ if success:
+ self.success(message, tip, limitedTime=limitedTime)
+ else:
+ self.failure(message, tip, limitedTime=limitedTime)
+
+ def success(self, message=None, tip="", limitedTime=True):
+ """Displays specified message on button and flashes button green to let user know action was successful. If you want the success to be displayed until the user takes an action, set limitedTime to False. Then call self.reset() after the desired action. Threadsafe."""
+ isGuiThread = QtCore.QThread.currentThread() == QtCore.QCoreApplication.instance().thread()
+ if isGuiThread:
+ self.setEnabled(True)
+ #print "success"
+ self.startBlink("#0F0", message, tip, limitedTime=limitedTime)
+ else:
+ self.sigCallSuccess.emit(message, tip, limitedTime)
+
+ def failure(self, message=None, tip="", limitedTime=True):
+ """Displays specified message on button and flashes button red to let user know there was an error. If you want the error to be displayed until the user takes an action, set limitedTime to False. Then call self.reset() after the desired action. Threadsafe. """
+ isGuiThread = QtCore.QThread.currentThread() == QtCore.QCoreApplication.instance().thread()
+ if isGuiThread:
+ self.setEnabled(True)
+ #print "fail"
+ self.startBlink("#F00", message, tip, limitedTime=limitedTime)
+ else:
+ self.sigCallFailure.emit(message, tip, limitedTime)
+
+ def processing(self, message="Processing..", tip="", processEvents=True):
+ """Displays specified message on button to let user know the action is in progress. Threadsafe. """
+ isGuiThread = QtCore.QThread.currentThread() == QtCore.QCoreApplication.instance().thread()
+ if isGuiThread:
+ self.setEnabled(False)
+ self.setText(message, temporary=True)
+ self.setToolTip(tip, temporary=True)
+ if processEvents:
+ QtGui.QApplication.processEvents()
+ else:
+ self.sigCallProcess.emit(message, tip, processEvents)
+
+
+ def reset(self):
+ """Resets the button to its original text and style. Threadsafe."""
+ isGuiThread = QtCore.QThread.currentThread() == QtCore.QCoreApplication.instance().thread()
+ if isGuiThread:
+ self.limitedTime = True
+ self.setText()
+ self.setToolTip()
+ self.setStyleSheet()
+ else:
+ self.sigReset.emit()
+
+ def startBlink(self, color, message=None, tip="", limitedTime=True):
+ #if self.origStyle is None:
+ #self.origStyle = self.styleSheet()
+ #self.origText = self.text()
+ self.setFixedHeight(self.height())
+
+ if message is not None:
+ self.setText(message, temporary=True)
+ self.setToolTip(tip, temporary=True)
+ self.count = 0
+ #self.indStyle = "QPushButton {border: 2px solid %s; border-radius: 5px}" % color
+ self.indStyle = "QPushButton {background-color: %s}" % color
+ self.limitedTime = limitedTime
+ self.borderOn()
+ if limitedTime:
+ QtCore.QTimer.singleShot(2000, self.setText)
+ QtCore.QTimer.singleShot(10000, self.setToolTip)
+
+ def borderOn(self):
+ self.setStyleSheet(self.indStyle, temporary=True)
+ if self.limitedTime or self.count <=2:
+ QtCore.QTimer.singleShot(100, self.borderOff)
+
+
+ def borderOff(self):
+ self.setStyleSheet()
+ self.count += 1
+ if self.count >= 2:
+ if self.limitedTime:
+ return
+ QtCore.QTimer.singleShot(30, self.borderOn)
+
+
+ def setText(self, text=None, temporary=False):
+ if text is None:
+ text = self.origText
+ #print text
+ QtGui.QPushButton.setText(self, text)
+ if not temporary:
+ self.origText = text
+
+ def setToolTip(self, text=None, temporary=False):
+ if text is None:
+ text = self.origTip
+ QtGui.QPushButton.setToolTip(self, text)
+ if not temporary:
+ self.origTip = text
+
+ def setStyleSheet(self, style=None, temporary=False):
+ if style is None:
+ style = self.origStyle
+ QtGui.QPushButton.setStyleSheet(self, style)
+ if not temporary:
+ self.origStyle = style
+
+
+if __name__ == '__main__':
+ import time
+ app = QtGui.QApplication([])
+ win = QtGui.QMainWindow()
+ btn = FeedbackButton("Button")
+ fail = True
+ def click():
+ btn.processing("Hold on..")
+ time.sleep(2.0)
+
+ global fail
+ fail = not fail
+ if fail:
+ btn.failure(message="FAIL.", tip="There was a failure. Get over it.")
+ else:
+ btn.success(message="Bueno!")
+ btn.clicked.connect(click)
+ win.setCentralWidget(btn)
+ win.show()
\ No newline at end of file
diff --git a/pyqtgraph/widgets/FileDialog.py b/pyqtgraph/widgets/FileDialog.py
new file mode 100644
index 00000000..33b838a2
--- /dev/null
+++ b/pyqtgraph/widgets/FileDialog.py
@@ -0,0 +1,14 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import sys
+
+__all__ = ['FileDialog']
+
+class FileDialog(QtGui.QFileDialog):
+ ## Compatibility fix for OSX:
+ ## For some reason the native dialog doesn't show up when you set AcceptMode to AcceptSave on OS X, so we don't use the native dialog
+
+ def __init__(self, *args):
+ QtGui.QFileDialog.__init__(self, *args)
+
+ if sys.platform == 'darwin':
+ self.setOption(QtGui.QFileDialog.DontUseNativeDialog)
\ No newline at end of file
diff --git a/pyqtgraph/widgets/GradientWidget.py b/pyqtgraph/widgets/GradientWidget.py
new file mode 100644
index 00000000..2b9b52d2
--- /dev/null
+++ b/pyqtgraph/widgets/GradientWidget.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+from .GraphicsView import GraphicsView
+from pyqtgraph.graphicsItems.GradientEditorItem import GradientEditorItem
+import weakref
+import numpy as np
+
+__all__ = ['TickSlider', 'GradientWidget', 'BlackWhiteSlider']
+
+
+class GradientWidget(GraphicsView):
+
+ sigGradientChanged = QtCore.Signal(object)
+ sigGradientChangeFinished = QtCore.Signal(object)
+
+ def __init__(self, parent=None, orientation='bottom', *args, **kargs):
+ GraphicsView.__init__(self, parent, useOpenGL=False, background=None)
+ self.maxDim = 31
+ kargs['tickPen'] = 'k'
+ self.item = GradientEditorItem(*args, **kargs)
+ self.item.sigGradientChanged.connect(self.sigGradientChanged)
+ self.item.sigGradientChangeFinished.connect(self.sigGradientChangeFinished)
+ self.setCentralItem(self.item)
+ self.setOrientation(orientation)
+ self.setCacheMode(self.CacheNone)
+ self.setRenderHints(QtGui.QPainter.Antialiasing | QtGui.QPainter.TextAntialiasing)
+ self.setFrameStyle(QtGui.QFrame.NoFrame | QtGui.QFrame.Plain)
+ #self.setBackgroundRole(QtGui.QPalette.NoRole)
+ #self.setBackgroundBrush(QtGui.QBrush(QtCore.Qt.NoBrush))
+ #self.setAutoFillBackground(False)
+ #self.setAttribute(QtCore.Qt.WA_PaintOnScreen, False)
+ #self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent, True)
+
+ def setOrientation(self, ort):
+ self.item.setOrientation(ort)
+ self.orientation = ort
+ self.setMaxDim()
+
+ def setMaxDim(self, mx=None):
+ if mx is None:
+ mx = self.maxDim
+ else:
+ self.maxDim = mx
+
+ if self.orientation in ['bottom', 'top']:
+ self.setFixedHeight(mx)
+ self.setMaximumWidth(16777215)
+ else:
+ self.setFixedWidth(mx)
+ self.setMaximumHeight(16777215)
+
+ def __getattr__(self, attr):
+ ### wrap methods from GradientEditorItem
+ return getattr(self.item, attr)
+
+
diff --git a/pyqtgraph/widgets/GraphicsLayoutWidget.py b/pyqtgraph/widgets/GraphicsLayoutWidget.py
new file mode 100644
index 00000000..1e667278
--- /dev/null
+++ b/pyqtgraph/widgets/GraphicsLayoutWidget.py
@@ -0,0 +1,12 @@
+from pyqtgraph.Qt import QtGui
+from pyqtgraph.graphicsItems.GraphicsLayout import GraphicsLayout
+from .GraphicsView import GraphicsView
+
+__all__ = ['GraphicsLayoutWidget']
+class GraphicsLayoutWidget(GraphicsView):
+ def __init__(self, parent=None, **kargs):
+ GraphicsView.__init__(self, parent)
+ self.ci = GraphicsLayout(**kargs)
+ for n in ['nextRow', 'nextCol', 'nextColumn', 'addPlot', 'addViewBox', 'addItem', 'getItem', 'addLabel', 'addLayout', 'addLabel', 'addViewBox', 'removeItem', 'itemIndex', 'clear']:
+ setattr(self, n, getattr(self.ci, n))
+ self.setCentralItem(self.ci)
diff --git a/pyqtgraph/widgets/GraphicsView.py b/pyqtgraph/widgets/GraphicsView.py
new file mode 100644
index 00000000..403aed9d
--- /dev/null
+++ b/pyqtgraph/widgets/GraphicsView.py
@@ -0,0 +1,384 @@
+# -*- coding: utf-8 -*-
+"""
+GraphicsView.py - Extension of QGraphicsView
+Copyright 2010 Luke Campagnola
+Distributed under MIT/X11 license. See license.txt for more infomation.
+"""
+
+from pyqtgraph.Qt import QtCore, QtGui
+import pyqtgraph as pg
+
+try:
+ from pyqtgraph.Qt import QtOpenGL
+ HAVE_OPENGL = True
+except ImportError:
+ HAVE_OPENGL = False
+
+from pyqtgraph.Point import Point
+import sys, os
+from .FileDialog import FileDialog
+from pyqtgraph.GraphicsScene import GraphicsScene
+import numpy as np
+import pyqtgraph.functions as fn
+import pyqtgraph.debug as debug
+import pyqtgraph
+
+__all__ = ['GraphicsView']
+
+class GraphicsView(QtGui.QGraphicsView):
+ """Re-implementation of QGraphicsView that removes scrollbars and allows unambiguous control of the
+ viewed coordinate range. Also automatically creates a GraphicsScene and a central QGraphicsWidget
+ that is automatically scaled to the full view geometry.
+
+ This widget is the basis for :class:`PlotWidget `,
+ :class:`GraphicsLayoutWidget `, and the view widget in
+ :class:`ImageView `.
+
+ By default, the view coordinate system matches the widget's pixel coordinates and
+ automatically updates when the view is resized. This can be overridden by setting
+ autoPixelRange=False. The exact visible range can be set with setRange().
+
+ The view can be panned using the middle mouse button and scaled using the right mouse button if
+ enabled via enableMouse() (but ordinarily, we use ViewBox for this functionality)."""
+
+ sigRangeChanged = QtCore.Signal(object, object)
+ sigTransformChanged = QtCore.Signal(object)
+ sigMouseReleased = QtCore.Signal(object)
+ sigSceneMouseMoved = QtCore.Signal(object)
+ #sigRegionChanged = QtCore.Signal(object)
+ sigScaleChanged = QtCore.Signal(object)
+ lastFileDir = None
+
+ def __init__(self, parent=None, useOpenGL=None, background='default'):
+ """
+ ============ ============================================================
+ Arguments:
+ parent Optional parent widget
+ useOpenGL If True, the GraphicsView will use OpenGL to do all of its
+ rendering. This can improve performance on some systems,
+ but may also introduce bugs (the combination of
+ QGraphicsView and QGLWidget is still an 'experimental'
+ feature of Qt)
+ background Set the background color of the GraphicsView. Accepts any
+ single argument accepted by
+ :func:`mkColor `. By
+ default, the background color is determined using the
+ 'backgroundColor' configuration option (see
+ :func:`setConfigOption `.
+ ============ ============================================================
+ """
+
+ self.closed = False
+
+ QtGui.QGraphicsView.__init__(self, parent)
+
+ if useOpenGL is None:
+ useOpenGL = pyqtgraph.getConfigOption('useOpenGL')
+
+ self.useOpenGL(useOpenGL)
+
+ self.setCacheMode(self.CacheBackground)
+
+ ## This might help, but it's probably dangerous in the general case..
+ #self.setOptimizationFlag(self.DontSavePainterState, True)
+
+ self.setBackground(background)
+
+ self.setFocusPolicy(QtCore.Qt.StrongFocus)
+ self.setFrameShape(QtGui.QFrame.NoFrame)
+ self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+ self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+ self.setTransformationAnchor(QtGui.QGraphicsView.NoAnchor)
+ self.setResizeAnchor(QtGui.QGraphicsView.AnchorViewCenter)
+ self.setViewportUpdateMode(QtGui.QGraphicsView.MinimalViewportUpdate)
+
+
+ self.lockedViewports = []
+ self.lastMousePos = None
+ self.setMouseTracking(True)
+ self.aspectLocked = False
+ self.range = QtCore.QRectF(0, 0, 1, 1)
+ self.autoPixelRange = True
+ self.currentItem = None
+ self.clearMouse()
+ self.updateMatrix()
+ self.sceneObj = GraphicsScene()
+ self.setScene(self.sceneObj)
+
+ ## Workaround for PySide crash
+ ## This ensures that the scene will outlive the view.
+ if pyqtgraph.Qt.USE_PYSIDE:
+ self.sceneObj._view_ref_workaround = self
+
+ ## by default we set up a central widget with a grid layout.
+ ## this can be replaced if needed.
+ self.centralWidget = None
+ self.setCentralItem(QtGui.QGraphicsWidget())
+ self.centralLayout = QtGui.QGraphicsGridLayout()
+ self.centralWidget.setLayout(self.centralLayout)
+
+ self.mouseEnabled = False
+ self.scaleCenter = False ## should scaling center around view center (True) or mouse click (False)
+ self.clickAccepted = False
+
+ def setAntialiasing(self, aa):
+ """Enable or disable default antialiasing.
+ Note that this will only affect items that do not specify their own antialiasing options."""
+ if aa:
+ self.setRenderHints(self.renderHints() | QtGui.QPainter.Antialiasing)
+ else:
+ self.setRenderHints(self.renderHints() & ~QtGui.QPainter.Antialiasing)
+
+ def setBackground(self, background):
+ """
+ Set the background color of the GraphicsView.
+ To use the defaults specified py pyqtgraph.setConfigOption, use background='default'.
+ To make the background transparent, use background=None.
+ """
+ self._background = background
+ if background == 'default':
+ background = pyqtgraph.getConfigOption('background')
+ if background is None:
+ self.setBackgroundRole(QtGui.QPalette.NoRole)
+ else:
+ brush = fn.mkBrush(background)
+ self.setBackgroundBrush(brush)
+
+
+ def close(self):
+ self.centralWidget = None
+ self.scene().clear()
+ self.currentItem = None
+ self.sceneObj = None
+ self.closed = True
+ self.setViewport(None)
+
+ def useOpenGL(self, b=True):
+ if b:
+ if not HAVE_OPENGL:
+ raise Exception("Requested to use OpenGL with QGraphicsView, but QtOpenGL module is not available.")
+ v = QtOpenGL.QGLWidget()
+ else:
+ v = QtGui.QWidget()
+
+ self.setViewport(v)
+
+ def keyPressEvent(self, ev):
+ self.scene().keyPressEvent(ev) ## bypass view, hand event directly to scene
+ ## (view likes to eat arrow key events)
+
+
+ def setCentralItem(self, item):
+ return self.setCentralWidget(item)
+
+ def setCentralWidget(self, item):
+ """Sets a QGraphicsWidget to automatically fill the entire view (the item will be automatically
+ resize whenever the GraphicsView is resized)."""
+ if self.centralWidget is not None:
+ self.scene().removeItem(self.centralWidget)
+ self.centralWidget = item
+ self.sceneObj.addItem(item)
+ self.resizeEvent(None)
+
+ def addItem(self, *args):
+ return self.scene().addItem(*args)
+
+ def removeItem(self, *args):
+ return self.scene().removeItem(*args)
+
+ def enableMouse(self, b=True):
+ self.mouseEnabled = b
+ self.autoPixelRange = (not b)
+
+ def clearMouse(self):
+ self.mouseTrail = []
+ self.lastButtonReleased = None
+
+ def resizeEvent(self, ev):
+ if self.closed:
+ return
+ if self.autoPixelRange:
+ self.range = QtCore.QRectF(0, 0, self.size().width(), self.size().height())
+ GraphicsView.setRange(self, self.range, padding=0, disableAutoPixel=False) ## we do this because some subclasses like to redefine setRange in an incompatible way.
+ self.updateMatrix()
+
+ def updateMatrix(self, propagate=True):
+ self.setSceneRect(self.range)
+ if self.autoPixelRange:
+ self.resetTransform()
+ else:
+ if self.aspectLocked:
+ self.fitInView(self.range, QtCore.Qt.KeepAspectRatio)
+ else:
+ self.fitInView(self.range, QtCore.Qt.IgnoreAspectRatio)
+
+ self.sigRangeChanged.emit(self, self.range)
+ self.sigTransformChanged.emit(self)
+
+ if propagate:
+ for v in self.lockedViewports:
+ v.setXRange(self.range, padding=0)
+
+ def viewRect(self):
+ """Return the boundaries of the view in scene coordinates"""
+ ## easier to just return self.range ?
+ r = QtCore.QRectF(self.rect())
+ return self.viewportTransform().inverted()[0].mapRect(r)
+
+ def visibleRange(self):
+ ## for backward compatibility
+ return self.viewRect()
+
+ def translate(self, dx, dy):
+ self.range.adjust(dx, dy, dx, dy)
+ self.updateMatrix()
+
+ def scale(self, sx, sy, center=None):
+ scale = [sx, sy]
+ if self.aspectLocked:
+ scale[0] = scale[1]
+
+ if self.scaleCenter:
+ center = None
+ if center is None:
+ center = self.range.center()
+
+ w = self.range.width() / scale[0]
+ h = self.range.height() / scale[1]
+ self.range = QtCore.QRectF(center.x() - (center.x()-self.range.left()) / scale[0], center.y() - (center.y()-self.range.top()) /scale[1], w, h)
+
+
+ self.updateMatrix()
+ self.sigScaleChanged.emit(self)
+
+ def setRange(self, newRect=None, padding=0.05, lockAspect=None, propagate=True, disableAutoPixel=True):
+ if disableAutoPixel:
+ self.autoPixelRange=False
+ if newRect is None:
+ newRect = self.visibleRange()
+ padding = 0
+
+ padding = Point(padding)
+ newRect = QtCore.QRectF(newRect)
+ pw = newRect.width() * padding[0]
+ ph = newRect.height() * padding[1]
+ newRect = newRect.adjusted(-pw, -ph, pw, ph)
+ scaleChanged = False
+ if self.range.width() != newRect.width() or self.range.height() != newRect.height():
+ scaleChanged = True
+ self.range = newRect
+ #print "New Range:", self.range
+ self.centralWidget.setGeometry(self.range)
+ self.updateMatrix(propagate)
+ if scaleChanged:
+ self.sigScaleChanged.emit(self)
+
+ def scaleToImage(self, image):
+ """Scales such that pixels in image are the same size as screen pixels. This may result in a significant performance increase."""
+ pxSize = image.pixelSize()
+ image.setPxMode(True)
+ try:
+ self.sigScaleChanged.disconnect(image.setScaledMode)
+ except TypeError:
+ pass
+ tl = image.sceneBoundingRect().topLeft()
+ w = self.size().width() * pxSize[0]
+ h = self.size().height() * pxSize[1]
+ range = QtCore.QRectF(tl.x(), tl.y(), w, h)
+ GraphicsView.setRange(self, range, padding=0)
+ self.sigScaleChanged.connect(image.setScaledMode)
+
+
+
+ def lockXRange(self, v1):
+ if not v1 in self.lockedViewports:
+ self.lockedViewports.append(v1)
+
+ def setXRange(self, r, padding=0.05):
+ r1 = QtCore.QRectF(self.range)
+ r1.setLeft(r.left())
+ r1.setRight(r.right())
+ GraphicsView.setRange(self, r1, padding=[padding, 0], propagate=False)
+
+ def setYRange(self, r, padding=0.05):
+ r1 = QtCore.QRectF(self.range)
+ r1.setTop(r.top())
+ r1.setBottom(r.bottom())
+ GraphicsView.setRange(self, r1, padding=[0, padding], propagate=False)
+
+ def wheelEvent(self, ev):
+ QtGui.QGraphicsView.wheelEvent(self, ev)
+ if not self.mouseEnabled:
+ return
+ sc = 1.001 ** ev.delta()
+ #self.scale *= sc
+ #self.updateMatrix()
+ self.scale(sc, sc)
+
+ def setAspectLocked(self, s):
+ self.aspectLocked = s
+
+ def leaveEvent(self, ev):
+ self.scene().leaveEvent(ev) ## inform scene when mouse leaves
+
+ def mousePressEvent(self, ev):
+ QtGui.QGraphicsView.mousePressEvent(self, ev)
+
+
+ if not self.mouseEnabled:
+ return
+ self.lastMousePos = Point(ev.pos())
+ self.mousePressPos = ev.pos()
+ self.clickAccepted = ev.isAccepted()
+ if not self.clickAccepted:
+ self.scene().clearSelection()
+ return ## Everything below disabled for now..
+
+ def mouseReleaseEvent(self, ev):
+ QtGui.QGraphicsView.mouseReleaseEvent(self, ev)
+ if not self.mouseEnabled:
+ return
+ self.sigMouseReleased.emit(ev)
+ self.lastButtonReleased = ev.button()
+ return ## Everything below disabled for now..
+
+ def mouseMoveEvent(self, ev):
+ if self.lastMousePos is None:
+ self.lastMousePos = Point(ev.pos())
+ delta = Point(ev.pos() - self.lastMousePos)
+ self.lastMousePos = Point(ev.pos())
+
+ QtGui.QGraphicsView.mouseMoveEvent(self, ev)
+ if not self.mouseEnabled:
+ return
+ self.sigSceneMouseMoved.emit(self.mapToScene(ev.pos()))
+
+ if self.clickAccepted: ## Ignore event if an item in the scene has already claimed it.
+ return
+
+ if ev.buttons() == QtCore.Qt.RightButton:
+ delta = Point(np.clip(delta[0], -50, 50), np.clip(-delta[1], -50, 50))
+ scale = 1.01 ** delta
+ self.scale(scale[0], scale[1], center=self.mapToScene(self.mousePressPos))
+ self.sigRangeChanged.emit(self, self.range)
+
+ elif ev.buttons() in [QtCore.Qt.MidButton, QtCore.Qt.LeftButton]: ## Allow panning by left or mid button.
+ px = self.pixelSize()
+ tr = -delta * px
+
+ self.translate(tr[0], tr[1])
+ self.sigRangeChanged.emit(self, self.range)
+
+ def pixelSize(self):
+ """Return vector with the length and width of one view pixel in scene coordinates"""
+ p0 = Point(0,0)
+ p1 = Point(1,1)
+ tr = self.transform().inverted()[0]
+ p01 = tr.map(p0)
+ p11 = tr.map(p1)
+ return Point(p11 - p01)
+
+ def dragEnterEvent(self, ev):
+ ev.ignore() ## not sure why, but for some reason this class likes to consume drag events
+
+
diff --git a/pyqtgraph/widgets/HistogramLUTWidget.py b/pyqtgraph/widgets/HistogramLUTWidget.py
new file mode 100644
index 00000000..bc041595
--- /dev/null
+++ b/pyqtgraph/widgets/HistogramLUTWidget.py
@@ -0,0 +1,33 @@
+"""
+Widget displaying an image histogram along with gradient editor. Can be used to adjust the appearance of images.
+This is a wrapper around HistogramLUTItem
+"""
+
+from pyqtgraph.Qt import QtGui, QtCore
+from .GraphicsView import GraphicsView
+from pyqtgraph.graphicsItems.HistogramLUTItem import HistogramLUTItem
+
+__all__ = ['HistogramLUTWidget']
+
+
+class HistogramLUTWidget(GraphicsView):
+
+ def __init__(self, parent=None, *args, **kargs):
+ background = kargs.get('background', 'k')
+ GraphicsView.__init__(self, parent, useOpenGL=False, background=background)
+ self.item = HistogramLUTItem(*args, **kargs)
+ self.setCentralItem(self.item)
+ self.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding)
+ self.setMinimumWidth(95)
+
+
+ def sizeHint(self):
+ return QtCore.QSize(115, 200)
+
+
+
+ def __getattr__(self, attr):
+ return getattr(self.item, attr)
+
+
+
diff --git a/pyqtgraph/widgets/JoystickButton.py b/pyqtgraph/widgets/JoystickButton.py
new file mode 100644
index 00000000..201a957a
--- /dev/null
+++ b/pyqtgraph/widgets/JoystickButton.py
@@ -0,0 +1,95 @@
+from pyqtgraph.Qt import QtGui, QtCore
+
+
+__all__ = ['JoystickButton']
+
+class JoystickButton(QtGui.QPushButton):
+ sigStateChanged = QtCore.Signal(object, object) ## self, state
+
+ def __init__(self, parent=None):
+ QtGui.QPushButton.__init__(self, parent)
+ self.radius = 200
+ self.setCheckable(True)
+ self.state = None
+ self.setState(0,0)
+ self.setFixedWidth(50)
+ self.setFixedHeight(50)
+
+
+ def mousePressEvent(self, ev):
+ self.setChecked(True)
+ self.pressPos = ev.pos()
+ ev.accept()
+
+ def mouseMoveEvent(self, ev):
+ dif = ev.pos()-self.pressPos
+ self.setState(dif.x(), -dif.y())
+
+ def mouseReleaseEvent(self, ev):
+ self.setChecked(False)
+ self.setState(0,0)
+
+ def wheelEvent(self, ev):
+ ev.accept()
+
+
+ def doubleClickEvent(self, ev):
+ ev.accept()
+
+ def getState(self):
+ return self.state
+
+ def setState(self, *xy):
+ xy = list(xy)
+ d = (xy[0]**2 + xy[1]**2)**0.5
+ nxy = [0,0]
+ for i in [0,1]:
+ if xy[i] == 0:
+ nxy[i] = 0
+ else:
+ nxy[i] = xy[i]/d
+
+ if d > self.radius:
+ d = self.radius
+ d = (d/self.radius)**2
+ xy = [nxy[0]*d, nxy[1]*d]
+
+ w2 = self.width()/2.
+ h2 = self.height()/2
+ self.spotPos = QtCore.QPoint(w2*(1+xy[0]), h2*(1-xy[1]))
+ self.update()
+ if self.state == xy:
+ return
+ self.state = xy
+ self.sigStateChanged.emit(self, self.state)
+
+ def paintEvent(self, ev):
+ QtGui.QPushButton.paintEvent(self, ev)
+ p = QtGui.QPainter(self)
+ p.setBrush(QtGui.QBrush(QtGui.QColor(0,0,0)))
+ p.drawEllipse(self.spotPos.x()-3,self.spotPos.y()-3,6,6)
+
+ def resizeEvent(self, ev):
+ self.setState(*self.state)
+ QtGui.QPushButton.resizeEvent(self, ev)
+
+
+
+if __name__ == '__main__':
+ app = QtGui.QApplication([])
+ w = QtGui.QMainWindow()
+ b = JoystickButton()
+ w.setCentralWidget(b)
+ w.show()
+ w.resize(100, 100)
+
+ def fn(b, s):
+ print("state changed:", s)
+
+ b.sigStateChanged.connect(fn)
+
+ ## Start Qt event loop unless running in interactive mode.
+ import sys
+ if sys.flags.interactive != 1:
+ app.exec_()
+
\ No newline at end of file
diff --git a/pyqtgraph/widgets/LayoutWidget.py b/pyqtgraph/widgets/LayoutWidget.py
new file mode 100644
index 00000000..f567ad74
--- /dev/null
+++ b/pyqtgraph/widgets/LayoutWidget.py
@@ -0,0 +1,101 @@
+from pyqtgraph.Qt import QtGui, QtCore
+
+__all__ = ['LayoutWidget']
+class LayoutWidget(QtGui.QWidget):
+ """
+ Convenience class used for laying out QWidgets in a grid.
+ (It's just a little less effort to use than QGridLayout)
+ """
+
+ def __init__(self, parent=None):
+ QtGui.QWidget.__init__(self, parent)
+ self.layout = QtGui.QGridLayout()
+ self.setLayout(self.layout)
+ self.items = {}
+ self.rows = {}
+ self.currentRow = 0
+ self.currentCol = 0
+
+ def nextRow(self):
+ """Advance to next row for automatic widget placement"""
+ self.currentRow += 1
+ self.currentCol = 0
+
+ def nextColumn(self, colspan=1):
+ """Advance to next column, while returning the current column number
+ (generally only for internal use--called by addWidget)"""
+ self.currentCol += colspan
+ return self.currentCol-colspan
+
+ def nextCol(self, *args, **kargs):
+ """Alias of nextColumn"""
+ return self.nextColumn(*args, **kargs)
+
+
+ def addLabel(self, text=' ', row=None, col=None, rowspan=1, colspan=1, **kargs):
+ """
+ Create a QLabel with *text* and place it in the next available cell (or in the cell specified)
+ All extra keyword arguments are passed to QLabel().
+ Returns the created widget.
+ """
+ text = QtGui.QLabel(text, **kargs)
+ self.addItem(text, row, col, rowspan, colspan)
+ return text
+
+ def addLayout(self, row=None, col=None, rowspan=1, colspan=1, **kargs):
+ """
+ Create an empty LayoutWidget and place it in the next available cell (or in the cell specified)
+ All extra keyword arguments are passed to :func:`LayoutWidget.__init__ `
+ Returns the created widget.
+ """
+ layout = LayoutWidget(**kargs)
+ self.addItem(layout, row, col, rowspan, colspan)
+ return layout
+
+ def addWidget(self, item, row=None, col=None, rowspan=1, colspan=1):
+ """
+ Add a widget to the layout and place it in the next available cell (or in the cell specified).
+ """
+ if row == 'next':
+ self.nextRow()
+ row = self.currentRow
+ elif row is None:
+ row = self.currentRow
+
+
+ if col is None:
+ col = self.nextCol(colspan)
+
+ if row not in self.rows:
+ self.rows[row] = {}
+ self.rows[row][col] = item
+ self.items[item] = (row, col)
+
+ self.layout.addWidget(item, row, col, rowspan, colspan)
+
+ def getWidget(self, row, col):
+ """Return the widget in (*row*, *col*)"""
+ return self.row[row][col]
+
+ #def itemIndex(self, item):
+ #for i in range(self.layout.count()):
+ #if self.layout.itemAt(i).graphicsItem() is item:
+ #return i
+ #raise Exception("Could not determine index of item " + str(item))
+
+ #def removeItem(self, item):
+ #"""Remove *item* from the layout."""
+ #ind = self.itemIndex(item)
+ #self.layout.removeAt(ind)
+ #self.scene().removeItem(item)
+ #r,c = self.items[item]
+ #del self.items[item]
+ #del self.rows[r][c]
+ #self.update()
+
+ #def clear(self):
+ #items = []
+ #for i in list(self.items.keys()):
+ #self.removeItem(i)
+
+
diff --git a/pyqtgraph/widgets/MatplotlibWidget.py b/pyqtgraph/widgets/MatplotlibWidget.py
new file mode 100644
index 00000000..25e058f9
--- /dev/null
+++ b/pyqtgraph/widgets/MatplotlibWidget.py
@@ -0,0 +1,37 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import matplotlib
+from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.backends.backend_qt4agg import NavigationToolbar2QTAgg as NavigationToolbar
+from matplotlib.figure import Figure
+
+class MatplotlibWidget(QtGui.QWidget):
+ """
+ Implements a Matplotlib figure inside a QWidget.
+ Use getFigure() and redraw() to interact with matplotlib.
+
+ Example::
+
+ mw = MatplotlibWidget()
+ subplot = mw.getFigure().add_subplot(111)
+ subplot.plot(x,y)
+ mw.draw()
+ """
+
+ def __init__(self, size=(5.0, 4.0), dpi=100):
+ QtGui.QWidget.__init__(self)
+ self.fig = Figure(size, dpi=dpi)
+ self.canvas = FigureCanvas(self.fig)
+ self.canvas.setParent(self)
+ self.toolbar = NavigationToolbar(self.canvas, self)
+
+ self.vbox = QtGui.QVBoxLayout()
+ self.vbox.addWidget(self.toolbar)
+ self.vbox.addWidget(self.canvas)
+
+ self.setLayout(self.vbox)
+
+ def getFigure(self):
+ return self.fig
+
+ def draw(self):
+ self.canvas.draw()
diff --git a/MultiPlotWidget.py b/pyqtgraph/widgets/MultiPlotWidget.py
similarity index 86%
rename from MultiPlotWidget.py
rename to pyqtgraph/widgets/MultiPlotWidget.py
index 8071127a..400bee92 100644
--- a/MultiPlotWidget.py
+++ b/pyqtgraph/widgets/MultiPlotWidget.py
@@ -5,16 +5,16 @@ Copyright 2010 Luke Campagnola
Distributed under MIT/X11 license. See license.txt for more infomation.
"""
-from GraphicsView import *
-from MultiPlotItem import *
-import exceptions
+from .GraphicsView import GraphicsView
+import pyqtgraph.graphicsItems.MultiPlotItem as MultiPlotItem
+__all__ = ['MultiPlotWidget']
class MultiPlotWidget(GraphicsView):
"""Widget implementing a graphicsView with a single PlotItem inside."""
def __init__(self, parent=None):
GraphicsView.__init__(self, parent)
self.enableMouse(False)
- self.mPlotItem = MultiPlotItem()
+ self.mPlotItem = MultiPlotItem.MultiPlotItem()
self.setCentralItem(self.mPlotItem)
## Explicitly wrap methods from mPlotItem
#for m in ['setData']:
@@ -25,7 +25,7 @@ class MultiPlotWidget(GraphicsView):
m = getattr(self.mPlotItem, attr)
if hasattr(m, '__call__'):
return m
- raise exceptions.NameError(attr)
+ raise NameError(attr)
def widgetGroupInterface(self):
return (None, MultiPlotWidget.saveState, MultiPlotWidget.restoreState)
diff --git a/pyqtgraph/widgets/PathButton.py b/pyqtgraph/widgets/PathButton.py
new file mode 100644
index 00000000..7950a53d
--- /dev/null
+++ b/pyqtgraph/widgets/PathButton.py
@@ -0,0 +1,50 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import pyqtgraph as pg
+__all__ = ['PathButton']
+
+
+class PathButton(QtGui.QPushButton):
+ """Simple PushButton extension which paints a QPainterPath on its face"""
+ def __init__(self, parent=None, path=None, pen='default', brush=None, size=(30,30)):
+ QtGui.QPushButton.__init__(self, parent)
+ self.path = None
+ if pen == 'default':
+ pen = 'k'
+ self.setPen(pen)
+ self.setBrush(brush)
+ if path is not None:
+ self.setPath(path)
+ if size is not None:
+ self.setFixedWidth(size[0])
+ self.setFixedHeight(size[1])
+
+
+ def setBrush(self, brush):
+ self.brush = pg.mkBrush(brush)
+
+ def setPen(self, pen):
+ self.pen = pg.mkPen(pen)
+
+ def setPath(self, path):
+ self.path = path
+ self.update()
+
+ def paintEvent(self, ev):
+ QtGui.QPushButton.paintEvent(self, ev)
+ margin = 7
+ geom = QtCore.QRectF(0, 0, self.width(), self.height()).adjusted(margin, margin, -margin, -margin)
+ rect = self.path.boundingRect()
+ scale = min(geom.width() / float(rect.width()), geom.height() / float(rect.height()))
+
+ p = QtGui.QPainter(self)
+ p.setRenderHint(p.Antialiasing)
+ p.translate(geom.center())
+ p.scale(scale, scale)
+ p.translate(-rect.center())
+ p.setPen(self.pen)
+ p.setBrush(self.brush)
+ p.drawPath(self.path)
+ p.end()
+
+
+
\ No newline at end of file
diff --git a/PlotWidget.py b/pyqtgraph/widgets/PlotWidget.py
similarity index 50%
rename from PlotWidget.py
rename to pyqtgraph/widgets/PlotWidget.py
index 1254b963..1fa07f2a 100644
--- a/PlotWidget.py
+++ b/pyqtgraph/widgets/PlotWidget.py
@@ -5,34 +5,56 @@ Copyright 2010 Luke Campagnola
Distributed under MIT/X11 license. See license.txt for more infomation.
"""
-from GraphicsView import *
-from PlotItem import *
-import exceptions
+from pyqtgraph.Qt import QtCore, QtGui
+from .GraphicsView import *
+from pyqtgraph.graphicsItems.PlotItem import *
+__all__ = ['PlotWidget']
class PlotWidget(GraphicsView):
#sigRangeChanged = QtCore.Signal(object, object) ## already defined in GraphicsView
- """Widget implementing a graphicsView with a single PlotItem inside."""
+ """
+ :class:`GraphicsView ` widget with a single
+ :class:`PlotItem ` inside.
+
+ The following methods are wrapped directly from PlotItem:
+ :func:`addItem `,
+ :func:`removeItem `,
+ :func:`clear `,
+ :func:`setXRange `,
+ :func:`setYRange `,
+ :func:`setRange `,
+ :func:`autoRange `,
+ :func:`setXLink `,
+ :func:`setYLink `,
+ :func:`viewRect `,
+ :func:`setMouseEnabled `,
+ :func:`enableAutoRange `,
+ :func:`disableAutoRange `,
+ :func:`setAspectLocked `,
+ :func:`register `,
+ :func:`unregister `
+
+
+ For all
+ other methods, use :func:`getPlotItem `.
+ """
def __init__(self, parent=None, **kargs):
+ """When initializing PlotWidget, all keyword arguments except *parent* are passed
+ to :func:`PlotItem.__init__() `."""
GraphicsView.__init__(self, parent)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
self.enableMouse(False)
self.plotItem = PlotItem(**kargs)
self.setCentralItem(self.plotItem)
## Explicitly wrap methods from plotItem
- for m in ['addItem', 'removeItem', 'autoRange', 'clear', 'setXRange', 'setYRange']:
+ ## NOTE: If you change this list, update the documentation above as well.
+ for m in ['addItem', 'removeItem', 'autoRange', 'clear', 'setXRange', 'setYRange', 'setRange', 'setAspectLocked', 'setMouseEnabled', 'setXLink', 'setYLink', 'enableAutoRange', 'disableAutoRange', 'register', 'unregister', 'viewRect']:
setattr(self, m, getattr(self.plotItem, m))
#QtCore.QObject.connect(self.plotItem, QtCore.SIGNAL('viewChanged'), self.viewChanged)
self.plotItem.sigRangeChanged.connect(self.viewRangeChanged)
-
- #def __dtor__(self):
- ##print "Called plotWidget sip destructor"
- #self.quit()
-
-
- #def quit(self):
-
+
def close(self):
self.plotItem.close()
self.plotItem = None
@@ -46,8 +68,8 @@ class PlotWidget(GraphicsView):
m = getattr(self.plotItem, attr)
if hasattr(m, '__call__'):
return m
- raise exceptions.NameError(attr)
-
+ raise NameError(attr)
+
def viewRangeChanged(self, view, range):
#self.emit(QtCore.SIGNAL('viewChanged'), *args)
self.sigRangeChanged.emit(self, range)
@@ -62,6 +84,7 @@ class PlotWidget(GraphicsView):
return self.plotItem.restoreState(state)
def getPlotItem(self):
+ """Return the PlotItem contained within."""
return self.plotItem
diff --git a/pyqtgraph/widgets/ProgressDialog.py b/pyqtgraph/widgets/ProgressDialog.py
new file mode 100644
index 00000000..0f55e227
--- /dev/null
+++ b/pyqtgraph/widgets/ProgressDialog.py
@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+
+__all__ = ['ProgressDialog']
+class ProgressDialog(QtGui.QProgressDialog):
+ """
+ Extends QProgressDialog for use in 'with' statements.
+
+ Example::
+
+ with ProgressDialog("Processing..", minVal, maxVal) as dlg:
+ # do stuff
+ dlg.setValue(i) ## could also use dlg += 1
+ if dlg.wasCanceled():
+ raise Exception("Processing canceled by user")
+ """
+ def __init__(self, labelText, minimum=0, maximum=100, cancelText='Cancel', parent=None, wait=250, busyCursor=False, disable=False):
+ """
+ ============== ================================================================
+ **Arguments:**
+ labelText (required)
+ cancelText Text to display on cancel button, or None to disable it.
+ minimum
+ maximum
+ parent
+ wait Length of time (im ms) to wait before displaying dialog
+ busyCursor If True, show busy cursor until dialog finishes
+ disable If True, the progress dialog will not be displayed
+ and calls to wasCanceled() will always return False.
+ If ProgressDialog is entered from a non-gui thread, it will
+ always be disabled.
+ ============== ================================================================
+ """
+ isGuiThread = QtCore.QThread.currentThread() == QtCore.QCoreApplication.instance().thread()
+ self.disabled = disable or (not isGuiThread)
+ if self.disabled:
+ return
+
+ noCancel = False
+ if cancelText is None:
+ cancelText = ''
+ noCancel = True
+
+ self.busyCursor = busyCursor
+
+ QtGui.QProgressDialog.__init__(self, labelText, cancelText, minimum, maximum, parent)
+ self.setMinimumDuration(wait)
+ self.setWindowModality(QtCore.Qt.WindowModal)
+ self.setValue(self.minimum())
+ if noCancel:
+ self.setCancelButton(None)
+
+
+ def __enter__(self):
+ if self.disabled:
+ return self
+ if self.busyCursor:
+ QtGui.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
+ return self
+
+ def __exit__(self, exType, exValue, exTrace):
+ if self.disabled:
+ return
+ if self.busyCursor:
+ QtGui.QApplication.restoreOverrideCursor()
+ self.setValue(self.maximum())
+
+ def __iadd__(self, val):
+ """Use inplace-addition operator for easy incrementing."""
+ if self.disabled:
+ return self
+ self.setValue(self.value()+val)
+ return self
+
+
+ ## wrap all other functions to make sure they aren't being called from non-gui threads
+
+ def setValue(self, val):
+ if self.disabled:
+ return
+ QtGui.QProgressDialog.setValue(self, val)
+
+ def setLabelText(self, val):
+ if self.disabled:
+ return
+ QtGui.QProgressDialog.setLabelText(self, val)
+
+ def setMaximum(self, val):
+ if self.disabled:
+ return
+ QtGui.QProgressDialog.setMaximum(self, val)
+
+ def setMinimum(self, val):
+ if self.disabled:
+ return
+ QtGui.QProgressDialog.setMinimum(self, val)
+
+ def wasCanceled(self):
+ if self.disabled:
+ return False
+ return QtGui.QProgressDialog.wasCanceled(self)
+
+ def maximum(self):
+ if self.disabled:
+ return 0
+ return QtGui.QProgressDialog.maximum(self)
+
+ def minimum(self):
+ if self.disabled:
+ return 0
+ return QtGui.QProgressDialog.minimum(self)
+
diff --git a/pyqtgraph/widgets/RawImageWidget.py b/pyqtgraph/widgets/RawImageWidget.py
new file mode 100644
index 00000000..ea5c98a0
--- /dev/null
+++ b/pyqtgraph/widgets/RawImageWidget.py
@@ -0,0 +1,84 @@
+from pyqtgraph.Qt import QtCore, QtGui
+try:
+ from pyqtgraph.Qt import QtOpenGL
+ HAVE_OPENGL = True
+except ImportError:
+ HAVE_OPENGL = False
+
+import pyqtgraph.functions as fn
+import numpy as np
+
+class RawImageWidget(QtGui.QWidget):
+ """
+ Widget optimized for very fast video display.
+ Generally using an ImageItem inside GraphicsView is fast enough,
+ but if you need even more performance, this widget is about as fast as it gets (but only in unscaled mode).
+ """
+ def __init__(self, parent=None, scaled=False):
+ """
+ Setting scaled=True will cause the entire image to be displayed within the boundaries of the widget. This also greatly reduces the speed at which it will draw frames.
+ """
+ QtGui.QWidget.__init__(self, parent=None)
+ self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding))
+ self.scaled = scaled
+ self.opts = None
+ self.image = None
+
+ def setImage(self, img, *args, **kargs):
+ """
+ img must be ndarray of shape (x,y), (x,y,3), or (x,y,4).
+ Extra arguments are sent to functions.makeARGB
+ """
+ self.opts = (img, args, kargs)
+ self.image = None
+ self.update()
+
+ def paintEvent(self, ev):
+ if self.opts is None:
+ return
+ if self.image is None:
+ argb, alpha = fn.makeARGB(self.opts[0], *self.opts[1], **self.opts[2])
+ self.image = fn.makeQImage(argb, alpha)
+ self.opts = ()
+ #if self.pixmap is None:
+ #self.pixmap = QtGui.QPixmap.fromImage(self.image)
+ p = QtGui.QPainter(self)
+ if self.scaled:
+ rect = self.rect()
+ ar = rect.width() / float(rect.height())
+ imar = self.image.width() / float(self.image.height())
+ if ar > imar:
+ rect.setWidth(int(rect.width() * imar/ar))
+ else:
+ rect.setHeight(int(rect.height() * ar/imar))
+
+ p.drawImage(rect, self.image)
+ else:
+ p.drawImage(QtCore.QPointF(), self.image)
+ #p.drawPixmap(self.rect(), self.pixmap)
+ p.end()
+
+if HAVE_OPENGL:
+ class RawImageGLWidget(QtOpenGL.QGLWidget):
+ """
+ Similar to RawImageWidget, but uses a GL widget to do all drawing.
+ Generally this will be about as fast as using GraphicsView + ImageItem,
+ but performance may vary on some platforms.
+ """
+ def __init__(self, parent=None, scaled=False):
+ QtOpenGL.QGLWidget.__init__(self, parent=None)
+ self.scaled = scaled
+ self.image = None
+
+ def setImage(self, img):
+ self.image = fn.makeQImage(img)
+ self.update()
+
+ def paintEvent(self, ev):
+ if self.image is None:
+ return
+ p = QtGui.QPainter(self)
+ p.drawImage(self.rect(), self.image)
+ p.end()
+
+
diff --git a/pyqtgraph/widgets/RemoteGraphicsView.py b/pyqtgraph/widgets/RemoteGraphicsView.py
new file mode 100644
index 00000000..3752a6bb
--- /dev/null
+++ b/pyqtgraph/widgets/RemoteGraphicsView.py
@@ -0,0 +1,172 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import pyqtgraph.multiprocess as mp
+import pyqtgraph as pg
+from .GraphicsView import GraphicsView
+import numpy as np
+import mmap, tempfile, ctypes, atexit
+
+__all__ = ['RemoteGraphicsView']
+
+class RemoteGraphicsView(QtGui.QWidget):
+ """
+ Replacement for GraphicsView that does all scene management and rendering on a remote process,
+ while displaying on the local widget.
+
+ GraphicsItems must be created by proxy to the remote process.
+
+ """
+ def __init__(self, parent=None, *args, **kwds):
+ self._img = None
+ self._imgReq = None
+ QtGui.QWidget.__init__(self)
+ self._proc = mp.QtProcess()
+ self.pg = self._proc._import('pyqtgraph')
+ self.pg.setConfigOptions(**self.pg.CONFIG_OPTIONS)
+ rpgRemote = self._proc._import('pyqtgraph.widgets.RemoteGraphicsView')
+ self._view = rpgRemote.Renderer(*args, **kwds)
+ self._view._setProxyOptions(deferGetattr=True)
+ self.setFocusPolicy(self._view.focusPolicy())
+
+ shmFileName = self._view.shmFileName()
+ self.shmFile = open(shmFileName, 'r')
+ self.shm = mmap.mmap(self.shmFile.fileno(), mmap.PAGESIZE, mmap.MAP_SHARED, mmap.PROT_READ)
+
+ self._view.sceneRendered.connect(mp.proxy(self.remoteSceneChanged))
+
+ for method in ['scene', 'setCentralItem']:
+ setattr(self, method, getattr(self._view, method))
+
+ def resizeEvent(self, ev):
+ ret = QtGui.QWidget.resizeEvent(self, ev)
+ self._view.resize(self.size(), _callSync='off')
+ return ret
+
+ def remoteSceneChanged(self, data):
+ w, h, size = data
+ if self.shm.size != size:
+ self.shm.close()
+ self.shm = mmap.mmap(self.shmFile.fileno(), size, mmap.MAP_SHARED, mmap.PROT_READ)
+ self.shm.seek(0)
+ self._img = QtGui.QImage(self.shm.read(w*h*4), w, h, QtGui.QImage.Format_ARGB32)
+ self.update()
+
+ def paintEvent(self, ev):
+ if self._img is None:
+ return
+ p = QtGui.QPainter(self)
+ p.drawImage(self.rect(), self._img, QtCore.QRect(0, 0, self._img.width(), self._img.height()))
+ p.end()
+
+ def mousePressEvent(self, ev):
+ self._view.mousePressEvent(ev.type(), ev.pos(), ev.globalPos(), ev.button(), int(ev.buttons()), int(ev.modifiers()), _callSync='off')
+ ev.accept()
+ return QtGui.QWidget.mousePressEvent(self, ev)
+
+ def mouseReleaseEvent(self, ev):
+ self._view.mouseReleaseEvent(ev.type(), ev.pos(), ev.globalPos(), ev.button(), int(ev.buttons()), int(ev.modifiers()), _callSync='off')
+ ev.accept()
+ return QtGui.QWidget.mouseReleaseEvent(self, ev)
+
+ def mouseMoveEvent(self, ev):
+ self._view.mouseMoveEvent(ev.type(), ev.pos(), ev.globalPos(), ev.button(), int(ev.buttons()), int(ev.modifiers()), _callSync='off')
+ ev.accept()
+ return QtGui.QWidget.mouseMoveEvent(self, ev)
+
+ def wheelEvent(self, ev):
+ self._view.wheelEvent(ev.pos(), ev.globalPos(), ev.delta(), int(ev.buttons()), int(ev.modifiers()), ev.orientation(), _callSync='off')
+ ev.accept()
+ return QtGui.QWidget.wheelEvent(self, ev)
+
+ def keyEvent(self, ev):
+ if self._view.keyEvent(ev.type(), int(ev.modifiers()), text, autorep, count):
+ ev.accept()
+ return QtGui.QWidget.keyEvent(self, ev)
+
+
+
+class Renderer(GraphicsView):
+
+ sceneRendered = QtCore.Signal(object)
+
+ def __init__(self, *args, **kwds):
+ ## Create shared memory for rendered image
+ #fd = os.open('/tmp/mmaptest', os.O_CREAT | os.O_TRUNC | os.O_RDWR)
+ #os.write(fd, '\x00' * mmap.PAGESIZE)
+ self.shmFile = tempfile.NamedTemporaryFile(prefix='pyqtgraph_shmem_')
+ self.shmFile.write('\x00' * mmap.PAGESIZE)
+ #fh.flush()
+ fd = self.shmFile.fileno()
+ self.shm = mmap.mmap(fd, mmap.PAGESIZE, mmap.MAP_SHARED, mmap.PROT_WRITE)
+ atexit.register(self.close)
+
+ GraphicsView.__init__(self, *args, **kwds)
+ self.scene().changed.connect(self.update)
+ self.img = None
+ self.renderTimer = QtCore.QTimer()
+ self.renderTimer.timeout.connect(self.renderView)
+ self.renderTimer.start(16)
+
+ def close(self):
+ self.shm.close()
+ self.shmFile.close()
+
+ def shmFileName(self):
+ return self.shmFile.name
+
+ def update(self):
+ self.img = None
+ return GraphicsView.update(self)
+
+ def resize(self, size):
+ oldSize = self.size()
+ GraphicsView.resize(self, size)
+ self.resizeEvent(QtGui.QResizeEvent(size, oldSize))
+ self.update()
+
+ def renderView(self):
+ if self.img is None:
+ ## make sure shm is large enough and get its address
+ size = self.width() * self.height() * 4
+ if size > self.shm.size():
+ self.shm.resize(size)
+ address = ctypes.addressof(ctypes.c_char.from_buffer(self.shm, 0))
+
+ ## render the scene directly to shared memory
+ self.img = QtGui.QImage(address, self.width(), self.height(), QtGui.QImage.Format_ARGB32)
+ self.img.fill(0xffffffff)
+ p = QtGui.QPainter(self.img)
+ self.render(p, self.viewRect(), self.rect())
+ p.end()
+ self.sceneRendered.emit((self.width(), self.height(), self.shm.size()))
+
+ def mousePressEvent(self, typ, pos, gpos, btn, btns, mods):
+ typ = QtCore.QEvent.Type(typ)
+ btns = QtCore.Qt.MouseButtons(btns)
+ mods = QtCore.Qt.KeyboardModifiers(mods)
+ return GraphicsView.mousePressEvent(self, QtGui.QMouseEvent(typ, pos, gpos, btn, btns, mods))
+
+ def mouseMoveEvent(self, typ, pos, gpos, btn, btns, mods):
+ typ = QtCore.QEvent.Type(typ)
+ btns = QtCore.Qt.MouseButtons(btns)
+ mods = QtCore.Qt.KeyboardModifiers(mods)
+ return GraphicsView.mouseMoveEvent(self, QtGui.QMouseEvent(typ, pos, gpos, btn, btns, mods))
+
+ def mouseReleaseEvent(self, typ, pos, gpos, btn, btns, mods):
+ typ = QtCore.QEvent.Type(typ)
+ btns = QtCore.Qt.MouseButtons(btns)
+ mods = QtCore.Qt.KeyboardModifiers(mods)
+ return GraphicsView.mouseReleaseEvent(self, QtGui.QMouseEvent(typ, pos, gpos, btn, btns, mods))
+
+ def wheelEvent(self, pos, gpos, d, btns, mods, ori):
+ btns = QtCore.Qt.MouseButtons(btns)
+ mods = QtCore.Qt.KeyboardModifiers(mods)
+ return GraphicsView.wheelEvent(self, QtGui.QWheelEvent(pos, gpos, d, btns, mods, ori))
+
+ def keyEvent(self, typ, mods, text, autorep, count):
+ typ = QtCore.QEvent.Type(typ)
+ mods = QtCore.Qt.KeyboardModifiers(mods)
+ GraphicsView.keyEvent(self, QtGui.QKeyEvent(typ, mods, text, autorep, count))
+ return ev.accepted()
+
+
+
\ No newline at end of file
diff --git a/pyqtgraph/widgets/SpinBox.py b/pyqtgraph/widgets/SpinBox.py
new file mode 100644
index 00000000..71695f4a
--- /dev/null
+++ b/pyqtgraph/widgets/SpinBox.py
@@ -0,0 +1,503 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.python2_3 import asUnicode
+from pyqtgraph.SignalProxy import SignalProxy
+
+import pyqtgraph.functions as fn
+from math import log
+from decimal import Decimal as D ## Use decimal to avoid accumulating floating-point errors
+from decimal import *
+import weakref
+
+__all__ = ['SpinBox']
+class SpinBox(QtGui.QAbstractSpinBox):
+ """
+ **Bases:** QtGui.QAbstractSpinBox
+
+ QSpinBox widget on steroids. Allows selection of numerical value, with extra features:
+
+ - SI prefix notation (eg, automatically display "300 mV" instead of "0.003 V")
+ - Float values with linear and decimal stepping (1-9, 10-90, 100-900, etc.)
+ - Option for unbounded values
+ - Delayed signals (allows multiple rapid changes with only one change signal)
+
+ ============================= ==============================================
+ **Signals:**
+ valueChanged(value) Same as QSpinBox; emitted every time the value
+ has changed.
+ sigValueChanged(self) Emitted when value has changed, but also combines
+ multiple rapid changes into one signal (eg,
+ when rolling the mouse wheel).
+ sigValueChanging(self, value) Emitted immediately for all value changes.
+ ============================= ==============================================
+ """
+
+ ## There's a PyQt bug that leaks a reference to the
+ ## QLineEdit returned from QAbstractSpinBox.lineEdit()
+ ## This makes it possible to crash the entire program
+ ## by making accesses to the LineEdit after the spinBox has been deleted.
+ ## I have no idea how to get around this..
+
+
+ valueChanged = QtCore.Signal(object) # (value) for compatibility with QSpinBox
+ sigValueChanged = QtCore.Signal(object) # (self)
+ sigValueChanging = QtCore.Signal(object, object) # (self, value) sent immediately; no delay.
+
+ def __init__(self, parent=None, value=0.0, **kwargs):
+ """
+ ============== ========================================================================
+ **Arguments:**
+ parent Sets the parent widget for this SpinBox (optional)
+ value (float/int) initial value
+ bounds (min,max) Minimum and maximum values allowed in the SpinBox.
+ Either may be None to leave the value unbounded.
+ suffix (str) suffix (units) to display after the numerical value
+ siPrefix (bool) If True, then an SI prefix is automatically prepended
+ to the units and the value is scaled accordingly. For example,
+ if value=0.003 and suffix='V', then the SpinBox will display
+ "300 mV" (but a call to SpinBox.value will still return 0.003).
+ step (float) The size of a single step. This is used when clicking the up/
+ down arrows, when rolling the mouse wheel, or when pressing
+ keyboard arrows while the widget has keyboard focus. Note that
+ the interpretation of this value is different when specifying
+ the 'dec' argument.
+ dec (bool) If True, then the step value will be adjusted to match
+ the current size of the variable (for example, a value of 15
+ might step in increments of 1 whereas a value of 1500 would
+ step in increments of 100). In this case, the 'step' argument
+ is interpreted *relative* to the current value. The most common
+ 'step' values when dec=True are 0.1, 0.2, 0.5, and 1.0.
+ minStep (float) When dec=True, this specifies the minimum allowable step size.
+ int (bool) if True, the value is forced to integer type
+ decimals (int) Number of decimal values to display
+ ============== ========================================================================
+ """
+ QtGui.QAbstractSpinBox.__init__(self, parent)
+ self.lastValEmitted = None
+ self.lastText = ''
+ self.textValid = True ## If false, we draw a red border
+ self.setMinimumWidth(0)
+ self.setMaximumHeight(20)
+ self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Preferred)
+ self.opts = {
+ 'bounds': [None, None],
+
+ ## Log scaling options #### Log mode is no longer supported.
+ #'step': 0.1,
+ #'minStep': 0.001,
+ #'log': True,
+ #'dec': False,
+
+ ## decimal scaling option - example
+ #'step': 0.1,
+ #'minStep': .001,
+ #'log': False,
+ #'dec': True,
+
+ ## normal arithmetic step
+ 'step': D('0.01'), ## if 'dec' is false, the spinBox steps by 'step' every time
+ ## if 'dec' is True, the step size is relative to the value
+ ## 'step' needs to be an integral divisor of ten, ie 'step'*n=10 for some integer value of n (but only if dec is True)
+ 'log': False,
+ 'dec': False, ## if true, does decimal stepping. ie from 1-10 it steps by 'step', from 10 to 100 it steps by 10*'step', etc.
+ ## if true, minStep must be set in order to cross zero.
+
+
+ 'int': False, ## Set True to force value to be integer
+
+ 'suffix': '',
+ 'siPrefix': False, ## Set to True to display numbers with SI prefix (ie, 100pA instead of 1e-10A)
+
+ 'delay': 0.3, ## delay sending wheel update signals for 300ms
+
+ 'delayUntilEditFinished': True, ## do not send signals until text editing has finished
+
+ ## for compatibility with QDoubleSpinBox and QSpinBox
+ 'decimals': 2,
+
+ }
+
+ self.decOpts = ['step', 'minStep']
+
+ self.val = D(asUnicode(value)) ## Value is precise decimal. Ordinary math not allowed.
+ self.updateText()
+ self.skipValidate = False
+ self.setCorrectionMode(self.CorrectToPreviousValue)
+ self.setKeyboardTracking(False)
+ self.setOpts(**kwargs)
+
+
+ self.editingFinished.connect(self.editingFinishedEvent)
+ self.proxy = SignalProxy(self.sigValueChanging, slot=self.delayedChange, delay=self.opts['delay'])
+
+ def event(self, ev):
+ ret = QtGui.QAbstractSpinBox.event(self, ev)
+ if ev.type() == QtCore.QEvent.KeyPress and ev.key() == QtCore.Qt.Key_Return:
+ ret = True ## For some reason, spinbox pretends to ignore return key press
+ return ret
+
+ ##lots of config options, just gonna stuff 'em all in here rather than do the get/set crap.
+ def setOpts(self, **opts):
+ """
+ Changes the behavior of the SpinBox. Accepts most of the arguments
+ allowed in :func:`__init__ `.
+
+ """
+ #print opts
+ for k in opts:
+ if k == 'bounds':
+ #print opts[k]
+ self.setMinimum(opts[k][0], update=False)
+ self.setMaximum(opts[k][1], update=False)
+ #for i in [0,1]:
+ #if opts[k][i] is None:
+ #self.opts[k][i] = None
+ #else:
+ #self.opts[k][i] = D(unicode(opts[k][i]))
+ elif k in ['step', 'minStep']:
+ self.opts[k] = D(asUnicode(opts[k]))
+ elif k == 'value':
+ pass ## don't set value until bounds have been set
+ else:
+ self.opts[k] = opts[k]
+ if 'value' in opts:
+ self.setValue(opts['value'])
+
+ ## If bounds have changed, update value to match
+ if 'bounds' in opts and 'value' not in opts:
+ self.setValue()
+
+ ## sanity checks:
+ if self.opts['int']:
+ if 'step' in opts:
+ step = opts['step']
+ ## not necessary..
+ #if int(step) != step:
+ #raise Exception('Integer SpinBox must have integer step size.')
+ else:
+ self.opts['step'] = int(self.opts['step'])
+
+ if 'minStep' in opts:
+ step = opts['minStep']
+ if int(step) != step:
+ raise Exception('Integer SpinBox must have integer minStep size.')
+ else:
+ ms = int(self.opts.get('minStep', 1))
+ if ms < 1:
+ ms = 1
+ self.opts['minStep'] = ms
+
+ if 'delay' in opts:
+ self.proxy.setDelay(opts['delay'])
+
+ self.updateText()
+
+
+
+ def setMaximum(self, m, update=True):
+ """Set the maximum allowed value (or None for no limit)"""
+ if m is not None:
+ m = D(asUnicode(m))
+ self.opts['bounds'][1] = m
+ if update:
+ self.setValue()
+
+ def setMinimum(self, m, update=True):
+ """Set the minimum allowed value (or None for no limit)"""
+ if m is not None:
+ m = D(asUnicode(m))
+ self.opts['bounds'][0] = m
+ if update:
+ self.setValue()
+
+ def setPrefix(self, p):
+ self.setOpts(prefix=p)
+
+ def setRange(self, r0, r1):
+ self.setOpts(bounds = [r0,r1])
+
+ def setProperty(self, prop, val):
+ ## for QSpinBox compatibility
+ if prop == 'value':
+ #if type(val) is QtCore.QVariant:
+ #val = val.toDouble()[0]
+ self.setValue(val)
+ else:
+ print("Warning: SpinBox.setProperty('%s', ..) not supported." % prop)
+
+ def setSuffix(self, suf):
+ self.setOpts(suffix=suf)
+
+ def setSingleStep(self, step):
+ self.setOpts(step=step)
+
+ def setDecimals(self, decimals):
+ self.setOpts(decimals=decimals)
+
+ def value(self):
+ """
+ Return the value of this SpinBox.
+
+ """
+ if self.opts['int']:
+ return int(self.val)
+ else:
+ return float(self.val)
+
+ def setValue(self, value=None, update=True, delaySignal=False):
+ """
+ Set the value of this spin.
+ If the value is out of bounds, it will be clipped to the nearest boundary.
+ If the spin is integer type, the value will be coerced to int.
+ Returns the actual value set.
+
+ If value is None, then the current value is used (this is for resetting
+ the value after bounds, etc. have changed)
+ """
+
+ if value is None:
+ value = self.value()
+
+ bounds = self.opts['bounds']
+ if bounds[0] is not None and value < bounds[0]:
+ value = bounds[0]
+ if bounds[1] is not None and value > bounds[1]:
+ value = bounds[1]
+
+ if self.opts['int']:
+ value = int(value)
+
+ value = D(asUnicode(value))
+ if value == self.val:
+ return
+ prev = self.val
+
+ self.val = value
+ if update:
+ self.updateText(prev=prev)
+
+ self.sigValueChanging.emit(self, float(self.val)) ## change will be emitted in 300ms if there are no subsequent changes.
+ if not delaySignal:
+ self.emitChanged()
+
+ return value
+
+
+ def emitChanged(self):
+ self.lastValEmitted = self.val
+ self.valueChanged.emit(float(self.val))
+ self.sigValueChanged.emit(self)
+
+ def delayedChange(self):
+ try:
+ if self.val != self.lastValEmitted:
+ self.emitChanged()
+ except RuntimeError:
+ pass ## This can happen if we try to handle a delayed signal after someone else has already deleted the underlying C++ object.
+
+ def widgetGroupInterface(self):
+ return (self.valueChanged, SpinBox.value, SpinBox.setValue)
+
+ def sizeHint(self):
+ return QtCore.QSize(120, 0)
+
+
+ def stepEnabled(self):
+ return self.StepUpEnabled | self.StepDownEnabled
+
+ #def fixup(self, *args):
+ #print "fixup:", args
+
+ def stepBy(self, n):
+ n = D(int(n)) ## n must be integral number of steps.
+ s = [D(-1), D(1)][n >= 0] ## determine sign of step
+ val = self.val
+
+ for i in range(abs(n)):
+
+ if self.opts['log']:
+ raise Exception("Log mode no longer supported.")
+ # step = abs(val) * self.opts['step']
+ # if 'minStep' in self.opts:
+ # step = max(step, self.opts['minStep'])
+ # val += step * s
+ if self.opts['dec']:
+ if val == 0:
+ step = self.opts['minStep']
+ exp = None
+ else:
+ vs = [D(-1), D(1)][val >= 0]
+ #exp = D(int(abs(val*(D('1.01')**(s*vs))).log10()))
+ fudge = D('1.01')**(s*vs) ## fudge factor. at some places, the step size depends on the step sign.
+ exp = abs(val * fudge).log10().quantize(1, ROUND_FLOOR)
+ step = self.opts['step'] * D(10)**exp
+ if 'minStep' in self.opts:
+ step = max(step, self.opts['minStep'])
+ val += s * step
+ #print "Exp:", exp, "step", step, "val", val
+ else:
+ val += s*self.opts['step']
+
+ if 'minStep' in self.opts and abs(val) < self.opts['minStep']:
+ val = D(0)
+ self.setValue(val, delaySignal=True) ## note all steps (arrow buttons, wheel, up/down keys..) emit delayed signals only.
+
+
+ def valueInRange(self, value):
+ bounds = self.opts['bounds']
+ if bounds[0] is not None and value < bounds[0]:
+ return False
+ if bounds[1] is not None and value > bounds[1]:
+ return False
+ if self.opts.get('int', False):
+ if int(value) != value:
+ return False
+ return True
+
+
+ def updateText(self, prev=None):
+ #print "Update text."
+ self.skipValidate = True
+ if self.opts['siPrefix']:
+ if self.val == 0 and prev is not None:
+ (s, p) = fn.siScale(prev)
+ txt = "0.0 %s%s" % (p, self.opts['suffix'])
+ else:
+ txt = fn.siFormat(float(self.val), suffix=self.opts['suffix'])
+ else:
+ txt = '%g%s' % (self.val , self.opts['suffix'])
+ self.lineEdit().setText(txt)
+ self.lastText = txt
+ self.skipValidate = False
+
+ def validate(self, strn, pos):
+ if self.skipValidate:
+ #print "skip validate"
+ #self.textValid = False
+ ret = QtGui.QValidator.Acceptable
+ else:
+ try:
+ ## first make sure we didn't mess with the suffix
+ suff = self.opts.get('suffix', '')
+ if len(suff) > 0 and asUnicode(strn)[-len(suff):] != suff:
+ #print '"%s" != "%s"' % (unicode(strn)[-len(suff):], suff)
+ ret = QtGui.QValidator.Invalid
+
+ ## next see if we actually have an interpretable value
+ else:
+ val = self.interpret()
+ if val is False:
+ #print "can't interpret"
+ #self.setStyleSheet('SpinBox {border: 2px solid #C55;}')
+ #self.textValid = False
+ ret = QtGui.QValidator.Intermediate
+ else:
+ if self.valueInRange(val):
+ if not self.opts['delayUntilEditFinished']:
+ self.setValue(val, update=False)
+ #print " OK:", self.val
+ #self.setStyleSheet('')
+ #self.textValid = True
+
+ ret = QtGui.QValidator.Acceptable
+ else:
+ ret = QtGui.QValidator.Intermediate
+
+ except:
+ #print " BAD"
+ #import sys
+ #sys.excepthook(*sys.exc_info())
+ #self.textValid = False
+ #self.setStyleSheet('SpinBox {border: 2px solid #C55;}')
+ ret = QtGui.QValidator.Intermediate
+
+ ## draw / clear border
+ if ret == QtGui.QValidator.Intermediate:
+ self.textValid = False
+ elif ret == QtGui.QValidator.Acceptable:
+ self.textValid = True
+ ## note: if text is invalid, we don't change the textValid flag
+ ## since the text will be forced to its previous state anyway
+ self.update()
+
+ ## support 2 different pyqt APIs. Bleh.
+ if hasattr(QtCore, 'QString'):
+ return (ret, pos)
+ else:
+ return (ret, strn, pos)
+
+ def paintEvent(self, ev):
+ QtGui.QAbstractSpinBox.paintEvent(self, ev)
+
+ ## draw red border if text is invalid
+ if not self.textValid:
+ p = QtGui.QPainter(self)
+ p.setRenderHint(p.Antialiasing)
+ p.setPen(fn.mkPen((200,50,50), width=2))
+ p.drawRoundedRect(self.rect().adjusted(2, 2, -2, -2), 4, 4)
+ p.end()
+
+
+ def interpret(self):
+ """Return value of text. Return False if text is invalid, raise exception if text is intermediate"""
+ strn = self.lineEdit().text()
+ suf = self.opts['suffix']
+ if len(suf) > 0:
+ if strn[-len(suf):] != suf:
+ return False
+ #raise Exception("Units are invalid.")
+ strn = strn[:-len(suf)]
+ try:
+ val = fn.siEval(strn)
+ except:
+ #sys.excepthook(*sys.exc_info())
+ #print "invalid"
+ return False
+ #print val
+ return val
+
+ #def interpretText(self, strn=None):
+ #print "Interpret:", strn
+ #if strn is None:
+ #strn = self.lineEdit().text()
+ #self.setValue(siEval(strn), update=False)
+ ##QtGui.QAbstractSpinBox.interpretText(self)
+
+
+ def editingFinishedEvent(self):
+ """Edit has finished; set value."""
+ #print "Edit finished."
+ if asUnicode(self.lineEdit().text()) == self.lastText:
+ #print "no text change."
+ return
+ try:
+ val = self.interpret()
+ except:
+ return
+
+ if val is False:
+ #print "value invalid:", str(self.lineEdit().text())
+ return
+ if val == self.val:
+ #print "no value change:", val, self.val
+ return
+ self.setValue(val, delaySignal=False) ## allow text update so that values are reformatted pretty-like
+
+ #def textChanged(self):
+ #print "Text changed."
+
+
+### Drop-in replacement for SpinBox; just for crash-testing
+#class SpinBox(QtGui.QDoubleSpinBox):
+ #valueChanged = QtCore.Signal(object) # (value) for compatibility with QSpinBox
+ #sigValueChanged = QtCore.Signal(object) # (self)
+ #sigValueChanging = QtCore.Signal(object) # (value)
+ #def __init__(self, parent=None, *args, **kargs):
+ #QtGui.QSpinBox.__init__(self, parent)
+
+ #def __getattr__(self, attr):
+ #return lambda *args, **kargs: None
+
+ #def widgetGroupInterface(self):
+ #return (self.valueChanged, SpinBox.value, SpinBox.setValue)
+
diff --git a/pyqtgraph/widgets/TableWidget.py b/pyqtgraph/widgets/TableWidget.py
new file mode 100644
index 00000000..dc4f875b
--- /dev/null
+++ b/pyqtgraph/widgets/TableWidget.py
@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph.python2_3 import asUnicode
+
+import numpy as np
+try:
+ import metaarray
+ HAVE_METAARRAY = True
+except:
+ HAVE_METAARRAY = False
+
+__all__ = ['TableWidget']
+class TableWidget(QtGui.QTableWidget):
+ """Extends QTableWidget with some useful functions for automatic data handling
+ and copy / export context menu. Can automatically format and display:
+
+ - numpy arrays
+ - numpy record arrays
+ - metaarrays
+ - list-of-lists [[1,2,3], [4,5,6]]
+ - dict-of-lists {'x': [1,2,3], 'y': [4,5,6]}
+ - list-of-dicts [{'x': 1, 'y': 4}, {'x': 2, 'y': 5}, ...]
+ """
+
+ def __init__(self, *args):
+ QtGui.QTableWidget.__init__(self, *args)
+ self.setVerticalScrollMode(self.ScrollPerPixel)
+ self.setSelectionMode(QtGui.QAbstractItemView.ContiguousSelection)
+ self.clear()
+ self.contextMenu = QtGui.QMenu()
+ self.contextMenu.addAction('Copy Selection').triggered.connect(self.copySel)
+ self.contextMenu.addAction('Copy All').triggered.connect(self.copyAll)
+ self.contextMenu.addAction('Save Selection').triggered.connect(self.saveSel)
+ self.contextMenu.addAction('Save All').triggered.connect(self.saveAll)
+
+ def clear(self):
+ QtGui.QTableWidget.clear(self)
+ self.verticalHeadersSet = False
+ self.horizontalHeadersSet = False
+ self.items = []
+ self.setRowCount(0)
+ self.setColumnCount(0)
+
+ def setData(self, data):
+ self.clear()
+ self.appendData(data)
+
+ def appendData(self, data):
+ """Types allowed:
+ 1 or 2D numpy array or metaArray
+ 1D numpy record array
+ list-of-lists, list-of-dicts or dict-of-lists
+ """
+ fn0, header0 = self.iteratorFn(data)
+ if fn0 is None:
+ self.clear()
+ return
+ it0 = fn0(data)
+ try:
+ first = next(it0)
+ except StopIteration:
+ return
+ #if type(first) == type(np.float64(1)):
+ # return
+ fn1, header1 = self.iteratorFn(first)
+ if fn1 is None:
+ self.clear()
+ return
+
+ #print fn0, header0
+ #print fn1, header1
+ firstVals = [x for x in fn1(first)]
+ self.setColumnCount(len(firstVals))
+
+ #print header0, header1
+ if not self.verticalHeadersSet and header0 is not None:
+ #print "set header 0:", header0
+ self.setRowCount(len(header0))
+ self.setVerticalHeaderLabels(header0)
+ self.verticalHeadersSet = True
+ if not self.horizontalHeadersSet and header1 is not None:
+ #print "set header 1:", header1
+ self.setHorizontalHeaderLabels(header1)
+ self.horizontalHeadersSet = True
+
+ self.setRow(0, firstVals)
+ i = 1
+ for row in it0:
+ self.setRow(i, [x for x in fn1(row)])
+ i += 1
+
+ def iteratorFn(self, data):
+ """Return 1) a function that will provide an iterator for data and 2) a list of header strings"""
+ if isinstance(data, list):
+ return lambda d: d.__iter__(), None
+ elif isinstance(data, dict):
+ return lambda d: iter(d.values()), list(map(str, data.keys()))
+ elif HAVE_METAARRAY and (hasattr(data, 'implements') and data.implements('MetaArray')):
+ if data.axisHasColumns(0):
+ header = [str(data.columnName(0, i)) for i in range(data.shape[0])]
+ elif data.axisHasValues(0):
+ header = list(map(str, data.xvals(0)))
+ else:
+ header = None
+ return self.iterFirstAxis, header
+ elif isinstance(data, np.ndarray):
+ return self.iterFirstAxis, None
+ elif isinstance(data, np.void):
+ return self.iterate, list(map(str, data.dtype.names))
+ elif data is None:
+ return (None,None)
+ else:
+ raise Exception("Don't know how to iterate over data type: %s" % str(type(data)))
+
+ def iterFirstAxis(self, data):
+ for i in range(data.shape[0]):
+ yield data[i]
+
+ def iterate(self, data): ## for numpy.void, which can be iterated but mysteriously has no __iter__ (??)
+ for x in data:
+ yield x
+
+ def appendRow(self, data):
+ self.appendData([data])
+
+ def addRow(self, vals):
+ #print "add row:", vals
+ row = self.rowCount()
+ self.setRowCount(row+1)
+ self.setRow(row, vals)
+
+ def setRow(self, row, vals):
+ if row > self.rowCount()-1:
+ self.setRowCount(row+1)
+ for col in range(self.columnCount()):
+ val = vals[col]
+ if isinstance(val, float) or isinstance(val, np.floating):
+ s = "%0.3g" % val
+ else:
+ s = str(val)
+ item = QtGui.QTableWidgetItem(s)
+ item.value = val
+ #print "add item to row %d:"%row, item, item.value
+ self.items.append(item)
+ self.setItem(row, col, item)
+
+ def serialize(self, useSelection=False):
+ """Convert entire table (or just selected area) into tab-separated text values"""
+ if useSelection:
+ selection = self.selectedRanges()[0]
+ rows = list(range(selection.topRow(), selection.bottomRow()+1))
+ columns = list(range(selection.leftColumn(), selection.rightColumn()+1))
+ else:
+ rows = list(range(self.rowCount()))
+ columns = list(range(self.columnCount()))
+
+
+ data = []
+ if self.horizontalHeadersSet:
+ row = []
+ if self.verticalHeadersSet:
+ row.append(asUnicode(''))
+
+ for c in columns:
+ row.append(asUnicode(self.horizontalHeaderItem(c).text()))
+ data.append(row)
+
+ for r in rows:
+ row = []
+ if self.verticalHeadersSet:
+ row.append(asUnicode(self.verticalHeaderItem(r).text()))
+ for c in columns:
+ item = self.item(r, c)
+ if item is not None:
+ row.append(asUnicode(item.value))
+ else:
+ row.append(asUnicode(''))
+ data.append(row)
+
+ s = ''
+ for row in data:
+ s += ('\t'.join(row) + '\n')
+ return s
+
+ def copySel(self):
+ """Copy selected data to clipboard."""
+ QtGui.QApplication.clipboard().setText(self.serialize(useSelection=True))
+
+ def copyAll(self):
+ """Copy all data to clipboard."""
+ QtGui.QApplication.clipboard().setText(self.serialize(useSelection=False))
+
+ def saveSel(self):
+ """Save selected data to file."""
+ self.save(self.serialize(useSelection=True))
+
+ def saveAll(self):
+ """Save all data to file."""
+ self.save(self.serialize(useSelection=False))
+
+ def save(self, data):
+ fileName = QtGui.QFileDialog.getSaveFileName(self, "Save As..", "", "Tab-separated values (*.tsv)")
+ if fileName == '':
+ return
+ open(fileName, 'w').write(data)
+
+
+ def contextMenuEvent(self, ev):
+ self.contextMenu.popup(ev.globalPos())
+
+ def keyPressEvent(self, ev):
+ if ev.text() == 'c' and ev.modifiers() == QtCore.Qt.ControlModifier:
+ ev.accept()
+ self.copy()
+ else:
+ ev.ignore()
+
+
+
+if __name__ == '__main__':
+ app = QtGui.QApplication([])
+ win = QtGui.QMainWindow()
+ t = TableWidget()
+ win.setCentralWidget(t)
+ win.resize(800,600)
+ win.show()
+
+ ll = [[1,2,3,4,5]] * 20
+ ld = [{'x': 1, 'y': 2, 'z': 3}] * 20
+ dl = {'x': list(range(20)), 'y': list(range(20)), 'z': list(range(20))}
+
+ a = np.ones((20, 5))
+ ra = np.ones((20,), dtype=[('x', int), ('y', int), ('z', int)])
+
+ t.setData(ll)
+
+ if HAVE_METAARRAY:
+ ma = metaarray.MetaArray(np.ones((20, 3)), info=[
+ {'values': np.linspace(1, 5, 20)},
+ {'cols': [
+ {'name': 'x'},
+ {'name': 'y'},
+ {'name': 'z'},
+ ]}
+ ])
+ t.setData(ma)
+
diff --git a/pyqtgraph/widgets/TreeWidget.py b/pyqtgraph/widgets/TreeWidget.py
new file mode 100644
index 00000000..97fbe953
--- /dev/null
+++ b/pyqtgraph/widgets/TreeWidget.py
@@ -0,0 +1,284 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+from weakref import *
+
+__all__ = ['TreeWidget', 'TreeWidgetItem']
+class TreeWidget(QtGui.QTreeWidget):
+ """Extends QTreeWidget to allow internal drag/drop with widgets in the tree.
+ Also maintains the expanded state of subtrees as they are moved.
+ This class demonstrates the absurd lengths one must go to to make drag/drop work."""
+
+ sigItemMoved = QtCore.Signal(object, object, object) # (item, parent, index)
+
+ def __init__(self, parent=None):
+ QtGui.QTreeWidget.__init__(self, parent)
+ #self.itemWidgets = WeakKeyDictionary()
+ self.setAcceptDrops(True)
+ self.setDragEnabled(True)
+ self.setEditTriggers(QtGui.QAbstractItemView.EditKeyPressed|QtGui.QAbstractItemView.SelectedClicked)
+ self.placeholders = []
+ self.childNestingLimit = None
+
+ def setItemWidget(self, item, col, wid):
+ """
+ Overrides QTreeWidget.setItemWidget such that widgets are added inside an invisible wrapper widget.
+ This makes it possible to move the item in and out of the tree without its widgets being automatically deleted.
+ """
+ w = QtGui.QWidget() ## foster parent / surrogate child widget
+ l = QtGui.QVBoxLayout()
+ l.setContentsMargins(0,0,0,0)
+ w.setLayout(l)
+ w.setSizePolicy(wid.sizePolicy())
+ w.setMinimumHeight(wid.minimumHeight())
+ w.setMinimumWidth(wid.minimumWidth())
+ l.addWidget(wid)
+ w.realChild = wid
+ self.placeholders.append(w)
+ QtGui.QTreeWidget.setItemWidget(self, item, col, w)
+
+ def itemWidget(self, item, col):
+ w = QtGui.QTreeWidget.itemWidget(self, item, col)
+ if w is not None:
+ w = w.realChild
+ return w
+
+ def dropMimeData(self, parent, index, data, action):
+ item = self.currentItem()
+ p = parent
+ #print "drop", item, "->", parent, index
+ while True:
+ if p is None:
+ break
+ if p is item:
+ return False
+ #raise Exception("Can not move item into itself.")
+ p = p.parent()
+
+ if not self.itemMoving(item, parent, index):
+ return False
+
+ currentParent = item.parent()
+ if currentParent is None:
+ currentParent = self.invisibleRootItem()
+ if parent is None:
+ parent = self.invisibleRootItem()
+
+ if currentParent is parent and index > parent.indexOfChild(item):
+ index -= 1
+
+ self.prepareMove(item)
+
+ currentParent.removeChild(item)
+ #print " insert child to index", index
+ parent.insertChild(index, item) ## index will not be correct
+ self.setCurrentItem(item)
+
+ self.recoverMove(item)
+ #self.emit(QtCore.SIGNAL('itemMoved'), item, parent, index)
+ self.sigItemMoved.emit(item, parent, index)
+ return True
+
+ def itemMoving(self, item, parent, index):
+ """Called when item has been dropped elsewhere in the tree.
+ Return True to accept the move, False to reject."""
+ return True
+
+ def prepareMove(self, item):
+ item.__widgets = []
+ item.__expanded = item.isExpanded()
+ for i in range(self.columnCount()):
+ w = self.itemWidget(item, i)
+ item.__widgets.append(w)
+ if w is None:
+ continue
+ w.setParent(None)
+ for i in range(item.childCount()):
+ self.prepareMove(item.child(i))
+
+ def recoverMove(self, item):
+ for i in range(self.columnCount()):
+ w = item.__widgets[i]
+ if w is None:
+ continue
+ self.setItemWidget(item, i, w)
+ for i in range(item.childCount()):
+ self.recoverMove(item.child(i))
+
+ item.setExpanded(False) ## Items do not re-expand correctly unless they are collapsed first.
+ QtGui.QApplication.instance().processEvents()
+ item.setExpanded(item.__expanded)
+
+ def collapseTree(self, item):
+ item.setExpanded(False)
+ for i in range(item.childCount()):
+ self.collapseTree(item.child(i))
+
+ def removeTopLevelItem(self, item):
+ for i in range(self.topLevelItemCount()):
+ if self.topLevelItem(i) is item:
+ self.takeTopLevelItem(i)
+ return
+ raise Exception("Item '%s' not in top-level items." % str(item))
+
+ def listAllItems(self, item=None):
+ items = []
+ if item != None:
+ items.append(item)
+ else:
+ item = self.invisibleRootItem()
+
+ for cindex in range(item.childCount()):
+ foundItems = self.listAllItems(item=item.child(cindex))
+ for f in foundItems:
+ items.append(f)
+ return items
+
+ def dropEvent(self, ev):
+ QtGui.QTreeWidget.dropEvent(self, ev)
+ self.updateDropFlags()
+
+
+ def updateDropFlags(self):
+ ### intended to put a limit on how deep nests of children can go.
+ ### self.childNestingLimit is upheld when moving items without children, but if the item being moved has children/grandchildren, the children/grandchildren
+ ### can end up over the childNestingLimit.
+ if self.childNestingLimit == None:
+ pass # enable drops in all items (but only if there are drops that aren't enabled? for performance...)
+ else:
+ items = self.listAllItems()
+ for item in items:
+ parentCount = 0
+ p = item.parent()
+ while p is not None:
+ parentCount += 1
+ p = p.parent()
+ if parentCount >= self.childNestingLimit:
+ item.setFlags(item.flags() & (~QtCore.Qt.ItemIsDropEnabled))
+ else:
+ item.setFlags(item.flags() | QtCore.Qt.ItemIsDropEnabled)
+
+ @staticmethod
+ def informTreeWidgetChange(item):
+ if hasattr(item, 'treeWidgetChanged'):
+ item.treeWidgetChanged()
+ else:
+ for i in xrange(item.childCount()):
+ TreeWidget.informTreeWidgetChange(item.child(i))
+
+
+ def addTopLevelItem(self, item):
+ QtGui.QTreeWidget.addTopLevelItem(self, item)
+ self.informTreeWidgetChange(item)
+
+ def addTopLevelItems(self, items):
+ QtGui.QTreeWidget.addTopLevelItems(self, items)
+ for item in items:
+ self.informTreeWidgetChange(item)
+
+ def insertTopLevelItem(self, index, item):
+ QtGui.QTreeWidget.insertTopLevelItem(self, index, item)
+ self.informTreeWidgetChange(item)
+
+ def insertTopLevelItems(self, index, items):
+ QtGui.QTreeWidget.insertTopLevelItems(self, index, items)
+ for item in items:
+ self.informTreeWidgetChange(item)
+
+ def takeTopLevelItem(self, index):
+ item = self.topLevelItem(index)
+ if item is not None:
+ self.prepareMove(item)
+ item = QtGui.QTreeWidget.takeTopLevelItem(self, index)
+ self.prepareMove(item)
+ self.informTreeWidgetChange(item)
+ return item
+
+ def topLevelItems(self):
+ return map(self.topLevelItem, xrange(self.topLevelItemCount()))
+
+ def clear(self):
+ items = self.topLevelItems()
+ for item in items:
+ self.prepareMove(item)
+ QtGui.QTreeWidget.clear(self)
+
+ ## Why do we want to do this? It causes RuntimeErrors.
+ #for item in items:
+ #self.informTreeWidgetChange(item)
+
+
+class TreeWidgetItem(QtGui.QTreeWidgetItem):
+ """
+ TreeWidgetItem that keeps track of its own widgets.
+ Widgets may be added to columns before the item is added to a tree.
+ """
+ def __init__(self, *args):
+ QtGui.QTreeWidgetItem.__init__(self, *args)
+ self._widgets = {} # col: widget
+ self._tree = None
+
+
+ def setChecked(self, column, checked):
+ self.setCheckState(column, QtCore.Qt.Checked if checked else QtCore.Qt.Unchecked)
+
+ def setWidget(self, column, widget):
+ if column in self._widgets:
+ self.removeWidget(column)
+ self._widgets[column] = widget
+ tree = self.treeWidget()
+ if tree is None:
+ return
+ else:
+ tree.setItemWidget(self, column, widget)
+
+ def removeWidget(self, column):
+ del self._widgets[column]
+ tree = self.treeWidget()
+ if tree is None:
+ return
+ tree.removeItemWidget(self, column)
+
+ def treeWidgetChanged(self):
+ tree = self.treeWidget()
+ if self._tree is tree:
+ return
+ self._tree = self.treeWidget()
+ if tree is None:
+ return
+ for col, widget in self._widgets.items():
+ tree.setItemWidget(self, col, widget)
+
+ def addChild(self, child):
+ QtGui.QTreeWidgetItem.addChild(self, child)
+ TreeWidget.informTreeWidgetChange(child)
+
+ def addChildren(self, childs):
+ QtGui.QTreeWidgetItem.addChildren(self, childs)
+ for child in childs:
+ TreeWidget.informTreeWidgetChange(child)
+
+ def insertChild(self, index, child):
+ QtGui.QTreeWidgetItem.insertChild(self, index, child)
+ TreeWidget.informTreeWidgetChange(child)
+
+ def insertChildren(self, index, childs):
+ QtGui.QTreeWidgetItem.addChildren(self, index, childs)
+ for child in childs:
+ TreeWidget.informTreeWidgetChange(child)
+
+ def removeChild(self, child):
+ QtGui.QTreeWidgetItem.removeChild(self, child)
+ TreeWidget.informTreeWidgetChange(child)
+
+ def takeChild(self, index):
+ child = QtGui.QTreeWidgetItem.takeChild(self, index)
+ TreeWidget.informTreeWidgetChange(child)
+ return child
+
+ def takeChildren(self):
+ childs = QtGui.QTreeWidgetItem.takeChildren(self)
+ for child in childs:
+ TreeWidget.informTreeWidgetChange(child)
+ return childs
+
+
diff --git a/pyqtgraph/widgets/ValueLabel.py b/pyqtgraph/widgets/ValueLabel.py
new file mode 100644
index 00000000..7f6fa84b
--- /dev/null
+++ b/pyqtgraph/widgets/ValueLabel.py
@@ -0,0 +1,73 @@
+from pyqtgraph.Qt import QtCore, QtGui
+from pyqtgraph.ptime import time
+import pyqtgraph as pg
+from functools import reduce
+
+__all__ = ['ValueLabel']
+
+class ValueLabel(QtGui.QLabel):
+ """
+ QLabel specifically for displaying numerical values.
+ Extends QLabel adding some extra functionality:
+
+ - displaying units with si prefix
+ - built-in exponential averaging
+ """
+
+ def __init__(self, parent=None, suffix='', siPrefix=False, averageTime=0, formatStr=None):
+ """
+ ============ ==================================================================================
+ Arguments
+ suffix (str or None) The suffix to place after the value
+ siPrefix (bool) Whether to add an SI prefix to the units and display a scaled value
+ averageTime (float) The length of time in seconds to average values. If this value
+ is 0, then no averaging is performed. As this value increases
+ the display value will appear to change more slowly and smoothly.
+ formatStr (str) Optionally, provide a format string to use when displaying text. The text
+ will be generated by calling formatStr.format(value=, avgValue=, suffix=)
+ (see Python documentation on str.format)
+ This option is not compatible with siPrefix
+ ============ ==================================================================================
+ """
+ QtGui.QLabel.__init__(self, parent)
+ self.values = []
+ self.averageTime = averageTime ## no averaging by default
+ self.suffix = suffix
+ self.siPrefix = siPrefix
+ if formatStr is None:
+ formatStr = '{avgValue:0.2g} {suffix}'
+ self.formatStr = formatStr
+
+ def setValue(self, value):
+ now = time()
+ self.values.append((now, value))
+ cutoff = now - self.averageTime
+ while len(self.values) > 0 and self.values[0][0] < cutoff:
+ self.values.pop(0)
+ self.update()
+
+ def setFormatStr(self, text):
+ self.formatStr = text
+ self.update()
+
+ def setAverageTime(self, t):
+ self.averageTime = t
+
+ def averageValue(self):
+ return reduce(lambda a,b: a+b, [v[1] for v in self.values]) / float(len(self.values))
+
+
+ def paintEvent(self, ev):
+ self.setText(self.generateText())
+ return QtGui.QLabel.paintEvent(self, ev)
+
+ def generateText(self):
+ if len(self.values) == 0:
+ return ''
+ avg = self.averageValue()
+ val = self.values[-1][1]
+ if self.siPrefix:
+ return pg.siFormat(avg, suffix=self.suffix)
+ else:
+ return self.formatStr.format(value=val, avgValue=avg, suffix=self.suffix)
+
diff --git a/pyqtgraph/widgets/VerticalLabel.py b/pyqtgraph/widgets/VerticalLabel.py
new file mode 100644
index 00000000..fa45ae5d
--- /dev/null
+++ b/pyqtgraph/widgets/VerticalLabel.py
@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+from pyqtgraph.Qt import QtGui, QtCore
+
+__all__ = ['VerticalLabel']
+#class VerticalLabel(QtGui.QLabel):
+ #def paintEvent(self, ev):
+ #p = QtGui.QPainter(self)
+ #p.rotate(-90)
+ #self.hint = p.drawText(QtCore.QRect(-self.height(), 0, self.height(), self.width()), QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter, self.text())
+ #p.end()
+ #self.setMinimumWidth(self.hint.height())
+ #self.setMinimumHeight(self.hint.width())
+
+ #def sizeHint(self):
+ #if hasattr(self, 'hint'):
+ #return QtCore.QSize(self.hint.height(), self.hint.width())
+ #else:
+ #return QtCore.QSize(16, 50)
+
+class VerticalLabel(QtGui.QLabel):
+ def __init__(self, text, orientation='vertical', forceWidth=True):
+ QtGui.QLabel.__init__(self, text)
+ self.forceWidth = forceWidth
+ self.orientation = None
+ self.setOrientation(orientation)
+
+ def setOrientation(self, o):
+ if self.orientation == o:
+ return
+ self.orientation = o
+ self.update()
+ self.updateGeometry()
+
+ def paintEvent(self, ev):
+ p = QtGui.QPainter(self)
+ #p.setBrush(QtGui.QBrush(QtGui.QColor(100, 100, 200)))
+ #p.setPen(QtGui.QPen(QtGui.QColor(50, 50, 100)))
+ #p.drawRect(self.rect().adjusted(0, 0, -1, -1))
+
+ #p.setPen(QtGui.QPen(QtGui.QColor(255, 255, 255)))
+
+ if self.orientation == 'vertical':
+ p.rotate(-90)
+ rgn = QtCore.QRect(-self.height(), 0, self.height(), self.width())
+ else:
+ rgn = self.contentsRect()
+ align = self.alignment()
+ #align = QtCore.Qt.AlignTop|QtCore.Qt.AlignHCenter
+
+ self.hint = p.drawText(rgn, align, self.text())
+ p.end()
+
+ if self.orientation == 'vertical':
+ self.setMaximumWidth(self.hint.height())
+ self.setMinimumWidth(0)
+ self.setMaximumHeight(16777215)
+ if self.forceWidth:
+ self.setMinimumHeight(self.hint.width())
+ else:
+ self.setMinimumHeight(0)
+ else:
+ self.setMaximumHeight(self.hint.height())
+ self.setMinimumHeight(0)
+ self.setMaximumWidth(16777215)
+ if self.forceWidth:
+ self.setMinimumWidth(self.hint.width())
+ else:
+ self.setMinimumWidth(0)
+
+ def sizeHint(self):
+ if self.orientation == 'vertical':
+ if hasattr(self, 'hint'):
+ return QtCore.QSize(self.hint.height(), self.hint.width())
+ else:
+ return QtCore.QSize(19, 50)
+ else:
+ if hasattr(self, 'hint'):
+ return QtCore.QSize(self.hint.width(), self.hint.height())
+ else:
+ return QtCore.QSize(50, 19)
+
+
+if __name__ == '__main__':
+ app = QtGui.QApplication([])
+ win = QtGui.QMainWindow()
+ w = QtGui.QWidget()
+ l = QtGui.QGridLayout()
+ w.setLayout(l)
+
+ l1 = VerticalLabel("text 1", orientation='horizontal')
+ l2 = VerticalLabel("text 2")
+ l3 = VerticalLabel("text 3")
+ l4 = VerticalLabel("text 4", orientation='horizontal')
+ l.addWidget(l1, 0, 0)
+ l.addWidget(l2, 1, 1)
+ l.addWidget(l3, 2, 2)
+ l.addWidget(l4, 3, 3)
+ win.setCentralWidget(w)
+ win.show()
\ No newline at end of file
diff --git a/pyqtgraph/widgets/__init__.py b/pyqtgraph/widgets/__init__.py
new file mode 100644
index 00000000..a81fe391
--- /dev/null
+++ b/pyqtgraph/widgets/__init__.py
@@ -0,0 +1,21 @@
+## just import everything from sub-modules
+
+#import os
+
+#d = os.path.split(__file__)[0]
+#files = []
+#for f in os.listdir(d):
+ #if os.path.isdir(os.path.join(d, f)):
+ #files.append(f)
+ #elif f[-3:] == '.py' and f != '__init__.py':
+ #files.append(f[:-3])
+
+#for modName in files:
+ #mod = __import__(modName, globals(), locals(), fromlist=['*'])
+ #if hasattr(mod, '__all__'):
+ #names = mod.__all__
+ #else:
+ #names = [n for n in dir(mod) if n[0] != '_']
+ #for k in names:
+ #print modName, k
+ #globals()[k] = getattr(mod, k)
diff --git a/setup.py b/setup.py
new file mode 100644
index 00000000..e4dc07cf
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,41 @@
+from distutils.core import setup
+import os
+
+## generate list of all sub-packages
+subdirs = [i[0].split(os.path.sep)[1:] for i in os.walk('./pyqtgraph') if '__init__.py' in i[2]]
+subdirs = filter(lambda p: len(p) == 1 or p[1] != 'build', subdirs)
+all_packages = ['.'.join(p) for p in subdirs] + ['pyqtgraph.examples']
+
+setup(name='pyqtgraph',
+ version='',
+ description='Scientific Graphics and GUI Library for Python',
+ long_description="""\
+PyQtGraph is a pure-python graphics and GUI library built on PyQt4/PySide and numpy.
+
+It is intended for use in mathematics / scientific / engineering applications. Despite being written entirely in python, the library is very fast due to its heavy leverage of numpy for number crunching, Qt's GraphicsView framework for 2D display, and OpenGL for 3D display.
+""",
+ license='MIT',
+ url='http://www.pyqtgraph.org',
+ author='Luke Campagnola',
+ author_email='luke.campagnola@gmail.com',
+ packages=all_packages,
+ package_dir={'pyqtgraph.examples': 'examples'}, ## install examples along with the rest of the source
+ #package_data={'pyqtgraph': ['graphicsItems/PlotItem/*.png']},
+ classifiers = [
+ "Programming Language :: Python",
+ "Programming Language :: Python :: 3",
+ "Development Status :: 4 - Beta",
+ "Environment :: Other Environment",
+ "Intended Audience :: Science/Research",
+ "License :: OSI Approved :: MIT License",
+ "Operating System :: OS Independent",
+ "Topic :: Software Development :: Libraries :: Python Modules",
+ "Topic :: Scientific/Engineering :: Visualization",
+ "Topic :: Software Development :: User Interfaces",
+ ],
+ requires = [
+ 'numpy',
+ 'scipy',
+ ],
+)
+
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/svg.py b/tests/svg.py
new file mode 100644
index 00000000..7c26833e
--- /dev/null
+++ b/tests/svg.py
@@ -0,0 +1,70 @@
+"""
+SVG export test
+"""
+import test
+import pyqtgraph as pg
+app = pg.mkQApp()
+
+class SVGTest(test.TestCase):
+ #def test_plotscene(self):
+ #pg.setConfigOption('foreground', (0,0,0))
+ #w = pg.GraphicsWindow()
+ #w.show()
+ #p1 = w.addPlot()
+ #p2 = w.addPlot()
+ #p1.plot([1,3,2,3,1,6,9,8,4,2,3,5,3], pen={'color':'k'})
+ #p1.setXRange(0,5)
+ #p2.plot([1,5,2,3,4,6,1,2,4,2,3,5,3], pen={'color':'k', 'cosmetic':False, 'width': 0.3})
+ #app.processEvents()
+ #app.processEvents()
+
+ #ex = pg.exporters.SVGExporter.SVGExporter(w.scene())
+ #ex.export(fileName='test.svg')
+
+
+ def test_simple(self):
+ scene = pg.QtGui.QGraphicsScene()
+ #rect = pg.QtGui.QGraphicsRectItem(0, 0, 100, 100)
+ #scene.addItem(rect)
+ #rect.setPos(20,20)
+ #rect.translate(50, 50)
+ #rect.rotate(30)
+ #rect.scale(0.5, 0.5)
+
+ #rect1 = pg.QtGui.QGraphicsRectItem(0, 0, 100, 100)
+ #rect1.setParentItem(rect)
+ #rect1.setFlag(rect1.ItemIgnoresTransformations)
+ #rect1.setPos(20, 20)
+ #rect1.scale(2,2)
+
+ #el1 = pg.QtGui.QGraphicsEllipseItem(0, 0, 100, 100)
+ #el1.setParentItem(rect1)
+ ##grp = pg.ItemGroup()
+ #grp.setParentItem(rect)
+ #grp.translate(200,0)
+ ##grp.rotate(30)
+
+ #rect2 = pg.QtGui.QGraphicsRectItem(0, 0, 100, 25)
+ #rect2.setFlag(rect2.ItemClipsChildrenToShape)
+ #rect2.setParentItem(grp)
+ #rect2.setPos(0,25)
+ #rect2.rotate(30)
+ #el = pg.QtGui.QGraphicsEllipseItem(0, 0, 100, 50)
+ #el.translate(10,-5)
+ #el.scale(0.5,2)
+ #el.setParentItem(rect2)
+
+ grp2 = pg.ItemGroup()
+ scene.addItem(grp2)
+ grp2.scale(100,100)
+
+ rect3 = pg.QtGui.QGraphicsRectItem(0,0,2,2)
+ rect3.setPen(pg.mkPen(width=1, cosmetic=False))
+ grp2.addItem(rect3)
+
+ ex = pg.exporters.SVGExporter.SVGExporter(scene)
+ ex.export(fileName='test.svg')
+
+
+if __name__ == '__main__':
+ test.unittest.main()
\ No newline at end of file
diff --git a/tests/test.py b/tests/test.py
new file mode 100644
index 00000000..f24a7d42
--- /dev/null
+++ b/tests/test.py
@@ -0,0 +1,8 @@
+import unittest
+import os, sys
+## make sure this instance of pyqtgraph gets imported first
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+## all tests should be defined with this class so we have the option to tweak it later.
+class TestCase(unittest.TestCase):
+ pass
\ No newline at end of file
diff --git a/tools/py2exe.bat b/tools/py2exe.bat
new file mode 100644
index 00000000..f2b070fb
--- /dev/null
+++ b/tools/py2exe.bat
@@ -0,0 +1,10 @@
+rem
+rem This is a simple windows batch file containing the commands needed to package
+rem a program with pyqtgraph and py2exe. See the packaging tutorial at
+rem http://luke.campagnola.me/code/pyqtgraph for more information.
+rem
+
+rmdir /S /Q dist
+rmdir /S /Q build
+python .\py2exeSetupWindows.py py2exe --includes sip
+pause
diff --git a/tools/py2exeSetupWindows.py b/tools/py2exeSetupWindows.py
new file mode 100644
index 00000000..086b5a4a
--- /dev/null
+++ b/tools/py2exeSetupWindows.py
@@ -0,0 +1,26 @@
+"""
+Example distutils setup script for packaging a program with
+pyqtgraph and py2exe. See the packaging tutorial at
+http://luke.campagnola.me/code/pyqtgraph for more information.
+"""
+
+from distutils.core import setup
+from glob import glob
+import py2exe
+import sys
+
+## This path must contain msvcm90.dll, msvcp90.dll, msvcr90.dll, and Microsoft.VC90.CRT.manifest
+## (see http://www.py2exe.org/index.cgi/Tutorial)
+dllpath = r'C:\Windows\WinSxS\x86_Microsoft.VC90.CRT...'
+
+sys.path.append(dllpath)
+data_files = [
+ ## Instruct setup to copy the needed DLL files into the build directory
+ ("Microsoft.VC90.CRT", glob(dllpath + r'\*.*')),
+]
+
+setup(
+ data_files=data_files,
+ windows=['main.py'] ,
+ options={"py2exe": {"excludes":["Tkconstants", "Tkinter", "tcl"]}}
+)
diff --git a/widgets.py b/widgets.py
deleted file mode 100644
index 8516fefc..00000000
--- a/widgets.py
+++ /dev/null
@@ -1,1302 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-widgets.py - Interactive graphics items for GraphicsView (ROI widgets)
-Copyright 2010 Luke Campagnola
-Distributed under MIT/X11 license. See license.txt for more infomation.
-
-Implements a series of graphics items which display movable/scalable/rotatable shapes
-for use as region-of-interest markers. ROI class automatically handles extraction
-of array data from ImageItems.
-"""
-
-from PyQt4 import QtCore, QtGui
-if not hasattr(QtCore, 'Signal'):
- QtCore.Signal = QtCore.pyqtSignal
-#from numpy import array, arccos, dot, pi, zeros, vstack, ubyte, fromfunction, ceil, floor, arctan2
-import numpy as np
-from numpy.linalg import norm
-import scipy.ndimage as ndimage
-from Point import *
-from Transform import Transform
-from math import cos, sin
-import functions as fn
-#from ObjectWorkaround import *
-
-def rectStr(r):
- return "[%f, %f] + [%f, %f]" % (r.x(), r.y(), r.width(), r.height())
-
-# Multiple inheritance not allowed in PyQt. Retarded workaround:
-#class QObjectWorkaround:
- #def __init__(self):
- #self._qObj_ = QtCore.QObject()
- #def __getattr__(self, attr):
- #if attr == '_qObj_':
- #raise Exception("QObjectWorkaround not initialized!")
- #return getattr(self._qObj_, attr)
- #def connect(self, *args):
- #return QtCore.QObject.connect(self._qObj_, *args)
-
-
-class ROI(QtGui.QGraphicsObject):
- """Generic region-of-interest widget.
- Can be used for implementing many types of selection box with rotate/translate/scale handles."""
-
- sigRegionChangeFinished = QtCore.Signal(object)
- sigRegionChangeStarted = QtCore.Signal(object)
- sigRegionChanged = QtCore.Signal(object)
-
- def __init__(self, pos, size=Point(1, 1), angle=0.0, invertible=False, maxBounds=None, snapSize=1.0, scaleSnap=False, translateSnap=False, rotateSnap=False, parent=None, pen=None):
- #QObjectWorkaround.__init__(self)
- QtGui.QGraphicsObject.__init__(self, parent)
- pos = Point(pos)
- size = Point(size)
- self.aspectLocked = False
- self.translatable = True
-
- if pen is None:
- self.pen = QtGui.QPen(QtGui.QColor(255, 255, 255))
- else:
- self.pen = fn.mkPen(pen)
- self.handlePen = QtGui.QPen(QtGui.QColor(150, 255, 255))
- self.handles = []
- self.state = {'pos': pos, 'size': size, 'angle': angle} ## angle is in degrees for ease of Qt integration
- self.lastState = None
- self.setPos(pos)
- #self.rotate(-angle * 180. / np.pi)
- self.rotate(-angle)
- self.setZValue(10)
- self.isMoving = False
-
- self.handleSize = 5
- self.invertible = invertible
- self.maxBounds = maxBounds
-
- self.snapSize = snapSize
- self.translateSnap = translateSnap
- self.rotateSnap = rotateSnap
- self.scaleSnap = scaleSnap
- self.setFlag(self.ItemIsSelectable, True)
-
- def getState(self):
- return self.state.copy()
-
- def setState(self, state):
- self.setPos(state['pos'], update=False)
- self.setSize(state['size'], update=False)
- self.setAngle(state['angle'])
-
- def setZValue(self, z):
- QtGui.QGraphicsItem.setZValue(self, z)
- for h in self.handles:
- h['item'].setZValue(z+1)
-
- def sceneBounds(self):
- return self.sceneTransform().mapRect(self.boundingRect())
-
- def parentBounds(self):
- return self.mapToParent(self.boundingRect()).boundingRect()
-
- def setPen(self, pen):
- self.pen = pen
- self.update()
-
- def setPos(self, pos, update=True):
- #print "setPos() called."
- pos = Point(pos)
- self.state['pos'] = pos
- QtGui.QGraphicsItem.setPos(self, pos)
- if update:
- self.updateHandles()
- self.handleChange()
-
- def setSize(self, size, update=True):
- size = Point(size)
- self.prepareGeometryChange()
- self.state['size'] = size
- if update:
- self.updateHandles()
- self.handleChange()
-
- def setAngle(self, angle, update=True):
- self.state['angle'] = angle
- tr = QtGui.QTransform()
- #tr.rotate(-angle * 180 / np.pi)
- tr.rotate(angle)
- self.setTransform(tr)
- if update:
- self.updateHandles()
- self.handleChange()
-
-
- def addTranslateHandle(self, pos, axes=None, item=None, name=None):
- pos = Point(pos)
- return self.addHandle({'name': name, 'type': 't', 'pos': pos, 'item': item})
-
- def addFreeHandle(self, pos, axes=None, item=None, name=None):
- pos = Point(pos)
- return self.addHandle({'name': name, 'type': 'f', 'pos': pos, 'item': item})
-
- def addScaleHandle(self, pos, center, axes=None, item=None, name=None, lockAspect=False):
- pos = Point(pos)
- center = Point(center)
- info = {'name': name, 'type': 's', 'center': center, 'pos': pos, 'item': item, 'lockAspect': lockAspect}
- if pos.x() == center.x():
- info['xoff'] = True
- if pos.y() == center.y():
- info['yoff'] = True
- return self.addHandle(info)
-
- def addRotateHandle(self, pos, center, item=None, name=None):
- pos = Point(pos)
- center = Point(center)
- return self.addHandle({'name': name, 'type': 'r', 'center': center, 'pos': pos, 'item': item})
-
- def addScaleRotateHandle(self, pos, center, item=None, name=None):
- pos = Point(pos)
- center = Point(center)
- if pos[0] != center[0] and pos[1] != center[1]:
- raise Exception("Scale/rotate handles must have either the same x or y coordinate as their center point.")
- return self.addHandle({'name': name, 'type': 'sr', 'center': center, 'pos': pos, 'item': item})
-
- def addRotateFreeHandle(self, pos, center, axes=None, item=None, name=None):
- pos = Point(pos)
- center = Point(center)
- return self.addHandle({'name': name, 'type': 'rf', 'center': center, 'pos': pos, 'item': item})
-
- def addHandle(self, info):
- if not info.has_key('item') or info['item'] is None:
- #print "BEFORE ADD CHILD:", self.childItems()
- h = Handle(self.handleSize, typ=info['type'], pen=self.handlePen, parent=self)
- #print "AFTER ADD CHILD:", self.childItems()
- h.setPos(info['pos'] * self.state['size'])
- info['item'] = h
- else:
- h = info['item']
- iid = len(self.handles)
- h.connectROI(self, iid)
- #h.mouseMoveEvent = lambda ev: self.pointMoveEvent(iid, ev)
- #h.mousePressEvent = lambda ev: self.pointPressEvent(iid, ev)
- #h.mouseReleaseEvent = lambda ev: self.pointReleaseEvent(iid, ev)
- self.handles.append(info)
- h.setZValue(self.zValue()+1)
- #if self.isSelected():
- #h.show()
- #else:
- #h.hide()
- return h
-
- def getLocalHandlePositions(self, index=None):
- """Returns the position of a handle in ROI coordinates"""
- if index == None:
- positions = []
- for h in self.handles:
- positions.append((h['name'], h['pos']))
- return positions
- else:
- return (self.handles[index]['name'], self.handles[index]['pos'])
-
- def getSceneHandlePositions(self, index = None):
- if index == None:
- positions = []
- for h in self.handles:
- positions.append((h['name'], h['item'].scenePos()))
- return positions
- else:
- return (self.handles[index]['name'], self.handles[index]['item'].scenePos())
-
-
- def mapSceneToParent(self, pt):
- return self.mapToParent(self.mapFromScene(pt))
-
- def setSelected(self, s):
- QtGui.QGraphicsItem.setSelected(self, s)
- #print "select", self, s
- if s:
- for h in self.handles:
- h['item'].show()
- else:
- for h in self.handles:
- h['item'].hide()
-
- def mousePressEvent(self, ev):
- ## Bug: sometimes we get events we shouldn't.
- p = ev.pos()
- if not self.isMoving and not self.shape().contains(p):
- ev.ignore()
- return
- if ev.button() == QtCore.Qt.LeftButton:
- self.setSelected(True)
- if self.translatable:
- self.isMoving = True
- self.preMoveState = self.getState()
- self.cursorOffset = self.scenePos() - ev.scenePos()
- #self.emit(QtCore.SIGNAL('regionChangeStarted'), self)
- self.sigRegionChangeStarted.emit(self)
- ev.accept()
- elif ev.button() == QtCore.Qt.RightButton:
- if self.isMoving:
- ev.accept()
- self.cancelMove()
- else:
- ev.ignore()
- else:
- ev.ignore()
-
- def mouseMoveEvent(self, ev):
- #print "mouse move", ev.pos()
- if self.translatable and self.isMoving and ev.buttons() == QtCore.Qt.LeftButton:
- snap = None
- if self.translateSnap or (ev.modifiers() & QtCore.Qt.ControlModifier):
- snap = Point(self.snapSize, self.snapSize)
- newPos = ev.scenePos() + self.cursorOffset
- newPos = self.mapSceneToParent(newPos)
- self.translate(newPos - self.pos(), snap=snap)
-
- def mouseReleaseEvent(self, ev):
- if self.translatable:
- self.isMoving = False
- #self.emit(QtCore.SIGNAL('regionChangeFinished'), self)
- self.sigRegionChangeFinished.emit(self)
-
- def cancelMove(self):
- self.isMoving = False
- self.setState(self.preMoveState)
-
- def pointPressEvent(self, pt, ev):
- #print "press"
- self.isMoving = True
- self.preMoveState = self.getState()
-
- #self.emit(QtCore.SIGNAL('regionChangeStarted'), self)
- self.sigRegionChangeStarted.emit(self)
- #self.pressPos = self.mapFromScene(ev.scenePos())
- #self.pressHandlePos = self.handles[pt]['item'].pos()
-
- def pointReleaseEvent(self, pt, ev):
- #print "release"
- self.isMoving = False
- #self.emit(QtCore.SIGNAL('regionChangeFinished'), self)
- self.sigRegionChangeFinished.emit(self)
-
- def stateCopy(self):
- sc = {}
- sc['pos'] = Point(self.state['pos'])
- sc['size'] = Point(self.state['size'])
- sc['angle'] = self.state['angle']
- return sc
-
- def updateHandles(self):
- #print "update", self.handles
- for h in self.handles:
- #print " try", h
- if h['item'] in self.childItems():
- p = h['pos']
- h['item'].setPos(h['pos'] * self.state['size'])
- #else:
- #print " Not child!", self.childItems()
-
-
- def checkPointMove(self, pt, pos, modifiers):
- return True
-
- def pointMoveEvent(self, pt, ev):
- self.movePoint(pt, ev.scenePos(), ev.modifiers())
-
-
- def movePoint(self, pt, pos, modifiers=QtCore.Qt.KeyboardModifier()):
- #print "movePoint() called."
- ## pos is the new position of the handle in scene coords, as requested by the handle.
-
- newState = self.stateCopy()
- h = self.handles[pt]
- #p0 = self.mapToScene(h['item'].pos())
- ## p0 is current (before move) position of handle in scene coords
- p0 = self.mapToScene(h['pos'] * self.state['size'])
- p1 = Point(pos)
-
- ## transform p0 and p1 into parent's coordinates (same as scene coords if there is no parent). I forget why.
- p0 = self.mapSceneToParent(p0)
- p1 = self.mapSceneToParent(p1)
-
- ## Handles with a 'center' need to know their local position relative to the center point (lp0, lp1)
- if h.has_key('center'):
- c = h['center']
- cs = c * self.state['size']
- #lpOrig = h['pos'] -
- #lp0 = self.mapFromScene(p0) - cs
- #lp1 = self.mapFromScene(p1) - cs
- lp0 = self.mapFromParent(p0) - cs
- lp1 = self.mapFromParent(p1) - cs
-
- if h['type'] == 't':
- #p0 = Point(self.mapToScene(h['item'].pos()))
- #p1 = Point(pos + self.mapToScene(self.pressHandlePos) - self.mapToScene(self.pressPos))
- snap = None
- if self.translateSnap or (modifiers & QtCore.Qt.ControlModifier):
- snap = Point(self.snapSize, self.snapSize)
- self.translate(p1-p0, snap=snap, update=False)
-
- elif h['type'] == 'f':
- h['item'].setPos(self.mapFromScene(pos))
- #self.emit(QtCore.SIGNAL('regionChanged'), self)
- self.sigRegionChanged.emit(self)
-
- elif h['type'] == 's':
- #c = h['center']
- #cs = c * self.state['size']
- #p1 = (self.mapFromScene(ev.scenePos()) + self.pressHandlePos - self.pressPos) - cs
-
- ## If a handle and its center have the same x or y value, we can't scale across that axis.
- if h['center'][0] == h['pos'][0]:
- lp1[0] = 0
- if h['center'][1] == h['pos'][1]:
- lp1[1] = 0
-
- ## snap
- if self.scaleSnap or (modifiers & QtCore.Qt.ControlModifier):
- lp1[0] = round(lp1[0] / self.snapSize) * self.snapSize
- lp1[1] = round(lp1[1] / self.snapSize) * self.snapSize
-
- ## preserve aspect ratio (this can override snapping)
- if h['lockAspect'] or (modifiers & QtCore.Qt.AltModifier):
- #arv = Point(self.preMoveState['size']) -
- lp1 = lp1.proj(lp0)
-
- ## determine scale factors and new size of ROI
- hs = h['pos'] - c
- if hs[0] == 0:
- hs[0] = 1
- if hs[1] == 0:
- hs[1] = 1
- newSize = lp1 / hs
-
- ## Perform some corrections and limit checks
- if newSize[0] == 0:
- newSize[0] = newState['size'][0]
- if newSize[1] == 0:
- newSize[1] = newState['size'][1]
- if not self.invertible:
- if newSize[0] < 0:
- newSize[0] = newState['size'][0]
- if newSize[1] < 0:
- newSize[1] = newState['size'][1]
- if self.aspectLocked:
- newSize[0] = newSize[1]
-
- ## Move ROI so the center point occupies the same scene location after the scale
- s0 = c * self.state['size']
- s1 = c * newSize
- cc = self.mapToParent(s0 - s1) - self.mapToParent(Point(0, 0))
-
- ## update state, do more boundary checks
- newState['size'] = newSize
- newState['pos'] = newState['pos'] + cc
- if self.maxBounds is not None:
- r = self.stateRect(newState)
- if not self.maxBounds.contains(r):
- return
-
- self.setPos(newState['pos'], update=False)
- self.prepareGeometryChange()
- self.state = newState
-
- ## move handles to their new locations
- self.updateHandles()
-
- elif h['type'] in ['r', 'rf']:
- ## If the handle is directly over its center point, we can't compute an angle.
- if lp1.length() == 0 or lp0.length() == 0:
- return
-
- ## determine new rotation angle, constrained if necessary
- ang = newState['angle'] - lp0.angle(lp1)
- if ang is None: ## this should never happen..
- return
- if self.rotateSnap or (modifiers & QtCore.Qt.ControlModifier):
- ang = round(ang / 15.) * 15. ## 180/12 = 15
-
- ## create rotation transform
- tr = QtGui.QTransform()
- #tr.rotate(-ang * 180. / np.pi)
- tr.rotate(ang)
-
- ## mvoe ROI so that center point remains stationary after rotate
- cc = self.mapToParent(cs) - (tr.map(cs) + self.state['pos'])
- newState['angle'] = ang
- newState['pos'] = newState['pos'] + cc
-
- ## check boundaries, update
- if self.maxBounds is not None:
- r = self.stateRect(newState)
- if not self.maxBounds.contains(r):
- return
- self.setTransform(tr)
- self.setPos(newState['pos'], update=False)
- self.state = newState
-
- ## If this is a free-rotate handle, its distance from the center may change.
-
- if h['type'] == 'rf':
- h['item'].setPos(self.mapFromScene(p1)) ## changes ROI coordinates of handle
-
-
- #elif h['type'] == 'rf':
- ### If the handle is directly over its center point, we can't compute an angle.
- #if lp1.length() == 0 or lp0.length() == 0:
- #return
-
- ### determine new rotation angle, constrained if necessary
- #pos = Point(pos)
- #ang = newState['angle'] + lp0.angle(lp1)
- #if ang is None:
- ##h['item'].setPos(self.mapFromScene(Point(pos[0], 0.0))) ## changes ROI coordinates of handle
- #h['item'].setPos(self.mapFromScene(pos))
- #return
- #if self.rotateSnap or (modifiers & QtCore.Qt.ControlModifier):
- #ang = round(ang / (np.pi/12.)) * (np.pi/12.)
-
-
- #tr = QtGui.QTransform()
- #tr.rotate(-ang * 180. / np.pi)
-
- #cc = self.mapToParent(cs) - (tr.map(cs) + self.state['pos'])
- #newState['angle'] = ang
- #newState['pos'] = newState['pos'] + cc
- #if self.maxBounds is not None:
- #r = self.stateRect(newState)
- #if not self.maxBounds.contains(r):
- #return
- #self.setTransform(tr)
- #self.setPos(newState['pos'], update=False)
- #self.state = newState
-
- #h['item'].setPos(self.mapFromScene(pos)) ## changes ROI coordinates of handle
- ##self.emit(QtCore.SIGNAL('regionChanged'), self)
-
- elif h['type'] == 'sr':
- #newState = self.stateCopy()
- if h['center'][0] == h['pos'][0]:
- scaleAxis = 1
- else:
- scaleAxis = 0
-
- #c = h['center']
- #cs = c * self.state['size']
- #p0 = Point(h['item'].pos()) - cs
- #p1 = (self.mapFromScene(ev.scenePos()) + self.pressHandlePos - self.pressPos) - cs
- if lp1.length() == 0 or lp0.length() == 0:
- return
-
- ang = newState['angle'] - lp0.angle(lp1)
- if ang is None:
- return
- if self.rotateSnap or (modifiers & QtCore.Qt.ControlModifier):
- #ang = round(ang / (np.pi/12.)) * (np.pi/12.)
- ang = round(ang / 15.) * 15.
-
- hs = abs(h['pos'][scaleAxis] - c[scaleAxis])
- newState['size'][scaleAxis] = lp1.length() / hs
- if self.scaleSnap or (modifiers & QtCore.Qt.ControlModifier):
- newState['size'][scaleAxis] = round(newState['size'][scaleAxis] / self.snapSize) * self.snapSize
- if newState['size'][scaleAxis] == 0:
- newState['size'][scaleAxis] = 1
-
- c1 = c * newState['size']
- tr = QtGui.QTransform()
- #tr.rotate(-ang * 180. / np.pi)
- tr.rotate(ang)
-
- cc = self.mapToParent(cs) - (tr.map(c1) + self.state['pos'])
- newState['angle'] = ang
- newState['pos'] = newState['pos'] + cc
- if self.maxBounds is not None:
- r = self.stateRect(newState)
- if not self.maxBounds.contains(r):
- return
- self.setTransform(tr)
- self.setPos(newState['pos'], update=False)
- self.prepareGeometryChange()
- self.state = newState
-
- self.updateHandles()
-
- self.handleChange()
-
- def handleChange(self):
- """The state of the ROI has changed; redraw if needed."""
- #print "handleChange() called."
- changed = False
- #print "self.lastState:", self.lastState
- if self.lastState is None:
- changed = True
- else:
- for k in self.state.keys():
- #print k, self.state[k], self.lastState[k]
- if self.state[k] != self.lastState[k]:
- #print "state %s has changed; emit signal" % k
- changed = True
- self.lastState = self.stateCopy()
- #print "changed =", changed
- if changed:
- #print "handle changed."
- self.update()
- #self.emit(QtCore.SIGNAL('regionChanged'), self)
- self.sigRegionChanged.emit(self)
-
-
- def scale(self, s, center=[0,0]):
- c = self.mapToScene(Point(center) * self.state['size'])
- self.prepareGeometryChange()
- self.state['size'] = self.state['size'] * s
- c1 = self.mapToScene(Point(center) * self.state['size'])
- self.state['pos'] = self.state['pos'] + c - c1
- self.setPos(self.state['pos'])
- self.updateHandles()
-
-
- def translate(self, *args, **kargs):
- """accepts either (x, y, snap) or ([x,y], snap) as arguments"""
- if 'snap' not in kargs:
- snap = None
- else:
- snap = kargs['snap']
-
- if len(args) == 1:
- pt = args[0]
- else:
- pt = args
-
- newState = self.stateCopy()
- newState['pos'] = newState['pos'] + pt
- if snap != None:
- newState['pos'][0] = round(newState['pos'][0] / snap[0]) * snap[0]
- newState['pos'][1] = round(newState['pos'][1] / snap[1]) * snap[1]
-
-
- #d = ev.scenePos() - self.mapToScene(self.pressPos)
- if self.maxBounds is not None:
- r = self.stateRect(newState)
- #r0 = self.sceneTransform().mapRect(self.boundingRect())
- d = Point(0,0)
- if self.maxBounds.left() > r.left():
- d[0] = self.maxBounds.left() - r.left()
- elif self.maxBounds.right() < r.right():
- d[0] = self.maxBounds.right() - r.right()
- if self.maxBounds.top() > r.top():
- d[1] = self.maxBounds.top() - r.top()
- elif self.maxBounds.bottom() < r.bottom():
- d[1] = self.maxBounds.bottom() - r.bottom()
- newState['pos'] += d
-
- self.state['pos'] = newState['pos']
- self.setPos(self.state['pos'])
- #if 'update' not in kargs or kargs['update'] is True:
- self.handleChange()
-
- def stateRect(self, state):
- r = QtCore.QRectF(0, 0, state['size'][0], state['size'][1])
- tr = QtGui.QTransform()
- #tr.rotate(-state['angle'] * 180 / np.pi)
- tr.rotate(-state['angle'])
- r = tr.mapRect(r)
- return r.adjusted(state['pos'][0], state['pos'][1], state['pos'][0], state['pos'][1])
-
- def boundingRect(self):
- return QtCore.QRectF(0, 0, self.state['size'][0], self.state['size'][1])
-
- def paint(self, p, opt, widget):
- p.save()
- r = self.boundingRect()
- p.setRenderHint(QtGui.QPainter.Antialiasing)
- p.setPen(self.pen)
- p.translate(r.left(), r.top())
- p.scale(r.width(), r.height())
- p.drawRect(0, 0, 1, 1)
- p.restore()
-
- def getArraySlice(self, data, img, axes=(0,1), returnSlice=True):
- """Return a tuple of slice objects that can be used to slice the region from data covered by this ROI.
- Also returns the transform which maps the ROI into data coordinates.
-
- If returnSlice is set to False, the function returns a pair of tuples with the values that would have
- been used to generate the slice objects. ((ax0Start, ax0Stop), (ax1Start, ax1Stop))"""
- #print "getArraySlice"
-
- ## Determine shape of array along ROI axes
- dShape = (data.shape[axes[0]], data.shape[axes[1]])
- #print " dshape", dShape
-
- ## Determine transform that maps ROI bounding box to image coordinates
- tr = self.sceneTransform() * img.sceneTransform().inverted()[0]
-
- ## Modify transform to scale from image coords to data coords
- #m = QtGui.QTransform()
- tr.scale(float(dShape[0]) / img.width(), float(dShape[1]) / img.height())
- #tr = tr * m
-
- ## Transform ROI bounds into data bounds
- dataBounds = tr.mapRect(self.boundingRect())
- #print " boundingRect:", self.boundingRect()
- #print " dataBounds:", dataBounds
-
- ## Intersect transformed ROI bounds with data bounds
- intBounds = dataBounds.intersect(QtCore.QRectF(0, 0, dShape[0], dShape[1]))
- #print " intBounds:", intBounds
-
- ## Determine index values to use when referencing the array.
- bounds = (
- (int(min(intBounds.left(), intBounds.right())), int(1+max(intBounds.left(), intBounds.right()))),
- (int(min(intBounds.bottom(), intBounds.top())), int(1+max(intBounds.bottom(), intBounds.top())))
- )
- #print " bounds:", bounds
-
- if returnSlice:
- ## Create slice objects
- sl = [slice(None)] * data.ndim
- sl[axes[0]] = slice(*bounds[0])
- sl[axes[1]] = slice(*bounds[1])
- return tuple(sl), tr
- else:
- return bounds, tr
-
-
- def getArrayRegion(self, data, img, axes=(0,1)):
- shape = self.state['size']
-
- origin = self.mapToItem(img, QtCore.QPointF(0, 0))
-
- ## vx and vy point in the directions of the slice axes, but must be scaled properly
- vx = self.mapToItem(img, QtCore.QPointF(1, 0)) - origin
- vy = self.mapToItem(img, QtCore.QPointF(0, 1)) - origin
-
- lvx = np.sqrt(vx.x()**2 + vx.y()**2)
- lvy = np.sqrt(vy.x()**2 + vy.y()**2)
- pxLen = img.width() / data.shape[axes[0]]
- sx = pxLen / lvx
- sy = pxLen / lvy
-
- vectors = ((vx.x()*sx, vx.y()*sx), (vy.x()*sy, vy.y()*sy))
- shape = self.state['size']
- shape = [abs(shape[0]/sx), abs(shape[1]/sy)]
-
- origin = (origin.x(), origin.y())
-
- #print "shape", shape, "vectors", vectors, "origin", origin
-
- return fn.affineSlice(data, shape=shape, vectors=vectors, origin=origin, axes=axes, order=1)
-
- ### transpose data so x and y are the first 2 axes
- #trAx = range(0, data.ndim)
- #trAx.remove(axes[0])
- #trAx.remove(axes[1])
- #tr1 = tuple(axes) + tuple(trAx)
- #arr = data.transpose(tr1)
-
- ### Determine the minimal area of the data we will need
- #(dataBounds, roiDataTransform) = self.getArraySlice(data, img, returnSlice=False, axes=axes)
-
- ### Pad data boundaries by 1px if possible
- #dataBounds = (
- #(max(dataBounds[0][0]-1, 0), min(dataBounds[0][1]+1, arr.shape[0])),
- #(max(dataBounds[1][0]-1, 0), min(dataBounds[1][1]+1, arr.shape[1]))
- #)
-
- ### Extract minimal data from array
- #arr1 = arr[dataBounds[0][0]:dataBounds[0][1], dataBounds[1][0]:dataBounds[1][1]]
-
- ### Update roiDataTransform to reflect this extraction
- #roiDataTransform *= QtGui.QTransform().translate(-dataBounds[0][0], -dataBounds[1][0])
- #### (roiDataTransform now maps from ROI coords to extracted data coords)
-
-
- ### Rotate array
- #if abs(self.state['angle']) > 1e-5:
- #arr2 = ndimage.rotate(arr1, self.state['angle'] * 180 / np.pi, order=1)
-
- ### update data transforms to reflect this rotation
- #rot = QtGui.QTransform().rotate(self.state['angle'] * 180 / np.pi)
- #roiDataTransform *= rot
-
- ### The rotation also causes a shift which must be accounted for:
- #dataBound = QtCore.QRectF(0, 0, arr1.shape[0], arr1.shape[1])
- #rotBound = rot.mapRect(dataBound)
- #roiDataTransform *= QtGui.QTransform().translate(-rotBound.left(), -rotBound.top())
-
- #else:
- #arr2 = arr1
-
-
-
- #### Shift off partial pixels
- ## 1. map ROI into current data space
- #roiBounds = roiDataTransform.mapRect(self.boundingRect())
-
- ## 2. Determine amount to shift data
- #shift = (int(roiBounds.left()) - roiBounds.left(), int(roiBounds.bottom()) - roiBounds.bottom())
- #if abs(shift[0]) > 1e-6 or abs(shift[1]) > 1e-6:
- ## 3. pad array with 0s before shifting
- #arr2a = np.zeros((arr2.shape[0]+2, arr2.shape[1]+2) + arr2.shape[2:], dtype=arr2.dtype)
- #arr2a[1:-1, 1:-1] = arr2
-
- ## 4. shift array and udpate transforms
- #arr3 = ndimage.shift(arr2a, shift + (0,)*(arr2.ndim-2), order=1)
- #roiDataTransform *= QtGui.QTransform().translate(1+shift[0], 1+shift[1])
- #else:
- #arr3 = arr2
-
-
- #### Extract needed region from rotated/shifted array
- ## 1. map ROI into current data space (round these values off--they should be exact integer values at this point)
- #roiBounds = roiDataTransform.mapRect(self.boundingRect())
- ##print self, roiBounds.height()
- ##import traceback
- ##traceback.print_stack()
-
- #roiBounds = QtCore.QRect(round(roiBounds.left()), round(roiBounds.top()), round(roiBounds.width()), round(roiBounds.height()))
-
- ##2. intersect ROI with data bounds
- #dataBounds = roiBounds.intersect(QtCore.QRect(0, 0, arr3.shape[0], arr3.shape[1]))
-
- ##3. Extract data from array
- #db = dataBounds
- #bounds = (
- #(db.left(), db.right()+1),
- #(db.top(), db.bottom()+1)
- #)
- #arr4 = arr3[bounds[0][0]:bounds[0][1], bounds[1][0]:bounds[1][1]]
-
- #### Create zero array in size of ROI
- #arr5 = np.zeros((roiBounds.width(), roiBounds.height()) + arr4.shape[2:], dtype=arr4.dtype)
-
- ### Fill array with ROI data
- #orig = Point(dataBounds.topLeft() - roiBounds.topLeft())
- #subArr = arr5[orig[0]:orig[0]+arr4.shape[0], orig[1]:orig[1]+arr4.shape[1]]
- #subArr[:] = arr4[:subArr.shape[0], :subArr.shape[1]]
-
-
- ### figure out the reverse transpose order
- #tr2 = np.array(tr1)
- #for i in range(0, len(tr2)):
- #tr2[tr1[i]] = i
- #tr2 = tuple(tr2)
-
- ### Untranspose array before returning
- #return arr5.transpose(tr2)
-
- def getGlobalTransform(self, relativeTo=None):
- """Return global transformation (rotation angle+translation) required to move from relative state to current state. If relative state isn't specified,
- then we use the state of the ROI when mouse is pressed."""
- if relativeTo == None:
- relativeTo = self.preMoveState
- st = self.getState()
-
- ## this is only allowed because we will be comparing the two
- relativeTo['scale'] = relativeTo['size']
- st['scale'] = st['size']
-
-
-
- t1 = Transform(relativeTo)
- t2 = Transform(st)
- return t2/t1
-
-
- #st = self.getState()
-
- ### rotation
- #ang = (st['angle']-relativeTo['angle']) * 180. / 3.14159265358
- #rot = QtGui.QTransform()
- #rot.rotate(-ang)
-
- ### We need to come up with a universal transformation--one that can be applied to other objects
- ### such that all maintain alignment.
- ### More specifically, we need to turn the ROI's position and angle into
- ### a rotation _around the origin_ and a translation.
-
- #p0 = Point(relativeTo['pos'])
-
- ### base position, rotated
- #p1 = rot.map(p0)
-
- #trans = Point(st['pos']) - p1
- #return trans, ang
-
- def applyGlobalTransform(self, tr):
- st = self.getState()
-
- st['scale'] = st['size']
- st = Transform(st)
- st = (st * tr).saveState()
- st['size'] = st['scale']
- self.setState(st)
-
-
-class Handle(QtGui.QGraphicsItem):
-
- types = { ## defines number of sides, start angle for each handle type
- 't': (4, np.pi/4),
- 'f': (4, np.pi/4),
- 's': (4, 0),
- 'r': (12, 0),
- 'sr': (12, 0),
- 'rf': (12, 0),
- }
-
- def __init__(self, radius, typ=None, pen=QtGui.QPen(QtGui.QColor(200, 200, 220)), parent=None):
- #print " create item with parent", parent
- self.bounds = QtCore.QRectF(-1e-10, -1e-10, 2e-10, 2e-10)
- QtGui.QGraphicsItem.__init__(self, parent)
- self.setFlag(self.ItemIgnoresTransformations)
- self.setZValue(11)
- self.roi = []
- self.radius = radius
- self.typ = typ
- self.prepareGeometryChange()
- self.pen = pen
- self.pen.setWidth(0)
- self.pen.setCosmetic(True)
- self.isMoving = False
- self.sides, self.startAng = self.types[typ]
- self.buildPath()
-
- def connectROI(self, roi, i):
- self.roi.append((roi, i))
-
- def boundingRect(self):
- return self.bounds
-
- def mousePressEvent(self, ev):
- # Bug: sometimes we get events not meant for us!
- p = ev.pos()
- if not self.isMoving and not self.path.contains(p):
- ev.ignore()
- return
-
- #print "handle press"
- if ev.button() == QtCore.Qt.LeftButton:
- self.isMoving = True
- self.cursorOffset = self.scenePos() - ev.scenePos()
- for r in self.roi:
- r[0].pointPressEvent(r[1], ev)
- #print " accepted."
- ev.accept()
- elif ev.button() == QtCore.Qt.RightButton:
- if self.isMoving:
- self.isMoving = False ## prevents any further motion
- for r in self.roi:
- r[0].cancelMove()
- ev.accept()
- else:
- ev.ignore()
- else:
- ev.ignore()
-
-
- def mouseReleaseEvent(self, ev):
- #print "release"
- if ev.button() == QtCore.Qt.LeftButton:
- self.isMoving = False
- for r in self.roi:
- r[0].pointReleaseEvent(r[1], ev)
-
- def mouseMoveEvent(self, ev):
- #print "handle mouseMove", ev.pos()
- if self.isMoving and ev.buttons() == QtCore.Qt.LeftButton:
- pos = ev.scenePos() + self.cursorOffset
- self.movePoint(pos, ev.modifiers())
-
- def movePoint(self, pos, modifiers=QtCore.Qt.KeyboardModifier()):
- for r in self.roi:
- if not r[0].checkPointMove(r[1], pos, modifiers):
- return
- #print "point moved; inform %d ROIs" % len(self.roi)
- # A handle can be used by multiple ROIs; tell each to update its handle position
- for r in self.roi:
- r[0].movePoint(r[1], pos, modifiers)
-
- def buildPath(self):
- size = self.radius
- self.path = QtGui.QPainterPath()
- ang = self.startAng
- dt = 2*np.pi / self.sides
- for i in range(0, self.sides+1):
- x = size * cos(ang)
- y = size * sin(ang)
- ang += dt
- if i == 0:
- self.path.moveTo(x, y)
- else:
- self.path.lineTo(x, y)
-
- def paint(self, p, opt, widget):
- ## determine rotation of transform
- m = self.sceneTransform()
- #mi = m.inverted()[0]
- v = m.map(QtCore.QPointF(1, 0)) - m.map(QtCore.QPointF(0, 0))
- va = np.arctan2(v.y(), v.x())
-
- ## Determine length of unit vector in painter's coords
- #size = mi.map(Point(self.radius, self.radius)) - mi.map(Point(0, 0))
- #size = (size.x()*size.x() + size.y() * size.y()) ** 0.5
- size = self.radius
-
- bounds = QtCore.QRectF(-size, -size, size*2, size*2)
- if bounds != self.bounds:
- self.bounds = bounds
- self.prepareGeometryChange()
- p.setRenderHints(p.Antialiasing, True)
- p.setPen(self.pen)
-
- p.rotate(va * 180. / 3.1415926)
- p.drawPath(self.path)
-
- #ang = self.startAng + va
- #dt = 2*np.pi / self.sides
- #for i in range(0, self.sides):
- #x1 = size * cos(ang)
- #y1 = size * sin(ang)
- #x2 = size * cos(ang+dt)
- #y2 = size * sin(ang+dt)
- #ang += dt
- #p.drawLine(Point(x1, y1), Point(x2, y2))
-
-
-
-
-
-class TestROI(ROI):
- def __init__(self, pos, size, **args):
- #QtGui.QGraphicsRectItem.__init__(self, pos[0], pos[1], size[0], size[1])
- ROI.__init__(self, pos, size, **args)
- #self.addTranslateHandle([0, 0])
- self.addTranslateHandle([0.5, 0.5])
- self.addScaleHandle([1, 1], [0, 0])
- self.addScaleHandle([0, 0], [1, 1])
- self.addScaleRotateHandle([1, 0.5], [0.5, 0.5])
- self.addScaleHandle([0.5, 1], [0.5, 0.5])
- self.addRotateHandle([1, 0], [0, 0])
- self.addRotateHandle([0, 1], [1, 1])
-
-
-
-class RectROI(ROI):
- def __init__(self, pos, size, centered=False, sideScalers=False, **args):
- #QtGui.QGraphicsRectItem.__init__(self, 0, 0, size[0], size[1])
- ROI.__init__(self, pos, size, **args)
- if centered:
- center = [0.5, 0.5]
- else:
- center = [0, 0]
-
- #self.addTranslateHandle(center)
- self.addScaleHandle([1, 1], center)
- if sideScalers:
- self.addScaleHandle([1, 0.5], [center[0], 0.5])
- self.addScaleHandle([0.5, 1], [0.5, center[1]])
-
-class LineROI(ROI):
- def __init__(self, pos1, pos2, width, **args):
- pos1 = Point(pos1)
- pos2 = Point(pos2)
- d = pos2-pos1
- l = d.length()
- ang = Point(1, 0).angle(d)
- ra = ang * np.pi / 180.
- c = Point(-width/2. * sin(ra), -width/2. * cos(ra))
- pos1 = pos1 + c
-
- ROI.__init__(self, pos1, size=Point(l, width), angle=ang, **args)
- self.addScaleRotateHandle([0, 0.5], [1, 0.5])
- self.addScaleRotateHandle([1, 0.5], [0, 0.5])
- self.addScaleHandle([0.5, 1], [0.5, 0.5])
-
-
-class MultiLineROI(QtGui.QGraphicsObject):
-
- sigRegionChangeFinished = QtCore.Signal(object)
- sigRegionChangeStarted = QtCore.Signal(object)
- sigRegionChanged = QtCore.Signal(object)
-
- def __init__(self, points, width, pen=None, **args):
- QtGui.QGraphicsObject.__init__(self)
- self.pen = pen
- self.roiArgs = args
- if len(points) < 2:
- raise Exception("Must start with at least 2 points")
- self.lines = []
- self.lines.append(ROI([0, 0], [1, 5], parent=self, pen=pen, **args))
- self.lines[-1].addScaleHandle([0.5, 1], [0.5, 0.5])
- h = self.lines[-1].addScaleRotateHandle([0, 0.5], [1, 0.5])
- h.movePoint(points[0])
- h.movePoint(points[0])
- for i in range(1, len(points)):
- h = self.lines[-1].addScaleRotateHandle([1, 0.5], [0, 0.5])
- if i < len(points)-1:
- self.lines.append(ROI([0, 0], [1, 5], parent=self, pen=pen, **args))
- self.lines[-1].addScaleRotateHandle([0, 0.5], [1, 0.5], item=h)
- h.movePoint(points[i])
- h.movePoint(points[i])
-
- for l in self.lines:
- l.translatable = False
- #self.addToGroup(l)
- #l.connect(l, QtCore.SIGNAL('regionChanged'), self.roiChangedEvent)
- l.sigRegionChanged.connect(self.roiChangedEvent)
- #l.connect(l, QtCore.SIGNAL('regionChangeStarted'), self.roiChangeStartedEvent)
- l.sigRegionChangeStarted.connect(self.roiChangeStartedEvent)
- #l.connect(l, QtCore.SIGNAL('regionChangeFinished'), self.roiChangeFinishedEvent)
- l.sigRegionChangeFinished.connect(self.roiChangeFinishedEvent)
-
- def paint(self, *args):
- pass
-
- def boundingRect(self):
- return QtCore.QRectF()
-
- def roiChangedEvent(self):
- w = self.lines[0].state['size'][1]
- for l in self.lines[1:]:
- w0 = l.state['size'][1]
- l.scale([1.0, w/w0], center=[0.5,0.5])
- #self.emit(QtCore.SIGNAL('regionChanged'), self)
- self.sigRegionChanged.emit(self)
-
- def roiChangeStartedEvent(self):
- #self.emit(QtCore.SIGNAL('regionChangeStarted'), self)
- self.sigRegionChangeStarted.emit(self)
-
- def roiChangeFinishedEvent(self):
- #self.emit(QtCore.SIGNAL('regionChangeFinished'), self)
- self.sigRegionChangeFinished.emit(self)
-
-
- def getArrayRegion(self, arr, img=None):
- rgns = []
- for l in self.lines:
- rgn = l.getArrayRegion(arr, img)
- if rgn is None:
- continue
- #return None
- rgns.append(rgn)
- #print l.state['size']
- #print [(r.shape) for r in rgns]
- return np.vstack(rgns)
-
-
-class EllipseROI(ROI):
- def __init__(self, pos, size, **args):
- #QtGui.QGraphicsRectItem.__init__(self, 0, 0, size[0], size[1])
- ROI.__init__(self, pos, size, **args)
- self.addRotateHandle([1.0, 0.5], [0.5, 0.5])
- self.addScaleHandle([0.5*2.**-0.5 + 0.5, 0.5*2.**-0.5 + 0.5], [0.5, 0.5])
-
- def paint(self, p, opt, widget):
- r = self.boundingRect()
- p.setRenderHint(QtGui.QPainter.Antialiasing)
- p.setPen(self.pen)
-
- p.scale(r.width(), r.height())## workaround for GL bug
- r = QtCore.QRectF(r.x()/r.width(), r.y()/r.height(), 1,1)
-
- p.drawEllipse(r)
-
- def getArrayRegion(self, arr, img=None):
- arr = ROI.getArrayRegion(self, arr, img)
- if arr is None or arr.shape[0] == 0 or arr.shape[1] == 0:
- return None
- w = arr.shape[0]
- h = arr.shape[1]
- ## generate an ellipsoidal mask
- mask = np.fromfunction(lambda x,y: (((x+0.5)/(w/2.)-1)**2+ ((y+0.5)/(h/2.)-1)**2)**0.5 < 1, (w, h))
-
- return arr * mask
-
- def shape(self):
- self.path = QtGui.QPainterPath()
- self.path.addEllipse(self.boundingRect())
- return self.path
-
-
-class CircleROI(EllipseROI):
- def __init__(self, pos, size, **args):
- ROI.__init__(self, pos, size, **args)
- self.aspectLocked = True
- #self.addTranslateHandle([0.5, 0.5])
- self.addScaleHandle([0.5*2.**-0.5 + 0.5, 0.5*2.**-0.5 + 0.5], [0.5, 0.5])
-
-class PolygonROI(ROI):
- def __init__(self, positions, pos=None, **args):
- if pos is None:
- pos = [0,0]
- ROI.__init__(self, pos, [1,1], **args)
- #ROI.__init__(self, positions[0])
- for p in positions:
- self.addFreeHandle(p)
- self.setZValue(1000)
-
- def listPoints(self):
- return [p['item'].pos() for p in self.handles]
-
- def movePoint(self, *args, **kargs):
- ROI.movePoint(self, *args, **kargs)
- self.prepareGeometryChange()
- for h in self.handles:
- h['pos'] = h['item'].pos()
-
- def paint(self, p, *args):
- p.setRenderHint(QtGui.QPainter.Antialiasing)
- p.setPen(self.pen)
- for i in range(len(self.handles)):
- h1 = self.handles[i]['item'].pos()
- h2 = self.handles[i-1]['item'].pos()
- p.drawLine(h1, h2)
-
- def boundingRect(self):
- r = QtCore.QRectF()
- for h in self.handles:
- r |= self.mapFromItem(h['item'], h['item'].boundingRect()).boundingRect() ## |= gives the union of the two QRectFs
- return r
-
- def shape(self):
- p = QtGui.QPainterPath()
- p.moveTo(self.handles[0]['item'].pos())
- for i in range(len(self.handles)):
- p.lineTo(self.handles[i]['item'].pos())
- return p
-
- def stateCopy(self):
- sc = {}
- sc['pos'] = Point(self.state['pos'])
- sc['size'] = Point(self.state['size'])
- sc['angle'] = self.state['angle']
- #sc['handles'] = self.handles
- return sc
-
-
-class LineSegmentROI(ROI):
- def __init__(self, positions, pos=None, **args):
- if pos is None:
- pos = [0,0]
- ROI.__init__(self, pos, [1,1], **args)
- #ROI.__init__(self, positions[0])
- for p in positions:
- self.addFreeHandle(p)
- self.setZValue(1000)
-
- def listPoints(self):
- return [p['item'].pos() for p in self.handles]
-
- def movePoint(self, *args, **kargs):
- ROI.movePoint(self, *args, **kargs)
- self.prepareGeometryChange()
- for h in self.handles:
- h['pos'] = h['item'].pos()
-
- def paint(self, p, *args):
- p.setRenderHint(QtGui.QPainter.Antialiasing)
- p.setPen(self.pen)
- for i in range(len(self.handles)-1):
- h1 = self.handles[i]['item'].pos()
- h2 = self.handles[i-1]['item'].pos()
- p.drawLine(h1, h2)
-
- def boundingRect(self):
- r = QtCore.QRectF()
- for h in self.handles:
- r |= self.mapFromItem(h['item'], h['item'].boundingRect()).boundingRect() ## |= gives the union of the two QRectFs
- return r
-
- def shape(self):
- p = QtGui.QPainterPath()
- p.moveTo(self.handles[0]['item'].pos())
- for i in range(len(self.handles)):
- p.lineTo(self.handles[i]['item'].pos())
- return p
-
- def stateCopy(self):
- sc = {}
- sc['pos'] = Point(self.state['pos'])
- sc['size'] = Point(self.state['size'])
- sc['angle'] = self.state['angle']
- #sc['handles'] = self.handles
- return sc
-
-
-
-class SpiralROI(ROI):
- def __init__(self, pos=None, size=None, **args):
- if size == None:
- size = [100e-6,100e-6]
- if pos == None:
- pos = [0,0]
- ROI.__init__(self, pos, size, **args)
- self.translateSnap = False
- self.addFreeHandle([0.25,0], name='a')
- self.addRotateFreeHandle([1,0], [0,0], name='r')
- #self.getRadius()
- #QtCore.connect(self, QtCore.SIGNAL('regionChanged'), self.
-
-
- def getRadius(self):
- radius = Point(self.handles[1]['item'].pos()).length()
- #r2 = radius[1]
- #r3 = r2[0]
- return radius
-
- def boundingRect(self):
- r = self.getRadius()
- return QtCore.QRectF(-r*1.1, -r*1.1, 2.2*r, 2.2*r)
- #return self.bounds
-
- def movePoint(self, *args, **kargs):
- ROI.movePoint(self, *args, **kargs)
- self.prepareGeometryChange()
- for h in self.handles:
- h['pos'] = h['item'].pos()/self.state['size'][0]
-
- def handleChange(self):
- ROI.handleChange(self)
- if len(self.handles) > 1:
- self.path = QtGui.QPainterPath()
- h0 = Point(self.handles[0]['item'].pos()).length()
- a = h0/(2.0*np.pi)
- theta = 30.0*(2.0*np.pi)/360.0
- self.path.moveTo(QtCore.QPointF(a*theta*cos(theta), a*theta*sin(theta)))
- x0 = a*theta*cos(theta)
- y0 = a*theta*sin(theta)
- radius = self.getRadius()
- theta += 20.0*(2.0*np.pi)/360.0
- i = 0
- while Point(x0, y0).length() < radius and i < 1000:
- x1 = a*theta*cos(theta)
- y1 = a*theta*sin(theta)
- self.path.lineTo(QtCore.QPointF(x1,y1))
- theta += 20.0*(2.0*np.pi)/360.0
- x0 = x1
- y0 = y1
- i += 1
-
-
- return self.path
-
-
- def shape(self):
- p = QtGui.QPainterPath()
- p.addEllipse(self.boundingRect())
- return p
-
- def paint(self, p, *args):
- p.setRenderHint(QtGui.QPainter.Antialiasing)
- #path = self.shape()
- p.setPen(self.pen)
- p.drawPath(self.path)
- p.setPen(QtGui.QPen(QtGui.QColor(255,0,0)))
- p.drawPath(self.shape())
- p.setPen(QtGui.QPen(QtGui.QColor(0,0,255)))
- p.drawRect(self.boundingRect())
-
-
-
-
-
-
\ No newline at end of file