def update(self, yaw, pitch, roll): """ IMU data defined as follows: """ """ coordinate: x -> front, y -> left, z -> up """ """ positive direction: yaw -> turn right, pitch -> headup, roll -> roll left """ PI = np.pi # rescale and limitate the data so that they can all be treated as angles alfa, beta, gama = np.array([yaw, pitch, roll]) * PI/180 / self.scale if abs(alfa) > PI: alfa = PI * np.sign(alfa) # -180 <= alfa <= 180 if abs(beta) > PI/2: beta = PI/2 * np.sign(beta) # -90 <= beta <= 90 if abs(gama) > PI/2: gama = PI/2 * np.sign(gama) # -90 <= gama <= 90 # the projection of (unit vector erected on the body) on (the un-tumbled body system) x =-np.tan(beta) / (1+np.tan(beta)**2+np.tan(gama)**2)**0.5 y = np.tan(gama) / (1+np.tan(beta)**2+np.tan(gama)**2)**0.5 x, y = -y, x # rotate from the un-tumbled body system to the figrue system rad = np.arctan(y/-x) if x<0 else PI-np.arctan(y/x) if x>0 else PI/2*np.sign(y) # angle of arrow in figure system (left is 0 and clockwise is positive) if hasattr(self, 'arr1'): self.fig.removeItem(self.arr1) if hasattr(self, 'arr2'): self.fig.removeItem(self.arr2) rr = 1.15 # rescale the coordinate value to make the plot nice self.crv0.setData([0,x/rr], [0,y/rr]) self.arr1 = pg.ArrowItem(pen=None, brush='w', headLen=8, tipAngle=45, angle=rad/PI*180, pos=(x,y)) self.arr2 = pg.ArrowItem(pen=None, brush='r', headLen=10, tipAngle=45, angle=alfa/PI*180+90, pos=(rr*np.sin(alfa), rr*np.cos(alfa))) # yaw is relative to north self.fig.addItem(self.arr1) self.fig.addItem(self.arr2)
def plotText(self):
lenClose = len(self.listClose)
if lenClose >= 5: # Fractal Signal
if self.listClose[-1] > self.listClose[-2] and self.listClose[
-3] > self.listClose[-2] and self.listClose[
-4] > self.listClose[-2] and self.listClose[
-5] > self.listClose[-2] and self.listfastEMA[
-1] > self.listslowEMA[-1]:
## Draw an arrowhead next to the text box
# self.pw2.removeItem(self.arrow)
self.arrow = pg.ArrowItem(pos=(lenClose - 1, self.listLow[-1]),
angle=90,
brush=(255, 0, 0))
self.pw2.addItem(self.arrow)
elif self.listClose[-1] < self.listClose[-2] and self.listClose[
-3] < self.listClose[-2] and self.listClose[
-4] < self.listClose[-2] and self.listClose[
-5] < self.listClose[-2] and self.listfastEMA[
-1] < self.listslowEMA[-1]:
## Draw an arrowhead next to the text box
# self.pw2.removeItem(self.arrow)
self.arrow = pg.ArrowItem(pos=(lenClose - 1,
self.listHigh[-1]),
angle=-90,
brush=(0, 255, 0))
self.pw2.addItem(self.arrow)
def plotMark(self):
"""显示开平仓信号"""
# 检查是否有数据
if len(self.datas) == 0:
return
for arrow in self.arrows:
self.pwKL.removeItem(arrow)
# 画买卖信号
for i in range(len(self.listSig)):
# 无信号
if self.listSig[i] == 0:
continue
# 买信号
elif self.listSig[i] > 0:
arrow = pg.ArrowItem(pos=(i, self.datas[i]['low']),
angle=90,
brush=(255, 0, 0))
# 卖信号
elif self.listSig[i] < 0:
arrow = pg.ArrowItem(pos=(i, self.datas[i]['high']),
angle=-90,
brush=(0, 255, 0))
self.pwKL.addItem(arrow)
self.arrows.append(arrow)
def __init__(self, angle, col, dangle=5, parent=None):
super().__init__(parent)
color = QColor(0, 0, 0) if col else QColor(128, 128, 128)
angle_d = np.rad2deg(angle)
angle_2 = 90 - angle_d - dangle
angle_1 = 270 - angle_d + dangle
dangle = np.deg2rad(dangle)
arrow1 = pg.ArrowItem(parent=self,
angle=angle_1,
brush=color,
pen=pg.mkPen(color))
arrow1.setPos(np.cos(angle - dangle), np.sin(angle - dangle))
arrow2 = pg.ArrowItem(parent=self,
angle=angle_2,
brush=color,
pen=pg.mkPen(color))
arrow2.setPos(np.cos(angle + dangle), np.sin(angle + dangle))
arc_x = np.fromfunction(lambda i: np.cos(
(angle - dangle) + (2 * dangle) * i / 120.), (121, ),
dtype=int)
arc_y = np.fromfunction(lambda i: np.sin(
(angle - dangle) + (2 * dangle) * i / 120.), (121, ),
dtype=int)
pg.PlotCurveItem(parent=self,
x=arc_x,
y=arc_y,
pen=pg.mkPen(color),
antialias=False)
def add_origin_label(self, image_ui):
# origin label
text_id = pg.TextItem(html="<span style='color: yellow;'>(0,0)",
anchor=(1, 1))
image_ui.addItem(text_id)
text_id.setPos(-5, -5)
# x and y arrows directions
y_arrow = pg.ArrowItem(angle=-90,
tipAngle=35,
baseAngle=0,
headLen=20,
tailLen=40,
tailWidth=2,
pen='y',
brush=None)
image_ui.addItem(y_arrow)
y_arrow.setPos(0, 65)
y_text = pg.TextItem(html="<span style='color: yellow;'>Y")
image_ui.addItem(y_text)
y_text.setPos(-30, 20)
x_arrow = pg.ArrowItem(angle=180,
tipAngle=35,
baseAngle=0,
headLen=20,
tailLen=40,
tailWidth=2,
pen='y',
brush=None)
image_ui.addItem(x_arrow)
x_arrow.setPos(65, 0)
x_text = pg.TextItem(html="<span style='color: yellow;'>X")
image_ui.addItem(x_text)
x_text.setPos(20, -30)
def init_gui(self):
self.init_main_layout(orientation="vertical")
#self.main_layout = QtWidgets.QVBoxLayout()
#self.setLayout(self.main_layout)
self.init_attribute_layout()
# timer to update ival in gui
# self.timer_ival = QtCore.QTimer()
# self.timer_ival.setInterval(1000)
# self.timer_ival.timeout.connect(self.update_ival)
# self.timer_ival.start()
# dont know where this comes from, but it works if it is uncommented
self.attribute_layout.addStretch(1)
tailLene1 =100
tailLene2 =140
tailWidthe=2
headLens=40
teta1=15
teta2=teta1+90
self.setWindowTitle("Axis")
self.win = pg.GraphicsWindow(title="Axis")
self.plot_item = self.win.addPlot(title="Axis")
self.plot_item.showGrid(x=True, y=True)
self.main_layout.addWidget(self.win, stretch=1)
p = self.win.addPlot(row=0, col=0)
e1 = pg.ArrowItem(angle=-teta1, tipAngle=10, baseAngle=0, headLen=headLens, tailLen=tailLene1-headLens, tailWidth=tailWidthe, pen=None, brush='w')
e2 = pg.ArrowItem(angle=-teta2, tipAngle=10, baseAngle=0, headLen=headLens, tailLen=tailLene2-headLens, tailWidth=tailWidthe, pen=None, brush='w')
e1.setPos(0,0)
e2.setPos(0,0)
self.plot_item.addItem(e1)
self.plot_item.addItem(e2)
def add_arc(angle, col, dangle=5):
if col:
color = QColor(128, 128, 128) # gray
else:
color = QColor(0, 0, 0) # black
angle_d = np.rad2deg(angle)
angle_2 = 90 - angle_d - dangle
angle_1 = 270 - angle_d + dangle
dangle = np.deg2rad(dangle)
arrow1 = pg.ArrowItem(
parent=None, angle=angle_1, brush=color, pen=pg.mkPen(color, width=1)
)
arrow1.setPos(np.cos(angle - dangle), np.sin(angle - dangle))
arrow2 = pg.ArrowItem(
parent=None, angle=angle_2, brush=color, pen=pg.mkPen(color, width=1)
)
arrow2.setPos(np.cos(angle + dangle), np.sin(angle + dangle))
arc_x = np.fromfunction(
lambda i: np.cos((angle - dangle) + (2 * dangle) * i / 120.0), (121,), dtype=int
)
arc_y = np.fromfunction(
lambda i: np.sin((angle - dangle) + (2 * dangle) * i / 120.0), (121,), dtype=int
)
arc = pg.PlotCurveItem(
x=arc_x, y=arc_y, pen=pg.mkPen(color, width=1), antialias=False
)
return [arc, arrow1, arrow2]
def setup_figure(self):
#connect settings to ui
self.settings.Magnification.connect_to_widget(
self.ui.magnification_comboBox)
self.settings.W1.connect_to_widget(self.ui.w1_spinBox)
self.settings.H1.connect_to_widget(self.ui.h1_spinBox)
self.settings.W2.connect_to_widget(self.ui.w2_spinBox)
self.settings.H2.connect_to_widget(self.ui.h2_spinBox)
self.settings.dW.connect_to_widget(self.ui.dw_label)
self.settings.dH.connect_to_widget(self.ui.dh_label)
self.settings.dX.connect_to_widget(self.ui.dx_label)
self.settings.dY.connect_to_widget(self.ui.dy_label)
#setup ui signals
self.ui.load_image_pushButton.clicked.connect(self.load_image)
self.ui.export_pushButton.clicked.connect(
self.export_relative_movements)
self.ui.clear_pushButton.clicked.connect(self.clear_selections)
self.ui.move_stage_pushButton.clicked.connect(self.start)
#plot where selected image will be displayed
self.image_layout = pg.GraphicsLayoutWidget()
self.ui.image_groupBox.layout().addWidget(self.image_layout)
self.image_plot = self.image_layout.addPlot(title="")
self.image_plot.setAspectLocked(lock=True, ratio=1)
#image item
self.image = pg.ImageItem()
self.image_plot.addItem(self.image)
self.image.setPos(0, 0)
#arrow showing location of first selected point
self.arrow1 = pg.ArrowItem()
self.arrow1.setPos(0, 0)
self.image_plot.addItem(self.arrow1)
#arrow showing location of second selected point
self.arrow2 = pg.ArrowItem()
self.arrow2.setPos(0, 0)
self.arrow2.setStyle(brush='r')
self.image_plot.addItem(self.arrow2)
#when selecting multiple points, arrow showing location of last selected point
self.arrow_last_pos = pg.ArrowItem()
self.arrow_last_pos.setPos(0, 0)
self.image_plot.addItem(self.arrow_last_pos)
#make sure values update when a new point is selected
self.settings.W1.updated_value.connect(self.update_positions)
self.settings.H1.updated_value.connect(self.update_positions)
self.settings.W2.updated_value.connect(self.update_positions)
self.settings.H2.updated_value.connect(self.update_positions)
self.settings.Magnification.updated_value.connect(
self.update_positions)
self.image_plot.scene().sigMouseClicked.connect(
self.image_click) #setup plot click signal
self.ui.tabWidget.currentChanged.connect(
self.switch_arrows) #setup tab switch signal
def add_signals(self):
self.signals_group_text = QtGui.QGraphicsItemGroup()
self.signals_group_arrow = QtGui.QGraphicsItemGroup()
self.signals_text_items = np.empty(len(Quotes), dtype=object)
for p in Portfolio.positions:
x, price = p.id_bar_open, p.open_price
if p.type == Order.BUY:
y = Quotes[x].low * 0.99
pg.ArrowItem(
parent=self.signals_group_arrow,
pos=(x, y),
pen=self.plotgroup.long_pen,
brush=self.plotgroup.long_brush,
angle=90,
headLen=12,
tipAngle=50,
)
text_sig = CenteredTextItem(
parent=self.signals_group_text,
pos=(x, y),
pen=self.plotgroup.long_pen,
brush=self.plotgroup.long_brush,
text=('Buy at {:.%df}' %
self.plotgroup.digits).format(price),
valign=QtCore.Qt.AlignBottom,
)
text_sig.hide()
else:
y = Quotes[x].high * 1.01
pg.ArrowItem(
parent=self.signals_group_arrow,
pos=(x, y),
pen=self.plotgroup.short_pen,
brush=self.plotgroup.short_brush,
angle=-90,
headLen=12,
tipAngle=50,
)
text_sig = CenteredTextItem(
parent=self.signals_group_text,
pos=(x, y),
pen=self.plotgroup.short_pen,
brush=self.plotgroup.short_brush,
text=('Sell at {:.%df}' %
self.plotgroup.digits).format(price),
valign=QtCore.Qt.AlignTop,
)
text_sig.hide()
self.signals_text_items[x] = text_sig
self.chart.addItem(self.signals_group_arrow)
self.chart.addItem(self.signals_group_text)
self.signals_visible = True
def updateIndicatorSar(self, sarDatas, startIndex):
"""更新sar指标 startIndex 从0到 len -1"""
if len(sarDatas) == 0:
return
while (len(self.sars) > (startIndex - 1)):
sar = self.sars[-1]
self.pwKL.removeItem(sar)
self.sars.remove(sar)
for i in range(startIndex, len(sarDatas)):
arrow = pg.ArrowItem(pos=(i, sarDatas[i]), angle=90, tipAngle=5, headLen=2, tailWidth=4, pen={'width': 1},
brush=(0, 0, 255))
defaultOpts = {
'pxMode': True,
'angle': -150, ## If the angle is 0, the arrow points left
'pos': (0, 0),
'headLen': 10,
'tipAngle': 10,
'baseAngle': 0,
'tailLen': None,
'tailWidth': 3,
'pen': (200, 200, 200),
'brush': (255, 0, 0),
}
# arrow.setStyle(defaultOpts)
self.pwKL.addItem(arrow)
self.sars.append(arrow)
def _arrows_changed(self, arrows):
"""
Set the locations and colours of arrows to be drawn
:param arrows: Sequence of tuples: (position, color). Position
is a XYZ tuple, color is anything that can
be passed to pyqtgraph.mkPen (e.g. color name
or RGB tuple)
"""
item_num = 0
for pos, col in arrows:
if item_num == len(self._arrow_items):
item = pg.ArrowItem()
self._viewbox.addItem(item)
self._arrow_items.append((pos, col, item))
_, _, item = self._arrow_items[item_num]
item.setPos(float(pos[self.xaxis]), float(pos[self.yaxis]))
item.setPen(pg.mkPen(col))
item.setBrush(pg.mkBrush(col))
item.setZValue(2)
self._arrow_items[item_num] = (pos, col, item)
item_num += 1
for _, _, item in self._arrow_items[item_num:]:
self._viewbox.removeItem(item)
self._arrow_items = self._arrow_items[:item_num]
self._update_visible_arrows()
def create_arrow(self, angle, row, col, center=False):
""""Create arrow."""
vb1 = self.pw2.addViewBox(row=row, col=col, enableMouse=False)
vb1.setBackgroundColor(None)
vb1.setAutoPan(False, False)
if center:
arrow_right = MyArrowItem(angle=angle,
tipAngle=60,
tailLen=80,
tailWidth=40,
headLen=80,
pen=None,
brush='fc0303')
else:
arrow_right = pg.ArrowItem(angle=angle,
tipAngle=60,
tailLen=80,
tailWidth=40,
headLen=80,
pen=None,
brush='fc0303')
vb1.addItem(arrow_right)
vb1.setRange(xRange=(-10, 10), yRange=(-10, 10))
return arrow_right
def plotMark(self):
"""显示开平仓信号"""
# 检查是否有数据
if len(self.datas) == 0:
return
for i in range(len(self.arrows)):
arrow = self.arrows[0]
self.pwKL.removeItem(self.arrows[0])
self.arrows.remove(self.arrows[0])
# 画买卖信号
# for i in range(len(self.listSig)):
# # 无信号
# if self.listSig[i][0] == 0:
# continue
# # 买开信号
# elif self.listSig[i][0] == 1:
# arrow = pg.ArrowItem(pos=(i, self.listSig[i][1]), angle=90, brush=(255, 0, 0))
# # 买平信号
# elif self.listSig[i][0] == 3:
# arrow = pg.ArrowItem(pos=(i, self.listSig[i][1]), angle=90, brush=(255, 255, 0))
# # 卖开信号
# elif self.listSig[i][0] == 2:
# arrow = pg.ArrowItem(pos=(i, self.listSig[i][1]), angle=-90, brush=(0, 255, 0))
# # 卖平信号
# elif self.listSig[i][0] == 4:
# arrow = pg.ArrowItem(pos=(i, self.listSig[i][1]), angle=-90, brush=(0, 0, 255))
# self.pwKL.addItem(arrow)
# self.arrows.append(arrow)
for i in range(len(self.listSig)):
arrow = pg.ArrowItem(pos=(self.listSig[i][0], self.listSig[i][1]),
angle=-90,
brush='y')
self.pwKL.addItem(arrow)
if arrow not in self.arrows:
self.arrows.append(arrow)
def update(self, parameter_name, time, value):
try:
parameter = self.db.get(parameter_name)
except KeyError:
parameter = self.db.create(parameter_name)
# Update parameter history
parameter.update(time, value)
# Update parameter curve
if parameter_name in self.curves:
curve = self.curves[parameter_name]
curve.setData(parameter.t_series, parameter.v_series)
curve.parameter = parameter # todo This is hacky
# Update value in parameter tree
if not parameter_name in self.qtree_widget_items:
item = QtGui.QTreeWidgetItem([parameter_name])
self.params_tree.addTopLevelItem(item)
self.qtree_widget_items[parameter_name] = item
item = self.qtree_widget_items[parameter_name]
item.setData(1, QtCore.Qt.DisplayRole, value)
# Add arrows if annotation event occurs
# todo This is slow and hacky
if parameter_name in self.annotators:
annotator = self.annotators[parameter_name]
if annotator.matches(parameter):
for parameter_name, curve in self.curves.items():
parameter = self.db.get(parameter_name)
arrow = pg.ArrowItem()
arrow.setPos(time, parameter.v_series[-1])
curve.parent.addItem(arrow)
def onMarker_1(self, state):
if state == 2:
self.MARKERS[0] = True
self.ui.deltaCheck.setEnabled(True)
self.ui.markerEdit_1.setEnabled(True)
self.ui.markerEdit_1.setRange(1, 1280)
self.ui.markerEdit_1.setValue(self.center/1e6)
self.markerValue[0] = self.ui.markerEdit_1.value()
self.marker_1 = pg.CurvePoint(self.curve)
self.plot.addItem(self.marker_1)
self.markers[0] = self.marker_1
self.markerArrow_1 = pg.ArrowItem(angle=270)
self.markerArrow_1.setParentItem(self.marker_1)
self.markerText_1 = pg.TextItem("Mk1", anchor=(0.5, 1.5))
self.markerText_1.setParentItem(self.marker_1)
self.markerText[0] = self.markerText_1
elif state == 0:
self.MARKERS[0] = False
self.markerIndex[0] = None
self.markerValue[0] = None
self.markerText[0] = None
self.ui.markerEdit_1.setDisabled(True)
self.ui.deltaCheck.setDisabled(True)
self.plot.removeItem(self.marker_1)
self.marker_1.deleteLater()
self.marker_1 = None
def _point_clicked(self, data_item, spot_items):
spot_item = spot_items[0]
position = spot_item.pos()
if self.arrow is None:
self.arrow = pyqtgraph.ArrowItem(angle=-120,
tipAngle=30,
baseAngle=20,
headLen=40,
tailLen=40,
tailWidth=8,
pen=None,
brush="y")
self.arrow.setPos(position)
# NB: temporary glitch if addItem is done before setPos
self.xy_plot.addItem(self.arrow)
else:
self.arrow.setPos(position)
self.selected_index = spot_item.histogram_index
if self.hist_plot_data is None:
self.hist_plot.clear()
self.hist_plot_data = self.hist_plot.plot(
x=self.histogram_bins,
y=spot_item.histogram_counts,
stepMode=True,
fillLevel=0,
brush=(0, 0, 255, 150))
else:
self.hist_plot_data.setData(x=self.histogram_bins,
y=spot_item.histogram_counts)
def setup_figure(self):
self.clear_qt_attr('graph_layout')
self.graph_layout = pg.GraphicsLayoutWidget(border=(100, 100, 100))
self.ui.plot_groupBox.layout().addWidget(self.graph_layout)
self.clear_qt_attr('img_plot')
self.img_plot = self.graph_layout.addPlot()
self.img_items = []
self.img_item = pg.ImageItem()
self.img_items.append(self.img_item)
self.img_plot.addItem(self.img_item)
self.img_plot.showGrid(x=True, y=True)
self.img_plot.setAspectLocked(lock=True, ratio=1)
self.current_stage_pos_arrow = pg.ArrowItem()
self.current_stage_pos_arrow.setZValue(100)
self.img_plot.addItem(self.current_stage_pos_arrow)
self.write_pen = pg.mkPen('r', width=5)
self.line_item = self.img_plot.plot(pen=self.write_pen)
self.img_plot.addItem(self.line_item)
def __init__(self, parent=None, **kwargs):
super(AppWindow, self).__init__(parent)
self.setupUi(self)
self.I = kwargs.get('I', None)
self.setWindowTitle(self.I.H.version_string + ' : ' +
params.get('name', '').replace('\n', ' '))
self.plot = self.add2DPlot(self.plot_area)
labelStyle = {'color': 'rgb(255,255,255)', 'font-size': '11pt'}
self.plot.setLabel('left', 'Value -->', units='', **labelStyle)
self.totalpoints = 2000
self.X = np.arange(self.totalpoints)
self.Y = np.zeros(self.totalpoints)
self.plot.setXRange(0, self.totalpoints)
self.plot.setYRange(-16, 16)
self.curve = self.addCurve(self.plot, name='Data')
self.curve.setPen(color=[255, 255, 255], width=1)
self.streamfunc = "I." + self.cmdlist.currentText()
self.start_time = time.time()
self.num = 0
self.arrow = pg.ArrowItem(angle=90)
self.plot.addItem(self.arrow)
self.plot_area.addWidget(self.plot)
self.looptimer = QtCore.QTimer()
self.looptimer.timeout.connect(self.acquire)
self.looptimer.start(1)
self.nm = 0
self.start_time = time.time()
self.averagingSamples = 1
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle('pyqtgraph example: PlotWidget')
self.resize(800,800)
centerwidget = QtGui.QWidget()
self.setCentralWidget(centerwidget)
layout = QtGui.QVBoxLayout()
centerwidget.setLayout(layout)
candleData = getCandleData()
mplWidget = MyMplCanvas(dataForCandle=candleData,width=5, height=4, dpi=100)
layout.addWidget(mplWidget)
plt = MyPyqtGraphPlot(dataForCandle=candleData)
layout.addWidget(plt)
PyqtGraph02 = pg.PlotWidget()
layout.addWidget(PyqtGraph02)
#p3.setXLink(p1)
PyqtGraph02.setXLink(plt)
x = np.random.normal(size=300)
y = np.random.normal(size=300)
PyqtGraph02.plot(x,y, pen=(255,0,0), name="Red curve")
for x1,y1 in zip(x,y):
a1 = pg.ArrowItem(angle=x1*100, tipAngle=x1*10, headLen=x1*10, tailLen=y1*10, tailWidth=y1*10, pen={'color': 'w', 'width': 3})
PyqtGraph02.addItem(a1)
a1.setPos(x1,y1)
def __init__(self, parent, place=0, name ="noname", xdata=[], ydata=[], color=1):
self.name =name
while (parent.colorRotation >= len(COLORS)):
parent.colorRotation = parent.colorRotation - len(COLORS)
#print("color", parent.colorRotation,len(COLORS) )
color = COLORS[color]
parent.colorRotation += 1
#color = (255,0,0)
self.curve = parent.p.plot(pen=color, name=name)
self.dat = ydata
self.xdat = xdata
#print(ydata)
self.maxLen = 1200*10 #1200 1 minut, 72000 en timme 1728000 24h
#print(1, self.curve)
self.curve.setData(x=self.xdat, y=self.dat)
## Set up an animated arrow and text that track the curve
#print(2)
self.curvePoint = pg.CurvePoint(self.curve)
#print(3)
parent.p.addItem(self.curvePoint)
self.arrow = pg.ArrowItem(angle=90)
parent.p.addItem(self.arrow)
self.text = pg.TextItem(self.name, anchor=(0.5, -1.0))
self.text.setParentItem(self.arrow)
def __init__(self, parent, line, graphicType, **kwrds):
self.parent = parent
self.saved_color = kwrds['color']
pg.TextItem.__init__(self,
text='',
anchor=(0.5, -1),
fill=pg.mkBrush(0, 0, 0, 0),
**kwrds)
self.graphicType = graphicType
if self.graphicType == 'short':
self.arrow = pg.ArrowItem(angle=90,
headWidth=0.5,
headLen=0,
tailLen=30,
brush=pg.mkBrush(255, 0, 0, 255),
pen=pg.mkPen(0, 0, 0, 0),
anchor=(0.5, -0.5))
elif self.graphicType == 'infinite':
self.arrow = pg.InfiniteLine(angle=90,
pen=pg.mkPen(color=kwrds['color'],
width=.5,
style=Qt.SolidLine),
label='') #style=Qt.DashLine
self.arrow.setParentItem(self)
self.setFont(QFont("SansSerif", 10))
self.line = line
self.setActive()
def __init__(self, model):
pg.GraphicsWidget.__init__(self)
pg.GraphicsWidgetAnchor.__init__(self)
self.model = model
self.arrow = pg.ArrowItem(
parent=self,
angle=0.0,
brush=(0, 0, 0, 180),
pen=(255, 255, 255),
pxMode=True,
)
self.label = pg.LabelItem("Towards Sat.",
justify="right",
size="8pt",
parent=self)
self.label.anchor(itemPos=(1.0, -1.0), parentPos=(1.0, 0.0))
# self.label.setBrush(pg.mkBrush(255, 255, 255, 180))
# self.label.setFont(QtGui.QFont(
# "Helvetica", weight=QtGui.QFont.DemiBold))
self.orientArrow()
self.model.sigSceneChanged.connect(self.orientArrow)
self.setFlag(self.ItemIgnoresTransformations)
def draw_sell_buy():
for order in orders_history:
if order["type"] == "sell":
angle = -90
elif order["type"] == "buy":
angle = 90
br = pg.mkBrush(color=pg.intColor(order['index']))
pn = pg.mkPen(color=pg.intColor(order['index']),
width=1,
style=QtCore.Qt.SolidLine)
a = pg.ArrowItem(pos=(order['mts'].replace(
tzinfo=datetime.timezone.utc).timestamp(), order['price']),
angle=angle,
tipAngle=60,
baseAngle=0,
headLen=10,
tailLen=None,
brush=br,
pen=pn)
self.ui.plot1.addItem(a)
self.ui.plot1_sell_buy.append(a)
if order['loss'] != 0.0:
t = pg.TextItem(text="%.2f" % order['loss'],
color=pg.intColor(order['index']),
anchor=(0, 0))
self.ui.plot1.addItem(t)
t.setPos(
order['mts'].replace(
tzinfo=datetime.timezone.utc).timestamp(),
order['price'])
self.ui.plot1_sell_buy.append(t)
def setup_figure(self):
#connecting settings to ui
self.pi_device_hw.settings.x_position.connect_to_widget(self.ui.x_label)
self.pi_device_hw.settings.y_position.connect_to_widget(self.ui.y_label)
self.settings.step_size.connect_to_widget(self.ui.step_size_spinBox)
#setup ui signals
self.ui.start_pushButton.clicked.connect(self.start)
self.ui.up_pushButton.clicked.connect(self.move_up)
self.ui.right_pushButton.clicked.connect(self.move_right)
self.ui.down_pushButton.clicked.connect(self.move_down)
self.ui.left_pushButton.clicked.connect(self.move_left)
#plot showing stage area
self.stage_layout=pg.GraphicsLayoutWidget()
self.ui.stage_groupBox.layout().addWidget(self.stage_layout)
self.stage_plot = self.stage_layout.addPlot(title="Stage view")
self.stage_plot.setXRange(0, 100)
self.stage_plot.setYRange(0, 100)
self.stage_plot.setLimits(xMin=0, xMax=100, yMin=0, yMax=100)
#arrow indicating stage position
self.current_stage_pos_arrow = pg.ArrowItem()
self.current_stage_pos_arrow.setZValue(100)
self.current_stage_pos_arrow.setPos(0, 0)
self.stage_plot.addItem(self.current_stage_pos_arrow)
def addIndicatorSar(self, sarDatas):
"""增加sar指标"""
if len(sarDatas) == 0:
return
for sar in self.sars:
self.pwKL.removeItem(sar)
# 画信号
for i in range(len(sarDatas)):
# arrow = pg.ArrowItem(pos=(i, sarDatas[i]),headLen=10, angle=90, brush=(0, 0, 255))
arrow = pg.ArrowItem(pos=(i, sarDatas[i]), angle=90, tipAngle=5, headLen=2, tailWidth=4, pen={'width': 1},
brush=(0, 0, 255))
defaultOpts = {
'pxMode': True,
'angle': -150, ## If the angle is 0, the arrow points left
'pos': (0, 0),
'headLen': 10,
'tipAngle': 10,
'baseAngle': 0,
'tailLen': None,
'tailWidth': 3,
'pen': (200, 200, 200),
'brush': (255, 0, 0),
}
# arrow.setStyle(defaultOpts)
self.pwKL.addItem(arrow)
self.sars.append(arrow)
def setPointer(self):
if hasattr(self, 'arrow'):
self.parent.parent.plot.vb.removeItem(self.arrow)
if self.reference:
pen = pg.mkPen(color=(180, 190, 30, 255),
width=1.5,
style=Qt.SolidLine)
else:
pen = pg.mkPen(color=self.saved_color,
width=.5,
style=Qt.SolidLine)
if self.va == 'down':
anchor, angle, tailLen, pos = [0.5, -2], 90, 30, (0, 5)
elif self.va == 'up':
anchor, angle, tailLen, pos = [0.5, 2], -90, 30, (0, -10)
if self.graphicType == 'short':
anchor[0] = anchor[1] - 1 if self.va == 'down' else anchor[1] + 1
self.arrow = pg.ArrowItem(angle=angle,
headWidth=0,
headLen=0,
tailLen=tailLen,
tailWidth=2,
brush=pg.mkBrush(self.saved_color),
pen=pg.mkPen(0, 0, 0, 0),
pos=pos)
elif self.graphicType == 'infinite':
self.arrow = pg.InfiniteLine(angle=90, pen=pen,
label='') #style=Qt.DashLine
self.arrow.setParentItem(self)
def add(
self,
uid: str,
x: float,
y: float,
color='default',
pointing: str = 'up',
) -> pg.ArrowItem:
"""Add an arrow graphic to view at given (x, y).
"""
yb = pg.mkBrush(hcolor('alert_yellow'))
angle = 90 if pointing == 'up' else -90
arrow = pg.ArrowItem(
angle=angle,
baseAngle=0,
headLen=5,
headWidth=2,
tailLen=None,
brush=yb,
)
arrow.setPos(x, y)
self._arrows[uid] = arrow
# render to view
self.chart.plotItem.addItem(arrow)
return arrow
def addIndicators(self):
self.sarDatas = self.hourSarData.ExtSARBuffer
"""增加sar指标"""
if len(self.sarDatas) == 0:
return
for sar in self.sars:
self.plotItem.removeItem(sar)
# 画信号
for i in range(len(self.sarDatas)):
arrow = pg.ArrowItem(pos=(i, self.sarDatas[i]),
angle=90,
tipAngle=5,
headLen=2,
tailWidth=4,
pen={'width': 1},
brush=(0, 0, 255))
defaultOpts = {
'pxMode': True,
'angle': -150, ## If the angle is 0, the arrow points left
'pos': (0, 0),
'headLen': 10,
'tipAngle': 10,
'baseAngle': 0,
'tailLen': None,
'tailWidth': 3,
'pen': (200, 200, 200),
'brush': (255, 0, 0),
}
self.plotItem.addItem(arrow)
self.sars.append(arrow)
self.setIndicatorsData()
def updateIndicators(self):
#sar 只计算最后3个值
preSARLen = len(self.hourSarData.ExtSARBuffer)
self.hourSarData.OnCalculate(len(self.parent.listHigh),
len(self.parent.listHigh) - 3,
self.parent.listHigh, self.parent.listLow)
startIndex = preSARLen - 1
self.sarDatas = self.hourSarData.ExtSARBuffer
for i in range(startIndex, preSARLen):
arrow = pg.ArrowItem(pos=(i, self.sarDatas[i]),
angle=90,
tipAngle=5,
headLen=2,
tailWidth=4,
pen={'width': 1},
brush=(0, 0, 255))
defaultOpts = {
'pxMode': True,
'angle': -150, ## If the angle is 0, the arrow points left
'pos': (0, 0),
'headLen': 10,
'tipAngle': 10,
'baseAngle': 0,
'tailLen': None,
'tailWidth': 3,
'pen': (200, 200, 200),
'brush': (255, 0, 0),
}
print self.base.plotItem
self.base.plotItem.addItem(arrow)
self.base.indicatorsElements.append(arrow)
def locate(self):
if len(self.y) < 10:
self.showStatus(
"Peak Detection | please click on upload / load data from file",
True)
return
import peak
self.clearPeaks()
indices = peak.indexes(self.y,
thres=self.thres.value() / max(self.y),
min_dist=self.peakGap)
for a in indices:
arr = pg.ArrowItem(angle=-160,
tipAngle=90,
headLen=7,
tailLen=9,
tailWidth=5,
pen={
'color': 'r',
'width': 1
})
self.plot.addItem(arr)
arr.setPos(a * self.xscale, self.y[a])
self.peakMarks[arr] = a
self.showStatus("Peak Detection | %d Peak(s) Found" % len(indices))