class TestWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle("Signal filtering 2 (guiqwt)")
self.setWindowIcon(get_icon('guiqwt.svg'))
hlayout = QHBoxLayout()
central_widget = QWidget(self)
central_widget.setLayout(hlayout)
self.setCentralWidget(central_widget)
#---guiqwt plot manager
self.manager = PlotManager(self)
#---
def add_plot(self, x, y, func, title):
widget = FilterTestWidget(self, x, y, func)
widget.setup_widget(title)
self.centralWidget().layout().addWidget(widget)
#---Register plot to manager
self.manager.add_plot(widget.plot)
#---
def setup_window(self):
#---Add toolbar and register manager tools
toolbar = self.addToolBar("tools")
self.manager.add_toolbar(toolbar, id(toolbar))
self.manager.register_all_curve_tools()
class CentralWidget(QWidget):
def __init__(self, parent):
QWidget.__init__(self, parent)
layout = QGridLayout()
self.setLayout(layout)
self.plot1 = ImagePlot(self)
layout.addWidget(self.plot1, 0, 0, 1, 1)
self.plot2 = ImagePlot(self)
layout.addWidget(self.plot2, 1, 0, 1, 1)
self.contrast = ContrastAdjustment(self)
layout.addWidget(self.contrast, 2, 0, 1, 2)
self.itemlist = PlotItemList(self)
layout.addWidget(self.itemlist, 0, 1, 2, 1)
self.manager = PlotManager(self)
for plot in (self.plot1, self.plot2):
self.manager.add_plot(plot)
for panel in (self.itemlist, self.contrast):
self.manager.add_panel(panel)
def register_tools(self):
self.manager.register_all_image_tools()
class iScope(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle("iScope (TM)")
hlayout = QHBoxLayout()
central_widget = QWidget(self)
central_widget.setLayout(hlayout)
self.setCentralWidget(central_widget)
# ---guiqwt plot manager
self.manager = PlotManager(self)
# ---
def add_plot(self, x, y):
widget = iScopeWidget(self, x, y)
widget.setup_widget()
self.centralWidget().layout().addWidget(widget)
# ---Register plot to manager
self.manager.add_plot(widget.plot)
# ---
def setup_window(self):
# ---Add toolbar and register manager tools
toolbar = self.addToolBar("tools")
self.manager.add_toolbar(toolbar, id(toolbar))
self.manager.register_standard_tools()
self.manager.tools[0].activate()
class CentralWidget(QWidget):
def __init__(self, parent):
QWidget.__init__(self, parent)
layout = QGridLayout()
self.setLayout(layout)
self.plot1 = ImagePlot(self)
layout.addWidget(self.plot1, 0, 0, 1, 1)
self.plot2 = ImagePlot(self)
layout.addWidget(self.plot2, 1, 0, 1, 1)
self.contrast = ContrastAdjustment(self)
layout.addWidget(self.contrast, 2, 0, 1, 2)
self.itemlist = PlotItemList(self)
layout.addWidget(self.itemlist, 0, 1, 2, 1)
self.manager = PlotManager(self)
for plot in (self.plot1, self.plot2):
self.manager.add_plot(plot)
for panel in (self.itemlist, self.contrast):
self.manager.add_panel(panel)
def register_tools(self):
self.manager.register_all_image_tools()
def configure_plot(self):
self.marker = add_marker(self.plot)
self.line = MeasurementLine()
self.line.setVisible(0)
self.label = make_label(self.marker, self.line)
setupCommonStyle(self.line, self.marker)
manager = PlotManager(self.widget)
manager.add_plot(self.plot)
tool = manager.add_tool(MzSelectionTool)
tool.activate()
manager.set_default_tool(tool)
self.plot.add_item(self.marker)
self.plot.add_item(self.label)
self.plot.add_item(self.line)
self.plot.startMeasuring.connect(self.line.start_measuring)
self.plot.moveMeasuring.connect(self.line.move_measuring)
self.plot.stopMeasuring.connect(self.line.stop_measuring)
self.plot.moveMarker.connect(self.marker.move_local_point_to)
self.line.updated.connect(self.plot.replot)
class TestWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle("Signal filtering 2 (guiqwt)")
self.setWindowIcon(get_icon('guiqwt.svg'))
hlayout = QHBoxLayout()
central_widget = QWidget(self)
central_widget.setLayout(hlayout)
self.setCentralWidget(central_widget)
#---guiqwt plot manager
self.manager = PlotManager(self)
#---
def add_plot(self, x, y, func, title):
widget = FilterTestWidget(self, x, y, func)
widget.setup_widget(title)
self.centralWidget().layout().addWidget(widget)
#---Register plot to manager
self.manager.add_plot(widget.plot)
#---
def setup_window(self):
#---Add toolbar and register manager tools
toolbar = self.addToolBar("tools")
self.manager.add_toolbar(toolbar, id(toolbar))
self.manager.register_all_curve_tools()
class GuiqwtScreen(QWidget):
"""
Hum hum hum
"""
def __init__(self, parent=None, x=[], y=[], data=[]):
QWidget.__init__(self, parent)
if len(x) < 2:
x = np.linspace(0, 1392, 1392)
y = np.linspace(0, 1040, 1040)
data = np.zeros((1040, 1392))
self.x = x
self.y = y
self.data = data
sx = 600
sy = int(sx / 1.338)
stretch_x = 3
stretch_y = 3
#self.setGeometry(QRect(0,0,sx,sy))
layout = QGridLayout(self)
layout.setMargin(0)
self.screen = ImageScreen(self, x, y, data)
self.cutX = CutScreen(self)
self.cutY = CutScreen(self)
layout.addWidget(self.screen, 1, 0)
layout.addWidget(self.cutX, 0, 0)
layout.addWidget(self.cutY, 1, 1)
layout.setColumnStretch(0, stretch_x)
layout.setColumnStretch(1, 1)
layout.setRowStretch(0, 1)
layout.setRowStretch(1, stretch_y)
self.setLayout(layout)
self.updateGeometry()
self.manager = PlotManager(self)
self.manager.add_plot(self.screen.plot)
self.manager.add_plot(self.cutX.plot)
self.manager.add_plot(self.cutY.plot)
#roi = ROISelectTool
#bkgnd = BKGNDSelectTool
self.tools = [tools.SelectTool, tools.RectZoomTool, tools.ColormapTool]
self.manager.register_all_curve_tools()
class GuiqwtScreen(QWidget):
"""
Hum hum hum
"""
def __init__(self, parent=None, x=[], y=[], data=[]):
QWidget.__init__(self, parent)
if len(x) < 2:
x = np.linspace(0, 1392, 1392)
y = np.linspace(0, 1040, 1040)
data = np.zeros((1040, 1392))
self.x = x
self.y = y
self.data = data
layout = QGridLayout(self)
'''
self.screen = ImageScreen(self,x,y,data,int(self.sizex*5.0/6.0),int(self.sizey*5.0/6.0))
self.cutX = CutScreen(self,sizex=int(self.sizex*5.0/6.0),sizey=int(self.sizey*1.0/6.0))
self.cutY = CutScreen(self,sizex=int(self.sizex*1.0/6.0),sizey=int(self.sizey*5.0/6.0))
'''
sx = 500
sy = int(sx / 1.338)
a = 0.2
self.screen = ImageScreen(self, x, y, data, sizex=sx, sizey=sy)
self.cutX = CutScreen(self, sizex=sx, sizey=int(a * sy))
self.cutY = CutScreen(self, sizex=int(a * sx), sizey=sy)
layout.addWidget(self.screen, 1, 0)
layout.addWidget(self.cutX, 0, 0)
layout.addWidget(self.cutY, 1, 1)
self.setLayout(layout)
self.updateGeometry()
self.manager = PlotManager(self)
self.manager.add_plot(self.screen.plot)
self.manager.add_plot(self.cutX.plot)
self.manager.add_plot(self.cutY.plot)
roi = RegionSelectTool
self.tools = [
tools.SelectTool, tools.RectZoomTool, roi, tools.ColormapTool
]
self.manager.register_all_curve_tools()
def configure_plot(self):
set_x_axis_scale_draw(self.widget)
manager = PlotManager(self.widget)
manager.add_plot(self.plot)
tool = manager.add_tool(RtSelectionTool)
tool.activate()
manager.set_default_tool(tool)
self.marker = add_marker(self.plot)
setupStyleRtMarker(self.marker)
self.marker.rts = (0, )
self.plot.moveMarker.connect(self.marker.move_local_point_to)
self.plot.moveMarker.connect(self.move_rt_cursor)
def Plot_Start_New(widget,PLOT_DEFINE,COLORS,x1,x2,y1,y2):
newmanager = PlotManager(widget)
newplots = []
newcurves = {}
for name in PLOT_DEFINE:
plot = CurvePlot()
#设置图表颜色
plot.setStyleSheet('''QWidget{
border: 1px solid #32435E;
border-radius: 3px;
font-size:11pt;
color:white;
font-family:"Microsoft YaHei UI";
/* padding: 0 8px; */
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #080B10,
stop: 1.0 #212C3F);
selection-background-color: #0A246A;
} '''
)
plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(20)
newplots.append(plot)
newmanager.add_plot(plot)
plot.plot_id = id(plot)
for curve_color, curve_name in map(None,COLORS,name):
if u"状态" in curve_name or u"打角/100" in curve_name :
newcurves[curve_name] = guiqwt_make.curve([0], [0],markerfacecolor = 'black', markeredgecolor=curve_color, title=curve_name,marker = 'Diamond',linestyle = 'NoPen',markersize = 6)
else:
newcurves[curve_name] = guiqwt_make.curve([0], [0], color=curve_color, title=curve_name)
plot.add_item(newcurves[curve_name])
#设置X轴y轴
plot.set_axis_limits(newcurves[curve_name].yAxis(),y1,y2)
plot.set_axis_limits(newcurves[curve_name].xAxis(),x1,x2)
plot.add_item(guiqwt_make.legend("BL"))
newmanager.register_standard_tools()
newmanager.get_default_tool().activate()
return (newmanager,newplots,newcurves)
class TestDialog(QDialog):
def __init__(self):
QDialog.__init__(self)
vlayout = QVBoxLayout()
self.setLayout(vlayout)
self.widget = CurveWidget()
self.curve_item = make.curve([], [], color='r')
self.widget.plot.add_item(self.curve_item)
self.pm = PlotManager(self.widget)
self.pm.add_plot(self.widget.plot)
t = self.pm.add_tool(MyTool)
t.curve_item = self.curve_item
self.pm.set_default_tool(t)
t.activate()
self.layout().addWidget(self.widget)
self.update_curve()
def update_curve(self):
x = np.arange(0,10,.1)
y = np.sin(np.sin(x))
self.curve_item.set_data(x, y)
self.curve_item.plot().replot()
class EicPlottingWidget(CurveWidget):
SELECTED_RANGE_CHANGED = pyqtSignal(float, float)
def __init__(self, parent=None, with_range=True):
super(EicPlottingWidget, self).__init__(parent, ylabel="I")
patch_inner_plot_object(self, EicPlot)
self._with_range = with_range
self._setup_plot()
def enable_range(self, flag):
self._with_range = flag
self._setup_range_selector()
def _setup_plot(self):
self.pm = PlotManager(self)
self.pm.add_plot(self.plot)
t = self.pm.add_tool(RtSelectionTool)
t.activate()
self.pm.set_default_tool(t)
self._setup_cursor()
self._setup_range_selector()
self._setup_label()
self._setup_axes()
def _setup_cursor(self):
marker = Marker(label_cb=self.plot.label_info,
constraint_cb=self.plot.on_plot)
marker.rts = [0]
setup_marker_param(
marker, {
"symbol.size": 0,
"symbol.alpha": 0.0,
"sel_symbol.size": 0,
"sel_symbol.alpha": 0.0,
"line.color": "#909090",
"line.width": 1.0,
"line.style": "SolidLine",
"sel_line.color": "#909090",
"sel_line.width": 1.0,
"sel_line.style": "SolidLine",
"markerstyle": "VLine"
})
marker.attach(self.plot)
self.marker = marker
self._setup_cursor_info(marker)
def _setup_cursor_info(self, marker):
self.cursor_info = RtCursorInfo(marker)
def _setup_range_selector(self):
if not self._with_range:
self.range_ = None
return
self.range_ = SnappingRangeSelection(0, 0)
# you have to register item to plot before you can register the
# rtSelectionHandler:
self.plot.add_item(self.range_)
self.range_.SELECTED_RANGE_CHANGED.connect(
self._range_selection_handler)
cc = make.info_label("TR", [RangeSelectionInfo(self.range_)],
title=None)
setup_label_param(cc, {"label": "", "font.size": 12})
self.plot.add_item(cc)
def _setup_label(self):
label = make.info_label("T", [self.cursor_info], title=None)
setup_label_param(label, {
"label": "",
"font.size": 12,
"border.color": "#ffffff"
})
self.label = label
def _setup_axes(self):
# render tic labels in modfied format:
set_rt_formatting_on_x_axis(self.plot)
self.plot.set_axis_title("bottom", "RT")
def plot_(self, eics):
self.add_eics(eics)
def set_cursor_pos(self, rt):
self.plot.set_rt(rt)
def set_overall_range(self, rtmin, rtmax):
self.plot.overall_x_min = rtmin
self.plot.overall_x_max = rtmax
def add_eics(self, data, labels=None, configs=None):
""" do not forget to call replot() after calling this function ! """
allrts = list()
if configs is None:
configs = [{"color": getColor(i)} for i in range(len(data))]
if labels is None:
labels = [""] * len(data)
unique_labels = set()
# items_with_label = []
seen = set()
for i, (rts, chromatogram) in enumerate(data):
# we do not plot duplicates, which might happen if multiple lines in the
# table explorer are sellected !
if (id(rts), id(chromatogram)) in seen:
continue
seen.add((id(rts), id(chromatogram)))
config = configs[i]
label = "<pre>%s</pre>" % labels[i]
unique_labels.add(label)
curve = make_unselectable_curve(rts,
chromatogram,
title=label,
**config)
allrts.extend(rts)
self.plot.add_item(curve)
self.plot.add_item(self.label)
self.plot.set_x_values(sorted(set(allrts)))
# no idea why guiqwt needs double registration here:
self.marker.attach(self.plot)
self.plot.add_item(self.marker)
# self._add_legend(unique_labels, items_with_label)
if self.range_ is not None:
self.plot.add_item(self.range_)
def _add_legend(self, unique_labels, items_with_label):
# überbleibsel von zeitreihen plott
unique_labels -= set((None, ))
unique_labels -= set(("", ))
if unique_labels:
legend = make.legend("TL", restrict_items=items_with_label)
setup_label_param(legend, {"font.size": 12})
self.plot.add_item(legend)
def add_eic_filled(self, rts, iis, baseline, color):
shape = create_closed_shape(rts, iis, baseline, color)
if shape is not None:
self.plot.add_item(shape)
def set_visible(self, visible):
self.plot.setVisible(visible)
def get_range_selection_limits(self):
if self.range_ is None:
return None, None
return sorted((self.range_._min, self.range_._max))
def set_range_selection_limits(self, xleft, xright):
if self.range_ is None:
return
self.range_.move_point_to(0, (xleft, 0))
self.range_.move_point_to(1, (xright, 0))
def reset_intensity_limits(self,
imin=None,
imax=None,
fac=1.1,
rtmin=None,
rtmax=None):
self.plot.reset_y_limits(imin, imax, fac, rtmin, rtmax)
@protect_signal_handler
def _range_selection_handler(self, left, right):
min_, max_ = sorted((left, right))
self.SELECTED_RANGE_CHANGED.emit(min_, max_)
def set_rt_axis_limits(self, xmin, xmax):
self.plot.update_plot_xlimits(xmin, xmax)
def get_limits(self):
return self.plot.get_plot_limits()
def updateAxes(self):
self.plot.updateAxes()
def set_intensity_axis_limits(self, ymin, ymax):
self.plot.update_plot_ylimits(ymin, ymax)
def reset_rt_limits(self, rt_min=None, rt_max=None, fac=1.1):
self.plot.reset_x_limits(rt_min, rt_max, fac)
def reset_intensitiy_limits(self,
i_min=None,
i_max=None,
fac=1.1,
rt_min=None,
rt_max=None):
self.plot.reset_y_limits(i_min, i_max, fac, rt_min, rt_max)
def set_limit(self, ix, value):
self.plot.set_limit(ix, value)
def getLimits(self):
return self.plot.get_plot_limits()
def replot(self):
self.plot.replot()
def del_all_items(self):
self.plot.del_all_items()
def reset(self):
"""empties plot"""
self.del_all_items()
self.replot()
def shrink_and_replot(self, rtmin, rtmax):
self.reset_rt_limits(rtmin, rtmax)
self.plot.reset_y_limits()
self.plot.replot()
class SyncXAxis(QtGui.QWidget):
def __init__(self):
super(SyncXAxis, self).__init__()
self.data = {u"t":array("d")}
for name in sum(PLOT_DEFINE, []):
self.data[name] = array("d")
self.i = 0
self.x = []
self.curves = {}
self.t = 0
self.sint = []
self.get_Roll = []
self.get_Pitch = []
self.get_Yaw = []
self.get_Angle1 = []
self.get_Angle2 =[]
self.get_Angle3 = []
vbox = QtGui.QGridLayout()
#工具栏
vbox.addLayout(self.setup_toolbar(),0,0)
self.manager = PlotManager(self)
self.plots = []
#生成竖直排列图形窗口
for i, define in enumerate(PLOT_DEFINE):
plot = CurvePlot()
plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(60)
self.manager.add_plot(plot)
self.plots.append(plot)
plot.plot_id = id(plot)
for j, curve_name in enumerate(define):
curve = self.curves[curve_name] = make.curve([0], [0], color=COLORS[j], title=curve_name)
plot.add_item(curve)
plot.add_item(make.legend("BL"))
#vbox.addWidget(plot)
vbox.addWidget(self.plots[0],1,0)
vbox.addWidget(self.plots[1],1,1)
vbox.addWidget(self.plots[2],2,0)
vbox.addWidget(self.plots[3],2,1)
self.manager.register_standard_tools()
self.manager.get_default_tool().activate()
self.manager.synchronize_axis(CurvePlot.X_BOTTOM, self.manager.plots.keys())
self.setLayout(vbox)
self.startTimer(20)
def setup_toolbar(self):
toolbar = QtGui.QGridLayout()
self.auto_xrange_checkbox = QtGui.QCheckBox(u"X轴自动调节")
self.xrange_box = QtGui.QSpinBox()
self.xrange_box.setMinimum(5)
self.xrange_box.setMaximum(100)
self.xrange_box.setValue(50)
self.auto_xrange_checkbox.setChecked(True)
self.Roll_label = QtGui.QLabel("PID KP:")
self.lineEdit1 = QtGui.QLineEdit()
self.lineEdit1.setText("1")
self.lineEdit1.returnPressed.connect(self.PID_Roll)
self.Roll_label.setBuddy(self.lineEdit1)
self.Pitch_label = QtGui.QLabel("PID KI:")
self.lineEdit2 = QtGui.QLineEdit()
self.Pitch_label.setBuddy(self.lineEdit2)
self.lineEdit2.setText("1")
self.lineEdit2.returnPressed.connect(self.PID_Pitch)
self.Yaw_label = QtGui.QLabel("PID KD:")
self.lineEdit3 = QtGui.QLineEdit()
self.Yaw_label.setBuddy(self.lineEdit3)
self.lineEdit3.setText("1")
self.lineEdit3.returnPressed.connect(self.PID_Yaw)
toolbar.addWidget(self.auto_xrange_checkbox,0,0)
toolbar.addWidget(self.xrange_box,0,1)
toolbar.addWidget(self.Roll_label,1,0)
toolbar.addWidget(self.lineEdit1,1,1)
toolbar.addWidget(self.Pitch_label,2,0)
toolbar.addWidget(self.lineEdit2,2,1)
toolbar.addWidget(self.Yaw_label,3,0)
toolbar.addWidget(self.lineEdit3,3,1)
return toolbar
def PID_Roll(self):
global RPY_Array
try:
#print str(int(self.lineEdit1.text()))
RPY_Array[0] = int(self.lineEdit1.text())
except:
pass
def PID_Pitch(self):
global RPY_Array
try:
#print str(self.lineEdit1.text())
RPY_Array[1] = int(self.lineEdit2.text())
except:
pass
def PID_Yaw(self):
global RPY_Array
try:
#print str(self.lineEdit1.text())
RPY_Array[2] = int(self.lineEdit3.text())
except:
pass
def timerEvent(self, event):
global RPY_Array,Roll,Pitch,Yaw,Angle1,Angle2,Angle3
global xSlider,ySlider,zSlider
self.x.append(self.t)
self.t += DT
self.sint.append(np.sin(self.t))
self.get_Roll.append(Roll)
self.get_Pitch.append(Pitch)
self.get_Yaw.append(Yaw)
self.get_Angle1.append(Angle1)
self.get_Angle2.append(Angle2)
self.get_Angle3.append(Angle3)
xSlider.setValue(Angle1 * 16)#初始值
ySlider.setValue(Angle3 * 16)
zSlider.setValue(Angle2 * 16)
#x轴的移动
if self.auto_xrange_checkbox.isChecked():
xmax = self.x[-1]
xmin = self.xrange_box.value()
if len(self.x) > xmin:
self.x = self.x[-xmin:-1]
self.get_Roll = self.get_Roll[-xmin:-1]
self.get_Pitch = self.get_Pitch[-xmin:-1]
self.get_Yaw = self.get_Yaw[-xmin:-1]
self.get_Angle1 = self.get_Angle1[-xmin:-1]
self.get_Angle2 = self.get_Angle2[-xmin:-1]
self.get_Angle3 = self.get_Angle3[-xmin:-1]
else :
pass
self.y_array = [[],[],[],[],[],[]]
#3 最后一个
#0 三
#2 二
self.y_array[2] = self.get_Roll
self.y_array[0] = self.get_Pitch
self.y_array[3] = self.get_Yaw
self.y_array[1] = self.get_Angle1
self.y_array[4] = self.get_Angle2
self.y_array[5] = self.get_Angle3
#print "\n",
#print Roll,Pitch,Yaw,Angle1,Angle2,Angle3
#发送PID参数
global RPY_Array
#serial_send(str("%04d" %RPY_Array[0]) + str("%04d" %RPY_Array[1]) + str("%04d" %RPY_Array[2]) + "111111")
#更新数据 刷新图像
self.i = 0
for key, curve in self.curves.iteritems():
#self.sint = self.sint + 1
#self.sint = [x + 0.1 for x in self.sint]
#print type(self.x),type(self.t)
try:
curve.set_data(self.x,self.y_array[self.i])
except:
pass
#print self.i
#print key
self.i += 1
for plot in self.plots:
if self.auto_xrange_checkbox.isChecked():
plot.do_autoscale()
elif self.auto_xrange_checkbox.isChecked():
plot.set_axis_limits("bottom", xmin, xmax)
plot.replot()
else:
plot.replot()
class Ui_PlotWidget_Feature_Set(QtGui.QWidget):
""""""
def __init__(self, parent=None):
"""Constructor for Ui_PlotWidget"""
QtGui.QWidget.__init__(self, parent)
self.setupUi()
def setupUi(self):
"""loads numpy array
Args:
self
Returns:
nothing
"""
# self.plot = CurvePlot(self)
self.dialog = CurveDialog(edit=False, toolbar=True, parent=self)
self.plot = self.dialog.get_plot()
self.plot.set_antialiasing(True)
# x = np.linspace(-10,10,200)
# dy = x/100.
# y = np.sin(np.sin(np.sin(x)))
# self.plot.add_item(make.curve(x,y))
self.loadButton = QtGui.QPushButton("Load")
self.trainButton = QtGui.QPushButton("Train Model")
ly = QtGui.QVBoxLayout()
ly.addWidget(self.plot)
# ly.addWidget(self.loadButton)
# ly.addWidget(self.trainButton)
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, "Time")
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, "Value")
self.manager = PlotManager(self)
self.manager.add_plot(self.plot)
# self.manager.
legend = make.legend("TL")
self.plot.add_item(legend)
self.setLayout(ly)
self.move(300, 200)
self.show()
self.dataController = DataController.DataController()
def loadData(self):
self.trainingData = self.dataController.loadSampleData()
import logic.dimreduce.paa as PAA
p = PAA.paa()
data = p.process(self.trainingData["PIR"][:], 100)
r = np.array(range(len(data))).reshape(len(data), 1)
s = np.array(data).reshape(len(data), 1)
rs = np.hstack((s, s))
print rs
import logic.featurex.kmeans as km
k = km.kmeans()
labels = k.process(rs, 2)
print labels
self.plot.add_item(make.curve(range(0, len(data)), data))
from guiqwt.styles import AnnotationParam
i = 0
i_beg = 0
i_end = 0
while i < len(labels):
cur = labels[i_end]
if i < len(labels) - 1:
if labels[i_end + 1] != cur:
i_end = i
from guiqwt.annotations import AnnotatedRectangle
param = AnnotationParam()
param.title = str(labels[int(i_beg)])
param.show_computations = False
anno = AnnotatedRectangle(r[int(i_beg)], 0.5, r[int(i_end)], 0.2, param) # TODO: y axis scaling
self.plot.add_item(anno)
i_beg = i_end
print "s1"
else:
i_end = i
print "s2"
print "s3"
print "s4", i_end, len(labels)
i += 1
# param = AnnotationParam()
# param.title = "alright"
# param.show_computations = False
##anno = AnnotatedRectangle(0., 1., 1.5, 0.5, param)
# anno.set_style("plot", "shape/drag")
# anno.set_style("shape/drag/fill/color", "white")
# self.plot.add_item(anno)
# self.rangeSelection = make.range(-2, 2)
# disp0 = make.range_info_label(self.rangeSelection, 'BR', u"x = %.1f +- %.1f cm",
# title="Range infos")
# self.plot.add_item(self.rangeSelection)
# self.plot.add_item(disp0)
self.plot.replot()
def trainData(self, string_length, vocab, window_length, clusterN):
a, b = self.rangeSelection.get_range()
if a > b:
a, b = b, a
print a, b
print "in widget", int(string_length), int(vocab), int(window_length), int(clusterN)
self.dataController.trainData(a, b, int(string_length), int(vocab), int(window_length), int(clusterN))
class Window(QMainWindow):
def __init__(self, wintitle):
super(Window, self).__init__()
self.default_tool = None
self.plots = []
self.itemlist = PlotItemList(None)
self.contrast = ContrastAdjustment(None)
self.xcsw = XCrossSection(None)
self.ycsw = YCrossSection(None)
self.manager = PlotManager(self)
self.toolbar = QToolBar(_("Tools"), self)
self.manager.add_toolbar(self.toolbar, "default")
self.toolbar.setMovable(True)
self.toolbar.setFloatable(True)
self.addToolBar(Qt.TopToolBarArea, self.toolbar)
frame = QFrame(self)
self.setCentralWidget(frame)
self.layout = QGridLayout()
layout = QVBoxLayout(frame)
frame.setLayout(layout)
layout.addLayout(self.layout)
self.frame = frame
self.setWindowTitle(wintitle)
self.setWindowIcon(get_icon('guiqwt.svg'))
def closeEvent(self, event):
global _figures, _current_fig, _current_axes
figure_title = to_text_string(self.windowTitle())
if _figures.pop(figure_title) == _current_fig:
_current_fig = None
_current_axes = None
self.itemlist.close()
self.contrast.close()
self.xcsw.close()
self.ycsw.close()
event.accept()
def add_plot(self, i, j, plot):
self.layout.addWidget(plot, i, j)
self.manager.add_plot(plot)
self.plots.append(plot)
def replot(self):
for plot in self.plots:
plot.replot()
item = plot.get_default_item()
if item is not None:
plot.set_active_item(item)
item.unselect()
def add_panels(self, images=False):
self.manager.add_panel(self.itemlist)
if images:
for panel in (self.ycsw, self.xcsw, self.contrast):
panel.hide()
self.manager.add_panel(panel)
def register_tools(self, images=False):
if images:
self.manager.register_all_image_tools()
else:
self.manager.register_all_curve_tools()
def display(self):
self.show()
self.replot()
self.manager.get_default_tool().activate()
self.manager.update_tools_status()
class MzPlottingWidget(CurveWidget):
def __init__(self, parent=None):
super(MzPlottingWidget, self).__init__(parent, xlabel="mz", ylabel="I")
patch_inner_plot_object(self, MzPlot)
self.plot.centralMz = None
def label(self, x):
# label with full precision:
return QwtText(str(x))
a = QwtScaleDraw()
a.label = new.instancemethod(label, self.plot, QwtScaleDraw)
self.plot.setAxisScaleDraw(self.plot.xBottom, a)
self.pm = PlotManager(self)
self.pm.add_plot(self.plot)
self.curve = make_unselectable_curve([], [], color="b", curvestyle="Sticks")
self.plot.add_item(self.curve)
t = self.pm.add_tool(MzSelectionTool)
self.pm.set_default_tool(t)
t.activate()
marker = Marker(label_cb=self.plot.label_info, constraint_cb=self.plot.on_plot)
marker.attach(self.plot)
line = make_measurement_line()
line.setVisible(0)
setupCommonStyle(line, marker)
line.shapeparam.line.color = "#555555"
line.shapeparam.update_shape(line)
label = make.info_label("TR", [MzCursorInfo(marker, line)], title=None)
label.labelparam.label = ""
label.labelparam.font.size = 12
label.labelparam.update_label(label)
self.marker = marker
self.label = label
self.line = line
def plot_spectra(self, all_peaks, labels):
self.plot.del_all_items()
self.plot.add_item(self.marker)
self.plot.add_item(make.legend("TL"))
self.plot.add_item(self.label)
for i, (peaks, label) in enumerate(zip(all_peaks, labels)):
config = dict(color=getColor(i))
curve = make_unselectable_curve([], [], title=label, curvestyle="Sticks", **config)
curve.set_data(peaks[:, 0], peaks[:, 1])
self.plot.add_item(curve)
self.plot.resample_config = []
self.plot.add_item(self.line)
if len(all_peaks):
self.plot.all_peaks = np.vstack(all_peaks)
else:
self.plot.all_peaks = np.zeros((0, 2))
def _setup_configs_and_titles(self, configs, titles, n):
configs = configs if configs is not None else [None] * n
titles = titles if titles is not None else [""] * n
def default(i):
return dict(color=getColor(i))
configs = [ci if ci is not None else default(i) for (i, ci) in enumerate(configs)]
return configs, titles
def set_overall_range(self, mzmin, mzmax):
self.plot.overall_x_min = mzmin
self.plot.overall_x_max = mzmax
def plot_peakmaps(self, peakmap_ranges, configs=None, titles=None):
has_titles = titles is not None
configs, titles = self._setup_configs_and_titles(configs, titles, len(peakmap_ranges))
self.plot.del_all_items()
self.plot.add_item(self.marker)
if has_titles:
self.plot.add_item(make.legend("TL"))
self.plot.add_item(self.label)
self.plot.plot_peakmap_ranges(peakmap_ranges, configs, titles)
self.plot.add_item(self.line)
def set_cursor_pos(self, mz):
self.plot.set_mz(mz)
def resetAxes(self):
self.plot.reset_x_limits()
def reset_mz_limits(self, xmin=None, xmax=None, fac=1.1):
self.plot.reset_x_limits(xmin, xmax, fac)
def reset(self):
self.plot.del_all_items()
self.replot()
def replot(self):
self.plot.replot()
def set_visible(self, visible):
self.plot.setVisible(visible)
def updateAxes(self):
self.plot.updateAxes()
def shrink_and_replot(self, mzmin, mzmax):
self.reset_mz_limits(mzmin, mzmax)
self.plot.reset_y_limits()
self.plot.replot()
class RtPlotter(PlotterBase):
def __init__(self, parent=None, rangeSelectionCallback=None):
PlotterBase.__init__(self, "RT", "I")
self.rangeSelectionCallback = rangeSelectionCallback
widget = self.widget
widget.plot.__class__ = RtPlot
self.pm = PlotManager(widget)
self.pm.add_plot(widget.plot)
t = self.pm.add_tool(RtSelectionTool)
t.activate()
self.pm.set_default_tool(t)
marker = Marker(label_cb=self.widget.plot.label_info,
constraint_cb=self.widget.plot.on_plot)
marker.rts = [0]
setupStyleRtMarker(marker)
marker.attach(self.widget.plot)
self.marker = marker
self.cursor_info = RtCursorInfo(marker)
label = make.info_label("T", [self.cursor_info], title=None)
label.labelparam.label = ""
label.labelparam.font.size = 12
label.labelparam.border.color = "#ffffff"
label.labelparam.update_label(label)
self.label = label
self.minRTRangeSelected = None
self.maxRTRangeSelected = None
def _set_rt_x_axis_labels(self):
# todo: refactor as helper
a = QwtScaleDraw()
# render tic labels in modfied format:
label = lambda self, v: QwtText(formatSeconds(v))
a.label = new.instancemethod(label, self.widget.plot, QwtScaleDraw)
self.widget.plot.setAxisScaleDraw(self.widget.plot.xBottom, a)
def _set_ts_x_axis_labels(self, data):
# todo: refactor as helper
all_ts = [tsi for ts in data for tsi in ts.x]
pos = find_datetime_split_pos(all_ts)
a = QwtScaleDraw()
# render tic labels in modfied format:
label = lambda self, v, pos=pos: QwtText(format_datetime_value(pos, v)) # QwtText(str(v))
a.label = new.instancemethod(label, self.widget.plot, QwtScaleDraw)
self.widget.plot.setAxisScaleDraw(self.widget.plot.xBottom, a)
def reset(self):
"""empties plot"""
self.plot([])
self.marker.rts = [0]
self.replot()
def plot(self, data, is_time_series=False, titles=None, configs=None,
withmarker=False):
""" do not forget to call replot() after calling this function ! """
allrts = []
self.widget.plot.del_all_items()
if is_time_series:
self._set_ts_x_axis_labels(data)
self.widget.plot.set_axis_title("bottom", "time")
else:
self._set_rt_x_axis_labels()
self.widget.plot.set_axis_title("bottom", "RT")
labels = set()
legend_items = []
if is_time_series:
seen = set()
for i, ts in enumerate(data):
# we do not plot duplicates, which might happen if multiple lines in the
# table explorer are sellected !
if id(ts) in seen:
continue
seen.add(id(ts))
config = None
if configs is not None:
config = configs[i]
if config is None:
config = dict(color=getColor(i))
title = ts.label
labels.add(title)
for j, (x, y) in enumerate(ts.for_plotting()):
x = [xi.toordinal() if isinstance(xi, datetime) else xi for xi in x]
allrts.extend(x)
curve = make.curve(x, y, title="<pre>%s</pre>" % title, **config)
curve.__class__ = ModifiedCurveItem
self.widget.plot.add_item(curve)
self.cursor_info.is_time_series = True
if j == 0:
legend_items.append(curve)
else:
seen = set()
for i, (rts, chromatogram) in enumerate(data):
# we do not plot duplicates, which might happen if multiple lines in the
# table explorer are sellected !
if (id(rts), id(chromatogram)) in seen:
continue
seen.add((id(rts), id(chromatogram)))
config = None
if configs is not None:
config = configs[i]
if config is None:
config = dict(color=getColor(i))
if titles:
title = "<pre>%s</pre>" % titles[i]
else:
title = ""
labels.add(title)
curve = make.curve(rts, chromatogram, title=title, **config)
curve.__class__ = ModifiedCurveItem
allrts.extend(rts)
self.widget.plot.add_item(curve)
self.cursor_info.is_time_series = False
if withmarker:
self.widget.plot.add_item(self.label)
allrts = sorted(set(allrts))
self.marker.rts = allrts
self.marker.attach(self.widget.plot)
self.widget.plot.add_item(self.marker)
labels -= set((None,))
labels -= set(("",))
if labels:
legend = make.legend("TL", restrict_items=legend_items)
legend.labelparam.font.size = 12
legend.labelparam.update_label(legend)
self.widget.plot.add_item(legend)
if not is_time_series:
self._add_range_selector(allrts)
def setEnabled(self, enabled):
self.widget.plot.setVisible(enabled)
def _add_range_selector(self, rtvalues):
self.rtvalues = rtvalues
self.minRTRangeSelected = 0
self.maxRTRangeSelected = 0
range_ = SnappingRangeSelection(self.minRTRangeSelected,
self.maxRTRangeSelected, self.rtvalues)
setupStyleRangeMarker(range_)
self.range_ = range_
# you have to register item to plot before you can register the
# rtSelectionHandler:
self.widget.plot.add_item(range_)
range_.SIG_RANGE_CHANGED.connect(self._range_selection_handler)
#self.widget.disconnect(range_.plot(), SIG_RANGE_CHANGED,
#self._range_selection_handler)
#self.widget.connect(range_.plot(), SIG_RANGE_CHANGED,
#self._range_selection_handler)
cc = make.info_label("TR", [RtRangeSelectionInfo(range_)], title=None)
cc.labelparam.label = ""
cc.labelparam.font.size = 12
cc.labelparam.update_label(cc)
self.widget.plot.add_item(cc)
def getRangeSelectionLimits(self):
return sorted((self.range_._min, self.range_._max))
def setRangeSelectionLimits(self, xleft, xright):
saved = self.rangeSelectionCallback
self.rangeSelectionCallback = None
self.minRTRangeSelected = xleft
self.maxRTRangeSelected = xright
# left and right bar of range marker
self.range_.move_point_to(0, (xleft, 0))
self.range_.move_point_to(1, (xright, 0))
self.rangeSelectionCallback = saved
@protect_signal_handler
def _range_selection_handler(self, obj, left, right):
min_, max_ = sorted((left, right))
self.minRTRangeSelected = min_
self.maxRTRangeSelected = max_
if self.rangeSelectionCallback is not None:
self.rangeSelectionCallback()
reset_rt_limits = PlotterBase.reset_x_limits
reset_intensity_limits = PlotterBase.reset_y_limits
class RealtimeDemo(QWidget):
def __init__(self):
super(RealtimeDemo, self).__init__()
self.setWindowTitle(u"Realtime Demo")
self.data = {u"t":array("d")}
for name in sum(PLOT_DEFINE, []):
self.data[name] = array("d")
self.curves = {}
self.t = 0
vbox = QVBoxLayout()
vbox.addWidget(self.setup_toolbar())
self.manager = PlotManager(self)
self.plots = []
for i, define in enumerate(PLOT_DEFINE):
plot = CurvePlot()
plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(60)
self.manager.add_plot(plot)
self.plots.append(plot)
plot.plot_id = id(plot)
for j, curve_name in enumerate(define):
curve = self.curves[curve_name] = make.curve([0], [0], color=COLORS[j], title=curve_name)
plot.add_item(curve)
plot.add_item(make.legend("BL"))
vbox.addWidget(plot)
self.manager.register_standard_tools()
self.manager.get_default_tool().activate()
self.manager.synchronize_axis(CurvePlot.X_BOTTOM, self.manager.plots.keys())
self.setLayout(vbox)
self.startTimer(100)
def setup_toolbar(self):
toolbar = QToolBar()
self.auto_yrange_checkbox = QCheckBox(u"Y轴自动调节")
self.auto_xrange_checkbox = QCheckBox(u"X轴自动调节")
self.xrange_box = QSpinBox()
self.xrange_box.setMinimum(1)
self.xrange_box.setMaximum(50)
self.xrange_box.setValue(1)
self.auto_xrange_checkbox.setChecked(True)
self.auto_yrange_checkbox.setChecked(True)
toolbar.addWidget(self.auto_yrange_checkbox)
toolbar.addWidget(self.auto_xrange_checkbox)
toolbar.addWidget(self.xrange_box)
return toolbar
def timerEvent(self, event):
global bin_ori
# writecache = []
drawcache = []
MAXRANGE = 65535
AMPL = 6
for i in range(n_channel):
# writecache.append([])
drawcache.append([])
for i in range(collecttime):
n = ser.inWaiting()
# print(n)
ori = ser.read(n)
bin_ori += str(binascii.b2a_hex(ori))[2:-1]
ffff_list = bin_ori.split('fffffffe')
bin_ori = ffff_list[-1]
wrong_no = 0
# print(len(ffff_list))
for i in range(1, len(ffff_list)):
if len(ffff_list[i]) != 4 * n_channel:
# print(i)
# print('receive wrong')
wrong_no += 1
# print(ffff_list[i])
continue
for j in range(n_channel):
temp = int(ffff_list[i][4 * j:4 * (j + 1)], 16)
drawcache[j].append((temp))# - MAXRANGE / 2) / (MAXRANGE / 2) * AMPL)
# writecache[j].append(str(temp))
# print(wrong_no)
# print(wrong_no / len(ffff_list))
for i in xrange(len(drawcache[0])):
t = self.t
self.data[u"t"].append(t)
# for j in xrange(n_channel):
# self.data[u"signal_"+str(j)].append(drawcache[j][i])
# self.data[u"signal_0"].append(drawcache[0][i])
self.data[u"signal_1"].append(drawcache[1][i])
# self.data[u"signal_2"].append(drawcache[2][i])
# self.data[u"signal_3"].append(drawcache[3][i])
self.data[u"signal_4"].append(drawcache[4][i])
# self.data[u"signal_5"].append(drawcache[5][i])
# self.data[u"signal_6"].append(drawcache[6][i])
self.data[u"signal_7"].append(drawcache[7][i])
# self.data[u"signal_8"].append(drawcache[8][i])
# self.data[u"signal_9"].append(drawcache[9][i])
self.t += DT
# for i in xrange(100):
# t = self.t
# self.data[u"t"].append(t)
# self.data[u"sin1f"].append(sin(t))
# self.data[u"cos1f"].append(cos(t))
# self.data[u"sin3f"].append(sin(3*t)/6)
# self.data[u"cos3f"].append(cos(3*t)/6)
# self.data[u"sin合成"].append(sin(t)+sin(3*t)/6)
# self.data[u"cos合成"].append(cos(t)+cos(3*t)/6)
# self.t += DT
if self.auto_xrange_checkbox.isChecked():
xmax = self.data["t"][-1]
xmin = max(xmax - self.xrange_box.value(), 0)
else:
xmin, xmax = self.plots[0].get_axis_limits('bottom')
for key, curve in self.curves.iteritems():
xdata = self.data["t"]
ydata = self.data[key]
x, y = get_peak_data(xdata, ydata, xmin, xmax, 600, 1/DT)
curve.set_data(x, y)
for plot in self.plots:
if self.auto_yrange_checkbox.isChecked() and self.auto_xrange_checkbox.isChecked():
plot.do_autoscale()
elif self.auto_xrange_checkbox.isChecked():
plot.set_axis_limits("bottom", xmin, xmax)
plot.replot()
else:
plot.replot()
class RtPlotter(PlotterBase):
def __init__(self, rangeSelectionCallback = None):
super(RtPlotter, self).__init__("RT", "I")
self.rangeSelectionCallback = rangeSelectionCallback
widget = self.widget
widget.plot.__class__ = RtPlot
# todo: refactor as helper
a = QwtScaleDraw()
# render tic labels in modfied format:
label = lambda self, v: QwtText(formatSeconds(v))
a.label = new.instancemethod(label, widget.plot, QwtScaleDraw)
widget.plot.setAxisScaleDraw(widget.plot.xBottom, a)
#a.label = new.instancemethod(label, widget.plot, QwtScaleDraw)
self.pm = PlotManager(widget)
self.pm.add_plot(widget.plot)
t = self.pm.add_tool(RtSelectionTool)
self.addTool(RtSelectionTool)
self.pm.set_default_tool(t)
marker = Marker(label_cb=self.widget.plot.label_info,\
constraint_cb=self.widget.plot.on_plot)
marker.rts = [0]
setupStyleRtMarker(marker)
marker.attach(self.widget.plot)
self.marker = marker
label = make.info_label("T", [RtCursorInfo(marker)], title=None)
label.labelparam.label = ""
self.label=label
self.minRTRangeSelected = None
self.maxRTRangeSelected = None
def addTool(self, tool):
t = self.pm.add_tool(tool)
t.activate()
def reset(self):
self.plot([])
self.marker.rts = [0]
self.replot()
def plot(self, chromatograms, titles=None, configs=None,\
withmarker=False):
""" do not forget to call replot() after calling this function ! """
allrts = set()
self.widget.plot.del_all_items()
#self.widget.plot.set_antialiasing(True)
for i in range(len(chromatograms)):
rts, chromatogram = chromatograms[i]
config = None
if configs is not None:
config = configs[i]
if config is None:
config = dict(color = getColor(i))
if titles:
title = titles[i]
else:
title = ""
curve = make.curve(rts, chromatogram, title=title, **config)
curve.__class__ = ModifiedCurveItem
allrts.update(rts)
self.widget.plot.add_item(curve)
if withmarker:
self.widget.plot.add_item(self.label)
allrts = sorted(allrts)
self.marker.rts = allrts
self.marker.attach(self.widget.plot)
self.widget.plot.add_item(self.marker)
if titles is not None:
self.widget.plot.add_item(make.legend("TL"))
self.addRangeSelector(allrts)
def setEnabled(self, enabled):
self.widget.plot.setVisible(enabled)
def addRangeSelector(self, rtvalues):
self.rtvalues = rtvalues
self.minRTRangeSelected = 0
self.maxRTRangeSelected = 0
range_ = SnappingRangeSelection(self.minRTRangeSelected,\
self.maxRTRangeSelected, self.rtvalues)
setupStyleRangeMarker(range_)
self.range_ = range_
# you have to register item to plot before you can register the
# rtSelectionHandler:
self.widget.plot.add_item(range_)
self.widget.disconnect(range_.plot(), SIG_RANGE_CHANGED,\
self.rangeSelectionHandler)
self.widget.connect(range_.plot(), SIG_RANGE_CHANGED,\
self.rangeSelectionHandler)
cc = make.info_label("TR", [RtRangeSelectionInfo(range_)], title=None)
cc.labelparam.label = ""
self.widget.plot.add_item(cc)
def getRangeSelectionLimits(self):
return sorted( (self.range_._min, self.range_._max) )
def setRangeSelectionLimits(self, xleft, xright):
saved = self.rangeSelectionCallback
self.rangeSelectionCallback = None
self.minRTRangeSelected = xleft
self.maxRTRangeSelected = xright
# left and right bar of range marker
self.range_.move_point_to(0, (xleft,0), emitsignal=False)
self.range_.move_point_to(1, (xright,0))
# calls self.rangeSelectionHandler !
self.rangeSelectionCallback = saved
@protect_signal_handler
def rangeSelectionHandler(self, obj, left, right):
min_, max_ = sorted((left, right))
self.minRTRangeSelected = min_
self.maxRTRangeSelected = max_
if self.rangeSelectionCallback is not None:
self.rangeSelectionCallback()
class ContrastAdjustment(PanelWidget):
"""Contrast adjustment tool"""
__implements__ = (IPanel,)
PANEL_ID = ID_CONTRAST
PANEL_TITLE = _("Contrast adjustment tool")
PANEL_ICON = "contrast.png"
def __init__(self, parent=None):
super(ContrastAdjustment, self).__init__(parent)
self.local_manager = None # local manager for the histogram plot
self.manager = None # manager for the associated image plot
# Storing min/max markers for each active image
self.min_markers = {}
self.max_markers = {}
# Select point tools
self.min_select_tool = None
self.max_select_tool = None
style = "<span style=\'color: #444444\'><b>%s</b></span>"
layout, _label = get_image_layout(self.PANEL_ICON,
style % self.PANEL_TITLE,
alignment=Qt.AlignCenter)
layout.setAlignment(Qt.AlignCenter)
vlayout = QVBoxLayout()
vlayout.addLayout(layout)
self.local_manager = PlotManager(self)
self.histogram = LevelsHistogram(parent)
vlayout.addWidget(self.histogram)
self.local_manager.add_plot(self.histogram)
hlayout = QHBoxLayout()
self.setLayout(hlayout)
hlayout.addLayout(vlayout)
self.toolbar = toolbar = QToolBar(self)
toolbar.setOrientation(Qt.Vertical)
# toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
hlayout.addWidget(toolbar)
# Add standard plot-related tools to the local manager
lman = self.local_manager
lman.add_tool(SelectTool)
lman.add_tool(BasePlotMenuTool, "item")
lman.add_tool(BasePlotMenuTool, "axes")
lman.add_tool(BasePlotMenuTool, "grid")
lman.add_tool(AntiAliasingTool)
lman.get_default_tool().activate()
self.outliers_param = EliminateOutliersParam(self.PANEL_TITLE)
def register_panel(self, manager):
"""Register panel to plot manager"""
self.manager = manager
default_toolbar = self.manager.get_default_toolbar()
self.manager.add_toolbar(self.toolbar, "contrast")
self.manager.set_default_toolbar(default_toolbar)
self.setup_actions()
for plot in manager.get_plots():
self.histogram.connect_plot(plot)
def configure_panel(self):
"""Configure panel"""
self.min_select_tool = self.manager.add_tool(SelectPointTool,
title=_("Minimum level"),
on_active_item=True, mode="create",
tip=_("Select minimum level on image"),
toolbar_id="contrast",
end_callback=self.apply_min_selection)
self.max_select_tool = self.manager.add_tool(SelectPointTool,
title=_("Maximum level"),
on_active_item=True, mode="create",
tip=_("Select maximum level on image"),
toolbar_id="contrast",
end_callback=self.apply_max_selection)
def get_plot(self):
return self.manager.get_active_plot()
def closeEvent(self, event):
self.hide()
event.ignore()
def setup_actions(self):
fullrange_ac = create_action(self, _("Full range"),
icon=get_icon("full_range.png"),
triggered=self.histogram.set_full_range,
tip=_("Scale the image's display range "
"according to data range") )
autorange_ac = create_action(self, _("Eliminate outliers"),
icon=get_icon("eliminate_outliers.png"),
triggered=self.eliminate_outliers,
tip=_("Eliminate levels histogram "
"outliers and scale the image's "
"display range accordingly") )
add_actions(self.toolbar, [fullrange_ac, autorange_ac])
def eliminate_outliers(self):
def apply(param):
self.histogram.eliminate_outliers(param.percent)
if self.outliers_param.edit(self, apply=apply):
apply(self.outliers_param)
def apply_min_selection(self, tool):
item = self.get_plot().get_last_active_item(IVoiImageItemType)
point = self.min_select_tool.get_coordinates()
z = item.get_data(*point)
self.histogram.set_min(z)
def apply_max_selection(self, tool):
item = self.get_plot().get_last_active_item(IVoiImageItemType)
point = self.max_select_tool.get_coordinates()
z = item.get_data(*point)
self.histogram.set_max(z)
def set_range(self, _min, _max):
"""Set contrast panel's histogram range"""
self.histogram.set_range(_min, _max)
# Update the levels histogram in case active item data has changed:
self.histogram.selection_changed(self.get_plot())
class MzPlotter(PlotterBase):
def __init__(self, c_callback=None):
super(MzPlotter, self).__init__("m/z", "I")
self.c_callback = c_callback
widget = self.widget
# inject mofified behaviour of wigets plot attribute:
widget.plot.__class__ = MzPlot
widget.plot.register_c_callback(self.handle_c_pressed)
self.setHalfWindowWidth(0.05)
self.centralMz = None
# todo: refactor as helper
a = QwtScaleDraw()
label = lambda self, x : QwtText("%s" % x)
a.label = new.instancemethod(label, widget.plot, QwtScaleDraw)
widget.plot.setAxisScaleDraw(widget.plot.xBottom, a)
self.pm = PlotManager(widget)
self.pm.add_plot(widget.plot)
self.curve = make.curve([], [], color='b', curvestyle="Sticks")
# inject modified behaviour:
self.curve.__class__ = ModifiedCurveItem
self.widget.plot.add_item(self.curve)
t = self.pm.add_tool(MzSelectionTool)
self.pm.set_default_tool(t)
t.activate()
marker = Marker(label_cb=widget.plot.label_info,\
constraint_cb=widget.plot.on_plot)
marker.attach(self.widget.plot)
line = make.segment(0, 0, 0, 0)
line.__class__ = ModifiedSegment
line.setVisible(0)
setupCommonStyle(line, marker)
label = make.info_label("TR", [MzCursorInfo(marker, line)], title=None)
label.labelparam.label = ""
self.marker = marker
self.label = label
self.line = line
def setHalfWindowWidth(self, w2):
self.widget.plot.set_half_window_width(w2)
def setCentralMz(self, mz):
self.widget.plot.set_central_mz(mz)
def handle_c_pressed(self, p):
if self.c_callback:
self.c_callback(p)
def plot(self, spectra, configs=None, titles=None):
""" do not forget to call replot() after calling this function ! """
self.widget.plot.del_all_items()
self.widget.plot.add_item(self.marker)
if titles is not None:
self.widget.plot.add_item(make.legend("TL"))
self.widget.plot.add_item(self.label)
allpeaks = []
for i in range(len(spectra)):
peaks = spectra[i]
allpeaks.append(peaks)
config = configs[i] if configs is not None else None
if config is None:
config = dict(color = getColor(i))
if titles is not None:
title = titles[i]
else:
title = u""
curve = make.curve([], [], title=title,\
curvestyle="Sticks", **config)
curve.set_data(peaks[:, 0], peaks[:, 1])
curve.__class__ = ModifiedCurveItem
self.widget.plot.add_item(curve)
self.widget.plot.add_item(self.line)
if len(allpeaks):
self.widget.plot.all_peaks = np.vstack(allpeaks)
else:
self.widget.plot.all_peaks = np.zeros((0,2))
def resetAxes(self):
self.widget.plot.reset_x_limits()
def reset(self):
self.plot(np.ndarray((0,2)))
self.replot()
class MainWindow(qg.QMainWindow):
"""This one generates the main window and orchestrates all other widgets
"""
def __init__(self):
qg.QMainWindow.__init__(self)
self.setWindowTitle("Neuron Database")
self.setWindowIcon(get_icon('guiqwt.png'))
self.setAttribute(qc.Qt.WA_DeleteOnClose,True)
hlayout = qg.QHBoxLayout()
central_widget = qg.QWidget(self)
central_widget.setLayout(hlayout)
self.setCentralWidget(central_widget)
#---guiqwt plot manager
self.manager = PlotManager(self)
#---
self.add_plot("1")
self._constructFileMenu()
self._constructEditMenu()
self._constructConsoleWidget(central_widget)
def _constructFileMenu(self):
"""
"""
file_menu = self.menuBar().addMenu("File")
quit_action = create_action(self, "Quit",
shortcut="Ctrl+Q",
icon=get_std_icon("DialogCloseButton"),
tip="Quit application",
triggered=self.close)
openDB_action = create_action(self, "Open database",
shortcut ="Ctrl+D",
tip ="Open an existing database into scroll area",
triggered=self.open_Database)
createDB_action = create_action(self,"New database",
shortcut ="Ctrl+N",
tip ="Create a new database",
triggered=self.create_Database)
closeDB_action = create_action(self,"Close database",
shortcut ="Ctrl+W",
tip = "Close an open database",
triggered=self.close_Database)
add_actions(file_menu, (quit_action, openDB_action, createDB_action,
closeDB_action))
def _constructEditMenu(self):
"""
"""
edit_menu = self.menuBar().addMenu("Edit")
editparam1_action = create_action(self, "Import dataset",
shortcut ="Ctrl+A",
tip ="Import data from matlab structure",
triggered=self.add_newData)
deleteNode_action = create_action(self, "Delete neuron",
tip ="Delete neuron from database",
triggered=self.delete_Neuron)
add_actions(edit_menu, (editparam1_action, deleteNode_action))
def _constructConsoleWidget(self, central_widget):
"""
"""
font = qg.QFont("Courier new")
font.setPointSize(12)
ns = {'win': self, 'widget': central_widget}
msg = "Try for example: widget.set_text('foobar') or win.close()"
# Note: by default, the internal shell is multithreaded which is safer
# but not compatible with graphical user interface creation.
# For example, if you need to plot data with Matplotlib, you will need
# to pass the option: multithreaded=False
self.console = cons = InternalShell(self, namespace=ns, message=msg)
# Setup the console widget
cons.set_font(font)
cons.set_codecompletion_auto(True)
cons.set_calltips(True)
cons.setup_calltips(size=600, font=font)
cons.setup_completion(size=(300, 100), font=font)
console_dock = qg.QDockWidget("Console", self)
console_dock.setWidget(cons)
# Add the console widget to window as a dockwidget
self.addDockWidget(qc.Qt.BottomDockWidgetArea, console_dock)
def add_plot(self, title):
"""
"""
self.widget = PlotWidget(self)
self.widget.setup_widget(title)
self.centralWidget().layout().addWidget(self.widget)
#---Register plot to manager
self.manager.add_plot(self.widget.plot)
def setup_window(self):
"""Add toolbar and register manager tools
"""
toolbar = self.addToolBar("tools")
self.manager.add_toolbar(toolbar, id(toolbar))
self.manager.register_all_curve_tools()
def closeEvent(self, event):
"""
"""
self.console.exit_interpreter()
event.accept()
def findOpenDBases(self):
"""
"""
return self.widget.databaseScroll.DataBasesOpen
### popup actions:
def add_newData(self):
"""
"""
DBname = Popup(self.findOpenDBases(),
textMessage = "add data to a database:",
style = 4)
if DBname.selection != None and DBname.selection != []:
name = DBname.selection[1]
neuronName = DBname.selection[2]
if self.widget.databaseScroll.isOpen(name):
addData = Dbase(DBaseName = name)
if not addData.Data.Exists(neuronName):
addData.AddData(neuronName, Directory = DBname.selection[0])
self.widget.databaseScroll.refreshTree()
print 'data import complete.'
else :
print ' '
print 'database already has Neuron named {0}'.format(neuronName)
else:
print 'database not open.'
def open_Database(self):
"""
"""
DBname = Popup(self.findOpenDBases(),
textMessage = "select database to open",
style = 3)
if DBname.selection != None and len(DBname.selection) > 1:
print DBname.selection
loadedDBname = DBname.selection
self.widget.databaseScroll.AppendDatabasesOpen(loadedDBname)
self.widget.databaseScroll.OpenDatabases(loadedDBname)
#self.widget.databaseScroll.refreshTree()
#print '{0} database opened.'.format(loadedDBname)
else:
pass
def create_Database(self):
"""
"""
DBname = Popup(self.findOpenDBases(),
textMessage = "enter name of new database",
style = 2)
if DBname.selection != None :
newDBname = DBname.selection
if newDBname[-3:] != '.h5':
newDBname = newDBname + '.h5'
self.widget.databaseScroll.AppendDatabasesOpen(newDBname)
self.widget.databaseScroll.refreshTree()
#print '{0} database created.'.format(newDBname)
else:
pass
def delete_Neuron(self):
"""
"""
DBname = Popup(self.findOpenDBases(),
textMessage = "enter name of neuron to delete",
style = 1)
if DBname.selection != None :
try:
name = DBname.selection[0]
if self.widget.databaseScroll.isOpen(name):
rmData = Dbase(DBaseName = name)
neuron = DBname.selection[1]
rmData.Data.RemoveNeuron(neuron, option = 1)
rmData.Data.CloseDatabase()
self.widget.databaseScroll.refreshTree()
print 'successfully deleted', neuron
else:
print 'database not open.'
except (ValueError, TypeError):
print 'sorry, could not delete. please make sure data exists.'
else:
pass
def close_Database(self):
"""
"""
DBname = Popup(self.findOpenDBases(),
textMessage = "select database to close",
style = 0)
if DBname.selection != None :
self.widget.databaseScroll.CloseDatabase(DBname.selection)
self.widget.databaseScroll.refreshTree()
print '{0} closed.'.format(DBname.selection)
else:
pass
class Ui_Form(object):
def __init__(self, type):
self.dc = DataController()
self.fec = FeatureExtractionControl()
self.flowData = self.dc.dimrecprocData
pos = self.fec.getAvailableAlgorithms().keys().index(type)
self.fec.selectAlgorithm(pos)
def setupUi(self, Form):
Form.setObjectName(_fromUtf8("Form"))
Form.resize(536, 384)
self.Form=Form
self.tableWidget = QtGui.QTableWidget(Form)
self.tableWidget.setGeometry(QtCore.QRect(90, 261, 221, 121))
self.tableWidget.setObjectName(_fromUtf8("tableWidget"))
self.tableWidget.setColumnCount(2)
self.tableWidget.setRowCount(len(self.fec.getRequiredParameters()))
item = QtGui.QTableWidgetItem()
self.tableWidget.setVerticalHeaderItem(0, item)
item = QtGui.QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(0, item)
item = QtGui.QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(1, item)
item = QtGui.QTableWidgetItem()
self.tableWidget.setItem(0, 0, item)
item = QtGui.QTableWidgetItem()
self.tableWidget.setItem(0, 1, item)
self.pushButton = QtGui.QPushButton(Form)
self.pushButton.setGeometry(QtCore.QRect(0, 300, 75, 23))
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.widget = QtGui.QWidget(Form)
self.widget.setGeometry(QtCore.QRect(10, 10, 521, 211))
self.widget.setObjectName(_fromUtf8("widget"))
self.pushButton_3 = QtGui.QPushButton(Form)
self.pushButton_3.setGeometry(QtCore.QRect(0, 360, 75, 23))
self.pushButton_3.setObjectName(_fromUtf8("pushButton_3"))
self.dialog = CurveDialog(edit=False, toolbar=False, parent=self.widget)
self.plot = self.dialog.get_plot()
self.plot.set_antialiasing(True)
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time')
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value')
self.manager = PlotManager(self)
self.manager.add_plot(self.plot)
legend = make.legend('TL')
self.plot.add_item(legend)
ly = QtGui.QVBoxLayout()
ly.addWidget(self.plot)
self.widget.setLayout(ly)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setHorizontalHeaderItem(0, item)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setItem(0, 0, item)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setItem(0, 1, item)
# item = self.tableWidget.horizontalHeaderItem(0)
# item.setText(_translate("Form", "Attribute", None))
c = 0
for it in self.fec.getRequiredParameters():
# item = QtGui.QTableWidgetItem()
# item.setText(_translate("Form", "Id" + str(c), None))
# self.tableWidget.setVerticalHeaderItem(c, item)
item = QtGui.QTableWidgetItem()
item.setText(it)
self.tableWidget.setItem(c, 0, item)
print it, self.fec.getRequiredParameters()[it]
item = QtGui.QTableWidgetItem()
item.setText(str(self.fec.getRequiredParameters()[it]))
self.tableWidget.setItem(c, 1, item)
print c
c += 1
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
Form.setWindowTitle(_translate("Form", "Form", None))
__sortingEnabled = self.tableWidget.isSortingEnabled()
self.tableWidget.setSortingEnabled(False)
self.tableWidget.setSortingEnabled(__sortingEnabled)
self.pushButton.setText(_translate("Form", "Process", None))
Form.connect(self.pushButton, QtCore.SIGNAL('clicked()'), self.process)
self.pushButton_3.setText(_translate("Form", "Save", None))
Form.connect(self.pushButton_3, QtCore.SIGNAL('clicked()'),self.saveDialog)
def process(self):
params = {}
for i in range(self.tableWidget.rowCount()):
a = self.tableWidget.item(i, 0)
b = self.tableWidget.item(i, 1)
params[str(a.text())] = int(b.text())
print "params", params
outpN = self.tableWidget.item(0, 0)
#params = {"none": "none", "output_length": outpN}
r = np.array(range(len(self.dc.dimrecprocData))).reshape(len(self.dc.dimrecprocData), 1)
s = np.array(self.dc.dimrecprocData).reshape(len(self.dc.dimrecprocData), 1)
rs = np.hstack((s, s))
labels = self.fec.extractFeature(rs, params)
print labels
self.plot.del_all_items()
self.plot.replot()
self.plot.add_item(
make.curve(range(0, len(self.dc.dimrecprocData)), self.dc.dimrecprocData))
from guiqwt.styles import AnnotationParam
i = 0
i_beg = 0
i_end = 0
while i < len(labels):
cur = labels[i_end]
if i < len(labels) - 1:
if labels[i_end + 1] != cur:
i_end = i
from guiqwt.annotations import AnnotatedRectangle
param = AnnotationParam()
param.title = str(labels[int(i_beg)])
param.show_computations = False
anno = AnnotatedRectangle(r[int(i_beg)], self.dc.dimrecprocData[int(i_beg)], int(i_end), self.dc.dimrecprocData[r[int(i_end)]], param) #TODO: y axis scaling
self.plot.add_item(anno)
i_beg = i_end
print "s1"
else:
i_end = i
print "s2"
print "s3"
print "s4", i_end, len(labels)
i += 1
self.rangeSelection = make.range(-2, 2)
disp0 = make.range_info_label(self.rangeSelection, 'BR', u"x = %.1f +- %.1f cm",
title="Range infos")
#self.plot.add_item(self.rangeSelection)
#self.plot.add_item(disp0)
#self.dc.setCurrentDataFlowObject(self.flowData)
self.dc.featureexData = self.flowData
self.dc.setCurrentLabels(labels)
print(self.dc.setCurrentLabels)
#ToDo: Check that following line, make property in data controller
self.dc.dimrecprocData = rs
self.plot.replot()
self.currentdata = np.reshape(labels, (-1, 1))
def saveDialog(self):
path = QtGui.QFileDialog.getSaveFileName(self.Form, 'Save File', '', 'CSV(*.csv)')
if not path.isEmpty():
with open(unicode(path), 'wb') as stream:
writer = csv.writer(stream)
[a,b]=self.currentdata.shape
print(a)
print(b)
for row in range(a):
rowdata = []
for column in range(b):
item = self.currentdata.item(row, column)
if item is not None:
rowdata.append(item)
else:
rowdata.append('')
writer.writerow(rowdata)
class RealtimeDemo(QWidget):
def __init__(self):
super(RealtimeDemo, self).__init__()
self.setWindowTitle(u"Realtime Demo")
self.data = {u"t": array("d")}
for name in sum(PLOT_DEFINE, []):
self.data[name] = array("d")
self.curves = {}
self.t = 0
vbox = QVBoxLayout()
vbox.addWidget(self.setup_toolbar())
self.manager = PlotManager(self)
self.plots = []
for i, define in enumerate(PLOT_DEFINE):
plot = CurvePlot()
plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(60)
self.manager.add_plot(plot)
self.plots.append(plot)
plot.plot_id = id(plot)
for j, curve_name in enumerate(define):
curve = self.curves[curve_name] = make.curve([0], [0], color=COLORS[j], title=curve_name)
plot.add_item(curve)
plot.add_item(make.legend("BL"))
vbox.addWidget(plot)
self.manager.register_standard_tools()
self.manager.get_default_tool().activate()
self.manager.synchronize_axis(CurvePlot.X_BOTTOM, self.manager.plots.keys())
self.setLayout(vbox)
self.startTimer(100)
def setup_toolbar(self):
toolbar = QToolBar()
self.auto_yrange_checkbox = QCheckBox(u"Y轴自动调节")
self.auto_xrange_checkbox = QCheckBox(u"X轴自动调节")
self.xrange_box = QSpinBox()
self.xrange_box.setMinimum(5)
self.xrange_box.setMaximum(50)
self.xrange_box.setValue(10)
self.auto_xrange_checkbox.setChecked(True)
self.auto_yrange_checkbox.setChecked(True)
toolbar.addWidget(self.auto_yrange_checkbox)
toolbar.addWidget(self.auto_xrange_checkbox)
toolbar.addWidget(self.xrange_box)
return toolbar
def timerEvent(self, event):
for i in xrange(100):
t = self.t
self.data[u"t"].append(t)
self.data[u"sin1f"].append(sin(t))
self.data[u"cos1f"].append(cos(t))
self.data[u"sin3f"].append(sin(3*t)/6)
self.data[u"cos3f"].append(cos(3*t)/6)
self.data[u"sin合成"].append(sin(t)+sin(3*t)/6)
self.data[u"cos合成"].append(cos(t)+cos(3*t)/6)
self.t += DT
if self.auto_xrange_checkbox.isChecked():
xmax = self.data["t"][-1]
xmin = max(xmax - self.xrange_box.value(), 0)
else:
xmin, xmax = self.plots[0].get_axis_limits('bottom')
for key, curve in self.curves.iteritems():
xdata = self.data["t"]
ydata = self.data[key]
x, y = get_peak_data(xdata, ydata, xmin, xmax, 600, 1/DT)
curve.set_data(x, y)
for plot in self.plots:
if self.auto_yrange_checkbox.isChecked() and self.auto_xrange_checkbox.isChecked():
plot.do_autoscale()
elif self.auto_xrange_checkbox.isChecked():
plot.set_axis_limits("bottom", xmin, xmax)
plot.replot()
else:
plot.replot()
class PlottingHelper(object):
'''This is the class implementing the plotting work.'''
def __init__(self, parent, signal_names, sample_rate):
'''Do the initialization work.
A PlottingHelper object helps plotting a group of signals all of which
has the same number of points to plot at one time.
signal_names:
a dictionary {'list_name':['list of signal names']}
sample_rate:
the sample_rate of the signals
'''
self.sample_rate = sample_rate
self.signal_names = signal_names
self.curve_items = {}
self.curve_plots = {}
self.plot_manager = PlotManager(parent)
for list_name, sig_name_list in self.signal_names.items():
# One CurvePlot object for every sig_name_list
curve_plot = CurvePlot()
curve_plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(10)
self.curve_plots[list_name] = curve_plot
curve_plot.plot_id = id(curve_plot)
for i, sig_name in enumerate(sig_name_list):
# One CurveItem object for every signal_name
print sig_name, colors[i]
self.curve_items[sig_name] = make.curve([0], [0], \
color=colors[i], title=sig_name)
curve_plot.add_item(self.curve_items[sig_name])
# add the curve_plot object to plot_manager
self.plot_manager.add_plot(curve_plot)
# register and activate the tools
self.plot_manager.register_standard_tools()
self.plot_manager.get_default_tool().activate()
self.plot_manager.synchronize_axis(CurvePlot.X_BOTTOM, \
self.plot_manager.plots.keys())
def update_curves(self, time, signals, interval_in_second):
'''update the curves everytime the signals change
time:
the time sequence, which is also the x_axis data
signal:
a dictionary of signals to plot, the keys of which is recorded
in self.signal_names.
and in fact these are the y_axis data
'''
xmax = time[-1]
xmin = max(xmax - interval_in_second, 0)
xdata = time
for list_name, sig_name_list in self.signal_names.items():
#
for i, sig_name in enumerate(sig_name_list):
#
ydata = signals[sig_name]
idxmn = int(xmin*self.sample_rate)
idxmx = int(xmax*self.sample_rate)
self.curve_items[sig_name].set_data(xdata[idxmn:idxmx], \
ydata[idxmn:idxmx])
self.curve_plots[list_name].do_autoscale()
class Ui_Form(object):
def setupUi(self, Form):
Form.setObjectName(_fromUtf8("Form"))
Form.resize(750, 453)
self.Form = Form
self.pushButton = QtGui.QPushButton(Form)
self.pushButton.setGeometry(QtCore.QRect(30, 0, 75, 23))
self.pushButton.setObjectName(_fromUtf8("pushButton"))
'''self.checkBox = QtGui.QCheckBox(Form)
self.checkBox.setGeometry(QtCore.QRect(20, 70, 70, 17))
self.checkBox.setObjectName(_fromUtf8("checkBox"))
self.checkBox_2 = QtGui.QCheckBox(Form)
self.checkBox_2.setGeometry(QtCore.QRect(100, 70, 70, 17))
self.checkBox_2.setObjectName(_fromUtf8("checkBox_2"))
self.checkBox_3 = QtGui.QCheckBox(Form)
self.checkBox_3.setGeometry(QtCore.QRect(180, 70, 70, 17))
self.checkBox_3.setObjectName(_fromUtf8("checkBox_3"))'''
self.widget = QtGui.QWidget(Form)
self.widget.setGeometry(QtCore.QRect(10, 110, 581, 251))
self.widget.setObjectName(_fromUtf8("widget"))
self.startD = QtGui.QLineEdit(Form)
self.startD.setGeometry(QtCore.QRect(120, 0, 81, 20))
self.startD.setObjectName(_fromUtf8("startD"))
self.endD = QtGui.QLineEdit(Form)
self.endD.setGeometry(QtCore.QRect(240, 0, 71, 20))
self.endD.setObjectName(_fromUtf8("endD"))
self.label = QtGui.QLabel(Form)
self.label.setGeometry(QtCore.QRect(290, 20, 46, 13))
self.label.setObjectName(_fromUtf8("label"))
self.label_2 = QtGui.QLabel(Form)
self.label_2.setGeometry(QtCore.QRect(170, 20, 46, 13))
self.label_2.setObjectName(_fromUtf8("label_2"))
self.Hint = QtGui.QLabel(Form)
self.Hint.setGeometry(QtCore.QRect(330, 10, 281, 16))
self.Hint.setObjectName(_fromUtf8("Hint"))
self.pushButton_2 = QtGui.QPushButton(Form)
self.pushButton_2.setGeometry(QtCore.QRect(30, 30, 75, 23))
self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))
self.pushButton.clicked.connect(self.loadDialog)
self.pushButton_2.clicked.connect(self.saveDialog)
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
Form.setWindowTitle(_translate("Form", "Form", None))
self.pushButton.setText(_translate("Form", "Load Data", None))
self.label.setText(_translate("Form", "End", None))
self.label_2.setText(_translate("Form", "Begin", None))
self.Hint.setText(_translate("Form", "Enter before loading. To load whole dataset, leave blank", None))
self.pushButton_2.setText(_translate("Form", "Save", None))
def loadDialog(self):
filename = QtGui.QFileDialog.getOpenFileName(self.Form, 'Open File', '.')
fname = open(filename)
data = fname.read()
#self.le.setText(filename)
do = pandas.read_csv(str(filename), delimiter=",")
#data = pd.read_csv('C:/Users/se00075/PycharmProjects/Test2/src' + '/' + 'data.csv')
if (self.startD.text().isEmpty()) & (self.endD.text().isEmpty()):
d=do
else:
do['time_stamp'] = do['time_stamp'].astype('datetime64[ns]')
st = int(self.startD.text())
en = int(self.endD.text())
select = (do['time_stamp'] >= do.time_stamp[0]+datetime.timedelta(days=st-1)) & (do['time_stamp'] < do.time_stamp[0]+datetime.timedelta(days=en))
d = do[select]
#d = pandas.read_csv(str(filename), delimiter=",")
#print d
##Lets add clean missing data here
space = 0
self.checkboxes = []
for i in d.columns:
c = QtGui.QCheckBox(self.Form)
#print space
c.setGeometry(QtCore.QRect(10 + space, 50, 70, 17))
c.setText(_fromUtf8(i))
c.show()
c.clicked.connect(self.selected)
self.checkboxes.append(c)
space += 68
self.original_data = d
#self.original_data=(self.original_data-self.original_data.mean()) / self.original_data.std()
self.dialog = CurveDialog(edit=False, toolbar=False, parent=self.widget)
self.plot = self.dialog.get_plot()
self.plot.set_antialiasing(True)
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time')
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value')
self.manager = PlotManager(self)
self.manager.add_plot(self.plot)
legend = make.legend('TL')
self.plot.add_item(legend)
ly = QtGui.QVBoxLayout()
ly.addWidget(self.plot)
self.widget.setLayout(ly)
self.widget.show()
self.Form.update()
self.Form.repaint()
def selected(self, state):
dc = logic.DataFlowControl.DataController()
from itertools import cycle
colors = cycle(["r", "g", "b", "y"])
self.plot.del_all_items()
selItems = []
for c in self.checkboxes:
c.isChecked()
c.text()
if c.isChecked():
selItems.append(str(c.text()))
self.selected_data = np.array(self.original_data[selItems])
print "fileLoader self.selected_data.shape", self.selected_data.shape
x = range(self.selected_data.shape[0])
for g in selItems:
k = make.curve(x, np.array(self.original_data[g]), color=colors.next())
self.plot.add_item(k)
print "fileLoader current data flow object",self.selected_data
#dc.setCurrentDataFlowObject(self.selected_data)
dc.originalData = self.selected_data
self.Form.repaint()
self.Form.repaint()
self.plot.update()
def saveDialog(self):
path = QtGui.QFileDialog.getSaveFileName(self.Form, 'Save File', '', 'CSV(*.csv)')
if not path.isEmpty():
with open(unicode(path), 'wb') as stream:
writer = csv.writer(stream)
[a,b]=self.selected_data.shape
print(a)
print(b)
for row in range(a):
rowdata = []
for column in range(b):
item = self.selected_data.item(row, column)
if item is not None:
rowdata.append(item)
else:
rowdata.append('')
writer.writerow(rowdata)
class MzPlotter(PlotterBase):
def __init__(self, c_callback=None, image_plot=None):
super(MzPlotter, self).__init__("m/z", "I")
self.c_callback = c_callback
widget = self.widget
# inject mofified behaviour of wigets plot attribute:
widget.plot.__class__ = MzPlot
widget.plot.register_c_callback(self.handle_c_pressed)
widget.plot.image_plot = image_plot
self.setHalfWindowWidth(0.05)
self.centralMz = None
# todo: refactor as helper
a = QwtScaleDraw()
label = lambda self, x: QwtText("%s" % x)
a.label = new.instancemethod(label, widget.plot, QwtScaleDraw)
widget.plot.setAxisScaleDraw(widget.plot.xBottom, a)
self.pm = PlotManager(widget)
self.pm.add_plot(widget.plot)
self.curve = make.curve([], [], color='b', curvestyle="Sticks")
# inject modified behaviour:
self.curve.__class__ = ModifiedCurveItem
self.widget.plot.add_item(self.curve)
t = self.pm.add_tool(MzSelectionTool)
self.pm.set_default_tool(t)
t.activate()
marker = Marker(label_cb=widget.plot.label_info,
constraint_cb=widget.plot.on_plot)
marker.attach(self.widget.plot)
line = make.segment(0, 0, 0, 0)
line.__class__ = ModifiedSegment
line.setVisible(0)
setupCommonStyle(line, marker)
label = make.info_label("TR", [MzCursorInfo(marker, line)], title=None)
label.labelparam.label = ""
self.marker = marker
self.label = label
self.line = line
def setHalfWindowWidth(self, w2):
self.widget.plot.set_half_window_width(w2)
def setCentralMz(self, mz):
self.widget.plot.set_central_mz(mz)
def handle_c_pressed(self, p):
if self.c_callback:
self.c_callback(p)
def plot(self, data, configs=None, titles=None):
""" do not forget to call replot() after calling this function ! """
self.widget.plot.del_all_items()
self.widget.plot.add_item(self.marker)
if titles is not None:
self.widget.plot.add_item(make.legend("TL"))
self.widget.plot.add_item(self.label)
all_peaks = []
self.widget.plot.data = []
self.widget.plot.curves = []
for i, (pm, rtmin, rtmax, mzmin, mzmax, npeaks) in enumerate(data):
if rtmin is None and rtmax is None:
rtmin, rtmax = pm.rtRange()
elif rtmin is None:
rtmin, __ = pm.rtRange()
elif rtmax is None:
__, rtmax = pm.rtRange()
if mzmin is None and mzmax is None:
mzmin, mzmax = pm.mzRange()
elif mzmin is None:
mzmin, __ = pm.mzRange()
elif mzmax is None:
__, mzmax = pm.mzRange()
if npeaks is None:
npeaks = 3000
peaks = sample_peaks(pm, rtmin, rtmax, mzmin, mzmax, npeaks)
all_peaks.append(peaks)
config = configs[i] if configs is not None else None
if config is None:
config = dict(color=getColor(i))
if titles is not None:
title = titles[i]
else:
title = u""
curve = make.curve([], [], title=title, curvestyle="Sticks", **config)
curve.set_data(peaks[:, 0], peaks[:, 1])
curve.__class__ = ModifiedCurveItem
self.widget.plot.add_item(curve)
self.widget.plot.curves.append(curve)
self.widget.plot.data.append((pm, rtmin, rtmax, mzmin, mzmax, npeaks))
self.widget.plot.add_item(self.line)
if len(all_peaks):
self.widget.plot.all_peaks = np.vstack(all_peaks)
else:
self.widget.plot.all_peaks = np.zeros((0, 2))
def resetAxes(self):
self.widget.plot.reset_x_limits()
def reset(self):
self.plot(np.ndarray((0, 2)))
self.replot()
class plotWindow(QMainWindow):
def __init__(self, *args, **kwargs):
QMainWindow.__init__(self, *args, **kwargs)
self.__initVars()
# init self
geo = self.geometry()
geo.setWidth(800)
geo.setHeight(600)
geo.setX(100)
geo.setY(100)
self.setGeometry(geo)
self.setWindowTitle("plot window")
self.__initLayout()
# end __init__
def __del__(self):
if (self.__p_manager):
del self.__p_manager
# end if
self.__initVars()
# end __del__
def __initVars(self):
self.__p_manager = False
self.__p_toolbar = False
self.__p_resizeButton = False
self.__l_layoutChilds = []
self.__v_wasInitialized = False
# end __initVars
def __initLayout(self):
# layout
layout = QGridLayout()
central_widget = QWidget(self)
central_widget.setLayout(layout)
self.setCentralWidget(central_widget)
# create plot manager
self.__p_manager = PlotManager(self)
# toolbar
if (self.__p_toolbar):
self.__p_toolbar.clear()
else:
self.__p_toolbar = self.addToolBar("tools")
# end if
# resize button
icon = QIcon("icons/center.png")
button = QToolButton()
button.setIcon(icon)
button.setToolTip("Resize")
self.connect(button, SIGNAL("clicked()"), self.__onAutoScale)
self.__p_manager.add_toolbar(self.__p_toolbar, id(self.__p_toolbar))
self.__p_toolbar.addWidget(button)
self.__v_wasInitialized = True
# end __initManager
def reInit(self):
for plot in self.__l_layoutChilds:
self.centralWidget().layout().removeWidget(plot)
del plot
# end if
self.__l_layoutChilds = []
# layout
oldLayout = self.centralWidget().layout()
del oldLayout
if (self.__p_manager):
del self.__p_manager
self.__p_manager = False
# end if
self.__initLayout()
# end reInit
def addCurvePlot(self, curves, *args, **kwargs):
return self.__addPlot(curves, noneBugCurvePlot, *args, **kwargs)
# end addCurvePlot
def addImagePlot(self, images, *args, **kwargs):
return self.__addPlot(images, ImagePlot, *args, **kwargs)
# end addImagePlot
def addImageWidget(self, images, *args, **kwargs):
widget = ImageWidget(self, *args, **kwargs)
plot = widget.get_plot()
if (images.__class__ is not list):
plot.add_item(images)
else:
for image in images:
plot.add_item(image)
# end for
# end if
self.centralWidget().layout().addWidget(widget)
self.__l_layoutChilds.append(widget)
return widget
# end addImageWidget
def getManager(self):
return self.__p_manager
# end getManager
def __addPlot(self, dataList, plotClass, *args, **kwargs):
"""
pos[0]: row
pos[1]: column
pos[2]: rowspan
pos[3]: columnspan
"""
pos = []
if ('position' in kwargs):
pos = kwargs.pop('position')
# end if
if ('pos' in kwargs):
pos = kwargs.pop('pos')
# end if
plot = plotClass(self, *args, **kwargs)
if (dataList.__class__ is not list):
plot.add_item(dataList)
else:
for data in dataList:
plot.add_item(data)
# end for
# end if
self.__registerPlot(plot, pos)
return plot
# end __addPlot
def __registerPlot(self, plot, pos):
# check for position
if (pos != []):
if (len(pos) == 2):
pos.append(1) # rowspan
pos.append(1) # columnspan
# end if
self.centralWidget().layout().addWidget(plot, pos[0], pos[1], pos[2], pos[3])
else:
self.centralWidget().layout().addWidget(plot)
# end if
self.__l_layoutChilds.append(plot)
self.__p_manager.add_plot(plot)
# end __registerPLot
def show(self, *args, **kwargs):
if (self.__v_wasInitialized):
self.__p_manager.register_all_curve_tools()
self.__v_wasInitialized = False
# end if
QMainWindow.show(self, *args, **kwargs)
# end show
def showEvent(self, event):
# emit signal
self.emit(SIGNAL("onShow()"))
# execute not overloaded showEvent
QMainWindow.showEvent(self, event)
# end showEvent
def closeEvent(self, event):
# emit signal
self.emit(SIGNAL("onClose()"))
# execute not overloaded closeEvent
QMainWindow.closeEvent(self, event)
# end closeEvent
def __onAutoScale(self):
plot = self.__p_manager.get_active_plot()
plot.do_autoscale(True)
class Ui_Form(object):
def __init__(self, type):
self.dc = DataController()
self.drc = RepresentationControl()
self.flowData = self.dc.abstractionData
pos = self.drc.getAvailableAlgorithms().keys().index(type)
self.drc.selectAlgorithm(pos)
def setupUi(self, Form):
Form.setObjectName(_fromUtf8("Form"))
Form.resize(536, 384)
self.tableWidget = QtGui.QTableWidget(Form)
self.tableWidget.setGeometry(QtCore.QRect(90, 261, 221, 121))
if self.dc.getCurrentLabels() is None:
QtGui.QMessageBox.warning(Form, "No Features Found", "Please select Feature Extraction Method first",
QtGui.QMessageBox.Ok)
self.tableWidget.setObjectName(_fromUtf8("tableWidget"))
self.tableWidget.setColumnCount(2)
self.tableWidget.setRowCount(len(list(set(self.dc.getCurrentLabels()))))
self.pushButton = QtGui.QPushButton(Form)
self.pushButton.setGeometry(QtCore.QRect(0, 360, 75, 23))
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.label = QtGui.QLabel(Form)
self.label.setGeometry(QtCore.QRect(10, 10, 521, 211))
self.label.setText("The state figure will be saved")
self.widget = QtGui.QWidget()
self.widget.setGeometry(QtCore.QRect(10, 10, 521, 211))
self.widget.setObjectName(_fromUtf8("widget"))
self.dialog = CurveDialog(edit=False, toolbar=False, parent=self.widget)
self.plot = self.dialog.get_plot()
self.plot.set_antialiasing(True)
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time')
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value')
self.manager = PlotManager(self)
self.manager.add_plot(self.plot)
ly = QtGui.QVBoxLayout()
ly.addWidget(QtGui.QLabel(self.widget))
ly.addWidget(QtGui.QLabel(self.plot))
self.widget.setLayout(ly)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setHorizontalHeaderItem(0, item)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setItem(0, 0, item)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setItem(0, 1, item)
# item = self.tableWidget.horizontalHeaderItem(0)
# item.setText(_translate("Form", "Attribute", None))
c = 0
for it in list(set(self.dc.getCurrentLabels())):
# item = QtGui.QTableWidgetItem()
# item.setText(_translate("Form", "Id" + str(c), None))
# self.tableWidget.setVerticalHeaderItem(c, item)
item = QtGui.QTableWidgetItem()
item.setText(str(it))
self.tableWidget.setItem(c, 0, item)
#print "jgaboo timeig", it
#print it, self.drc.getRequiredParameters()[it]
item = QtGui.QTableWidgetItem()
item.setText("States!")
self.tableWidget.setItem(c, 1, item)
#print c
c += 1
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
Form.setWindowTitle(_translate("Form", "Form", None))
__sortingEnabled = self.tableWidget.isSortingEnabled()
self.tableWidget.setSortingEnabled(False)
self.tableWidget.setSortingEnabled(__sortingEnabled)
self.pushButton.setText(_translate("Form", "Picture It!", None))
Form.connect(self.pushButton, QtCore.SIGNAL('clicked()'), self.processor)
def processor(self):
print "in process"
params = {}
for i in range(self.tableWidget.rowCount()):
a = self.tableWidget.item(i, 0)
b = self.tableWidget.item(i, 1)
params[str(a.text())] = str(b.text())
#print "paramsjo", params
#print "paramsjo2", self.dc.params
self.drc.represent(None,{"states":self.dc.params})
class ContrastAdjustment(PanelWidget):
"""Contrast adjustment tool"""
__implements__ = (IPanel, )
PANEL_ID = ID_CONTRAST
PANEL_TITLE = _("Contrast adjustment tool")
PANEL_ICON = "contrast.png"
def __init__(self, parent=None):
super(ContrastAdjustment, self).__init__(parent)
self.local_manager = None # local manager for the histogram plot
self.manager = None # manager for the associated image plot
# Storing min/max markers for each active image
self.min_markers = {}
self.max_markers = {}
# Select point tools
self.min_select_tool = None
self.max_select_tool = None
style = "<span style='color: #444444'><b>%s</b></span>"
layout, _label = get_image_layout(self.PANEL_ICON,
style % self.PANEL_TITLE,
alignment=Qt.AlignCenter)
layout.setAlignment(Qt.AlignCenter)
vlayout = QVBoxLayout()
vlayout.addLayout(layout)
self.local_manager = PlotManager(self)
self.histogram = LevelsHistogram(parent)
vlayout.addWidget(self.histogram)
self.local_manager.add_plot(self.histogram)
hlayout = QHBoxLayout()
self.setLayout(hlayout)
hlayout.addLayout(vlayout)
self.toolbar = toolbar = QToolBar(self)
toolbar.setOrientation(Qt.Vertical)
# toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
hlayout.addWidget(toolbar)
# Add standard plot-related tools to the local manager
lman = self.local_manager
lman.add_tool(SelectTool)
lman.add_tool(BasePlotMenuTool, "item")
lman.add_tool(BasePlotMenuTool, "axes")
lman.add_tool(BasePlotMenuTool, "grid")
lman.add_tool(AntiAliasingTool)
lman.get_default_tool().activate()
self.outliers_param = EliminateOutliersParam(self.PANEL_TITLE)
def register_panel(self, manager):
"""Register panel to plot manager"""
self.manager = manager
default_toolbar = self.manager.get_default_toolbar()
self.manager.add_toolbar(self.toolbar, "contrast")
self.manager.set_default_toolbar(default_toolbar)
self.setup_actions()
for plot in manager.get_plots():
self.histogram.connect_plot(plot)
def configure_panel(self):
"""Configure panel"""
self.min_select_tool = self.manager.add_tool(
SelectPointTool,
title=_("Minimum level"),
on_active_item=True,
mode="create",
tip=_("Select minimum level on image"),
toolbar_id="contrast",
end_callback=self.apply_min_selection,
)
self.max_select_tool = self.manager.add_tool(
SelectPointTool,
title=_("Maximum level"),
on_active_item=True,
mode="create",
tip=_("Select maximum level on image"),
toolbar_id="contrast",
end_callback=self.apply_max_selection,
)
def get_plot(self):
return self.manager.get_active_plot()
def closeEvent(self, event):
self.hide()
event.ignore()
def setup_actions(self):
fullrange_ac = create_action(
self,
_("Full range"),
icon=get_icon("full_range.png"),
triggered=self.histogram.set_full_range,
tip=_("Scale the image's display range "
"according to data range"),
)
autorange_ac = create_action(
self,
_("Eliminate outliers"),
icon=get_icon("eliminate_outliers.png"),
triggered=self.eliminate_outliers,
tip=_("Eliminate levels histogram "
"outliers and scale the image's "
"display range accordingly"),
)
add_actions(self.toolbar, [fullrange_ac, autorange_ac])
def eliminate_outliers(self):
def apply(param):
self.histogram.eliminate_outliers(param.percent)
if self.outliers_param.edit(self, apply=apply):
apply(self.outliers_param)
def apply_min_selection(self, tool):
item = self.get_plot().get_last_active_item(IVoiImageItemType)
point = self.min_select_tool.get_coordinates()
z = item.get_data(*point)
self.histogram.set_min(z)
def apply_max_selection(self, tool):
item = self.get_plot().get_last_active_item(IVoiImageItemType)
point = self.max_select_tool.get_coordinates()
z = item.get_data(*point)
self.histogram.set_max(z)
def set_range(self, _min, _max):
"""Set contrast panel's histogram range"""
self.histogram.set_range(_min, _max)
# Update the levels histogram in case active item data has changed:
self.histogram.selection_changed(self.get_plot())
class EicPlottingWidget(CurveWidget):
SELECTED_RANGE_CHANGED = pyqtSignal(float, float)
def __init__(self, parent=None, with_range=True):
super(EicPlottingWidget, self).__init__(parent, ylabel="I")
patch_inner_plot_object(self, EicPlot)
self._with_range = with_range
self._setup_plot()
def enable_range(self, flag):
self._with_range = flag
self._setup_range_selector()
def _setup_plot(self):
self.pm = PlotManager(self)
self.pm.add_plot(self.plot)
t = self.pm.add_tool(RtSelectionTool)
t.activate()
self.pm.set_default_tool(t)
self._setup_cursor()
self._setup_range_selector()
self._setup_label()
self._setup_axes()
def _setup_cursor(self):
marker = Marker(label_cb=self.plot.label_info, constraint_cb=self.plot.on_plot)
marker.rts = [0]
setup_marker_param(marker, {"symbol.size": 0,
"symbol.alpha": 0.0,
"sel_symbol.size": 0,
"sel_symbol.alpha": 0.0,
"line.color": "#909090",
"line.width": 1.0,
"line.style": "SolidLine",
"sel_line.color": "#909090",
"sel_line.width": 1.0,
"sel_line.style": "SolidLine",
"markerstyle": "VLine"})
marker.attach(self.plot)
self.marker = marker
self._setup_cursor_info(marker)
def _setup_cursor_info(self, marker):
self.cursor_info = RtCursorInfo(marker)
def _setup_range_selector(self):
if not self._with_range:
self.range_ = None
return
self.range_ = SnappingRangeSelection(0, 0)
# you have to register item to plot before you can register the
# rtSelectionHandler:
self.plot.add_item(self.range_)
self.range_.SELECTED_RANGE_CHANGED.connect(self._range_selection_handler)
cc = make.info_label("TR", [RangeSelectionInfo(self.range_)], title=None)
setup_label_param(cc, {"label": "", "font.size": 12})
self.plot.add_item(cc)
def _setup_label(self):
label = make.info_label("T", [self.cursor_info], title=None)
setup_label_param(label, {"label": "", "font.size": 12, "border.color": "#ffffff"})
self.label = label
def _setup_axes(self):
# render tic labels in modfied format:
set_rt_formatting_on_x_axis(self.plot)
self.plot.set_axis_title("bottom", "RT")
def plot_(self, eics):
self.add_eics(eics)
def set_cursor_pos(self, rt):
self.plot.set_rt(rt)
def set_overall_range(self, rtmin, rtmax):
self.plot.overall_x_min = rtmin
self.plot.overall_x_max = rtmax
def add_eics(self, data, labels=None, configs=None):
""" do not forget to call replot() after calling this function ! """
allrts = list()
if configs is None:
configs = [{"color": getColor(i)} for i in range(len(data))]
if labels is None:
labels = [""] * len(data)
unique_labels = set()
# items_with_label = []
seen = set()
for i, (rts, chromatogram) in enumerate(data):
# we do not plot duplicates, which might happen if multiple lines in the
# table explorer are sellected !
if (id(rts), id(chromatogram)) in seen:
continue
seen.add((id(rts), id(chromatogram)))
config = configs[i]
label = "<pre>%s</pre>" % labels[i]
unique_labels.add(label)
curve = make_unselectable_curve(rts, chromatogram, title=label, **config)
allrts.extend(rts)
self.plot.add_item(curve)
self.plot.add_item(self.label)
self.plot.set_x_values(sorted(set(allrts)))
# no idea why guiqwt needs double registration here:
self.marker.attach(self.plot)
self.plot.add_item(self.marker)
# self._add_legend(unique_labels, items_with_label)
if self.range_ is not None:
self.plot.add_item(self.range_)
def _add_legend(self, unique_labels, items_with_label):
# überbleibsel von zeitreihen plott
unique_labels -= set((None,))
unique_labels -= set(("",))
if unique_labels:
legend = make.legend("TL", restrict_items=items_with_label)
setup_label_param(legend, {"font.size": 12})
self.plot.add_item(legend)
def add_eic_filled(self, rts, iis, baseline, color):
shape = create_closed_shape(rts, iis, baseline, color)
if shape is not None:
self.plot.add_item(shape)
def set_visible(self, visible):
self.plot.setVisible(visible)
def get_range_selection_limits(self):
if self.range_ is None:
return None, None
return sorted((self.range_._min, self.range_._max))
def set_range_selection_limits(self, xleft, xright):
if self.range_ is None:
return
self.range_.move_point_to(0, (xleft, 0))
self.range_.move_point_to(1, (xright, 0))
def reset_intensity_limits(self, imin=None, imax=None, fac=1.1, rtmin=None, rtmax=None):
self.plot.reset_y_limits(imin, imax, fac, rtmin, rtmax)
@protect_signal_handler
def _range_selection_handler(self, left, right):
min_, max_ = sorted((left, right))
self.SELECTED_RANGE_CHANGED.emit(min_, max_)
def set_rt_axis_limits(self, xmin, xmax):
self.plot.update_plot_xlimits(xmin, xmax)
def get_limits(self):
return self.plot.get_plot_limits()
def updateAxes(self):
self.plot.updateAxes()
def set_intensity_axis_limits(self, ymin, ymax):
self.plot.update_plot_ylimits(ymin, ymax)
def reset_rt_limits(self, rt_min=None, rt_max=None, fac=1.1):
self.plot.reset_x_limits(rt_min, rt_max, fac)
def reset_intensitiy_limits(self, i_min=None, i_max=None, fac=1.1, rt_min=None, rt_max=None):
self.plot.reset_y_limits(i_min, i_max, fac, rt_min, rt_max)
def set_limit(self, ix, value):
self.plot.set_limit(ix, value)
def getLimits(self):
return self.plot.get_plot_limits()
def replot(self):
self.plot.replot()
def del_all_items(self):
self.plot.del_all_items()
def reset(self):
"""empties plot"""
self.del_all_items()
self.replot()
def shrink_and_replot(self, rtmin, rtmax):
self.reset_rt_limits(rtmin, rtmax)
self.plot.reset_y_limits()
self.plot.replot()
class Ui_Form(object):
def __init__(self, type):
self.dc = DataController()
self.prc = PreProcessingControl()
self.flowData = self.dc.originalData
pos = self.prc.getAvailableAlgorithms().keys().index(type)
self.prc.selectAlgorithm(pos)
def setupUi(self, Form):
Form.setObjectName(_fromUtf8("Form"))
Form.resize(536, 384)
self.Form=Form
self.tableWidget = QtGui.QTableWidget(Form)
self.tableWidget.setGeometry(QtCore.QRect(90, 261, 221, 121))
self.tableWidget.setObjectName(_fromUtf8("tableWidget"))
self.tableWidget.setColumnCount(2)
self.tableWidget.setRowCount(1)
item = QtGui.QTableWidgetItem()
self.tableWidget.setVerticalHeaderItem(0, item)
item = QtGui.QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(0, item)
item = QtGui.QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(1, item)
item = QtGui.QTableWidgetItem()
self.tableWidget.setItem(0, 0, item)
item = QtGui.QTableWidgetItem()
self.tableWidget.setItem(0, 1, item)
self.pushButton = QtGui.QPushButton(Form)
self.pushButton.setGeometry(QtCore.QRect(0, 300, 75, 23))
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.widget = QtGui.QWidget(Form)
self.widget.setGeometry(QtCore.QRect(10, 10, 521, 211))
self.widget.setObjectName(_fromUtf8("widget"))
#self.pushButton_2 = QtGui.QPushButton(Form)
#self.pushButton_2.setGeometry(QtCore.QRect(0, 330, 75, 23))
#self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))
self.pushButton_3 = QtGui.QPushButton(Form)
self.pushButton_3.setGeometry(QtCore.QRect(0, 360, 75, 23))
self.pushButton_3.setObjectName(_fromUtf8("pushButton_3"))
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
self.dialog = CurveDialog(edit=False, toolbar=False, parent=self.widget)
self.plot = self.dialog.get_plot()
self.plot.set_antialiasing(True)
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time')
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value')
self.manager = PlotManager(self)
self.manager.add_plot(self.plot)
legend = make.legend('TL')
self.plot.add_item(legend)
ly = QtGui.QVBoxLayout()
ly.addWidget(self.plot)
self.widget.setLayout(ly)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setHorizontalHeaderItem(0, item)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setItem(0, 0, item)
# item = QtGui.QTableWidgetItem()
# self.tableWidget.setItem(0, 1, item)
# item = self.tableWidget.horizontalHeaderItem(0)
# item.setText(_translate("Form", "Attribute", None))
c = 0
for it in self.prc.getRequiredParameters():
# item = QtGui.QTableWidgetItem()
# item.setText(_translate("Form", "Id" + str(c), None))
# self.tableWidget.setVerticalHeaderItem(c, item)
item = QtGui.QTableWidgetItem()
item.setText(it)
self.tableWidget.setItem(c, 0, item)
#print it, self.prc.getRequiredParameters()[it]
item = QtGui.QTableWidgetItem()
item.setText(str(self.prc.getRequiredParameters()[it]))
self.tableWidget.setItem(c, 1, item)
# print c
c += 1
####%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
self.currentdata=[]
def retranslateUi(self, Form):
Form.setWindowTitle(_translate("Form", "Form", None))
__sortingEnabled = self.tableWidget.isSortingEnabled()
self.tableWidget.setSortingEnabled(False)
self.tableWidget.setSortingEnabled(__sortingEnabled)
self.pushButton.setText(_translate("Form", "Process", None))
#self.pushButton_2.setText(_translate("Form", "Load", None))
self.pushButton_3.setText(_translate("Form", "Save", None))
Form.connect(self.pushButton, QtCore.SIGNAL('clicked()'),self.process)
#Form.connect(self.pushButton_2, QtCore.SIGNAL('clicked()'),self.loadDialog)
Form.connect(self.pushButton_3, QtCore.SIGNAL('clicked()'),self.saveDialog)
def process(self):
params = {}
print(self.tableWidget.rowCount())
for i in range(self.tableWidget.rowCount()):
a = self.tableWidget.item(i, 0)
b = self.tableWidget.item(i, 1)
params[str(a.text())] = int(b.text())
# print "params",params
outpN = self.tableWidget.item(0, 0)
#params = {"none": "none", "output_length": outpN}
'''
if self.currentdata==[]:
data = self.prc.preprocData(self.flowData, params)
else:
data = self.prc.preprocData(self.currentdata, params)
'''
#self.dc.setCurrentDataFlowObject(data)
#print data
if params==[]:
data = self.prc.preprocData(self.flowData, params)
elif params!=[]:
data = self.prc.preprocData(self.flowData, params)
self.plot.del_all_items()
print data
print type(data)
self.plot.add_item(make.curve(range(0, len(data)), data))
self.rangeSelection = make.range(-2, 2)
disp0 = make.range_info_label(self.rangeSelection, 'BR', u"x = %.1f +- %.1f cm",
title="Range infos")
#self.plot.add_item(self.rangeSelection)
#self.plot.add_item(disp0)
self.plot.replot()
#self.dc.setCurrentDataFlowObject(data)
self.dc.preprocData = data
self.currentdata = np.reshape(data, (-1, 1))
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
'''def loadDialog(self):
params = {}
for i in range(self.tableWidget.rowCount()):
a = self.tableWidget.item(i, 0)
b = self.tableWidget.item(i, 1)
params[str(a.text())] = int(b.text())
# print "params",params
outpN = self.tableWidget.item(0, 0)
#params = {"none": "none", "output_length": outpN}
filename = QtGui.QFileDialog.getOpenFileName(self.Form, 'Open File', '.')
fname = open(filename)
self.original_data = pandas.read_csv(str(filename), delimiter=",")
self.plot.del_all_items()
self.currentdata = np.array(self.original_data)
#print "fileLoader self.currentdata.shape", self.currentdata.shape
print type(self.currentdata)
print(self.currentdata.shape)
'''
def saveDialog(self):
path = QtGui.QFileDialog.getSaveFileName(self.Form, 'Save File', '', 'CSV(*.csv)')
if not path.isEmpty():
with open(unicode(path), 'wb') as stream:
writer = csv.writer(stream)
[a,b]=self.currentdata.shape
print(a)
print(b)
for row in range(a):
rowdata = []
for column in range(b):
item = self.currentdata.item(row, column)
if item is not None:
rowdata.append(item)
else:
rowdata.append('')
writer.writerow(rowdata)
class RealtimeDemo(QWidget):
def __init__(self):
super(RealtimeDemo, self).__init__()
self.setWindowTitle(u"Realtime Demo")
self.data = {u"t":array("d")}
for name in sum(PLOT_DEFINE, []):
self.data[name] = array("d")
self.curves = {}
self.t = 0
vbox = QVBoxLayout()
vbox.addWidget(self.setup_toolbar())
self.manager = PlotManager(self)
self.plots = []
for i, define in enumerate(PLOT_DEFINE):
plot = CurvePlot()
plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(60)
self.manager.add_plot(plot)
self.plots.append(plot)
plot.plot_id = id(plot)
for j, curve_name in enumerate(define):
curve = self.curves[curve_name] = make.curve([0], [0], color=COLORS[j], title=curve_name)
plot.add_item(curve)
plot.add_item(make.legend("BL"))
vbox.addWidget(plot)
self.manager.register_standard_tools()
self.manager.get_default_tool().activate()
self.manager.synchronize_axis(CurvePlot.X_BOTTOM, self.manager.plots.keys())
self.setLayout(vbox)
self.startTimer(100)
def setup_toolbar(self):
toolbar = QToolBar()
self.auto_yrange_checkbox = QCheckBox(u"Y-axis auto-adjust")
self.auto_xrange_checkbox = QCheckBox(u"X-axis auto-adjust")
self.xrange_box = QSpinBox()
self.xrange_box.setMinimum(5)
self.xrange_box.setMaximum(50)
self.xrange_box.setValue(10)
self.auto_xrange_checkbox.setChecked(True)
self.auto_yrange_checkbox.setChecked(True)
toolbar.addWidget(self.auto_yrange_checkbox)
toolbar.addWidget(self.auto_xrange_checkbox)
toolbar.addWidget(self.xrange_box)
return toolbar
def timerEvent(self, event):
for i in range(100):
t = self.t
self.data[u"t"].append(t)
self.data[u"sin1f"].append(sin(t))
self.data[u"sin3f"].append(sin(3*t)/6)
self.t += DT
if self.auto_xrange_checkbox.isChecked():
xmax = self.data["t"][-1]
xmin = max(xmax - self.xrange_box.value(), 0)
else:
xmin, xmax = self.plots[0].get_axis_limits('bottom')
for key, curve in self.curves.items():
xdata = self.data["t"]
ydata = self.data[key]
x, y = get_peak_data(xdata, ydata, xmin, xmax, 600, 1/DT)
curve.set_data(x, y)
for plot in self.plots:
if self.auto_yrange_checkbox.isChecked() and self.auto_xrange_checkbox.isChecked():
plot.do_autoscale()
elif self.auto_xrange_checkbox.isChecked():
plot.set_axis_limits("bottom", xmin, xmax)
plot.replot()
else:
plot.replot()
class Ui_PlotWidget_Reduce_Set(QtGui.QWidget):
""""""
def __init__(self, parent=None):
"""Constructor for Ui_PlotWidget"""
QtGui.QWidget.__init__(self, parent)
self.setupUi()
def setupUi(self):
"""loads numpy array
Args:
self
Returns:
nothing
"""
#self.plot = CurvePlot(self)
self.dialog = CurveDialog(edit=False, toolbar=True, parent=self)
self.plot = self.dialog.get_plot()
self.plot.set_antialiasing(True)
#x = np.linspace(-10,10,200)
#dy = x/100.
#y = np.sin(np.sin(np.sin(x)))
#self.plot.add_item(make.curve(x,y))
self.loadButton = QtGui.QPushButton("Load")
self.trainButton = QtGui.QPushButton("Train Model")
ly = QtGui.QVBoxLayout()
ly.addWidget(self.plot)
#ly.addWidget(self.loadButton)
#ly.addWidget(self.trainButton)
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time')
self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value')
self.manager = PlotManager(self)
self.manager.add_plot(self.plot)
#self.manager.
legend = make.legend('TL')
self.plot.add_item(legend)
self.setLayout(ly)
self.move(300, 200)
self.show()
self.dataController = DataController.DataController()
def loadData(self):
self.trainingData = self.dataController.loadSampleData()
import logic.DimensionalityReduceControl as controller
c = controller.DimensionalityReduceControl()
c.selectAlgorithm(2)
outpN = 100
params = {"none": "none", "output_length": outpN}
data = c.reduceData(self.trainingData["PIR"][:],params)
print data
self.plot.add_item(make.curve(range(0, len(data)), data))
self.rangeSelection = make.range(-2, 2)
disp0 = make.range_info_label(self.rangeSelection, 'BR', u"x = %.1f +- %.1f cm",
title="Range infos")
self.plot.add_item(self.rangeSelection)
self.plot.add_item(disp0)
self.plot.replot()
def trainData(self,string_length, vocab, window_length, clusterN):
a, b = self.rangeSelection.get_range()
if a > b:
a, b = b, a
print a, b
print "in widget", int(string_length), int(vocab), int(window_length), int(clusterN)
self.dataController.trainData(a,b,int(string_length), int(vocab), int(window_length), int(clusterN))
class GuiQwtPlot( QtGui.QMainWindow ):
def __init__( self ):
QtGui.QMainWindow.__init__( self )
self.__create_layout()
self.__setup_layout()
def __create_layout( self ):
self.setWindowTitle( "Live *.Chi plotter, v. 2.1.0 (April 2013)" )
self.plot = CurvePlot( self )
self.plot.set_antialiasing( True )
self.plot2 = CurvePlot( self )
self.plot2.set_antialiasing( True )
self.button = QtGui.QPushButton( "Search for files" )
self.button2 = QtGui.QPushButton( "Plot selected files" )
self.button3 = QtGui.QPushButton( "Select all" )
self.button4 = QtGui.QPushButton( "Select none" )
self.button5 = QtGui.QPushButton( "Integrate" )
self.button6 = QtGui.QPushButton( "Integral over ROI (defined by the two vertical cursors)" )
left_hbox0 = QtGui.QVBoxLayout()
right_hbox0 = QtGui.QVBoxLayout()
# Main graph
left_vbox = QtGui.QVBoxLayout()
left_vbox.addWidget( self.plot, 3)
# Smaller graph
left_vbox.addWidget( self.plot2, 1 )
self.tick_axis_reset = QtGui.QCheckBox("Reset axis when replotting data")
self.tick_axis_reset.setCheckState(Qt.Checked)
left_hbox0.addWidget( self.tick_axis_reset )
# Static text field
right_hbox0.addWidget( QtGui.QLabel('Directory'), 0, QtCore.Qt.AlignRight )
hbox0 = QtGui.QHBoxLayout()
hbox0.addLayout( left_hbox0 )
hbox0.addLayout( right_hbox0 )
left_vbox.addLayout( hbox0 )
# Add buttons to the left side
left_vbox.addWidget( self.button )
left_vbox.addWidget( self.button2 )
left_vbox.addWidget( self.button6 )
# Data series list view
log_label = QtGui.QLabel("Data series:")
self.series_list_model = QtGui.QStandardItemModel()
self.series_list_view = QtGui.QListView()
self.series_list_view.setModel(self.series_list_model)
right_vbox = QtGui.QVBoxLayout()
right_vbox.addWidget( log_label )
right_vbox.addWidget( self.series_list_view )
# Create editable text box for inputting directory
self.text1 = QtGui.QTextEdit()
self.text1.setFixedHeight(22)
# Put current directory to the text box
self.text1.setText(os.getcwd())
right_vbox.addWidget( self.text1 )
# Add buttons
right_vbox.addWidget( self.button3 )
right_vbox.addWidget( self.button4 )
right_vbox.addWidget( self.button5 )
# Combine left and right box
hbox = QtGui.QHBoxLayout()
hbox.addLayout( left_vbox, 2 ) # Second parameter is the stretch factor
hbox.addLayout( right_vbox, 1 ) # of the widget, letting the figure to stretch more
w = QtGui.QWidget()
w.setLayout( hbox )
self.setCentralWidget( w )
def __setup_layout( self ):
self.connect( self.button, QtCore.SIGNAL( 'clicked()' ), self.button_Click )
self.connect( self.button2, QtCore.SIGNAL( 'clicked()' ), self.button_Click2 )
self.connect( self.button3, QtCore.SIGNAL( 'clicked()' ), self.button_Click3 )
self.connect( self.button4, QtCore.SIGNAL( 'clicked()' ), self.button_Click4 )
self.connect( self.button5, QtCore.SIGNAL( 'clicked()' ), self.button_Click5 )
self.connect( self.button6, QtCore.SIGNAL( 'clicked()' ), self.button_Click6 )
# Vertical cursor
self.cursorposition = 0.8
self.cursorposition2 = 1.2
self.vcursor1 = make.vcursor(self.cursorposition, label='x = %.2f')
self.plot.add_item( self.vcursor1 )
self.vcursor2 = make.vcursor(self.cursorposition2, label='x = %.2f')
self.plot.add_item( self.vcursor2 )
# Define the y label, x might change depending on user definition
CurvePlot.set_axis_title(self.plot,CurvePlot.Y_LEFT,"Intensity (counts)")
# Crate the PlotManager
self.manager = PlotManager( self )
self.manager.add_plot( self.plot )
self.manager.add_plot( self.plot2 )
# Create Toolbar
toolbar = self.addToolBar( 'tools' )
self.manager.add_toolbar( toolbar, id( toolbar ) )
# Register the ToolBar's type
self.manager.register_all_curve_tools( )
# self.manager.register_other_tools()
# Register a custom tool
self.manager.add_tool( SelectPointTool, title = 'Position', on_active_item = True, mode = 'create' )
def fill_series_list(self, names):
self.series_list_model.clear()
counterlist = 0
for name in reversed(names):
item = QtGui.QStandardItem(name)
# if counterlist == 0: # Check only the first one
# item.setCheckState(Qt.Checked)
# else:
item.setCheckState(Qt.Unchecked)
item.setCheckable(True)
self.series_list_model.appendRow(item)
counterlist = counterlist + 1
# Load data to the list
def button_Click( self ):
# Find the newest files in the directory and subdirectories
# and populate the list of files
self.y = {}
self.x = {}
self.timestamp = {}
self.names = []
self.fullfilename = {}
# Clear the list in case used another directory before
self.series_list_model.clear()
# Go to the directory specified in the field or if none, give error message
curdir = str(self.text1.toPlainText())
if os.path.isdir(curdir):
os.chdir(curdir)
else:
print curdir+" is not a valid directory!"
# Find the files in the directory
counterfiles = 0
for dirpath, dirnames, filenames in os.walk(os.getcwd()):
filenames.sort(key=lambda x: os.path.getmtime(dirpath+'/'+x))
for file1 in filenames:
prefix,postfix = os.path.splitext(file1)
# Only *.chi files ending with a number are accepted
if len(re.findall("[\d]"+".chi",file1))>0:
fullfilename1 = dirpath+'/'+file1
time1 = os.path.getmtime(fullfilename1)
tmp,subpath = os.path.split(dirpath)
tmp,subpath2 = os.path.split(tmp)
seriesname1 = os.path.basename(str(subpath2+'_'+subpath+'_'+file1))
self.names.append(seriesname1)
# Load data
tmp = np.genfromtxt(str(fullfilename1),dtype=None,skip_header=4)
self.y[seriesname1] = map(float, np.transpose(tmp[:,1]))
self.x[seriesname1] = map(float, np.transpose(tmp[:,0]))
self.datalen = len(self.x[seriesname1])
self.timestamp[seriesname1] = time1
self.fullfilename[seriesname1] = fullfilename1
counterfiles = counterfiles + 1
# Populate the checkbox list
self.fill_series_list(self.names)
#Refresh the figure
def button_Click2( self ):
# has_series = False
# Seed for random generator of colors, so that they are always in the same order
random.seed(654321)
colorlistred = [220, 255, 155, 24, 0, 0, 48, 205, 255, 255, 0, 142]
colorlistgreen = [20, 105, 48, 116, 229, 238, 128, 205, 193, 97, 0, 142]
colorlistblue = [60, 180, 255, 205, 238, 118, 20, 0, 37, 3, 0, 142]
# Clear the plot first
self.plot.del_all_items()
# Add back the vertical cursor to the plot in the same position as before
self.plot.add_item( self.vcursor1 )
self.plot.add_item( self.vcursor2 )
# For axes take max of 2theta and max of intensity
maxtth = 0
maxintensity = 0
mintth = 100
minintensity = 100
# Use first predefined colours, then random
colorcounter = 0
# Two simple markers to test if mixed x ranges exist
foundq = 0
foundtth = 0
for row in range(self.series_list_model.rowCount()):
model_index = self.series_list_model.index(row, 0)
checked = self.series_list_model.data(model_index,
Qt.CheckStateRole) == QVariant(Qt.Checked)
name = str(self.series_list_model.data(model_index).toString())
if checked:
# has_series = True
self.curveAlabel = name
if len(colorlistred) > colorcounter:
self.curveA = make.curve( [ ], [ ], self.curveAlabel, QtGui.QColor( colorlistred[colorcounter], colorlistgreen[colorcounter], colorlistblue[colorcounter] ), linewidth=3.0)
colorcounter = colorcounter + 1
else:
self.curveA = make.curve( [ ], [ ], self.curveAlabel, QtGui.QColor( random.randint(0,255), random.randint(0,255), random.randint(0,255) ), linewidth=3.0)
self.plot.add_item( self.curveA )
self.curveA.set_data( self.x[name], self.y[name])
if max(self.x[name])>maxtth:
maxtth = max(self.x[name])
if max(self.y[name])>maxintensity:
maxintensity = max(self.y[name])
if min(self.x[name])<mintth:
mintth = min(self.x[name])
if min(self.y[name])<minintensity and min(self.y[name]) > 0:
minintensity = min(self.y[name])
# Check if TTH or Q range, redefine x label if Q
f = open(str(self.fullfilename[name]))
text1 = f.read()
f.close()
if 'Azimuth (Degrees)' in text1:
foundtth = 1
CurvePlot.set_axis_title(self.plot,CurvePlot.X_BOTTOM,"Azimuth angle (degrees)")
elif 'Q' in text1:
foundq = 1
CurvePlot.set_axis_title(self.plot,CurvePlot.X_BOTTOM,"q (1/nm)")
elif '2-Theta Angle (Degrees)' in text1:
foundtth = 1
CurvePlot.set_axis_title(self.plot,CurvePlot.X_BOTTOM,"2-theta (degrees)")
if foundq == 1 and foundtth == 1:
CurvePlot.set_axis_title(self.plot,CurvePlot.X_BOTTOM,"Mixed! q (1/nm) and 2-theta (degrees)")
self.legend = make.legend( 'TR' ) # Top Right
self.plot.add_item( self.legend )
# Reset axis if checkbox is checked, otherwise ignore
if self.tick_axis_reset.isChecked()==True:
CurvePlot.set_axis_limits(self.plot,CurvePlot.X_BOTTOM,mintth*0.9,maxtth*1.1)
CurvePlot.set_axis_limits(self.plot,CurvePlot.Y_LEFT,minintensity*0.9,maxintensity*1.1)
# Plot everything
self.plot.replot( )
# Refresh also the integral plot
self.button_Click6( )
# Select all
def button_Click3( self ):
for k in range(0,len(self.names)):
self.series_list_model.item(k).setCheckState( Qt.Checked )
# Select none
def button_Click4( self ):
for k in range(0,len(self.names)):
self.series_list_model.item(k).setCheckState( Qt.Unchecked )
# Download and integrate button
def button_Click5( self ):
curdir = str(self.text1.toPlainText())
execfile(curdir+"/setup/pipeline.py")
# Update file list after integrating
self.button_Click( )
# Sum over ROI and update the lower graph
def button_Click6( self ):
# Clear the plot first
self.plot2.del_all_items()
# Seed for random generator of colors, so that they are always in the same order
random.seed(654321)
colorlistred = [220, 255, 155, 24, 0, 0, 48, 205, 255, 255, 0, 142]
colorlistgreen = [20, 105, 48, 116, 229, 238, 128, 205, 193, 97, 0, 142]
colorlistblue = [60, 180, 255, 205, 238, 118, 20, 0, 37, 3, 0, 142]
markerlist = ['Rect','Diamond', 'UTriangle', 'DTriangle', 'RTriangle','Cross', 'Ellipse', 'Star1', 'XCross', 'LTriangle', 'Star2']
# Get cursor positions to define ROI
x1 = guiqwt.shapes.Marker.xValue(self.vcursor1)
x2 = guiqwt.shapes.Marker.xValue(self.vcursor2)
if x2 < x1:
x3 = copy.deepcopy(x1)
x1 = copy.deepcopy(x2)
x2 = x3
indices = []
self.sumy = {}
self.sumx = {}
# Use first predefined colours, then random
colorcounter = 0
maxsumx = 0
minsumx = 10000
maxsumy = 0
minsumy = 10000000
self.sumxall = {}
self.sumyall = {}
seriesnames = []
for row in range(self.series_list_model.rowCount()):
model_index = self.series_list_model.index(row, 0)
checked = self.series_list_model.data(model_index,
Qt.CheckStateRole) == QVariant(Qt.Checked)
name = str(self.series_list_model.data(model_index).toString())
if checked:
# Find x values over which to sum
indices = []
for index,value in enumerate(self.x[name]):
if value > x1 and value < x2:
indices.append(index)
xx = np.array(self.x[name])
yy = np.array(self.y[name])
sumy1 = np.trapz(yy[indices],xx[indices])
self.sumy[name] = [float(sumy1)]
number1 = re.findall("(?<=_|-)[\d]*(?=.chi)",name)
sumx1 = int(number1[0])
self.sumx[name] = [float(sumx1)]
if max(self.sumx[name])>maxsumx:
maxsumx = max(self.sumx[name])
if max(self.sumy[name])>maxsumy:
maxsumy = max(self.sumy[name])
if min(self.sumx[name])<minsumx:
minsumx = min(self.sumx[name])
if min(self.sumy[name])<minsumy and min(self.sumy[name]) > 0:
minsumy = min(self.sumy[name])
# Check which series names we have
name1 = re.findall("[\W\S\d]*(?=-[\d]{5}.chi)",name)
# Try different versions of writing the names if first one does not succeed
if name1 == []:
name1 = re.findall("[\W\S\d]*(?=_[\d]{4}.chi)",name)
if name1 == []:
name1 = re.findall("[\W\S\d]*(?=_[\d]{5}.chi)",name)
seriesname1 = str(name1[0])
if seriesname1 not in seriesnames:
seriesnames.append(seriesname1)
self.sumxall[seriesname1] = []
self.sumyall[seriesname1] = []
self.sumxall[seriesname1].append(sumx1)
self.sumyall[seriesname1].append(sumy1)
# Make lines and legends to separate different sample series
colorcounter = 0
random.seed(654321)
markercounter = 0
for seriesname1 in seriesnames:
if len(colorlistred) > colorcounter:
self.curveB = make.curve( [ ], [ ], seriesname1, QtGui.QColor( colorlistred[colorcounter], colorlistgreen[colorcounter], colorlistblue[colorcounter] ), linewidth=3.0, marker=markerlist[markercounter], markerfacecolor = QtGui.QColor( colorlistred[colorcounter], colorlistgreen[colorcounter], colorlistblue[colorcounter] ), markeredgecolor= QtGui.QColor( colorlistred[colorcounter], colorlistgreen[colorcounter], colorlistblue[colorcounter] ))
colorcounter = colorcounter + 1
markercounter = markercounter + 1
else:
newcolor = QtGui.QColor( random.randint(0,255), random.randint(0,255), random.randint(0,255))
self.curveB = make.curve( [ ], [ ], seriesname1, newcolor, linewidth=3.0, marker=markerlist[markercounter], markerfacecolor = newcolor, markeredgecolor = newcolor )
markercounter = markercounter + 1
if markercounter > len(markerlist):
markercounter = 0
self.plot2.add_item( self.curveB )
self.curveB.set_data( self.sumxall[seriesname1],self.sumyall[seriesname1] )
CurvePlot.set_axis_title(self.plot2,CurvePlot.X_BOTTOM,"File number")
CurvePlot.set_axis_title(self.plot2,CurvePlot.Y_LEFT,"ROI sum")
self.legend2 = make.legend( 'TR' ) # Top Right
self.plot2.add_item( self.legend2 )
# Reset axis if ticked
if self.tick_axis_reset.isChecked()==True:
CurvePlot.set_axis_limits(self.plot2,CurvePlot.X_BOTTOM,minsumx*0.9,maxsumx*1.1)
CurvePlot.set_axis_limits(self.plot2,CurvePlot.Y_LEFT,minsumy*0.9,maxsumy*1.1)
# Plot everything
self.plot2.replot( )
class MzPlottingWidget(CurveWidget):
def __init__(self, parent=None):
super(MzPlottingWidget, self).__init__(parent, xlabel="mz", ylabel="I")
patch_inner_plot_object(self, MzPlot)
self.plot.centralMz = None
def label(self, x):
# label with full precision:
return QwtText(str(x))
a = QwtScaleDraw()
a.label = new.instancemethod(label, self.plot, QwtScaleDraw)
self.plot.setAxisScaleDraw(self.plot.xBottom, a)
self.pm = PlotManager(self)
self.pm.add_plot(self.plot)
self.curve = make_unselectable_curve([], [],
color="b",
curvestyle="Sticks")
self.plot.add_item(self.curve)
t = self.pm.add_tool(MzSelectionTool)
self.pm.set_default_tool(t)
t.activate()
marker = Marker(label_cb=self.plot.label_info,
constraint_cb=self.plot.on_plot)
marker.attach(self.plot)
line = make_measurement_line()
line.setVisible(0)
setupCommonStyle(line, marker)
line.shapeparam.line.color = "#555555"
line.shapeparam.update_shape(line)
label = make.info_label("TR", [MzCursorInfo(marker, line)], title=None)
label.labelparam.label = ""
label.labelparam.font.size = 12
label.labelparam.update_label(label)
self.marker = marker
self.label = label
self.line = line
def plot_spectra(self, all_peaks, labels):
self.plot.del_all_items()
self.plot.add_item(self.marker)
self.plot.add_item(make.legend("TL"))
self.plot.add_item(self.label)
for i, (peaks, label) in enumerate(zip(all_peaks, labels)):
config = dict(color=getColor(i))
curve = make_unselectable_curve([], [],
title=label,
curvestyle="Sticks",
**config)
curve.set_data(peaks[:, 0], peaks[:, 1])
self.plot.add_item(curve)
self.plot.resample_config = []
self.plot.add_item(self.line)
if len(all_peaks):
self.plot.all_peaks = np.vstack(all_peaks)
else:
self.plot.all_peaks = np.zeros((0, 2))
def _setup_configs_and_titles(self, configs, titles, n):
configs = configs if configs is not None else [None] * n
titles = titles if titles is not None else [""] * n
def default(i):
return dict(color=getColor(i))
configs = [
ci if ci is not None else default(i)
for (i, ci) in enumerate(configs)
]
return configs, titles
def set_overall_range(self, mzmin, mzmax):
self.plot.overall_x_min = mzmin
self.plot.overall_x_max = mzmax
def plot_peakmaps(self, peakmap_ranges, configs=None, titles=None):
has_titles = titles is not None
configs, titles = self._setup_configs_and_titles(
configs, titles, len(peakmap_ranges))
self.plot.del_all_items()
self.plot.add_item(self.marker)
if has_titles:
self.plot.add_item(make.legend("TL"))
self.plot.add_item(self.label)
self.plot.plot_peakmap_ranges(peakmap_ranges, configs, titles)
self.plot.add_item(self.line)
def set_cursor_pos(self, mz):
self.plot.set_mz(mz)
def resetAxes(self):
self.plot.reset_x_limits()
def reset_mz_limits(self, xmin=None, xmax=None, fac=1.1):
self.plot.reset_x_limits(xmin, xmax, fac)
def reset(self):
self.plot.del_all_items()
self.replot()
def replot(self):
self.plot.replot()
def set_visible(self, visible):
self.plot.setVisible(visible)
def updateAxes(self):
self.plot.updateAxes()
def shrink_and_replot(self, mzmin, mzmax):
self.reset_mz_limits(mzmin, mzmax)
self.plot.reset_y_limits()
self.plot.replot()
class Window(QMainWindow):
def __init__(self, wintitle):
super(Window, self).__init__()
self.default_tool = None
self.plots = []
self.itemlist = PlotItemList(None)
self.contrast = ContrastAdjustment(None)
self.xcsw = XCrossSection(None)
self.ycsw = YCrossSection(None)
self.manager = PlotManager(self)
self.toolbar = QToolBar(_("Tools"), self)
self.manager.add_toolbar(self.toolbar, "default")
self.toolbar.setMovable(True)
self.toolbar.setFloatable(True)
self.addToolBar(Qt.TopToolBarArea, self.toolbar)
frame = QFrame(self)
self.setCentralWidget(frame)
self.layout = QGridLayout()
layout = QVBoxLayout(frame)
frame.setLayout(layout)
layout.addLayout(self.layout)
self.frame = frame
self.setWindowTitle(wintitle)
self.setWindowIcon(get_icon('guiqwt.svg'))
def closeEvent(self, event):
global _figures, _current_fig, _current_axes
figure_title = to_text_string(self.windowTitle())
if _figures.pop(figure_title) == _current_fig:
_current_fig = None
_current_axes = None
self.itemlist.close()
self.contrast.close()
self.xcsw.close()
self.ycsw.close()
event.accept()
def add_plot(self, i, j, plot):
self.layout.addWidget(plot, i, j)
self.manager.add_plot(plot)
self.plots.append(plot)
def replot(self):
for plot in self.plots:
plot.replot()
item = plot.get_default_item()
if item is not None:
plot.set_active_item(item)
item.unselect()
def add_panels(self, images=False):
self.manager.add_panel(self.itemlist)
if images:
for panel in (self.ycsw, self.xcsw, self.contrast):
panel.hide()
self.manager.add_panel(panel)
def register_tools(self, images=False):
if images:
self.manager.register_all_image_tools()
else:
self.manager.register_all_curve_tools()
def display(self):
self.show()
self.replot()
self.manager.get_default_tool().activate()
self.manager.update_tools_status()
class UI(QtGui.QMainWindow):
def __init__(self, parent=None):
super(UI, self).__init__(parent)
self.ui_obj = None
self.y_position = 0
self.slider_pos = 0
self.image_temp = None
self.image_w = 0
self.image_h = 0
self.image_path = None
self.ui_init()
self.init_connect()
self.plot_init()
def ui_init(self):
self.ui_obj = Ui_MainWindow()
self.ui_obj.setupUi(self)
def init_connect(self):
self.connect(self.ui_obj.y_verticalSlider,
QtCore.SIGNAL('valueChanged(int)'), self.plot_line_gray)
self.ui_obj.open_image_button.clicked.connect(self.open_image)
self.ui_obj.save_plot_button.clicked.connect(self.save_image)
def open_image(self):
self.file_name = QtGui.QFileDialog.getOpenFileName(
self, "open file dialog", "C:\Users\Administrator\Desktop",
"*.jpg *.png")
print self.file_name
if self.file_name != "":
# if self.ui_obj.image_path_lineEdit.text() != "":
# self.image_path = self.ui_obj.image_path_lineEdit.text()
self.image_path = self.file_name
if os.path.exists(self.image_path):
self.display_image()
else:
# self.image_clean()
print "path is not exists!!\n"
else:
# self.image_clean()
print "pls fill imagepath\n"
def save_image(self):
pass
def image_clean(self):
self.image_temp = None
self.image_w = 0
self.image_h = 0
def display_image(self):
# print "cv2 imread path :"+str(self.image_path)
self.image_temp = cv2.imread(str(self.image_path))
self.image_h = len(self.image_temp)
self.image_w = len(self.image_temp[0])
# #print image.shape[1],image.shape[0]
# #print self.ui_obj.picture_display.width(),self.ui_obj.picture_display.height()
# qimage = QtGui.QImage(image, image.shape[1], image.shape[0], QtGui.QImage.Format_RGB888)
# qimage_resize = qimage.scaled(self.ui_obj.picture_display.width(), self.ui_obj.picture_display.height(), 0, 0)
# self.ui_obj.picture_display.setPixmap(QtGui.QPixmap.fromImage(qimage_resize))
# self.ui_obj.picture_display.show()
pixmap = QtGui.QPixmap()
pixmap.load(str(self.image_path))
newpixmap = pixmap.scaled(self.ui_obj.picture_display.width(),
self.ui_obj.picture_display.height(), 0, 0)
self.ui_obj.picture_display.setPixmap(newpixmap)
self.ui_obj.picture_display.setAlignment(QtCore.Qt.AlignCenter)
self.ui_obj.picture_display.show()
def plot_init(self):
self.manager = PlotManager(self)
self.plots = []
self.plot = CurvePlot(xlabel="", ylabel="")
# self.plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(10)
self.manager.add_plot(self.plot)
self.plots.append(self.plot)
self.plot.plot_id = id(self.plot)
self.curve = make.curve([0], [0], color="blue", title="gray value")
self.plot.add_item(self.curve)
self.plot.add_item(make.legend("TR"))
self.ui_obj.line_info_display.addWidget(self.plot)
def plot_line_gray(self):
self.slider_pos = self.ui_obj.y_verticalSlider.value()
# print"print line ",self.slider_pos
# print type(self.slider_pos), len(self.image_temp)
self.y_position = (100 - self.slider_pos) * (int(self.image_h) / 100)
print "y_position:", self.y_position
line = [
self.image_temp[self.y_position][i][1]
for i in range(len(self.image_temp[self.y_position]))
]
print len(line), [i for i in range(len(line))]
self.plot.set_axis_limits('left', 0, 255)
self.plot.set_axis_limits('bottom', 0, self.image_w)
self.curve.set_data([i for i in range(len(line))], line)
self.plot.replot()
# print "image :", self.image_temp[3]
def blur(self, kernel):
pass
def nosie(self, method):
pass
class RtPlotter(PlotterBase):
def __init__(self, rangeSelectionCallback=None):
super(RtPlotter, self).__init__("RT", "I")
self.rangeSelectionCallback = rangeSelectionCallback
widget = self.widget
widget.plot.__class__ = RtPlot
# todo: refactor as helper
a = QwtScaleDraw()
# render tic labels in modfied format:
label = lambda self, v: QwtText(formatSeconds(v))
a.label = new.instancemethod(label, widget.plot, QwtScaleDraw)
widget.plot.setAxisScaleDraw(widget.plot.xBottom, a)
self.pm = PlotManager(widget)
self.pm.add_plot(widget.plot)
t = self.pm.add_tool(RtSelectionTool)
self.addTool(RtSelectionTool)
self.pm.set_default_tool(t)
marker = Marker(label_cb=self.widget.plot.label_info,
constraint_cb=self.widget.plot.on_plot)
marker.rts = [0]
setupStyleRtMarker(marker)
marker.attach(self.widget.plot)
self.marker = marker
label = make.info_label("T", [RtCursorInfo(marker)], title=None)
label.labelparam.label = ""
self.label = label
self.minRTRangeSelected = None
self.maxRTRangeSelected = None
def addTool(self, tool):
t = self.pm.add_tool(tool)
t.activate()
def reset(self):
self.plot([])
self.marker.rts = [0]
self.replot()
def plot(self, chromatograms, titles=None, configs=None,
withmarker=False):
""" do not forget to call replot() after calling this function ! """
allrts = set()
self.widget.plot.del_all_items()
# self.widget.plot.set_antialiasing(True)
for i in range(len(chromatograms)):
rts, chromatogram = chromatograms[i]
config = None
if configs is not None:
config = configs[i]
if config is None:
config = dict(color=getColor(i))
if titles:
title = titles[i]
else:
title = ""
curve = make.curve(rts, chromatogram, title=title, **config)
curve.__class__ = ModifiedCurveItem
allrts.update(rts)
self.widget.plot.add_item(curve)
if withmarker:
self.widget.plot.add_item(self.label)
allrts = sorted(allrts)
self.marker.rts = allrts
self.marker.attach(self.widget.plot)
self.widget.plot.add_item(self.marker)
if titles is not None:
self.widget.plot.add_item(make.legend("TL"))
self.addRangeSelector(allrts)
def setEnabled(self, enabled):
self.widget.plot.setVisible(enabled)
def addRangeSelector(self, rtvalues):
self.rtvalues = rtvalues
self.minRTRangeSelected = 0
self.maxRTRangeSelected = 0
range_ = SnappingRangeSelection(self.minRTRangeSelected,
self.maxRTRangeSelected, self.rtvalues)
setupStyleRangeMarker(range_)
self.range_ = range_
# you have to register item to plot before you can register the
# rtSelectionHandler:
self.widget.plot.add_item(range_)
self.widget.disconnect(range_.plot(), SIG_RANGE_CHANGED,
self.rangeSelectionHandler)
self.widget.connect(range_.plot(), SIG_RANGE_CHANGED,
self.rangeSelectionHandler)
cc = make.info_label("TR", [RtRangeSelectionInfo(range_)], title=None)
cc.labelparam.label = ""
self.widget.plot.add_item(cc)
def getRangeSelectionLimits(self):
return sorted((self.range_._min, self.range_._max))
def setRangeSelectionLimits(self, xleft, xright):
saved = self.rangeSelectionCallback
self.rangeSelectionCallback = None
self.minRTRangeSelected = xleft
self.maxRTRangeSelected = xright
# left and right bar of range marker
self.range_.move_point_to(0, (xleft, 0), emitsignal=False)
self.range_.move_point_to(1, (xright, 0))
# calls self.rangeSelectionHandler !
self.rangeSelectionCallback = saved
@protect_signal_handler
def rangeSelectionHandler(self, obj, left, right):
min_, max_ = sorted((left, right))
self.minRTRangeSelected = min_
self.maxRTRangeSelected = max_
if self.rangeSelectionCallback is not None:
self.rangeSelectionCallback()
