def bounding_box(self, data, ax, label, bBoundingBoxes, bLabels):
"""Draw bounding box around data."""
data = np.array(data)
width = max(data[:, 0]) - min(data[:, 0])
height = max(data[:, 1]) - min(data[:, 1])
r = Rectangle((min(data[:, 0]), min(data[:, 1])), width, height)
if bBoundingBoxes:
ax.add_artist(r)
r.set_clip_box(ax.bbox)
r.set_alpha(0.1)
r.set_facecolor((0.5, 0.5, 0.5))
if bLabels:
ax.annotate(label,
xy=(min(data[:, 0]), max(data[:, 1])),
xytext=(0, 0),
textcoords='offset points',
ha='right',
va='bottom',
bbox=dict(boxstyle='round,pad=0.5',
fc=(0.5, 0.5, 0.5),
alpha=0.1))
def candlestick(ax, quotes, width=0.2, colorup="k", colordown="r", alpha=1.0):
OFFSET = width / 2.0
lines = []
patches = []
for q in quotes:
t, open, close, high, low = q[:5]
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(xdata=(t, t), ydata=(low, high), color=color, linewidth=0.5, antialiased=True)
rect = Rectangle(xy=(t - OFFSET, lower), width=width, height=height, facecolor=color, edgecolor=color)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
return lines, patches
def fooCandlestick(ax, quotes, width=0.029, colorup='#FFA500', colordown='#222', alpha=1.0): OFFSET = width/2.0 lines = [] boxes = [] for q in quotes: timestamp, op, hi, lo, close = q[:5] box_h = max(op, close) box_l = min(op, close) height = box_h - box_l if close>=op: color = '#3fd624' else: color = '#e83e2c' vline_lo = Line2D( xdata=(timestamp, timestamp), ydata=(lo, box_l), color = 'k', linewidth=0.5, antialiased=True, zorder=10 ) vline_hi = Line2D( xdata=(timestamp, timestamp), ydata=(box_h, hi), color = 'k', linewidth=0.5, antialiased=True, zorder=10 ) rect = Rectangle( xy = (timestamp-OFFSET, box_l), width = width, height = height, facecolor = color, edgecolor = color, zorder=10) rect.set_alpha(alpha) lines.append(vline_lo) lines.append(vline_hi) boxes.append(rect) ax.add_line(vline_lo) ax.add_line(vline_hi) ax.add_patch(rect) ax.autoscale_view() return lines, boxes
def plotKLine(self, data, timescale=1.0,
width=0.9, colorup='r', colorflat = 'w', colordown='g', alpha=1.0):
u"""根据数据画一个新的K线"""
self.priceChart.set_xlim(data[0]-50*timescale/86400,data[0]+8*timescale/86400)
t, open, close, high, low = data[:5]
if close > open:
color = colorup
elif close == open:
color = colorflat
else:
color = colordown
if close == open:
close = open + 0.005
shadowline = Line2D(xdata=(t, t), ydata=(low, high),
color=color,linewidth=0.5,antialiased=True,)
rect = Rectangle(xy = (t-width*timescale/172800, open),
width = width*timescale/86400,
height = close-open, facecolor=color, edgecolor=color,)
rect.set_alpha(alpha)
self.priceChart.add_line(shadowline)
self.priceChart.add_patch(rect)
return shadowline, rect
def candlestick(self, axis, prices, width=0.5, colorup='green',
colordown='red', alpha=1.0):
"""
Plot the time, open, close, high, low as a vertical line ranging
from low to high. Use a rectangular bar to represent the
open-close span. If close >= open, use colorup to color the bar,
otherwise use colordown
ax : an Axes instance to plot to
width : fraction of a day for the rectangle width
colorup : the color of the rectangle where close >= open
colordown : the color of the rectangle where close < open
alpha : the rectangle alpha level
"""
dates = []
lines = []
for date in self.dates:
t = date2num(date)
close = prices.close[date]
open_ = prices.open[date]
if close >= open_:
color = colorup
lower = open_
height = close - open_
else:
color = colordown
lower = close
height = open_ - close
lines.extend([prices.low[date], prices.high[date], None])
dates.extend([t, t, None])
rect = Rectangle(xy=(t - width/2, lower), width=width,
height=height, facecolor=color, edgecolor=color, zorder=2)
rect.set_alpha(alpha)
axis.add_patch(rect)
axis.plot(dates, lines, linewidth=0.5, zorder=1, antialiased=True)
return min(y for y in lines if y is not None), max(lines)
def __plot_volume(self, ax, params=None):
if params is None:
width = 0.6
else:
width = params["width"]
prices = self.prices.tail(self.candlestick_num)
for i in self.indices:
p = prices.iloc[i, :]
open = p["Open"]
close = p["Close"]
volume = p["Volume"]
if close >= open:
color = "red"
else:
color = "green"
rect = Rectangle(
xy = (i - width/2, 0),
width = width,
height = volume,
facecolor = color,
edgecolor = color,
)
rect.set_alpha(0.5)
ax.add_patch(rect)
ax.set_ylim([0, prices["Volume"].max() * 1.25])
ax.grid(b=True, axis='x')
def plotKLine(self, data, timescale=1.0,
width=0.9, colorup='r', colorflat = 'w', colordown='g', alpha=1.0):
self.priceChart.set_xlim(data[0]-50*timescale/86400,data[0]+8*timescale/86400)
t, open, close, high, low = data[:5]
if close > open:
color = colorup
elif close == open:
color = colorflat
else:
color = colordown
if close == open:
close = open + 0.005
shadowline = Line2D(xdata=(t, t), ydata=(low, high),
color=color,linewidth=0.5,antialiased=True,)
rect = Rectangle(xy = (t-width*timescale/172800, open),
width = width*timescale/86400,
height = close-open, facecolor=color, edgecolor=color,)
rect.set_alpha(alpha)
#self.priceChart.axhline(y=close,xmin=0.2,xmax=0.8)
self.priceChart.add_line(shadowline)
self.priceChart.add_patch(rect)
#返回画的图形，方便后面adjust
return shadowline, rect
def plotVolume(self,
data,
timescale=1.0,
width=0.9,
colorup='r',
colorflat='w',
colordown='g',
alpha=1.0):
u"""根据数据画一个新的成交量rect"""
self.volumeChart.set_xlim(data[0] - 50 * timescale / 86400,
data[0] + 8 * timescale / 86400)
t, open, close = data[:3]
volume = data[5]
if close > open:
color = colorup
elif close == open:
color = colorflat
else:
color = colordown
rect = Rectangle(xy=(t - width * timescale / 172800, 0),
width=width * timescale / 86400,
height=volume,
facecolor=color,
edgecolor=color)
rect.set_alpha(alpha)
self.volumeChart.add_patch(rect)
return rect
def render_sticks(ax, quotes, width=1000, colorup='#00FF00', colordown='#FF0000', alpha=0.8):
for q in quotes:
t, open, high, low, close = q[:5]
timestamp = dates.date2num(t)
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(timestamp, timestamp), ydata=(low, high),
color=color,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(timestamp, lower),
width=0.5/len(quotes),
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
rect.set_linewidth((width * 0.8)/len(quotes))
ax.add_line(vline)
ax.add_patch(rect)
def __fill_fibonacci_retracement_rectangle_dic__(self):
index_left = self.xy[0, 0]
index_right = self.xy[self.xy.shape[0] - 1, 0]
value_left = self.xy[0, 1]
value_right = self.xy[self.xy.shape[0] - 1, 1]
value_range = value_right - value_left
width = index_right - index_left
for k in range(
0,
len(fibonacci_helper.retracement_array_for_plotting) - 1):
ret_01 = fibonacci_helper.retracement_array_for_plotting[k]
ret_02 = fibonacci_helper.retracement_array_for_plotting[k + 1]
value_01 = round(value_left + ret_01 * value_range, 2)
value_02 = round(value_left + ret_02 * value_range, 2)
height = value_02 - value_01
rectangle = Rectangle(np.array([index_left, value_01]),
width=width,
height=height)
rectangle.set_linewidth(1)
rectangle.set_linestyle('dashed')
rectangle.set_color(self.color_list[k])
rectangle.set_edgecolor('k')
rectangle.set_alpha(0.1)
rectangle.set_visible(False)
self.__fib_retracement_rectangle_dic[ret_02] = rectangle
self.__fill_retracement_text_annotations__(index_left, ret_02,
value_02)
self.__fill_retracement_spikes_text_annotations__(ret_02, k + 1)
def plot_quad_system_geometry(stateSolMat, timeStep):
'''
stateSol is the state vector of the payload, for each time step
X=x xDot y yDot theta thetaDot
ax is the returned figure axis
'''
stateSol = stateSolMat[timeStep]
# Figure #1
fig = plt.figure(figsize=(13, 8))
ax = fig.gca()
# ax.axis todo: set limits to axes so they are bigger then expected geometry
ax.scatter(stateSol[0], stateSol[2], s=20, c='b') #stateSol[:,0]
print stateSol[0], stateSol[2]
# # LumpedMass payload
# lumpedPayload = Circle((stateSol[0,0], stateSol[0,0]), 13)
# Circle.set_color(lumpedPayload, '0.75')
# Circle.set_alpha(lumpedPayload, 0.1)
# ax.add_patch(lumpedPayload)
# print stateSol[0,0]
# rectangular payload
payloadW = 1.2
payloadH = 0.1
rectPayload = Rectangle((stateSol[0], stateSol[2]), payloadW, payloadH)
Rectangle.set_color(rectPayload, '0.75')
Rectangle.set_alpha(rectPayload, 0.71) #1-opac 0-transparent
ax.add_patch(rectPayload)
return fig
def draw_box(x1, x2, y1, y2, ax, col):
c = array([[x1], [y1]])
rect = Rectangle(c, width=x2 - x1, height=y2 - y1, angle=0)
rect.set_facecolor(array([0.4, 0.3, 0.6]))
ax.add_patch(rect)
rect.set_clip_box(ax.bbox)
rect.set_alpha(0.7)
rect.set_facecolor(col)
def _plot_rect(self, xy, color='b'):
rect = Rectangle(xy=xy,
width=1,
height=1,
facecolor=color,
edgecolor=color)
rect.set_alpha(1)
self.ax.add_patch(rect)
def william_edu_candlestick(ax,
quotes,
width=0.2,
colorup='#00FF00',
colordown='#FF0000',
alpha=1.0,
shadowCol='k',
ochl=True):
OFFSET = width / 2.0
lines = []
patches = []
for q in quotes:
if ochl:
t, open, close, high, low = q[:5]
else:
t, open, high, low, close = q[:5]
if close >= open:
color = colorup
lower = open
height = close - open
vline = Line2D(
xdata=(t, t),
ydata=(low, high),
color=colorup,
linewidth=0.5,
antialiased=True,
)
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(t, t),
ydata=(low, high),
color=colordown,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(t - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
return lines, patches
def nextCandlestick(positionAfterOpen=0,
width=0.6,
colorup='g',
colordown='r',
alpha=1.0):
global ax, ws, wb, lineMode, figureTitle, titleText, candlenumber, currentPosition, entryPrice, entryDate, PandL, datesList, opensList, closesList, highsList, lowsList
OFFSET = width / 2.0
lineMode = False
close = closesList[candlenumber]
open = opensList[candlenumber]
if currentPosition != 0 and currentPosition != positionAfterOpen:
profit = currentPosition * (open - entryPrice)
PandL += profit
ws.append((positionStrings[currentPosition], entryPrice, open,
(datesList[candlenumber] - entryDate).days, profit))
wb.save('/Users/sanatana/Documents/Paper_Trades.xlsx')
if positionAfterOpen != 0 and currentPosition != positionAfterOpen:
entryPrice = open
entryDate = datesList[candlenumber]
currentPosition = positionAfterOpen
tradeValue = currentPosition * (close - entryPrice)
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = lin.Line2D(xdata=(candlenumber + 1, candlenumber + 1),
ydata=(lowsList[candlenumber], highsList[candlenumber]),
color=color,
linewidth=1.0,
antialiased=True)
rect = Rectangle(xy=(candlenumber + 1 - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color)
rect.set_alpha(alpha)
ax.add_line(vline)
ax.add_patch(rect)
setView()
candlenumber += 1
if currentPosition == 0:
entryString = "---"
valueString = "---"
else:
entryString = str(round(entryPrice, 2))
valueString = str(round(tradeValue, 2))
titleText = "P&L: " + str(round(
PandL, 2)) + " Currently: " + positionStrings[currentPosition]
titleText += " Entry: " + entryString + " Latest Price: " + str(
round(close, 2)) + " Position Value: " + valueString
figureTitle.set_text(titleText)
def candlestick(ax, df, width=0.4, colorup='k', colordown='r', alpha=1.0):
""" draw candle stick chart on an matplotlib axis """
from matplotlib.lines import Line2D
from matplotlib.patches import Rectangle
from matplotlib.dates import date2num
import matplotlib.dates as mdates
import matplotlib.ticker as mticker
OFFSET = width / 2.0
low = df.low.values
high = df.high.values
op = df.open.values
co = df.close.values
t = df.index.to_pydatetime()
tt = date2num(t)
lines = []
rects = []
for i in range(len(tt)):
if co[i] >= op[i]:
color = colorup
lower = op[i]
height = co[i] - op[i]
else:
color = colordown
lower = co[i]
height = op[i] - co[i]
vline = Line2D(
xdata=(tt[i], tt[i]),
ydata=(low[i], high[i]),
color=color,
linewidth=0.5,
#antialiased=True,
)
vline.set_alpha(alpha)
rect = Rectangle(
xy=(tt[i] - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
lines.append(vline)
rects.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
# end of for
ax.autoscale_view()
return lines, rects
def draw_rectangle(self,xs,ys,alpha=0.2,color='g'):
xy = (min(xs),min(ys))
width = np.abs(np.diff(xs))
height = np.abs(np.diff(ys))
re = Rectangle(xy, width, height, angle=0.0)
ax = self.axs[0]
ax.add_artist(re)
re.set_alpha(alpha=alpha)
re.set_facecolor(color)
return re
def addDynamicComponent(momdp, ax, col, row, colorComponent, totProb):
obstPatchList = []
for i in range(0, len(row)):
x = col[i]
y = momdp.gridVar.shape[0] - row[i] - 1
patch = Rectangle((x, y), 1, 1, fc=colorComponent, ec=colorComponent)
patch.set_alpha(1 - totProb[i])
obstPatchList.append(patch)
ax.add_patch(obstPatchList[-1])
return obstPatchList
def candlestick(ax,
quotes_df,
width=0.2,
colorup='w',
colordown='k',
alpha=1.0):
lines = []
patches = []
offset = width / 2.0
for i in range(len(quotes_df)):
pr_open = quotes_df['Open'][i]
pr_high = quotes_df['High'][i]
pr_low = quotes_df['Low'][i]
pr_close = quotes_df['Close'][i]
if pr_close >= pr_open:
color = colorup
lower = pr_open
upper = pr_close
height = pr_close - pr_open
else:
color = colordown
lower = pr_close
upper = pr_open
height = pr_open - pr_close
vline = Line2D(xdata=(i, i),
ydata=(pr_low, lower),
color='k',
linewidth=0.5,
antialiased=True)
vline2 = Line2D(xdata=(i, i),
ydata=(upper, pr_high),
color='k',
linewidth=0.5,
antialiased=True)
rect = Rectangle(xy=(i - offset, lower),
width=width,
height=height,
facecolor=color,
edgecolor='k',
linewidth=0.5)
rect.set_alpha(alpha)
lines.append(vline)
lines.append(vline2)
patches.append(rect)
ax.add_line(vline)
ax.add_line(vline2)
ax.add_patch(rect)
ax.set_xlim(0, len(quotes_df))
ax.grid(axis='x', color='0.4', aa=True)
ax.autoscale_view()
return lines, patches
def draw_rectangles(img,
catalog,
colnames=['x', 'y'],
header=None,
ax=None,
rectangle_size=[30, 30],
pixel_scale=0.168,
color='r',
**kwargs):
if ax is None:
fig = plt.figure(figsize=(12, 12))
fig.subplots_adjust(left=0.0,
right=1.0,
bottom=0.0,
top=1.0,
wspace=0.00,
hspace=0.00)
gs = gridspec.GridSpec(2, 2)
gs.update(wspace=0.0, hspace=0.00)
ax1 = fig.add_subplot(gs[0])
else:
ax1 = ax
#ax1.yaxis.set_major_formatter(NullFormatter())
#ax1.xaxis.set_major_formatter(NullFormatter())
#ax1.axis('off')
from matplotlib.patches import Rectangle
if np.any([item.lower() == 'ra' for item in colnames]):
if header is None:
raise ValueError(
'# Header containing WCS must be provided to convert sky coordinates into image coordinates.'
)
return
else:
w = wcs.WCS(header)
x, y = w.wcs_world2pix(
Table(catalog)[colnames[0]].data.data,
Table(catalog)[colnames[1]].data.data, 0)
else:
x, y = catalog[colnames[0]], catalog[colnames[1]]
display_single(img, ax=ax1, pixel_scale=pixel_scale, **kwargs)
for i in range(len(catalog)):
e = Rectangle(xy=(x[i] - rectangle_size[0] // 2,
y[i] - rectangle_size[1] // 2),
height=rectangle_size[0],
width=rectangle_size[1],
angle=0)
e.set_facecolor('none')
e.set_edgecolor(color)
e.set_alpha(0.7)
e.set_linewidth(1.3)
ax1.add_artist(e)
if ax is not None:
return ax
def fooCandlestick(ax,
quotes,
width=0.5,
colorup='k',
colordown='r',
alpha=1.0):
OFFSET = width / 2.0
linewidth = width * 2
print(width)
lines = []
boxes = []
for q in quotes:
# t, op, cl, hi, lo = q[:5]
t, op, hi, lo, cl = q[:5]
box_h = max(op, cl)
box_l = min(op, cl)
height = box_h - box_l
if cl >= op:
color = colorup
else:
color = colordown
vline_lo = Line2D(
xdata=(t, t),
ydata=(lo, box_l),
color=color,
linewidth=linewidth,
antialiased=True,
)
vline_hi = Line2D(
xdata=(t, t),
ydata=(box_h, hi),
color=color,
linewidth=linewidth,
antialiased=True,
)
rect = Rectangle(
xy=(t - OFFSET, box_l),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
lines.append(vline_lo)
lines.append(vline_hi)
boxes.append(rect)
ax.add_line(vline_lo)
ax.add_line(vline_hi)
ax.add_patch(rect)
ax.autoscale_view()
return lines, boxes
def addDynamicComponent(momdp, ax, col, row, colorComponent, bt):
obstPatchList = []
for i in range(0, len(row)):
x = col[i]
y = momdp.gridVar.shape[0] - row[i] - 1
patch = Rectangle((x, y), 1, 1, fc=colorComponent, ec=colorComponent)
totProb = 0
for j in range(0, momdp.numO):
totProb = totProb + (1 - momdp.comb[j][i]) * bt[0][j]
patch.set_alpha(1 - totProb)
obstPatchList.append(patch)
ax.add_patch(obstPatchList[-1])
return obstPatchList
def candlestick(self,
ax,
quotes,
width=0.4,
colorup='k',
colordown='r',
alpha=1.0,
ochl=True):
OFFSET = width / 2.0
lines = []
patches = []
for q in quotes:
if ochl:
t, open, close, high, low = q[:5]
else:
t, open, high, low, close = q[:5]
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(t, t),
ydata=(low, high),
color=color,
linewidth=0.7,
antialiased=True,
)
rect = Rectangle(
xy=(t - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
ax.yaxis.tick_right()
return lines, patches
def __plot_candlestick(self, ax, width=0.5, colorup='red', colordown='green', alpha=0.8):
offset = width / 2.0
line_width = width * 2
prices = self.prices.tail(self.candlestick_num)
for i in self.indices:
p = prices.iloc[i, :]
open = p["Open"]
close = p["Close"]
high = p["High"]
low = p["Low"]
box_high = max(open, close)
box_low = min(open, close)
height = box_high - box_low
if close >= open:
color = colorup
else:
color = colordown
vline_low = Line2D(
xdata=(i, i), ydata=(low, box_low),
color = 'black',
linewidth=line_width,
antialiased=True,
)
vline_high = Line2D(
xdata=(i, i), ydata=(box_high, high),
color = 'black',
linewidth=line_width,
antialiased=True,
)
rect = Rectangle(
xy = (i - offset, box_low),
width = width,
height = height,
facecolor = color,
edgecolor = color,
)
rect.set_alpha(alpha)
ax.add_line(vline_low)
ax.add_line(vline_high)
ax.add_patch(rect)
ax.autoscale_view()
def plot_rectangle(bboxes, ax, step, c='#ff7f0e'):
for bbox in bboxes[bboxes['ts'] % step == 0]:
s_phi_offset, c_phi_offset = np.sin(bbox['orientation']), np.cos(bbox['orientation'])
rot = np.array([[c_phi_offset, - s_phi_offset], [s_phi_offset, c_phi_offset]])
offset_xy = np.dot(rot, 0.5 * bbox['dimension'])
r = Rectangle(xy=bbox['center_xy'] - offset_xy, width=bbox['dimension'][0], height=bbox['dimension'][1],
angle=np.rad2deg(bbox['orientation']))
ax.add_artist(r)
r.set_clip_box(ax.bbox)
r.set_alpha(0.8)
r.set_facecolor('none')
r.set_edgecolor(c)
def render_sticks(ax,
quotes,
has_date,
base_rect_coef=0.5,
width=1000,
colorup='#00FF00',
colordown='#FF0000',
alpha=0.8):
index = 0
rect_width = (base_rect_coef *
0.5 if len(quotes) < 100 else base_rect_coef) / len(quotes)
for q in quotes:
if has_date:
open, high, low, close = q[1], q[2], q[3], q[4]
timestamp = dates.date2num(q[0])
else:
open, high, low, close = q[0], q[1], q[2], q[3]
timestamp = index
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(timestamp, timestamp),
ydata=(low, high),
color=color,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(timestamp, lower),
width=rect_width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
rect.set_linewidth((width * 0.8) / len(quotes))
ax.add_line(vline)
ax.add_patch(rect)
index += 1
def addTicker(self, ticker):
t = date2num(ticker.getDate())
open = ticker.getOpen()
close = ticker.getAdjustedClose()
high = ticker.getHigh()
low = ticker.getLow()
volume = ticker.getVolume()
if close >= open:
color = self.__colorup
lower = open
height = close - open
else:
color = self.__colordown
lower = close
height = open - close
vline = Line2D(
xdata=(t, t), ydata=(low, high),
color='k',
linewidth=1,
antialiased=True,
)
rectTicker = Rectangle(
xy=(t - self.__offset, lower),
width = self.__candleWidth,
height = height,
facecolor = color,
edgecolor = color,
)
rectTicker.set_alpha(self.__alpha)
rectVolume = Rectangle(
xy=(t - self.__offset, 0),
width = self.__candleWidth,
height = volume,
facecolor = color,
edgecolor = color,
)
self.__axCandle.add_line(vline)
self.__axCandle.add_patch(rectTicker)
self.__axVolume.add_patch(rectVolume)
def boundingBox(self, data, ax, label, bBoundingBoxes, bLabels): ''' Draw bounding box around data.''' data = np.array(data) width = max(data[:,0]) - min(data[:,0]) height = max(data[:,1]) - min(data[:,1]) r = Rectangle((min(data[:,0]), min(data[:,1])), width, height) if bBoundingBoxes: ax.add_artist(r) r.set_clip_box(ax.bbox) r.set_alpha(0.1) r.set_facecolor((0.5, 0.5, 0.5)) if bLabels: ax.annotate(label, xy = (min(data[:,0]), max(data[:,1])), xytext = (0, 0), textcoords = 'offset points', ha = 'right', va = 'bottom', bbox = dict(boxstyle = 'round,pad=0.5', fc = (0.5, 0.5, 0.5), alpha = 0.1))
def candlestick(ax, quotes, width=0.2, colorup='k', colordown='r', alpha=1.0):
OFFSET = width / 2.0
for q in quotes:
t, open, high, low, close = q[:5]
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(xdata=(t, t),
ydata=(low, high),
color=color,
linewidth=0.5,
antialiased=True)
rect = Rectangle(xy=(t - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color)
rect.set_alpha(alpha)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
ax.plot(quotes[:, 0],
calc.calc_avg_exp(quotes[:, -1], 12),
label="exponential moving average over 12 days")
ax.plot(quotes[:, 0],
calc.calc_avg_exp(quotes[:, -1], 26),
label="exponential moving average over 26 days")
ax.legend()
return ax
def __init__(self, py_time, ohlc):
self.config()
t = awarePyTime2Float(py_time)
open = ohlc[0]
high = ohlc[1]
low = ohlc[2]
close = ohlc[3]
if close >= open:
color = self.color_positive
line_color = self.box_line_color_positive
box_low = open
box_high = close
height = close - open
else:
color = self.color_negative
line_color = self.box_line_color_negative
box_low = close
box_high = open
height = open - close
line_upper = Line2D([(t, t)],[(box_high, high)],
color=line_color,
linewidth=self.line_width,
antialiased=True)
line_lower = Line2D(xdata=(t, t),
ydata=(box_low, low),
color=line_color,
linewidth=self.line_width,
antialiased=True)
rect = Rectangle(xy=(t - self.box_width / 2, box_low),
width=self.box_width,
height=height,
facecolor=color,
edgecolor=line_color)
rect.set_alpha(self.alpha)
self.line_upper = line_upper
self.line_lower = line_lower
self.rect = rect
return
def _candlestick(ax, quotes, width=0.2, colorup='k', colordown='r', alpha=1.0):
# https://github.com/matplotlib/mpl_finance/blob/master/mpl_finance.py
from matplotlib.lines import Line2D
from matplotlib.patches import Rectangle
OFFSET = width / 2.0
for q in quotes:
t, open, high, low, close = q[:5]
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(t, t),
ydata=(low, high),
color=color,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(t - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
def plot_candle(self, q):
colorup = 'r'
colordown = 'g'
width = 180
OFFSET = width / 2.0
t, open, high, low, close = q[:5]
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(t, t),
ydata=(low, high),
color=color,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(t - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(1)
self.ax.add_line(vline)
self.ax.add_patch(rect)
self.ax.autoscale_view()
return vline, rect
def plotCandleStick(ax,
quotes,
xdata=None,
width=0.2,
colorup='#B70203',
colordown='#3ACCCC',
alpha=1.0):
if xdata is None: xdata = np.arange(quotes.shape[0])
OFFSET = width / 2.0
Lines, Patches = [], []
for i in range(quotes.shape[0]):
if pd.isnull(quotes[i]).sum() > 0: continue
iOpen, iHigh, iLow, iClose = quotes[i]
if iClose >= iOpen:
iColor = colorup
iLower = iOpen
iHeight = iClose - iOpen
else:
iColor = colordown
iLower = iClose
iHeight = iOpen - iClose
iVLine = Line2D(xdata=(xdata[i], xdata[i]),
ydata=(iLow, iHigh),
color=iColor,
linewidth=0.5,
antialiased=True)
iRect = Rectangle(xy=(i - OFFSET, iLower),
width=width,
height=iHeight,
facecolor=iColor,
edgecolor=iColor)
iRect.set_alpha(alpha)
Lines.append(iVLine)
Patches.append(iRect)
ax.add_line(iVLine)
ax.add_patch(iRect)
ax.autoscale_view()
return Lines, Patches
def candlestick(ax, quotes_df, width=0.2, colorup='w', colordown='k', alpha=1.0):
lines = []
patches = []
offset = width/2.0
for i in range(len(quotes_df)):
pr_open = quotes_df['Open'][i]
pr_high = quotes_df['High'][i]
pr_low = quotes_df['Low'][i]
pr_close = quotes_df['Close'][i]
if pr_close >= pr_open:
color = colorup
lower = pr_open
upper = pr_close
height = pr_close - pr_open
else:
color = colordown
lower = pr_close
upper = pr_open
height = pr_open - pr_close
vline = Line2D(xdata=(i, i), ydata=(pr_low, lower), color='k', linewidth=0.5, antialiased=True)
vline2 = Line2D(xdata=(i, i), ydata=(upper, pr_high), color='k', linewidth=0.5, antialiased=True)
rect = Rectangle(xy=(i - offset, lower), width=width, height=height, facecolor=color,
edgecolor='k', linewidth=0.5)
rect.set_alpha(alpha)
lines.append(vline)
lines.append(vline2)
patches.append(rect)
ax.add_line(vline)
ax.add_line(vline2)
ax.add_patch(rect)
ax.set_xlim(0, len(quotes_df))
ax.grid(axis='x', color='0.4', aa=True)
ax.autoscale_view()
return lines, patches
def addBar(xpos, quote, barWidth, colorUpper, colorLower, alpha):
date, o, h, l, c = quote
if o >= c:
color = colorLower
barHeight = o - c
lowestBarPosition = c
else:
color = colorUpper
barHeight = c - o
lowestBarPosition = o
line = Line2D(xdata=(xpos, xpos),
ydata=(l, h),
color=color,
linewidth=0.5,
antialiased=True)
bar = Rectangle(xy=(xpos - barWidth / 2.0, lowestBarPosition),
width=barWidth,
height=barHeight,
facecolor=color,
edgecolor=color)
bar.set_alpha(alpha)
return line, bar
def plotVolume(self, data, timescale=1.0,
width=0.9, colorup='r', colorflat='w',colordown='g', alpha=1.0):
u"""根据数据画一个新的成交量rect"""
self.volumeChart.set_xlim(data[0]-50*timescale/86400,data[0]+8*timescale/86400)
t, open, close= data[:3]
volume = data[5]
if close > open:
color = colorup
elif close == open:
color = colorflat
else:
color = colordown
rect = Rectangle(xy = (t-width*timescale/172800, 0),
width = width*timescale/86400,
height = volume, facecolor=color, edgecolor=color)
rect.set_alpha(alpha)
self.volumeChart.add_patch(rect)
return rect
def buildExcVol(cutX,cutY,cutZ,ax):
"""
Builds rectangular prism (excluded volume).
"""
r1 = Rectangle((-cutX,-cutZ),2.0*cutX,2.0*cutZ)
r4 = Rectangle((-cutX,-cutZ),2.0*cutX,2.0*cutZ)
r2 = Rectangle((-cutY,-cutZ),2.0*cutY,2.0*cutZ)
r5 = Rectangle((-cutY,-cutZ),2.0*cutY,2.0*cutZ)
r3 = Rectangle((-cutX,-cutY),2.0*cutX,2.0*cutY)
r6 = Rectangle((-cutX,-cutY),2.0*cutX,2.0*cutY)
r1.set_alpha(0.1)
r2.set_alpha(0.1)
r3.set_alpha(0.1)
r4.set_alpha(0.1)
r5.set_alpha(0.1)
r6.set_alpha(0.1)
ax.add_patch(r1), ax.add_patch(r2)
ax.add_patch(r3), ax.add_patch(r4)
ax.add_patch(r5), ax.add_patch(r6)
art3d.pathpatch_2d_to_3d(r1, z=-cutY, zdir="y")
art3d.pathpatch_2d_to_3d(r4, z=cutY, zdir="y")
art3d.pathpatch_2d_to_3d(r2, z=cutX, zdir="x")
art3d.pathpatch_2d_to_3d(r5, z=-cutX, zdir="x")
art3d.pathpatch_2d_to_3d(r3, z=cutZ, zdir="z")
art3d.pathpatch_2d_to_3d(r6, z=-cutZ, zdir="z")
def _candlestick(ax,
quotes,
width=0.2,
colorup='k',
colordown='r',
alpha=1.0,
ochl=True):
"""
Plot the time, open, high, low, close as a vertical line ranging
from low to high. Use a rectangular bar to represent the
open-close span. If close >= open, use colorup to color the bar,
otherwise use colordown
Parameters
----------
ax : `Axes`
an Axes instance to plot to
quotes : sequence of quote sequences
data to plot. time must be in float date format - see date2num
(time, open, high, low, close, ...) vs
(time, open, close, high, low, ...)
set by `ochl`
width : float
fraction of a day for the rectangle width
colorup : color
the color of the rectangle where close >= open
colordown : color
the color of the rectangle where close < open
alpha : float
the rectangle alpha level
ochl: bool
argument to select between ochl and ohlc ordering of quotes
Returns
-------
ret : tuple
returns (lines, patches) where lines is a list of lines
added and patches is a list of the rectangle patches added
"""
OFFSET = width / 2.0
lines = []
patches = []
for q in quotes:
if ochl:
t, open, close, high, low = q[:5]
else:
t, open, high, low, close = q[:5]
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(t, t),
ydata=(low, high),
color=color,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(t - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
return lines, patches
def buildOuter(Lx,Ly,Lz,ax,col='Purple'):
"""
Builds rectangular prism (outer cell walls).
"""
r7 = Rectangle((-Lx/2,-Lz/2),Lx,Lz, color=col)
r8 = Rectangle((-Lx/2,-Lz/2),Lx,Lz, color=col)
r9 = Rectangle((-Ly/2,-Lz/2),Ly,Lz, color=col)
r10 = Rectangle((-Ly/2,-Lz/2),Ly,Lz, color=col)
r11 = Rectangle((-Lx/2,-Ly/2),Lx,Ly, color=col)
r12 = Rectangle((-Lx/2,-Ly/2),Lx,Ly, color=col)
r7.set_alpha(0.1)
r8.set_alpha(0.1)
r9.set_alpha(0.1)
r10.set_alpha(0.1)
r11.set_alpha(0.1)
r12.set_alpha(0.1)
ax.add_patch(r7), ax.add_patch(r8)
ax.add_patch(r9), ax.add_patch(r10)
ax.add_patch(r11), ax.add_patch(r12)
art3d.pathpatch_2d_to_3d(r7, z=-Ly/2, zdir="y")
art3d.pathpatch_2d_to_3d(r8, z=Ly/2, zdir="y")
art3d.pathpatch_2d_to_3d(r9, z=Lx/2, zdir="x")
art3d.pathpatch_2d_to_3d(r10, z=-Lx/2, zdir="x")
art3d.pathpatch_2d_to_3d(r11, z=Lz/2, zdir="z")
art3d.pathpatch_2d_to_3d(r12, z=-Lz/2, zdir="z")
def candlestick(ax, quotes, width=0.2, colorup='k', colordown='r',
alpha=1.0):
"""
quotes is a sequence of (time, open, close, high, low, ...) sequences.
As long as the first 5 elements are these values,
the record can be as long as you want (eg it may store volume).
time must be in float days format - see date2num
Plot the time, open, close, high, low as a vertical line ranging
from low to high. Use a rectangular bar to represent the
open-close span. If close >= open, use colorup to color the bar,
otherwise use colordown
ax : an Axes instance to plot to
width : fraction of a day for the rectangle width
colorup : the color of the rectangle where close >= open
colordown : the color of the rectangle where close < open
alpha : the rectangle alpha level
return value is lines, patches where lines is a list of lines
added and patches is a list of the rectangle patches added
"""
OFFSET = width/2.0
lines = []
patches = []
for q in quotes:
t, open, close, high, low = q[:5]
if close>=open :
color = colorup
lower = open
height = close-open
else :
color = colordown
lower = close
height = open-close
vline = Line2D(
xdata=(t, t), ydata=(low, high),
color='k',
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy = (t-OFFSET, lower),
width = width,
height = height,
facecolor = color,
edgecolor = color,
)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
return lines, patches
import matplotlib.pyplot as plt
import numpy as np
import numpy.random as npr
import utilities_nopd as utils
from matplotlib.font_manager import FontProperties
from matplotlib.patches import Rectangle
import colorbrewer as cb
from mpltools import color
legend_font = FontProperties()
legend_font.set_size('small')
ticks_font = FontProperties(family='Helvetica', style='normal', \
size=8, weight='normal', stretch='normal')
empty_rect = Rectangle((0,0),1,1)
empty_rect.set_alpha(0)
empty_rect.set_edgecolor('white')
color_scheme_names = ['BrBG', 'PiYG', 'PRGn', 'RdBu', 'RdGy', 'PuOr', \
'RdYlBu', 'RdYlGn', 'Spectral']
color_schemes = {}
for name in color_scheme_names:
color_schemes[name] = eval('cb.{0}'.format(name))
def to_rgb(t):
"""
Args:
t: 3-tuple of int's in range [0,255]
Returns:
out: 3-tuple of float's in range [0,1]
"""
r,g,b = np.array(t)/255.
def _candlestick(ax, df, width=0.2, colorup='k', colordown='r',
alpha=1.0):
"""
Plot the time, open, high, low, close as a vertical line ranging
from low to high. Use a rectangular bar to represent the
open-close span. If close >= open, use colorup to color the bar,
otherwise use colordown
Parameters
----------
ax : `Axes`
an Axes instance to plot to
df : pandas data from tushare
width : float
fraction of a day for the rectangle width
colorup : color
the color of the rectangle where close >= open
colordown : color
the color of the rectangle where close < open
alpha : float
the rectangle alpha level
ochl: bool
argument to select between ochl and ohlc ordering of quotes
Returns
-------
ret : tuple
returns (lines, patches) where lines is a list of lines
added and patches is a list of the rectangle patches added
"""
OFFSET = width / 2.0
lines = []
patches = []
for date_string,row in df.iterrows():
date_time = datetime.datetime.strptime(date_string,'%Y-%m-%d')
t = date2num(date_time)
open, high, close, low = row[:4]
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(t, t), ydata=(low, high),
color=color,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(t - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
return lines, patches
def create_board_figure(pcb, bom_row, layer=pcbnew.F_Cu, invert_axis=False):
qty, value, footpr, highlight_refs = bom_row
plt.figure(figsize=(5.8, 8.2))
ax = plt.subplot("111", aspect="equal")
color_pad1 = "lightgray"
color_pad2 = "#AA0000"
color_pad3 = "#CC4444"
color_bbox1 = "None"
color_bbox2 = "#E9AFAF"
# get board edges (assuming rectangular, axis aligned pcb)
edge_coords = []
for d in pcb.GetDrawings():
if (d.GetLayer() == pcbnew.Edge_Cuts):
edge_coords.append(d.GetStart())
edge_coords.append(d.GetEnd())
edge_coords = np.asarray(edge_coords) * 1e-6
board_xmin, board_ymin = edge_coords.min(axis=0)
board_xmax, board_ymax = edge_coords.max(axis=0)
# draw board edges
rct = Rectangle((board_xmin, board_ymin),
board_xmax - board_xmin,
board_ymax - board_ymin,
angle=0)
rct.set_color("None")
rct.set_edgecolor("black")
rct.set_linewidth(3)
ax.add_patch(rct)
# add title
ax.text(board_xmin + .5 * (board_xmax - board_xmin), board_ymin - 0.5,
"%dx %s, %s" % (qty, value, footpr), wrap=True,
horizontalalignment='center', verticalalignment='bottom')\
# add ref list
textsize = 12
refdes_text = ", ".join(highlight_refs)
if len(refdes_text) > 200: # limit the size to prevent truncation
textsize = 10
if len(refdes_text) > 500: # limit the size to prevent truncation
textsize = 8
if len(refdes_text) > 1100:
textsize = 6
ax.text(board_xmin + .5 * (board_xmax - board_xmin),
board_ymax + 0.5,
", ".join(highlight_refs),
wrap=True,
horizontalalignment='center',
verticalalignment='top',
fontsize=textsize)
# draw parts
for m in pcb.GetModules():
if m.GetLayer() != layer:
continue
ref, center = m.GetReference(), np.asarray(m.GetCenter()) * 1e-6
highlight = ref in highlight_refs
# bounding box
mrect = m.GetFootprintRect()
mrect_pos = np.asarray(mrect.GetPosition()) * 1e-6
mrect_size = np.asarray(mrect.GetSize()) * 1e-6
rct = Rectangle(mrect_pos, mrect_size[0], mrect_size[1])
rct.set_color(color_bbox2 if highlight else color_bbox1)
rct.set_alpha(0.7)
rct.set_zorder(-1)
if highlight:
rct.set_linewidth(.1)
rct.set_edgecolor(color_pad2)
ax.add_patch(rct)
# center marker
if highlight:
plt.plot(center[0],
center[1],
".",
markersize=mrect_size.min() / 4,
color=color_pad2)
# plot pads
for p in m.Pads():
pos = np.asarray(p.GetPosition()) * 1e-6
#additional scaling pads result in strange effects on pads made
#from multiple pads - so I removed the * 0.9
size = np.asarray(p.GetSize()) * 1e-6
is_pin1 = p.GetPadName() == "1" or p.GetPadName() == "A1"
shape = p.GetShape()
offset = p.GetOffset() # TODO: check offset
# pad rect
angle = p.GetOrientation() * 0.1
cos, sin = np.cos(np.pi / 180. * angle), np.sin(np.pi / 180. *
angle)
dpos = np.dot([[cos, -sin], [sin, cos]], -.5 * size)
if shape == pcbnew.PAD_SHAPE_RECT:
rct = Rectangle(pos + dpos, size[0], size[1], angle=angle)
elif shape == pcbnew.PAD_SHAPE_ROUNDRECT:
# subtract 2x corner radius from pad size, as FancyBboxPatch draws a rounded rectangle around the specified rectangle
pad = p.GetRoundRectCornerRadius() * 1e-6
# the bottom-left corner of the FancyBboxPatch is the inside rectangle so need to compensate with the corner radius
corneroffset = np.asarray([pad, pad])
#draw rounded patch
rct = FancyBboxPatch(pos + dpos + corneroffset,
size[0] - 2 * pad,
size[1] - 2 * pad,
boxstyle=matplotlib.patches.BoxStyle(
"Round", pad=pad))
#and rotate it
xy = pos + dpos
tfm = matplotlib.transforms.Affine2D().rotate_deg_around(
xy[0], xy[1], angle) + ax.transData
rct.set_transform(tfm)
elif shape == pcbnew.PAD_SHAPE_OVAL:
rct = Ellipse(pos, size[0], size[1], angle=angle)
elif shape == pcbnew.PAD_SHAPE_CIRCLE:
rct = Ellipse(pos, size[0], size[0], angle=angle)
elif shape == pcbnew.PAD_SHAPE_TRAPEZOID:
#draw trapezoid from scratch
sx = size[0]
sy = size[1]
delta = p.GetDelta()[1] * 1e-6
xy = np.array([[(sx + delta) / 2, sy / 2],
[(sx - delta) / 2, -sy / 2],
[(-sx + delta) / 2, -sy / 2],
[(-sx - delta) / 2, sy / 2]])
xy = xy + pos
rct = Polygon(xy)
#and rotate it
xy = pos
# TODO DEBUG: based on corrections made in ROUNDRECT code above, the angle should NOT be negative(might be bug). No use case so ignored for now
tfm = matplotlib.transforms.Affine2D().rotate_deg_around(
xy[0], xy[1], -angle) + ax.transData
rct.set_transform(tfm)
else:
print("Unsupported pad shape: {0} ".format(shape))
continue
rct.set_linewidth(0)
rct.set_color(color_pad2 if highlight else color_pad1)
rct.set_zorder(1)
# highlight pin1
if highlight and is_pin1:
rct.set_color(color_pad3)
rct.set_linewidth(.1)
rct.set_edgecolor(color_pad2)
ax.add_patch(rct)
plt.xlim(board_xmin, board_xmax)
plt.ylim(board_ymax, board_ymin)
if (invert_axis):
plt.gca().invert_xaxis()
plt.axis('off')
def candlestick(ax, data, width=0.6, colorup='r', colordown='g', time_format="%Y-%m-%d", alpha=0.7):
""" Optimized candle stick graph interface.
:type ax matplotlib.axes.Axes
"""
offset = width / 2.0
timeseries = data.index
t = [tt.strftime(time_format) for tt in timeseries]
oo = data['open']
cc = data['close']
hh = data['high']
ll = data['low']
ax.set_xlim(0.0, len(t)*width)
major_locator = MultipleLocator(20*width)
minor_locator = MultipleLocator(5*width)
ax.set_xticks([x*width for x in range(len(t))], minor=True)
ticklabels = [t[d] for d in range(len(timeseries)) if d % 20 == 0]
ticklabels.insert(0, 'dummy') # fix matplotlib tick bug
ax.tick_params(axis='both', direction='out', width=2, length=8,
labelsize=10, pad=8)
ax.xaxis.set_ticklabels(ticklabels, horizontalalignment='center')
ax.xaxis.set_major_locator(major_locator)
ax.xaxis.set_minor_locator(minor_locator)
lines = []
patches = []
for q in range(len(t)):
c = float(cc[q])
o = float(oo[q])
h = float(hh[q])
l = float(ll[q])
if c >= o:
color = colorup
lower = o
height = c - o
else:
color = colordown
lower = c
height = o - c
vline = Line2D(
xdata=(q*width, q*width), ydata=(l, h),
color=color,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(q*width-offset, lower),
width = width,
height = height,
facecolor = color,
edgecolor = color,
)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
return lines, patches
def _candlestick(ax, quotes, width=0.2, colorup='k', colordown='r',
alpha=1.0, ochl=True):
"""
Plot the time, open, high, low, close as a vertical line ranging
from low to high. Use a rectangular bar to represent the
open-close span. If close >= open, use colorup to color the bar,
otherwise use colordown
Parameters
----------
ax : `Axes`
an Axes instance to plot to
quotes : sequence of quote sequences
data to plot. time must be in float date format - see date2num
(time, open, high, low, close, ...) vs
(time, open, close, high, low, ...)
set by `ochl`
width : float
fraction of a day for the rectangle width
colorup : color
the color of the rectangle where close >= open
colordown : color
the color of the rectangle where close < open
alpha : float
the rectangle alpha level
ochl: bool
argument to select between ochl and ohlc ordering of quotes
Returns
-------
ret : tuple
returns (lines, patches) where lines is a list of lines
added and patches is a list of the rectangle patches added
"""
OFFSET = width / 2.0
lines = []
patches = []
for q in quotes:
if ochl:
t, open, close, high, low = q[:5]
else:
t, open, high, low, close = q[:5]
if close >= open:
color = colorup
lower = open
height = close - open
else:
color = colordown
lower = close
height = open - close
vline = Line2D(
xdata=(t, t), ydata=(low, high),
color=color,
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy=(t - OFFSET, lower),
width=width,
height=height,
facecolor=color,
edgecolor=color,
)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
return lines, patches
def candlestick(self, X = [],Y = [], # X-Y points in the graph.
labels = [], legend = [], # Basic Labelling
color = None, lw = 2, alpha = 1.0, # Basic line properties
nf = 0, na = 0, # New axis. To plot in a new axis # TODO: shareX option
ax = None, position = [], projection = "2d", # Type of plot
sharex = None, sharey = None,
fontsize = 20,fontsizeL = 10, fontsizeA = 15, # The font for the labels in the axis
xlim = None, ylim = None, xlimPad = None, ylimPad = None, # Limits of vision
ws = None, Ninit = 0,
loc = "best",
dataTransform = None,
xaxis_mode = None,yaxis_mode = None,AxesStyle = None, # Automatically do some formatting :)
barwidth = None, colorup = "g", colordown = "r"
):
# Management of the figure and properties
ax = self.figure_management(nf, na, ax = ax, sharex = sharex, sharey = sharey,
projection = projection, position = position)
## Preprocess the data given so that it meets the right format
X, Y = self.preprocess_data(X,Y,dataTransform)
NpY, NcY = Y.shape
plots,plots_typ = self.init_WidgetData(ws)
##################### PREPROCESSING AND PLOTTING #######################
# Prepare the data
openp = Y[self.start_indx:self.end_indx,0]
closep = Y[self.start_indx:self.end_indx,1]
highp = Y[self.start_indx:self.end_indx,2]
lowp = Y[self.start_indx:self.end_indx,3]
dates = X[self.start_indx:self.end_indx]
dates = ul.preprocess_dates(dates)
if (type(barwidth) == type(None)):
barwidth = self.get_barwidth(dates, barwidth) * 0.8
# PLOTTING !!
Npoints = dates.size
OFFSET = barwidth / 2.0
line_factor = 0.15
barwidth_HL = barwidth * line_factor
OFFSET_HL = barwidth_HL / 2.0
lines = []
patches = []
for i in range(Npoints):
if closep[i] >= openp[i] :
color = colorup
baseRectable = openp[i]
else:
color = colordown
baseRectable = closep[i]
height = np.abs(openp[i] - closep[i])
## High-low line
# line_HL = Line2D(
# xdata=(dates[i],dates[i]), ydata=(lowp[i], highp[i]),
# color=color,
# linewidth=lw,
# antialiased=True,
# )
rect_HL = Rectangle(
xy=(dates[i] - OFFSET_HL, lowp[i]),
width=barwidth_HL,
height=highp[i] - lowp[i],
facecolor=color,
edgecolor=color,
)
# print type(dates[i]), type(OFFSET)
## Open Close rectangle
rect_OP = Rectangle(
xy=(dates[i] - OFFSET, baseRectable),
width=barwidth,
height=height,
facecolor=color,
edgecolor=color,
)
rect_OP.set_alpha(alpha)
#
# lines.append(line_HL)
# patches.append(rect_OP)
# ax.add_line(line_HL)
ax.add_patch(rect_OP)
ax.add_patch(rect_HL)
# lines = mc.LineCollection(lines)
# ax.add_collection(lines)
# ax.add_collection(patches)
ax.autoscale() # TODO: The zoom is not changed if we do not say it !
############### Last setting functions ###########################
self.store_WidgetData(plots_typ, plots) # Store pointers to variables for interaction
self.update_legend(legend,NcY,ax = ax, loc = loc) # Update the legend
self.set_labels(labels)
self.set_zoom(ax = ax, xlim = xlim,ylim = ylim, xlimPad = xlimPad,ylimPad = ylimPad)
self.format_xaxis(ax = ax, xaxis_mode = xaxis_mode)
self.format_yaxis(ax = ax, yaxis_mode = yaxis_mode)
self.apply_style(nf,na,AxesStyle)
self.plots_type.append(["candlestick"])
# self.plots_list.append([plotting]) # We store the pointers to the plots
data_i = [Y, ax]
self.Data_list.append(data_i)
return ax
def getRectangle(x, y, width, height, color, alpha=1):
rect = Rectangle((x, y), width, height)
rect.set_color(color)
rect.set_alpha(alpha)
return rect
