def _render_price(self, current_step, net_worth, step_range, dates): self.price_ax.clear() # Format data for OHCL candlestick graph candlesticks = zip(dates, self.df['Open'].values[step_range], self.df['Close'].values[step_range], self.df['High'].values[step_range], self.df['Low'].values[step_range]) # Plot price using candlestick graph from mpl_finance candlestick(self.price_ax, candlesticks, width=2) last_date = self.df['Timestamp'].values[current_step] last_close = self.df['Close'].values[current_step] last_high = self.df['High'].values[current_step] # Print the current price to the price axis self.price_ax.annotate('{0:.2f}'.format(last_close), (last_date, last_close), xytext=(last_date, last_high), bbox=dict(boxstyle='round', fc='w', ec='k', lw=1), color="black", fontsize="small") # Shift price axis up to give volume chart space ylim = self.price_ax.get_ylim() self.price_ax.set_ylim( ylim[0] - (ylim[1] - ylim[0]) * VOLUME_CHART_HEIGHT, ylim[1])
def _render_price(self, current_step, net_worth, dates, step_range): self.price_ax.clear() candlesticks = zip(dates, self.df['Open'].values[step_range], self.df['Close'].values[step_range], self.df['High'].values[step_range], self.df['Low'].values[step_range]) candlestick(self.price_ax, candlesticks, width=1, colorup=UP_COLOR, colordown=DOWN_COLOR) last_date = date2num(self.df['Date'].values[current_step]) last_close = self.df['Close'].values[current_step] last_high = self.df['High'].values[current_step] self.price_ax.annotate('{0:.2f}'.format(last_close), (last_date, last_close), xytext=(last_date, last_high), bbox=dict(boxstyle='round', fc='w', ec='k', lw=1), color='black', fontsize='small') ylim = self.price_ax.get_ylim() self.price_ax.set_ylim( ylim[0] - (ylim[1] - ylim[0]) * VOLUME_CHART_HEIGHT, ylim[1])
def _render_price(self, current_step, step_range): self.price_ax.clear() candlesticks = zip(step_range, self.df['Open'].values[step_range], self.df['Close'].values[step_range], self.df['High'].values[step_range], self.df['Low'].values[step_range]) candlestick(self.price_ax, candlesticks, width=1, colorup=UP_COLOR, colordown=DOWN_COLOR) last_close = self.df['Close'].values[current_step] last_high = self.df['High'].values[current_step] self.price_ax.annotate('{0:.2f}'.format(last_close), (current_step, last_close), xytext=(current_step, last_high), bbox=dict(boxstyle='round', fc='w', ec='k', lw=1), color='black', fontsize='small')
def _render_price(self, current_step, net_worth, dates, step_range): candlesticks = {} last_dates = {} last_closes = {} last_highs = {} y_limit = {} for index, asset in enumerate(self.assets): if index == 0: self.price_axs[asset].set_title( 'Candlesticks') # ? this can go out? self.price_axs[asset].clear() candlesticks[asset] = zip(dates, self.df_features[asset]['open'].values[step_range], self.df_features[asset]['close'].values[step_range], self.df_features[asset]['high'].values[step_range], self.df_features[asset]['low'].values[step_range]) candlestick(self.price_axs[asset], candlesticks[asset], width=self.candlestick_width, colorup=UP_COLOR, colordown=DOWN_COLOR) last_dates[asset] = date2num( self.df_complete[asset]['Date'].values[current_step]) last_closes[asset] = self.df_features[asset]['close'].values[current_step] last_highs[asset] = self.df_features[asset]['high'].values[current_step] self.price_axs[asset].annotate(s="{0:.4f}".format(last_closes[asset]), xy=( last_dates[asset], last_closes[asset]), xytext=(last_dates[asset], last_highs[asset]), bbox=dict(boxstyle='round', fc='w', ec='k', lw=1), color='black', fontsize='small') y_limit[asset] = self.price_axs[asset].get_ylim() self.price_axs[asset].set_ylim(y_limit[asset][0] - ( y_limit[asset][1] - y_limit[asset][0]) * VOLUME_CHART_HEIGHT, y_limit[asset][1]) self.price_axs[asset].set_ylabel( '{}/{}'.format(asset, self.currency))
def candlestick(self, index, open, high, low, close, width=0.3, secondary_y=False, *args, **kwargs): """ Takes a df and plots a candlestick. Will auto search for proper columns """ data = {} data['open'] = open data['high'] = high data['low'] = low data['close'] = close df = pd.DataFrame(data, index=index) if self.index is None: self.index = index # grab merged data xax = np.arange(len(self.index)) quotes = izip(xax, df['open'], df['close'], df['high'], df['low']) ax = self.find_ax(secondary_y, kwargs) self.setup_datetime(index) candlestick(ax, quotes, width=width, colorup='g')
def generate_plot(name,hours): dates = [] btc = [] eth = [] n = 0 history_file = open('./history.txt','r') lines = history_file.readlines() history_file.close() date = datetime.now() while (datetime.now() - date).total_seconds() < hours * 3600: n = n + 1 line = lines[-n].split(",") date = datetime.strptime(line[0], "%Y-%m-%d %H:%M:%S.%f") btc_price = float(line[1]) eth_price = float(line[2]) dates.append(date) btc.append(btc_price) eth.append(eth_price) if name == 'BTC': fig, ax = plt.subplots() ax.plot(dates,btc) ax.set_title("Evolution of the price in the last "+str(hours)+" h") plt.xlabel("Date") plt.ylabel("BTC price") fig.autofmt_xdate() ax.fmt_xdata = mdates.DateFormatter('%H:%M') plt.grid() plt.savefig("./btc.png") plt.clf() fig, ax = plt.subplots() opens, closes, highs, lows , d = get_candlesticks(btc,dates,2*hours) candlestick(ax, opens, closes, highs, lows, width = 0.6) print("Candlesticks for BTC plotted") ax.set_title("Evolution of the price in the last "+str(hours)+" h") plt.xlabel("Step = "str(2*hours)+" points") plt.ylabel("BTC price") plt.grid() plt.savefig("./btc_candlestick.png") plt.clf() if name == 'ETH': fig, ax = plt.subplots() ax.plot(dates,eth) ax.set_title("Evolution of the price in the last "+str(hours)+" h") plt.xlabel("Step") plt.ylabel("ETH price") fig.autofmt_xdate() ax.fmt_xdata = mdates.DateFormatter('%H:%M') plt.grid() plt.savefig("./eth.png") plt.clf() fig, ax = plt.subplots() opens, closes, highs, lows, d = get_candlesticks(eth,dates,2*hours) candlestick(ax, opens, closes, highs , lows, width = 0.6) ax.set_title("Evolution of the price in the last "+str(hours)+" h") plt.xlabel("Step = "str(2*hours)+" points") plt.ylabel("ETH price") plt.grid() plt.savefig("./eth_candlestick.png") plt.clf()
def plot_candlestick_and_volume(data_df: pd.DataFrame): """ Plot a candlestick chart of open/high/low/close with the volume overlayed at the bottom :param data_df: pandas.DataFrame that requires columns: date, open, close, max, min, volume """ candlesticks = zip(date2num(data_df['date']), data_df['open'], data_df['close'], data_df['max'], data_df['min'], data_df['volume']) fig = plt.figure() ax = fig.add_subplot(1, 1, 1) ax.set_ylabel('Quote ($)', size=20) candlestick(ax, candlesticks, width=1, colorup='g', colordown='r') # shift y-limits of the candlestick plot so that there is space at the bottom for the volume bar chart pad = 0.25 yl = ax.get_ylim() ax.set_ylim(yl[0] - (yl[1] - yl[0]) * pad, yl[1]) # create the second axis for the volume bar-plot ax2 = ax.twinx() # set the position of ax2 so that it is short (y2=0.32) # but otherwise the same size as ax ax2.set_position(matplotlib.transforms.Bbox([[0.125, 0.1], [0.9, 0.32]])) # get data from candlesticks for a bar plot dates = [x[0] for x in candlesticks] dates = np.asarray(dates) volume = [x[5] for x in candlesticks] volume = np.asarray(volume) # make bar plots and color differently depending on up/down for the day pos = (data_df['open'] - data_df['close']) < 0 neg = (data_df['open'] - data_df['close']) > 0 ax2.bar(dates[pos], volume[pos], color='green', width=1, align='center') ax2.bar(dates[neg], volume[neg], color='red', width=1, align='center') # scale the x-axis tight ax2.set_xlim(min(dates), max(dates)) # the y-ticks for the bar were too dense, keep only every third one yticks = ax2.get_yticks() ax2.set_yticks(yticks[::3]) ax2.yaxis.set_label_position("right") ax2.set_ylabel('Volume', size=20) # format the x-ticks with a human-readable date. xt = ax.get_xticks() new_xticks = [datetime.date.isoformat(num2date(d)) for d in xt] ax.set_xticklabels(new_xticks, rotation=45, horizontalalignment='right') # plt.ion() # plt.show() return fig, ax
def _render_price(self, current_step, net_worth, step_range, dates): self.price_ax.clear() candlesticks = zip(dates, self.df['Open'].values[step_range], self.df['Close'].values[step_range], self.df['High'].values[step_range], self.df['Low'].values[step_range]) candlestick(self.price_ax, candlesticks, width=20) last_date = self.df['Timestamp'].values[current_step] last_close = self.df['Close'].values[current_step] last_high = self.df['High'].values[current_step]
def plot_k_line(data): candlesticks = zip(date2num(data['time'].values), data['open'], data['close'], data['high'], data['low'], data['vol']) scale = abs(candlesticks[1][0] - candlesticks[0][0]) fig = plt.figure() ax = fig.add_subplot(1, 1, 1) ax.set_ylabel('Quote ($)', size=20) candlestick(ax, candlesticks, width=scale, colorup='g', colordown='r') # shift y-limits of the candlestick plot so that there is space at the bottom for the volume bar chart pad = 0.25 yl = ax.get_ylim() ax.set_ylim(yl[0]-(yl[1]-yl[0])*pad,yl[1]) # create the second axis for the volume bar-plot ax2 = ax.twinx() # set the position of ax2 so that it is short (y2=0.32) but otherwise the same size as ax ax2.set_position(matplotlib.transforms.Bbox([[0.125, 0.1], [0.9, 0.32]])) # get data from candlesticks for a bar plot dates = [x[0] for x in candlesticks] dates = np.asarray(dates) volume = [x[5] for x in candlesticks] volume = np.asarray(volume) # make bar plots and color differently depending on up/down for the day pos = data['open'] - data['close'] < 0 neg = data['open'] - data['close'] > 0 ax2.bar(dates[pos], volume[pos], color='green', width=scale, align='center') ax2.bar(dates[neg], volume[neg], color='red', width=scale, align='center') #scale the x-axis tight ax2.set_xlim(min(dates),max(dates)) # the y-ticks for the bar were too dense, keep only every third one yticks = ax2.get_yticks() ax2.set_yticks(yticks[::3]) ax2.yaxis.set_label_position("right") ax2.set_ylabel('Volume', size=20) # format the x-ticks with a human-readable date. xt = ax.get_xticks() new_xticks = [num2date(d).strftime('%Y%m%d%H%M') for d in xt] #new_xticks = [datetime.date.isoformat(num2date(d)) for d in xt] ax.set_xticklabels(new_xticks,rotation=45, horizontalalignment='right') #plt.ion() plt.show()
def animate(self, i): #logger.info("[plotThread][animate] self.update_flag " + str(self.update_flag)) if self.update_flag: sec_id = singleton_data.getInstance().getOHLC_data() sec_id_ochl = np.array(pd.DataFrame({'0':date2num(sec_id.index), '1':sec_id.open, '2':sec_id.close, '3':sec_id.high, '4':sec_id.low})) #logger.info("[plotThread][animate] sec_id_ochl " + str(sec_id_ochl)) self.analysis = pd.DataFrame(index = sec_id.index) self.analysis['sma_f'] = sec_id.close.rolling(self.SMA_FAST).mean() self.analysis['sma_s'] = sec_id.close.rolling(self.SMA_SLOW).mean() self.analysis['rsi'] = ta.RSI(sec_id.close.to_numpy(), self.RSI_PERIOD) self.analysis['sma_r'] = self.analysis.rsi.rolling(self.RSI_PERIOD).mean() self.analysis['macd'], self.analysis['macdSignal'], self.analysis['macdHist'] = ta.MACD(sec_id.close.to_numpy(), fastperiod=self.MACD_FAST, slowperiod=self.MACD_SLOW, signalperiod=self.MACD_SIGNAL) self.analysis['stoch_k'], self.analysis['stoch_d'] = ta.STOCH(sec_id.high.to_numpy(), sec_id.low.to_numpy(), sec_id.close.to_numpy(), fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)#slowk_period=self.STOCH_K, slowd_period=self.STOCH_D) self.analysis['sma'] = np.where(self.analysis.sma_f > self.analysis.sma_s, 1, 0) # Plot candles width=.6/(24*60) candlestick(self.ax1, sec_id_ochl, width=.6/(24*60), colorup='g', colordown='r', alpha=1) # Draw Moving Averages self.analysis['sma_f'] = sec_id.close.rolling(self.SMA_FAST).mean() self.analysis['sma_s'] = sec_id.close.rolling(self.SMA_SLOW).mean() self.analysis.sma_f.plot(ax=self.ax1, c='r', linewidth=self.LINE_WIDTH) self.analysis.sma_s.plot(ax=self.ax1, c='g', linewidth=self.LINE_WIDTH) self.analysis.rsi.plot(ax = self.ax2, c='g', label = 'Period: ' + str(self.RSI_PERIOD), linewidth=self.LINE_WIDTH) self.analysis.sma_r.plot(ax = self.ax2, c='r', label = 'MA: ' + str(self.RSI_AVG_PERIOD), linewidth=self.LINE_WIDTH) self.analysis.macd.plot(ax=self.ax3, color='b', label='Macd', linewidth=self.LINE_WIDTH) self.analysis.macdSignal.plot(ax=self.ax3, color='g', label='Signal', linewidth=self.LINE_WIDTH) self.analysis.macdHist.plot(ax=self.ax3, color='r', label='Hist', linewidth=self.LINE_WIDTH) self.analysis.stoch_k.plot(ax=self.ax4, label='stoch_k:'+ str(self.STOCH_K), color='r', linewidth=self.LINE_WIDTH) self.analysis.stoch_d.plot(ax=self.ax4, label='stoch_d:'+ str(self.STOCH_D), color='g', linewidth=self.LINE_WIDTH) self.update_flag = False
def analyze(context, data, analysis): ticker = context.CURRENCY date_from = '2018-08-01' # Data for matplotlib finance plot data = data[data.index > date_from] data['Date'] = data.index.map(mdates.date2num) ohlc = data[['Date','OPEN_PRC','HIGH_PRC','LOW_PRC','CLS_PRC']] analysis = analysis[analysis.index > date_from] analysis.index = date2num(analysis.index.to_pydatetime()) # Prepare figure and plots fig, (ax1, ax2, ax3) = plt.subplots(3, 1, gridspec_kw={'height_ratios':[6,2,2]}, sharex=True) fig.set_size_inches(15,30) # Set ax1 ax1.set_ylabel(ticker, size=20) ax1.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d')) ax1.grid(True) # Draw Candlestick candlestick(ax1, ohlc.values, width=0.1, colorup='g', colordown='r', alpha=1) # Plot ZigZag ax1.plot(analysis.ix[analysis.ZIGZAG != 0].index, analysis.price[analysis.ZIGZAG != 0], 'k-') ax1.scatter(analysis.ix[analysis.ZIGZAG == 1].index, analysis.price[analysis.ZIGZAG == 1], color='g') ax1.scatter(analysis.ix[analysis.ZIGZAG == -1].index, analysis.price[analysis.ZIGZAG == -1], color='r') # Draw Moving Averages analysis.sma_f.plot(ax=ax1, c='r', label='SMA'+str(SMA_FAST)) analysis.sma_s.plot(ax=ax1, c='g', label='SMA'+str(SMA_SLOW)) #ax1.plot(analysis.ix[analysis.sma == 1].index, analysis.sma_f[analysis.sma == 1], '^') # Draw 3Inside ax1.plot(analysis.ix[analysis.CDL3INSIDE < 0].index, analysis.price[analysis.CDL3INSIDE < 0], 'v') ax1.plot(analysis.ix[analysis.CDL3INSIDE > 0].index, analysis.price[analysis.CDL3INSIDE > 0], '^') # Draw Support and Resistance Line support, resistance = indic.findsnp(data['CLS_PRC'], 10) for value in support+resistance: ax1.hlines(y=value, xmin=analysis.index.min(), xmax=analysis.index.max(), linewidth=1, color='r', linestyles='--') # Draw Peak and Valley # indices = peakutils.indexes(analysis['price'], valley=False, thres=0.3, min_dist=1, thres_abs=False) # peak1 = analysis.iloc[indices] # peak_indices = indic.detect_peaks(analysis['price'], edge='rising', valley=False, threshold=0.3) # valley_indices = indic.detect_peaks(analysis['price'], edge='falling', valley=True, threshold=0.3) # peaks = analysis.iloc[peak_indices] # valleys = analysis.iloc[valley_indices] # peaknvalley_indices = peak_indices.tolist()+valley_indices.tolist() # peaknvalley_indices.sort() # peaknvalley = analysis.iloc[peaknvalley_indices] # ax1.plot(peaknvalley.index, peaknvalley.price, 'k-') # ax1.scatter(peaks.index, peaks.price, color='y') # ax1.scatter(valleys.index, valleys.price, color='r') # ax1.scatter(peak1.index, peak1.price, color='b', marker='^') #RSI ax2.set_ylabel('RSI', size=Y_AXIS_SIZE) analysis.rsi.plot(ax=ax2, c='g', label = 'Period: ' + str(RSI_PERIOD)) analysis.sma_r.plot(ax=ax2, c='r', label = 'MA: ' + str(RSI_AVG_PERIOD)) ax2.axhline(y=30, c='b') ax2.axhline(y=50, c='black') ax2.axhline(y=70, c='b') ax2.set_ylim([0,100]) ax2.legend(loc='upper left') '''# Volume ax2.bar(analysis.index, analysis.volume, 0.2, align='center', color='b', label='Volume') ax2.legend(loc='upper left') ax2.grid(True)''' '''# Volume Change Rate ax3.set_ylabel('VOL_CHG', size=Y_AXIS_SIZE) analysis.VOL_CHG.plot(ax=ax3, c='g', label = 'VOL_CHG') handles, labels = ax3.get_legend_handles_labels() ax3.legend(handles, labels) ax3.grid()''' ''' # Draw MACD computed with Talib ax3.set_ylabel('MACD: '+ str(MACD_FAST) + ', ' + str(MACD_SLOW) + ', ' + str(MACD_SIGNAL), size=Y_AXIS_SIZE) analysis.macd.plot(ax=ax3, color='b', label='Macd') analysis.macdSignal.plot(ax=ax3, color='g', label='Signal') analysis.macdHist.plot(ax=ax3, color='r', label='Hist') ax3.axhline(0, lw=2, color='0') handles, labels = ax3.get_legend_handles_labels() ax3.legend(handles, labels) ax3.grid()''' # Stochastic plot # ax2.set_ylabel('Stoch1', size=Y_AXIS_SIZE) # analysis.STO_K.plot(ax=ax2, label='STO_K', color='b') # analysis.STO_D.plot(ax=ax2, label='STO_D', color='r') # ax2.legend(loc='upper left') # ax2.axhline(y=20, c='m') # ax2.axhline(y=80, c='m') # ax2.grid() # Stochastic plot ax3.set_ylabel('Stoch', size=Y_AXIS_SIZE) analysis.stoch_k.plot(ax=ax3, label='stoch_k', color='b') analysis.stoch_d.plot(ax=ax3, label='stoch_d', color='r') ax3.legend(loc='upper left') ax3.axhline(y=20, c='m') ax3.axhline(y=80, c='m') ax3.grid() # Plot Peak and Valley for Stochastic peak_indices = indic.detect_peaks(analysis['stoch_k'], edge='rising', valley=False, threshold=0.3) valley_indices = indic.detect_peaks(analysis['stoch_k'], edge='falling', valley=True, threshold=0.3) peaks = analysis.iloc[peak_indices] valleys = analysis.iloc[valley_indices] ax3.scatter(peaks.index, peaks.stoch_k, color='y') ax3.scatter(valleys.index, valleys.stoch_k, color='r') plt.show()
def _render_price(self, current_step, net_worth, dates, step_range): self.price_ax1.clear() self.price_ax2.clear() self.price_ax3.clear() candlesticks1 = zip(dates, self.df1['open'].values[step_range], self.df1['close'].values[step_range], self.df1['high'].values[step_range], self.df1['low'].values[step_range]) candlesticks2 = zip(dates, self.df2['open'].values[step_range], self.df2['close'].values[step_range], self.df2['high'].values[step_range], self.df2['low'].values[step_range]) candlesticks3 = zip(dates, self.df3['open'].values[step_range], self.df3['close'].values[step_range], self.df3['high'].values[step_range], self.df3['low'].values[step_range]) # Plot price using candlestick graph from mpl_finance candlestick(self.price_ax1, candlesticks1, width=.04, colorup=UP_COLOR, colordown=DOWN_COLOR) candlestick(self.price_ax2, candlesticks2, width=.04, colorup=UP_COLOR, colordown=DOWN_COLOR) candlestick(self.price_ax3, candlesticks3, width=.04, colorup=UP_COLOR, colordown=DOWN_COLOR) last_date = date2num(self.df1['Date'].values[current_step]) last_close1 = self.df1['close'].values[current_step] last_high1 = self.df1['high'].values[current_step] last_close2 = self.df2['close'].values[current_step] last_high2 = self.df2['high'].values[current_step] last_close3 = self.df3['close'].values[current_step] last_high3 = self.df3['high'].values[current_step] # Print the current price to the price axis self.price_ax1.annotate('{0:.4f}'.format(last_close1), (last_date, last_close1), xytext=(last_date, last_high1), bbox=dict(boxstyle='round', fc='w', ec='k', lw=1), color="black", fontsize="small") self.price_ax2.annotate('{0:.4f}'.format(last_close2), (last_date, last_close2), xytext=(last_date, last_high2), bbox=dict(boxstyle='round', fc='w', ec='k', lw=1), color="black", fontsize="small") self.price_ax3.annotate('{0:.4f}'.format(last_close3), (last_date, last_close3), xytext=(last_date, last_high3), bbox=dict(boxstyle='round', fc='w', ec='k', lw=1), color="black", fontsize="small") # Shift price axis up to give volume chart space ylim1 = self.price_ax1.get_ylim() ylim2 = self.price_ax2.get_ylim() ylim3 = self.price_ax3.get_ylim() self.price_ax1.set_ylim(ylim1[0] - (ylim1[1] - ylim1[0]) * VOLUME_CHART_HEIGHT, ylim1[1]) self.price_ax1.set_ylabel('BTC') self.price_ax2.set_ylim(ylim2[0] - (ylim2[1] - ylim2[0]) * VOLUME_CHART_HEIGHT, ylim2[1]) self.price_ax2.set_ylabel('ETH') self.price_ax3.set_ylim(ylim3[0] - (ylim3[1] - ylim3[0]) * VOLUME_CHART_HEIGHT, ylim3[1]) self.price_ax3.set_ylabel('LTC')
def show_tech_thru_code(code, days=100): ''' 展示蜡烛图 展示RSI 展示MACD https://wiki.fintechki.com/index.php?title=How_to_draw_MACD_Charts ''' ticker = code df = ts.get_hist_data(code) sec_id = df.sort_index(ascending=True) sec_id.index = pd.to_datetime(sec_id.index) part_sec_id = sec_id.sort_index(ascending=False).iloc[0:days] # Data for matplotlib finance plot sec_id_ochl = np.array( pd.DataFrame({ '0': date2num(part_sec_id.index), '1': part_sec_id.open, '2': part_sec_id.close, '3': part_sec_id.high, '4': part_sec_id.low })) analysis = pd.DataFrame(index=sec_id.index) analysis['sma_f'] = pd.Series.rolling(sec_id.close, SMA_FAST).mean() analysis['sma_s'] = pd.Series.rolling(sec_id.close, SMA_SLOW).mean() analysis['rsi'] = ta.RSI(sec_id.close.values, RSI_PERIOD) analysis['sma_r'] = pd.Series.rolling(analysis.rsi, RSI_AVG_PERIOD).mean() analysis['macd'], analysis['macdSignal'], analysis['macdHist'] = ta.MACD( sec_id.close.values, fastperiod=MACD_FAST, slowperiod=MACD_SLOW, signalperiod=MACD_SIGNAL) analysis['stoch_k'], analysis['stoch_d'] = ta.STOCH(sec_id.high.values, sec_id.low.values, sec_id.close.values, slowk_period=STOCH_K, slowd_period=STOCH_D) analysis['sma'] = np.where(analysis.sma_f > analysis.sma_s, 1, 0) analysis['macd_test'] = np.where((analysis.macd > analysis.macdSignal), 1, 0) analysis['stoch_k_test'] = np.where( (analysis.stoch_k < 50) & (analysis.stoch_k > analysis.stoch_k.shift(1)), 1, 0) analysis['rsi_test'] = np.where( (analysis.rsi < 50) & (analysis.rsi > analysis.rsi.shift(1)), 1, 0) analysis = analysis.sort_index(ascending=False) analysis = analysis.iloc[:100] # Prepare plot fig, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1, sharex=True) ax1.set_ylabel(ticker, size=20) #size plot fig.set_size_inches(15, 30) # Plot candles candlestick(ax1, sec_id_ochl, width=0.5, colorup='g', colordown='r', alpha=1) # Draw Moving Averages analysis.sma_f.plot(ax=ax1, c='r') analysis.sma_s.plot(ax=ax1, c='g') #RSI ax2.set_ylabel('RSI', size=Y_AXIS_SIZE) analysis.rsi.plot(ax=ax2, c='g', label='Period: ' + str(RSI_PERIOD)) analysis.sma_r.plot(ax=ax2, c='r', label='MA: ' + str(RSI_AVG_PERIOD)) ax2.axhline(y=30, c='b') ax2.axhline(y=50, c='black') ax2.axhline(y=70, c='b') ax2.set_ylim([0, 100]) handles, labels = ax2.get_legend_handles_labels() ax2.legend(handles, labels) # Draw MACD computed with Talib ax3.set_ylabel('MACD: ' + str(MACD_FAST) + ', ' + str(MACD_SLOW) + ', ' + str(MACD_SIGNAL), size=Y_AXIS_SIZE) analysis.macd.plot(ax=ax3, color='b', label='Macd') analysis.macdSignal.plot(ax=ax3, color='g', label='Signal') ax3.fill_between(analysis.index, analysis['macdHist'], color='gray', alpha=0.5, label='Histogram') ax3.axhline(0, lw=2, color='0') handles, labels = ax3.get_legend_handles_labels() ax3.legend(handles, labels) # Stochastic plot ax4.set_ylabel('Stoch (k,d)', size=Y_AXIS_SIZE) analysis.stoch_k.plot(ax=ax4, label='stoch_k:' + str(STOCH_K), color='r') analysis.stoch_d.plot(ax=ax4, label='stoch_d:' + str(STOCH_D), color='g') handles, labels = ax4.get_legend_handles_labels() ax4.legend(handles, labels) ax4.axhline(y=20, c='b') ax4.axhline(y=50, c='black') ax4.axhline(y=80, c='b') plt.show() return None
analysis['stoch_k_test'] = np.where( (analysis.stoch_k < 50) & (analysis.stoch_k > analysis.stoch_k.shift(1)), 1, 0) analysis['rsi_test'] = np.where( (analysis.rsi < 50) & (analysis.rsi > analysis.rsi.shift(1)), 1, 0) # Prepare plot #fig, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1, sharex=True) fig, (ax1, ax3) = plt.subplots(2, 1, sharex=True) ax1.set_ylabel(ticker, size=20) #size plot fig.set_size_inches(15, 30) # Plot candles candlestick(ax1, sec_id_ohlc, width=0.5, colorup='g', colordown='r', alpha=1) # Draw Moving Averages analysis.sma_f.plot(ax=ax1, c='r') analysis.sma_s.plot(ax=ax1, c='g') #RSI #ax2.set_ylabel('RSI', size=Y_AXIS_SIZE) #analysis.rsi.plot(ax = ax2, c='g', label = 'Period: ' + str(RSI_PERIOD)) #analysis.sma_r.plot(ax = ax2, c='r', label = 'MA: ' + str(RSI_AVG_PERIOD)) #ax2.axhline(y=30, c='b') #ax2.axhline(y=50, c='black') #ax2.axhline(y=70, c='b') #ax2.set_ylim([0,100]) #handles, labels = ax2.get_legend_handles_labels() #ax2.legend(handles, labels)
def run(self): logger.info("[bitmex_plot][run]") sec_id = singleton_data.instance().getOHLC_data() self.sec_id_ochl = np.array( pd.DataFrame({ '0': date2num(sec_id.index), #.to_pydatetime()), '1': sec_id.open, '2': sec_id.close, '3': sec_id.high, '4': sec_id.low })) #self.analysis.Date.dt.tz_localize('UTC') self.analysis = analysis.get_analysis(False) # Prepare plot self.fig, (self.ax1, self.ax2, self.ax3, self.ax4) = plt.subplots(4, 1, sharex=True) self.ax1.set_ylabel(ticker, size=20) self.ax1.xaxis.set_major_formatter( matplotlib.dates.DateFormatter('%H:%M:%S')) #size plot self.fig.set_size_inches(15, 30) # Plot candles width=.6/(24*60) candlestick(self.ax1, self.sec_id_ochl, width=.6 / (24 * 60), colorup='g', colordown='r', alpha=1) # Draw Moving Averages self.analysis.sma_f.plot(ax=self.ax1, c='r', linewidth=self.LINE_WIDTH) self.analysis.sma_s.plot(ax=self.ax1, c='g', linewidth=self.LINE_WIDTH) handles, labels = self.ax1.get_legend_handles_labels() self.ax1.legend(handles, labels) #RSI self.ax2.set_ylabel('RSI', size=self.Y_AXIS_SIZE) self.analysis.rsi.plot(ax=self.ax2, c='g', label='Period: ' + str(self.RSI_PERIOD), linewidth=self.LINE_WIDTH) self.analysis.sma_r.plot(ax=self.ax2, c='r', label='MA: ' + str(self.RSI_AVG_PERIOD), linewidth=self.LINE_WIDTH) self.ax2.axhline(y=30, c='b', linewidth=self.LINE_WIDTH) #self.ax2.axhline(y=50, c='black', linewidth=self.LINE_WIDTH) self.ax2.axhline(y=70, c='b', linewidth=self.LINE_WIDTH) self.ax2.set_ylim([0, 100]) handles, labels = self.ax2.get_legend_handles_labels() self.ax2.legend(handles, labels) # Draw MACD computed with Talib self.ax3.set_ylabel('MACD: ' + str(self.MACD_FAST) + ', ' + str(self.MACD_SLOW) + ', ' + str(self.MACD_SIGNAL), size=self.Y_AXIS_SIZE) self.analysis.macd.plot(ax=self.ax3, color='b', label='Macd', linewidth=self.LINE_WIDTH) self.analysis.macdSignal.plot(ax=self.ax3, color='g', label='Signal', linewidth=self.LINE_WIDTH) self.analysis.macdHist.plot(ax=self.ax3, color='r', label='Hist', linewidth=self.LINE_WIDTH) self.ax3.axhline(0, lw=2, color='0', linewidth=self.LINE_WIDTH) handles, labels = self.ax3.get_legend_handles_labels() self.ax3.legend(handles, labels) # Stochastic plot self.ax4.set_ylabel('Stoch (k,d)', size=self.Y_AXIS_SIZE) self.analysis.stoch_k.plot(ax=self.ax4, label='stoch_k:' + str(self.STOCH_K), color='r', linewidth=self.LINE_WIDTH) self.analysis.stoch_d.plot(ax=self.ax4, label='stoch_d:' + str(self.STOCH_D), color='g', linewidth=self.LINE_WIDTH) handles, labels = self.ax4.get_legend_handles_labels() self.ax4.legend(handles, labels) self.ax4.axhline(y=20, c='b', linewidth=self.LINE_WIDTH) self.ax4.axhline(y=50, c='black', linewidth=self.LINE_WIDTH) self.ax4.axhline(y=80, c='b', linewidth=self.LINE_WIDTH) self.ani = animation.FuncAnimation(self.fig, self.animate, interval=5000) plt.show()
# creation of new data by replacing the time array with equally spaced values. # this will allow to remove the gap between the days, when plotting the data data2 = np.hstack([np.arange(data[:, 0].size)[:, np.newaxis], data[:, 1:]]) # plot the data fig = plt.figure(figsize=(10, 5)) ax = fig.add_axes([0.1, 0.2, 0.85, 0.7]) # customization of the axis ax.spines['right'].set_color('none') ax.spines['top'].set_color('none') ax.xaxis.set_ticks_position('bottom') ax.yaxis.set_ticks_position('left') ax.tick_params(axis='both', direction='out', width=2, length=8, labelsize=12, pad=8) ax.spines['left'].set_linewidth(2) ax.spines['bottom'].set_linewidth(2) # set the ticks of the x axis only when starting a new day ax.set_xticks(data2[ndays[1], 0]) ax.set_xticklabels(xdays, rotation=45, horizontalalignment='right') ax.set_ylabel('Quote ($)', size=20) ax.set_ylim([177, 196]) candlestick(ax, data2, width=0.5, colorup='g', colordown='r') plt.show()