def sb_violinplot(series, dataframe=None, groupCol=None, **kwargs):
    import pandas as pd
    import seaborn as sns
    if not groupCol:
        assert isinstance(series, pd.Series)
        return to_bokeh(sns.violinplot(x=series, **kwargs).figure)
    else:
        assert dataframe and groupCol
        assert isinstance(series, str)
        return to_bokeh(
            sns.violinplot(x=groupCol, y=series, data=dataframe,
                           **kwargs).figure)
Beispiel #2
0
    def mc_results(self):
        # Compute Monte Carlo results 
        Y = self.Y.as_matrix()
        Y0 = float(self.ticker4_1)
        hist_point = int(self.ticker4)
        num_paths = int(self.ticker3)

        center_point = np.mean(Y[hist_point,:])
        stkgrid = np.linspace(0.5*center_point,1.5*center_point,100)
        meanlst = np.array([])
        stdlst  = np.array([])
        paylst  = np.array([])

        for stk in stkgrid:
            meanlst = np.append(meanlst, np.mean(payoff(Y[hist_point,:],stk)))
            stdlst = np.append(stdlst,np.std(payoff(Y[hist_point,:],stk))/np.sqrt(num_paths))

        plt.plot(stkgrid,meanlst+2*stdlst, 'g-')
        plt.plot(stkgrid,meanlst-2*stdlst,'g-',label='2-Sig Error')
        plt.plot(stkgrid,meanlst+stdlst,'r-')
        plt.plot(stkgrid,meanlst-stdlst,'r-',label='1-Sig Error')
        plt.plot(stkgrid,meanlst,'b',label='Mean')
        plt.title('MC Option Price (Blue) with 1-Sig (Red) and 2-Sig (Green) Errors')
        plt.xlabel('Strike')
        plt.ylabel('Value')

        p = mpl.to_bokeh()
        p.title_text_font_size= str(TITLE_SIZE)+'pt'

        return p
Beispiel #3
0
    def initialize_plot(self, ranges=None, plot=None, plots=None):
        element = self.hmap.last
        key = self.keys[-1]

        self.mplplot.initialize_plot(ranges)
        plot = mpl.to_bokeh(self.mplplot.state)
        self.handles['plot'] = plot
        return plot
Beispiel #4
0
    def initialize_plot(self, ranges=None, plot=None, plots=None):
        element = self.hmap.last
        key = self.keys[-1]

        self.mplplot.initialize_plot(ranges)
        plot = mpl.to_bokeh(self.mplplot.state)
        self.handles['plot'] = plot
        return plot
Beispiel #5
0
def test(datasets="", genes=None, samples=None, chart_type=None, scale=None):
    data = get_demo_normalized_set()
    sns.set_style("whitegrid")
    if chart_type is None or chart_type == "box":
        data.transpose().boxplot(column=[1, 2, 3], return_type="axes")
    elif chart_type == "scatter":
        pass

    return to_bokeh(name="descriptive")
Beispiel #6
0
def acid_violin(acid):
    olives = pd.read_sql('olives', db.engine, columns=['region', 'area_main', acid])
    sns.set_style("whitegrid")
    sns.mpl.rc("figure", figsize=(15, 6))
    ax = sns.violinplot(data=olives,
                        x="area_main",
                        y=acid,
                        cut=0.1,
                        scale='count',
                        title=acid + " acid distribution")
    bh = mpl.to_bokeh(ax.figure)
    return bh
Beispiel #7
0
def makeplot(dataframe):
	plt.figure(figsize=(11,8))
	dataframe.plot()#df plot function
#	ax.legend(bbox_to_anchor=(1,1),bbox_transform=plt.gcf().transFigure)    
	plt.legend(fontsize=20,bbox_to_anchor=(1.05,1),loc=2)
	plt.ylabel('Closing Price',fontsize=15)
	plt.xlabel('Day',fontsize=15)
#	fig.savefig('AAPL.png')
#	output_file("templates/plot.html",title="test")
	output_file("templates/plot.html",title="closingPrices")
#	show(mpl.to_bokeh())
	save(mpl.to_bokeh())
Beispiel #8
0
    def update_frame(self, key, ranges=None, plot=None, element=None, empty=False):
        self.mplplot.update_frame(key, ranges)

        reused = isinstance(self.hmap, DynamicMap) and self.overlaid
        if not reused and element is None:
            element = self._get_frame(key)
        else:
            self.current_key = key
            self.current_frame = element

        plot = mpl.to_bokeh(self.mplplot.state)
        update_plot(self.handles['plot'], plot)
        if not self.overlaid:
            self._update_plot(key, self.handles['plot'], element)
Beispiel #9
0
    def initialize_plot(self, ranges=None, plot=None, plots=None):
        self.mplplot.initialize_plot(ranges)

        plot = plot if plot else self.handles.get('plot')
        new_plot = mpl.to_bokeh(self.mplplot.state)
        if plot:
            update_plot(plot, new_plot)
        else:
            plot = new_plot

        self.handles['plot'] = plot
        if not self.overlaid:
            self._update_plot(self.keys[-1], plot, self.hmap.last)
        return plot
Beispiel #10
0
    def initialize_plot(self, ranges=None, plot=None, plots=None):
        self.mplplot.initialize_plot(ranges)

        plot = plot if plot else self.handles.get('plot')
        new_plot = mpl.to_bokeh(self.mplplot.state)
        if plot:
            update_plot(plot, new_plot)
        else:
            plot = new_plot

        self.handles['plot'] = plot
        if not self.overlaid:
            self._update_plot(self.keys[-1], plot, self.hmap.last)
        return plot
Beispiel #11
0
    def update_frame(self, key, ranges=None, plot=None, element=None, empty=False):
        self.mplplot.update_frame(key, ranges)

        reused = isinstance(self.hmap, DynamicMap) and self.overlaid
        if not reused and element is None:
            element = self._get_frame(key)
        else:
            self.current_key = key
            self.current_frame = element

        plot = mpl.to_bokeh(self.mplplot.state)
        update_plot(self.handles['plot'], plot)
        if not self.overlaid:
            self._update_plot(key, self.handles['plot'], element)
Beispiel #12
0
    def plot_pulses2(self, km=False):

        import matplotlib
        matplotlib.use('Agg')
        import matplotlib.pyplot as plt
        from bokeh.resources import CDN
        from bokeh.embed import components
        from bokeh.mpl import to_bokeh
        from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool

        lines = self.get_lines()

        N = len(lines)
        npoints = self.total_units / self.km2unit if km else self.total_units
        fig = plt.figure(figsize=(12, 2 + N * 0.5))
        ax = fig.add_subplot(111)
        labels = ['IPP']

        for i, line in enumerate(lines):
            labels.append(line.get_name(channel=True))
            l = ax.plot((0, npoints), (N - i - 1, N - i - 1))
            points = [(tup[0], tup[1] - tup[0])
                      for tup in line.pulses_as_points(km=km) if tup != (0, 0)]
            ax.broken_barh(points, (N - i - 1, 0.5),
                           edgecolor=l[0].get_color(),
                           facecolor='none')

        n = 0
        f = ((self.ntx + 50) / 100) * 5 if (
            (self.ntx + 50) / 100) * 10 > 0 else 2
        for x in np.arange(0, npoints,
                           self.ipp if km else self.ipp * self.km2unit):
            if n % f == 0:
                ax.text(x, N, '%s' % n, size=10)
            n += 1

        labels.reverse()
        ax.set_yticks(range(len(labels)))
        ax.set_yticklabels(labels)
        ax.set_xlabel = 'Units'
        plot = to_bokeh(fig, use_pandas=False)
        plot.tools = [
            PanTool(dimensions=['width']),
            WheelZoomTool(dimensions=['width']),
            ResetTool(),
            SaveTool()
        ]
        plot.toolbar_location = "above"

        return components(plot, CDN)
Beispiel #13
0
def plot_comparison(dataset_identifiers, features, type="boxplot"):
    sns.set_style("whitegrid")
    sns.set_palette("deep")
    generator = "matplot"
    f, axes = plt.subplots(1, 2)
    # dataset_identifiers = ['DESeq_1_18_0_umc_read_counts_table_without_8433',
    #                       'DESeq_1_18_0_genentech_read_counts_table']
    # features = ["ENSG00000002549"]
    path = APP_CONFIG["application_files_location"] + APP_CONFIG["application_store_name"]
    i = 0
    subset = None
    print features
    for d in dataset_identifiers:
        dataset = dr.get_data_frame_from_hdf(d, path)
        if type != "pca":
            subset = dataset.ix[features, :]

        if type == "boxplot":
            axes[i].boxplot(subset)
            create_csv_version(subset.transpose(), d, type, subset.columns)
        if type == "scatter":
            generator = "matplot"
            #print len(subset.ix[0, :])
            t = axes[i].plot(subset.transpose(), 'o')
            create_csv_version(subset.transpose(), d, type, subset.columns)
            plugins.connect(f, plugins.PointLabelTooltip(t[0], labels=(list(subset.columns))))
        if type == "pca":
            print(type)
            pca = PCA(n_components=2)
            t_data = dataset.transpose()
            pca_result = pca.fit(t_data)
            pca_transformed = pca_result.transform(t_data)
            t = axes[i].plot(pca_transformed[:, 0], pca_transformed[:, 1], 'o')
            create_csv_version(pca_transformed, d, type, dataset.columns)
            plugins.connect(f, plugins.PointLabelTooltip(t[0], labels=(list(dataset.columns))))
        axes[i].set_xlabel(d)
        axes[i].set_ylabel(str(features))


        i += 1

    if generator == "bokeh":
        bk = to_bokeh(name="descriptive")
    else:
        bk = plt.gcf()
        sz = bk.get_size_inches()
        bk.set_size_inches((sz[0]*2.5, sz[1]*2))
    return bk
def plot_multiple_agents(results_path, results_name, num_workers):
    def _get_data_from_files():
        dfs = []
        for i_work in range(num_workers):
            dfs.append(
                pd.read_json(os.path.abspath(files_name.format(i_work)),
                             lines=True))

        df = pd.DataFrame()
        df['epoch'] = dfs[0]['epoch']
        columns = list(dfs[0].columns.values)
        columns.remove('epoch')
        columns.remove('time')
        columns.remove('step')

        # ensure all matrices of the same size,
        # since not all agents necessarily reached the same epoch
        max_epochs = 0
        for d in dfs:
            epochs = d.shape[0]
            max_epochs = max(max_epochs, epochs)
        data = {}
        for c in columns:
            data[c] = np.vstack([df[c].as_matrix() for df in dfs])
        return data, columns

    files_name = os.path.join(results_path, results_name)
    plot_path = '{}.{}'.format(files_name, 'html')
    files_name += '_{}.json'

    data, columns = _get_data_from_files()

    figs = []
    for i, col in enumerate(columns):
        fig = plt.figure(i)
        axis = sns.tsplot(data=data[col], err_style="unit_traces")
        # axis = sns.tsplot(data=data[c], ci=[50, 70, 90], legend=True)
        axis.set_title(col)
        axis.set_xlabel('epochs')
        axis.set_ylabel(col)
        fig.add_axes(axis)
        figs.append(to_bokeh(fig))

    plot = column(Div(text='<h1 align="center">{}</h1>'.format(results_name)),
                  *figs)
    output_file(plot_path, title=results_name)
    save(plot)
Beispiel #15
0
    def hist_den_plot(self):
        Y = self.Y.as_matrix()
        hist_point = int(self.ticker4)
        delta_t = float(self.ticker3_2)

        data = Y[hist_point,:]
        sns.distplot(data, color='k', hist_kws={"color":"b"}, norm_hist=True)
        #sns.distplot(data, color='k', hist_kws={"color":"b"})
        plt.hist(data)
        plt.title('Distribution at T = ' + str(np.round(delta_t*hist_point,4)) + ' with Mean: ' +str(np.round(np.mean(data),4)) + ' and Std Dev: ' + str(np.round(np.std(data),4)))
        plt.xlabel('Price Bins')
        plt.ylabel('Bin Count')
       
        p = mpl.to_bokeh()
        p.title_text_font_size= str(TITLE_SIZE)+'pt'

        return p
def bokeh_frisbee(i):
    """ Creates a bokeh html file of the 3D plot """
    from bokeh import mpl
    from bokeh.plotting import output_file, save

    fig = plt.figure()
    fig.canvas.set_window_title('Frisbee Simulation HTML')
    ax = fig.gca(projection='3d')

    ax.plot(mat_z[0:i], mat_x[0:i], mat_y[0:i], label='Frisbee Flight')
    plt.ylabel("X distance (m)")
    plt.xlabel("Z distance (m)")
    if absmax(mat_z) < 1:
        ax.set_xlim(-1, 1)

    output_file("online_fig.html")
    save(mpl.to_bokeh(fig))
    return
Beispiel #17
0
def figtoHTML(figure, pathName):
    '''
    For a given figure object (matplotlib), saves it a specified file path as an HTML file (bokeh format).

    Args:
        figure: A matplotlib figure object to save.
        pathName: Path of file to save figure to.
    
    Returns:
        1 if successful, 0 if not successful.
    '''
    try:
        output_file(pathName)
        bfig = to_bokeh(figure)
    except:
        print('Failed to save figure to {}'.format(pathName))
        return 0
        
    return 1
def updateFigure():
    filename = str(selectFile.value)
    allData = []
    data = []
    with open(filePath, 'r') as csvfile:
        next(csvfile)
        allData = csv.reader(csvfile, delimiter=',')
        ##Making word cloud for the selected file
        data = [row for row in allData if row[1] == filename]
        print(data)
        words = []
        for row in data:
            words.append(row[2])
        print(words[0])
    csvfile.close()
    wordcloud = WordCloud(background_color="white",
                          max_font_size=40).generate(words[0])
    plt.imshow(wordcloud)  #, interpolation="bilinear"
    plt.axis("off")
    plt.show()
    fig = mpl.to_bokeh(plt.figure())
    return fig
Beispiel #19
0
def visualize_data():   
	data_file = parse(MY_FILE, "~")

	counter = Counter(item["Product"] for item in data_file)
   	
	data_list = [
	              counter["P-HYP"],
	              counter["RTVAST"],
	              counter["A-MKHYP"],
	              counter["P-HYPL"],
	            ]
	labels_tuple = tuple(["P-HYP", "RTVAST", "A-MKHYP", "P-HYPL"])

	plt.title("Test")
	plt.plot(data_list)
	plt.xticks(range(len(labels_tuple)), labels_tuple)
    
    #Save to bokeh
	plot = mpl.to_bokeh(name='test')
	bpl.show(plot)   
	output_file("test1.html")
	plt.clf()
Beispiel #20
0
    def path_plot(self):
        num_paths_plot = min(50,int(self.ticker3))
        hist_point = int(self.ticker4)
        #print 'Hist Point ', hist_point
        Y = self.Y.as_matrix()
        pltdat = Y[:,0:num_paths_plot]
        mY, MY = min(Y[hist_point,:]), max(Y[hist_point,:])

        plt.plot(pltdat, alpha=0.1, linewidth=1.8)
        sns.tsplot(pltdat.T,err_style='ci_band', ci=[68,95,99], alpha=1, \
                linewidth = 2.5, color='indianred')
        #sns.tsplot(pltdat.T,err_style='ci_band', ci=[68,95,99,99.99999], alpha=1, \
        #        linewidth = 2.5, condition='Mean Path', color='indianred')
        plt.plot([hist_point, hist_point], [0.99*mY, 1.01*MY], 'k-',label='Time Series Histogram')
        plt.xlabel('Time Step')
        plt.ylabel('Price')
        #plt.legend()

        p = mpl.to_bokeh()
        p.title = 'Mean Path (Red), MC Paths (Background) and Density Line (Black)'
        p.title_text_font_size= str(TITLE_SIZE)+'pt'

        return p
Beispiel #21
0
def plot_left_right(df,
                    colors,
                    plot_column='right',
                    grouping_column='party',
                    folder=RESULT_FOLDER,
                    plot_suffix=""):
    # median-centered per domain right position
    df[plot_column] = df[plot_column] - df[plot_column].median()
    ax = sns.violinplot(x=plot_column,
                        y=grouping_column,
                        data=df[[plot_column, grouping_column]],
                        palette=sns.color_palette(colors),
                        split=True,
                        scale="count",
                        inner="stick",
                        saturation=0.5)
    ax.set_xlim([0, 1])
    ax.set_xticks(np.arange(0, 1, .1))
    ax.set_xlabel("links-rechts Index")
    ax.set_ylabel("Partei")
    ax.set_facecolor("white")
    ax.set_title(plot_suffix)
    output_file(os.path.join(folder, "violinPlot-%s.html" % plot_suffix))
    show(mpl.to_bokeh())
import numpy as np
import pandas as pd
from bokeh import mpl
from bokeh.plotting import show

ts = pd.Series(np.random.randn(1000),
               index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()
p = ts.plot()

show(mpl.to_bokeh(name="series"))
Beispiel #23
0
import numpy as np
import pandas as pd
from bokeh import mpl

ts = pd.Series(np.random.randn(1000),
               index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()

df = pd.DataFrame(np.random.randn(1000, 4),
                  index=ts.index,
                  columns=list('ABCD'))
df = df.cumsum()
df.plot(legend=False)

mpl.to_bokeh(name="dataframe")
# a "waterfall" plot or a "stagger" plot.

nverts = 60
ncurves = 20
offs = (0.1, 0.0)

rs = np.random.RandomState([12345678])
yy = np.linspace(0, 2 * np.pi, nverts)
ym = np.amax(yy)
xx = (0.2 + (ym - yy) / ym)**2 * np.cos(yy - 0.4) * 0.5
segs = []
for i in range(ncurves):
    xxx = xx + 0.02 * rs.randn(nverts)
    curve = list(zip(xxx, yy * 100))
    segs.append(curve)

colors = [(1.0, 0.0, 0.0, 1.0), (0.0, 0.5, 0.0, 1.0), (0.0, 0.0, 1.0, 1.0),
          (0.0, 0.75, 0.75, 1.0), (0.75, 0.75, 0, 1.0), (0.75, 0, 0.75, 1.0),
          (0.0, 0.0, 0.0, 1.0)]

col = LineCollection(segs, linewidth=5, offsets=offs)

ax = plt.axes()
ax.add_collection(col, autolim=True)
col.set_color(colors)
ax.set_title('Successive data offsets')

fig = plt.gcf()

show(mpl.to_bokeh(name="lc_offsets"))
Beispiel #25
0
import numpy as np
import matplotlib.pyplot as plt
from bokeh import mpl
from bokeh.plotting import show

x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.sin(x)
z = np.cos(x)

plt.plot(x, y, "r-", marker='o')
plt.title("Matplotlib Figure in Bokeh")

# dashed lines work
plt.plot(x, z, "g-x", linestyle="-.")

#show(mpl.to_bokeh())
#show(mpl.to_bokeh(name="test"))
show(mpl.to_bokeh(plt.gcf(), name="test"))
#show(mpl.to_bokeh(plt.gcf(), server="default"))
#show(mpl.to_bokeh(plt.gcf(), name="test", server="default"))
Beispiel #26
0
verts = np.swapaxes(verts, 0, 1)

# In your case, "verts" might be something like:
# verts = zip(zip(lon1, lat1), zip(lon2, lat2), ...)
# If "data" in your case is a numpy array, there are cleaner ways to reorder
# things to suit.

facecolors = ['red', 'green', 'blue', 'cyan', 'yellow', 'magenta', 'black']
edgecolors = ['cyan', 'yellow', 'magenta', 'black', 'red', 'green', 'blue']
widths = [5, 10, 20, 10, 5]

# Make the collection and add it to the plot.
col = PolyCollection(verts,
                     facecolor=facecolors,
                     edgecolor=edgecolors,
                     linewidth=widths,
                     linestyle='--',
                     alpha=0.5)

ax = plt.axes()
ax.add_collection(col)

plt.xlim([-60, 60])
plt.ylim([-60, 60])

plt.title("MPL-PolyCollection support in Bokeh")

output_file("polycollection.html", title="polycollection.py example")

show(mpl.to_bokeh())
Beispiel #27
0
plt.setp(plt.gca(), xticklabels=[], yticks=(4, 8, 12), xticks=(0, 10, 20))
plt.ylabel('I', fontsize=20)

plt.subplot(222)
plt.plot(x, y2, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.setp(plt.gca(),
         xticklabels=[],
         yticks=(4, 8, 12),
         yticklabels=[],
         xticks=(0, 10, 20))
plt.ylabel('II', fontsize=20)

plt.subplot(223)
plt.plot(x, y3, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.ylabel('III', fontsize=20)
plt.setp(plt.gca(), yticks=(4, 8, 12), xticks=(0, 10, 20))

plt.subplot(224)

xfit = np.array([np.amin(x4), np.amax(x4)])
plt.plot(x4, y4, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.setp(plt.gca(), yticklabels=[], yticks=(4, 8, 12), xticks=(0, 10, 20))
plt.ylabel('IV', fontsize=20)

# We create the figure in matplotlib and then we "pass it" to Bokeh

mpl.to_bokeh(name="subplots")
import numpy as np
import matplotlib.pyplot as plt
from bokeh import mpl
from bokeh.plotting import show

x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.sin(x)
z = np.cos(x)

plt.plot(x, y, "r-", marker='o')
plt.title("Matplotlib Figure in Bokeh")

# dashed lines work
plt.plot(x, z, "g-x", linestyle="-.")

#show(mpl.to_bokeh())
#show(mpl.to_bokeh(name="sincos"))
show(mpl.to_bokeh(plt.gcf(), name="sincos"))
#show(mpl.to_bokeh(plt.gcf(), server="default"))
#show(mpl.to_bokeh(plt.gcf(), name="sincos", server="default"))
Beispiel #29
0
from ggplot import *
from bokeh import mpl
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "x": range(100),
    "y": np.random.choice([-1, 1], 100)
})

df.y = df.y.cumsum()

g = ggplot(aes(x='x', y='y'), data=df) + \
    geom_step()
g.draw()

plt.title("Step ggplot-based plot in Bokeh.")

mpl.to_bokeh(name="step")
Beispiel #30
0
    ax.plot(sel_by_wave1[j].wave.iloc[i],
            sel_by_wave1[j].abs_cal.iloc[i],
            marker='',
            color=colors[i],
            lw=0.1) for i in range(len(sel_by_wave1[j].wave))
] for j in range(len(sel_by_wave1))]

ax.set_xlabel(u'Wavelength [\AA]')
ax.set_ylabel(u'abs\_cal [erg s$^{-1}$ cm$^{-2}$ \AA$^{-1}$]')

# USING BOKEH
TOOLS = 'pan, box_zoom, wheel_zoom, hover, resize, undo, redo, reset, save'
# x = sel_by_wave1[0].wave.iloc[0]
# y = sel_by_wave1[0].abs_cal.iloc[0]
# # output_file('delOri.html')
# p = figure(tools=TOOLS)
#
# [p.line(x, y, color=color) for x, y, color in zip(sel_by_wave1[0].wave, sel_by_wave1[0].abs_cal, ['red', 'green'])]
#
# session = push_session(curdoc())
#
# session.show(p)
# session.loop_until_closed()
output_file('delOri.html')
show(to_bokeh(fig, tools=TOOLS))

fig.savefig('./RESULTS/spec_l1240.pdf')

plt.clf()
plt.close('all')
Beispiel #31
0
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from scipy import optimize
from bokeh import mpl

# Set the palette colors.
sns.set(palette="Set2")


# Build the sin wave
def sine_wave(n_x, obs_err_sd=1.5, tp_err_sd=.3):
    x = np.linspace(0, (n_x - 1) / 2, n_x)
    y = np.sin(x) + np.random.normal(0, obs_err_sd) + np.random.normal(0, tp_err_sd, n_x)
    return y

sines = np.array([sine_wave(31) for _ in range(20)])

# Generate the Seaborn plot with "ci" bars.
ax = sns.tsplot(sines, err_style="ci_bars", interpolate=False)
xmin, xmax = ax.get_xlim()
x = np.linspace(xmin, xmax, sines.shape[1])
out, _ = optimize.leastsq(lambda p: sines.mean(0) - (np.sin(x / p[1]) + p[0]), (0, 2))
a, b = out
xx = np.linspace(xmin, xmax, 100)
plt.plot(xx, np.sin(xx / b) + a, c="#444444")

plt.title("Seaborn tsplot with CI in bokeh.")

mpl.to_bokeh(name="sinerror")
    def plot_2d_graph(self, data_frame, gp, chart_type):

        if gp is None: gp = GraphProperties()
        if gp.chart_type is None and chart_type is None: chart_type = 'line'

        if gp.resample is not None: data_frame = data_frame.asfreq(gp.resample)

        self.apply_style_sheet(gp)

        # create figure & add a subplot
        fig = plt.figure(figsize = ((gp.width * gp.scale_factor)/gp.dpi,
                                    (gp.height * gp.scale_factor)/gp.dpi), dpi = gp.dpi)

        ax = fig.add_subplot(111)

        if gp.x_title != '': ax.set_xlabel(gp.x_title)
        if gp.y_title != '': ax.set_ylabel(gp.y_title)

        plt.xlabel(gp.x_title)
        plt.ylabel(gp.y_title)

        fig.suptitle(gp.title, fontsize = 14 * gp.scale_factor)

        # format Y axis
        y_formatter = matplotlib.ticker.ScalarFormatter(useOffset = False)
        ax.yaxis.set_major_formatter(y_formatter)

        # create a second y axis if necessary
        ax2 = []

        if gp.y_axis_2_series != []:
            ax2 = ax.twinx()

            # do not use a grid with multiple y axes
            ax.yaxis.grid(False)
            ax2.yaxis.grid(False)

        # matplotlib 1.5
        try:
            cyc = matplotlib.rcParams['axes.prop_cycle']
            color_cycle =  [x['color'] for x in cyc]
        except KeyError:
            # pre 1.5
            pass
            # color_cycle =  matplotlib.rcParams['axes.color_cycle']

        bar_ind = np.arange(0, len(data_frame.index))

        # for bar charts, create a proxy x-axis (then relabel)
        xd, bar_ind, has_bar, no_of_bars = self.get_bar_indices(data_frame, gp, chart_type, bar_ind)

        # plot the lines (using custom palettes as appropriate)
        try:
            # get all the correct colors (and construct gradients if necessary eg. from 'blues')
            color_spec = self.create_color_list(gp, data_frame)

            # for stacked bar
            yoff_pos = np.zeros(len(data_frame.index.values)) # the bottom values for stacked bar chart
            yoff_neg = np.zeros(len(data_frame.index.values)) # the bottom values for stacked bar chart

            zeros = np.zeros(len(data_frame.index.values))

            # for bar chart
            bar_space = 0.2
            bar_width = (1 - bar_space) / (no_of_bars)
            bar_index = 0

            has_matrix = False

            # some lines we should exclude from the color and use the default palette
            for i in range(0, len(data_frame.columns.values)):

                if gp.chart_type is not None:
                    if isinstance(gp.chart_type, list):
                        chart_type = gp.chart_type[i]
                    else:
                        chart_type = gp.chart_type

                if chart_type == 'heatmap':
                    # TODO experimental!
                    # ax.set_frame_on(False)
                    ax.pcolor(data_frame, cmap=plt.cm.Blues, alpha=0.8)
                    # plt.colorbar()
                    has_matrix = True
                    break

                label = str(data_frame.columns[i])

                ax_temp = self.get_axis(ax, ax2, label, gp.y_axis_2_series)

                yd = data_frame.ix[:,i]

                if color_spec[i] is None:
                    color_spec[i] = color_cycle[i % len(color_cycle)]

                if (chart_type == 'line'):
                    linewidth_t = self.get_linewidth(label,
                                                     gp.linewidth, gp.linewidth_2, gp.linewidth_2_series)

                    if linewidth_t is None: linewidth_t = matplotlib.rcParams['axes.linewidth']

                    ax_temp.plot(xd, yd, label = label, color = color_spec[i],
                                     linewidth = linewidth_t)

                elif(chart_type == 'bar'):
                    # for multiple bars we need to allocate space properly
                    bar_pos = [k - (1 - bar_space) / 2. + bar_index * bar_width for k in range(0,len(bar_ind))]

                    ax_temp.bar(bar_pos, yd, bar_width, label = label, color = color_spec[i])

                    bar_index = bar_index + 1

                elif(chart_type == 'stacked'):
                    bar_pos = [k - (1 - bar_space) / 2. + bar_index * bar_width for k in range(0,len(bar_ind))]

                    yoff = np.where(yd > 0, yoff_pos, yoff_neg)

                    ax_temp.bar(bar_pos, yd, label = label, color = color_spec[i], bottom = yoff)

                    yoff_pos = yoff_pos + np.maximum(yd, zeros)
                    yoff_neg = yoff_neg + np.minimum(yd, zeros)

                    # bar_index = bar_index + 1

                elif(chart_type == 'scatter'):
                    ax_temp.scatter(xd, yd, label = label, color = color_spec[i])

                    if gp.line_of_best_fit is True:
                        self.trendline(ax_temp, xd.values, yd.values, order=1, color= color_spec[i], alpha=1,
                                           scale_factor = gp.scale_factor)

            # format X axis
            self.format_x_axis(ax, data_frame, gp, has_bar, bar_ind, has_matrix)

        except: pass

        if gp.display_source_label == True:
            ax.annotate('Source: ' + gp.source, xy = (1, 0), xycoords='axes fraction', fontsize=7 * gp.scale_factor,
                        xytext=(-5 * gp.scale_factor, 10 * gp.scale_factor), textcoords='offset points',
                        ha='right', va='top', color = gp.source_color)

        if gp.display_brand_label == True:
            self.create_brand_label(ax, anno = gp.brand_label, scale_factor = gp.scale_factor)

        leg = []
        leg2 = []

        loc = 'best'

        # if we have two y-axis then make sure legends are in opposite corners
        if ax2 != []: loc = 2

        try:
            leg = ax.legend(loc = loc, prop={'size':10 * gp.scale_factor})
            leg.get_frame().set_linewidth(0.0)
            leg.get_frame().set_alpha(0)

            if ax2 != []:
                leg2 = ax2.legend(loc = 1, prop={'size':10 * gp.scale_factor})
                leg2.get_frame().set_linewidth(0.0)
                leg2.get_frame().set_alpha(0)
        except: pass

        try:
            if gp.display_legend is False:
                if leg != []: leg.remove()
                if leg2 != []: leg.remove()
        except: pass

        try:
            plt.savefig(gp.file_output, transparent=False)
        except: pass


        ####### various matplotlib converters are unstable
        # convert to D3 format with mpld3
        try:
            # output matplotlib charts externally to D3 based libraries
            import mpld3

            if gp.display_mpld3 == True:
                mpld3.save_d3_html(fig, gp.html_file_output)
                mpld3.show(fig)
        except: pass

        # FRAGILE! convert to Bokeh format
        # better to use direct Bokeh renderer
        try:
            if (gp.convert_matplotlib_to_bokeh == True):
                from bokeh.plotting import output_file, show
                from bokeh import mpl

                output_file(gp.html_file_output)
                show(mpl.to_bokeh())
        except: pass

        # FRAGILE! convert matplotlib chart to Plotly format
        # recommend using AdapterCufflinks instead to directly plot to Plotly
        try:
            import plotly.plotly as py
            import plotly
            import plotly.tools as tls

            if gp.convert_matplotlib_to_plotly == True:
                plotly.tools.set_credentials_file(username = gp.plotly_username,
                                                  api_key = gp.plotly_api_key)

                py_fig = tls.mpl_to_plotly(fig, strip_style = True)
                plot_url = py.plot_mpl(py_fig, filename = gp.plotly_url)
        except:
            pass

        # display in matplotlib window
        try:
            if GraphicsConstants.plotfactory_silent_display == True:
                return fig
            elif gp.silent_display == False:
                plt.show()
            else:
                return fig

        except:
            pass
Beispiel #33
0
import numpy as np
import pandas as pd

from bokeh import mpl
from bokeh.plotting import output_file, show

ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()

df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index, columns=list('ABCD'))
df = df.cumsum()
df.plot(legend=False)

output_file("dataframe.html")

show(mpl.to_bokeh())
Beispiel #34
0
    # You have several ways to input the colors:
    # colors = ['r','g','b','c','y','m','k']
    # colors = ['red','green','blue','cyan','yellow','magenta','black']
    # colors = ['#ff0000', '#008000', '#0000ff', '#00bfbf', '#bfbf00', '#bf00bf', '#000000']
    # colors = [(1.0, 0.0, 0.0, 1.0), (0.0, 0.5, 0.0, 1.0), (0.0, 0.0, 1.0, 1.0), (0.0, 0.75, 0.75, 1.0),
    #           (0.75, 0.75, 0, 1.0), (0.75, 0, 0.75, 1.0), (0.0, 0.0, 0.0, 1.0)]

    colors = ['r', 'g', 'b', 'c', 'y', 'm', 'k']
    widths = [5, 10, 20, 40, 20, 10, 5]

    segments = make_segments(x, y)
    lc = LineCollection(segments, colors=colors, linewidth=widths, alpha=alpha)

    ax = plt.gca()
    ax.add_collection(lc)

    return lc

# Colored sine wave

x = np.linspace(0, 4 * np.pi, 100)
y = np.sin(x)

colorline(x, y)

plt.title("MPL support for ListCollection in Bokeh")
plt.xlim(x.min(), x.max())
plt.ylim(-1.0, 1.0)

mpl.to_bokeh(name="listcollection")
Beispiel #35
0
def sample_distribution_for_genes(dataset_identifier, genes, title="", samples=None, unit="zscore", chart_type="heat",
                                  chart_rendering="html"):
    try:
        generator = None
        convert = False
        tooltip = False
        sns.set(style="whitegrid")
        #get path to HDF store from config file
        path_to_store = APP_CONFIG["application_files_location"] + APP_CONFIG["application_store_name"]

        print("path to store " + path_to_store)
        print(genes)

        #get data set as a pandas frame
        dataset = dr.get_data_frame_from_hdf(dataset_identifier, path_to_store)
        tooltip = None
        #filter selected genes
        gene_list = dataset.loc[genes, :]
        labels = list(gene_list.columns)

        #matplotlib settings
        ax = None
        fig = None

        #heatmap
        #html = dynamic plot
        #pdf = pdf file
        if chart_type == "heat":

            if chart_rendering == "html":
                print("bokeh heatmap")
                sns.set()
                title += " heatmap"
                generator = "bokeh"

                print("sns heatmap")
                fig = HeatMap(gene_list.dropna(), title=title)
            elif chart_rendering == "pdf":
                plt.switch_backend('Agg')
                title += " heatmap pdf"
                sns.set_context("paper", font_scale=0.8)
                generator = "matplot"
                ax = sns.heatmap(gene_list)
                #adapt label fontsize
                for tick in ax.xaxis.get_major_ticks():
                    tick.label.set_fontsize(2.0)
                    # tick.label.set
                print("axis loaded")
                print("heatmap with bokeh")
        elif chart_type == "box":
            #boxplot charts
            title += " boxplot"
            generator = "bokeh"
            # convert = True
            TOOLS = "resize,crosshair,pan,wheel_zoom,box_zoom,reset,previewsave,hover"
            print("creating box plot")
            # new_z_set = pd.DataFrame(stats.zscore(gene_list), index=gene_list.index, columns=gene_list.columns)
            t_genes = gene_list.transpose()
            # sns.boxplot(t_genes, color="coolwarm_r", names=t_genes.columns)
            fig = BoxPlot(t_genes, legend=True, tools=TOOLS)
            hover = fig.select(dict(type=HoverTool))
            hover.tooltips = [
                ("sample", "$index")
            ]
        elif chart_type == "scatter":
            if chart_rendering == "html":
                title += " scatter"
                generator = "bokeh"

                # tooltip = True
                TOOLS = "resize, crosshair, pan, wheel_zoom, box_zoom,reset, previewsave, hover"
                fig = bpl.figure(title=title, tools=TOOLS)
                current_palette = sns.color_palette()
                i = 0
                colors = bp.Spectral10
                # fig.scatter(dc, dc["index"])
                for e in gene_list.iterrows():
                    val = [v for v in e[1]]
                    idx = range(0, len(val))
                    col_data_source = ColumnDataSource(dict(
                        x=idx,
                        y=val,
                        sample=gene_list.columns[idx],
                    ))

                    fig.scatter('x', 'y', color=colors[i], legend=e[0], source=col_data_source)
                    i += 1

                hover = fig.select(dict(type=HoverTool))
                hover.tooltips = [
                    ("sample", "@sample"),
                    ("count", "$y")
                ]
            elif chart_rendering == "pdf":
                plt.switch_backend('PDF')
                sns.color_palette("deep")
                title += " scatter pdf"
                generator = "matplot"
                print("starting with matplot")
                transposed_data = gene_list.transpose()
                ax = transposed_data.plot(style='o')
                legend = plt.legend(frameon=1)
                frame = legend.get_frame()
                frame.set_edgecolor('blue')
                coll_len = len(gene_list.columns)
                for idx, gene in enumerate(gene_list.index):
                    for x, y in zip(range(0, coll_len), gene_list.iloc[idx, :]):
                        if y > gene_list.iloc[idx, :].quantile(0.99):
                            ax.annotate(labels[x], xy=(x, y), textcoords='data')
                # grid.add_legend(labels)
                print("plotted with matplot")

        if ax is not None:
            if generator == "matplot" and (title is not None):
                ax.set_title(title)
            elif generator == "matplot" and ax is not None:
                ax.set_title(title)

        if generator == "matplot":
            fig = plt.gcf()

        if convert is True and generator == "bokeh":
            fig = plt.gcf()
            fig = mpl.to_bokeh(fig)

        return {"generator": generator, "chart": fig}
    except BaseException as e:
        print(e.__str__())
Beispiel #36
0
def exoctk_tot_results():

    exo_dict = ExoCTK.tot.transit_obs.load_exo_dict()
    inst_dict = ExoCTK.tot.transit_obs.load_mode_dict('WFC3 G141')

    # Get the input from the form
    exo_dict['star']['hmag'] = float(
        request.form['hmag'])  # H-band magnitude of the system
    exo_dict['planet']['exopath'] = request.form[
        'exopath']  # filename for model spectrum [wavelength, flux]
    exo_dict['planet']['w_unit'] = request.form[
        'w_unit']  # wavelength unit (um or nm)
    exo_dict['planet']['f_unit'] = request.form[
        'f_unit']  # flux unit (fp/f* or (rp/r*)^2)
    exo_dict['planet'][
        'depth'] = 4.0e-3  # Approximate transit/eclipse depth for plotting purposes
    exo_dict['planet']['i'] = float(
        request.form['i'])  # Orbital inclination in degrees
    exo_dict['planet']['ars'] = float(
        request.form['ars']
    )  # Semi-major axis in units of stellar radii (a/R*)
    exo_dict['planet']['period'] = float(
        request.form['period'])  # Orbital period in days

    # Detector and Observation inputs (Make these form inputs!)
    exo_dict['calculation'] = 'scale'
    inst_dict['configuration']['detector'][
        'subarray'] = 'GRISM256'  # Subarray size, GRISM256 or GRISM512
    inst_dict['configuration']['detector']['nsamp'] = 10  # WFC3 NSAMP, 1..15
    inst_dict['configuration']['detector'][
        'samp_seq'] = 'SPARS5'  # WFC3 SAMP-SEQ, SPARS5, SPARS10, or SPARS25
    exo_dict['observation'][
        'transit_duration'] = 4170  # Full transit/eclipse duration in seconds
    exo_dict['observation']['norbits'] = 4  # Number of HST orbits per visit
    exo_dict['observation']['noccultations'] = 5  # Number of transits/eclipses
    exo_dict['observation'][
        'nchan'] = 15  # Number of spectrophotometric channels
    exo_dict['observation'][
        'scanDirection'] = 'Forward'  # Spatial scan direction, Forward or Round Trip
    exo_dict['observation'][
        'schedulability'] = '30'  # % time HST can observe target (30 or 100)

    # Run PandExo
    deptherr, rms, ptsOrbit = ExoCTK.tot.transit_obs.run_pandexo(
        exo_dict, inst_dict, output_file='wasp43b_G141.p')

    # Plot the model spectrum with simpulated data and uncertainties
    specfile = exo_dict['planet']['exopath']
    w_unit = exo_dict['planet']['w_unit']
    grism = inst_dict['configuration']['instrument']['disperser']
    nchan = exo_dict['observation']['nchan']
    binspec = ExoCTK.tot.transit_obs.plot_PlanSpec(
        specfile,
        w_unit,
        grism,
        deptherr,
        nchan,
        smooth=10,
        labels=['Model Spectrum', 'Simulated Obs.'])

    # Make the matplotlib plot into a Bokeh plot
    plt.savefig('static/plots/sim.png')
    sim_plot = mpl.to_bokeh(plt.gcf())
    output_file('test_sim.html')
    save(sim_plot)
    plt.close()
    xmin, xmax = (1.125, 1.650)
    ymin, ymax = (np.min(binspec) - 2 * deptherr,
                  np.max(binspec) + 2 * deptherr)
    sim_plot.y_range = Range1d(ymin, ymax)
    sim_plot.x_range = Range1d(xmin, 6)
    #    sim_plot.y_axis_label = 'Wavelength (micron)'
    sim_script, sim_plot = components(sim_plot)

    # Plot the transit curves
    numorbits = exo_dict['observation']['norbits']
    depth = exo_dict['planet']['depth']
    inc = exo_dict['planet']['i']
    aRs = exo_dict['planet']['ars']
    period = exo_dict['planet']['period']
    windowSize = 20  # observation start window size in minutes
    minphase, maxphase = ExoCTK.tot.transit_obs.calc_StartWindow('eclipse',
                                                                 rms,
                                                                 ptsOrbit,
                                                                 numorbits,
                                                                 depth,
                                                                 inc,
                                                                 aRs,
                                                                 period,
                                                                 windowSize,
                                                                 ecc=0,
                                                                 w=90.)

    # Make the matplotlib plot into a Bokeh plot
    plt.savefig('static/plots/obs.png')
    obs_plot = mpl.to_bokeh(plt.gcf())
    output_file('test_obs.html')
    save(obs_plot)
    plt.close()
    obs_script, obs_plot = components(obs_plot)

    exo_dict['minphase'] = round(minphase, 4)
    exo_dict['maxphase'] = round(maxphase, 4)

    sim = open('test_sim.html')
    lines = sim.readlines()
    sim_html = "".join(lines)
    sim.close()

    obs = open('test_obs.html')
    lines = obs.readlines()
    obs_html = "".join(lines)
    print(obs_html)
    html_dict = {'sim': sim_html, 'obs': obs_html}

    return render_template('tot_results.html',
                           exo_dict=exo_dict,
                           html_dict=html_dict)
import numpy as np
import pandas as pd
from bokeh import mpl
from bokeh.plotting import show

ts = pd.Series(np.random.randn(1000),
               index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()

df = pd.DataFrame(np.random.randn(1000, 4),
                  index=ts.index,
                  columns=list('ABCD'))
df = df.cumsum()
df.plot(legend=False)

show(mpl.to_bokeh(name="dataframe"))
Beispiel #38
0
# demo inspired by: http://matplotlib.org/examples/pylab_examples/stem_plot.html

from bokeh import mpl
from bokeh.plotting import output_file, show

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0.1, 2*np.pi, 10)
markerline, stemlines, baseline = plt.stem(x, np.cos(x), '-.')
plt.setp(markerline, 'markerfacecolor', 'b')
plt.setp(baseline, 'color', 'r', 'linewidth', 2)

output_file("mpl_stem.html", title="mpl_stem.py example")

show(mpl.to_bokeh(tools='pan, wheel_zoom, crosshair'))
Beispiel #39
0
                 rasterized=True,
                 linestyle=next(linecycler))

    legend = ax1.legend()
    ax1.legend(loc=0)
    ax1.minorticks_on()
    ax1.set_ylim((0, np.max(new_sigma)))
    ax1.set_xlim((0.1, 3.1))
    # ax1.set_title(r'$\sigma({0})={1:.1f}\%$'.format(str(label[key_y]), np.abs(sigma_just_CMB_y / fid[key_y] * 100.)))
    ax1.set_ylabel(r'sigma(' + label[key_y] + r')')
    ax1.set_xlabel(r'prior/sigma(x) old')
    plt.title(r'Prior results on ' + label[key_y])
    # ============================================
    # FINALLY SAVE
    # ============================================
    # ============================================

    # ============================================

    output_file("subplots.html")
    save(mpl.to_bokeh())
    plt.savefig(base_dir +
                'data/{}/run{}/output/prior_{}_snow_mass.pdf'.format(
                    data_type, str(run_idx), str(key_y)),
                dpi=400,
                papertype='Letter',
                format='pdf',
                transparent=True,
                bbox_inches='tight')
    plt.close()
Beispiel #40
0
plt.subplot(221)
plt.plot(x, y1, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.setp(plt.gca(), xticklabels=[], yticks=(4, 8, 12), xticks=(0, 10, 20))
plt.ylabel('I', fontsize=20)

plt.subplot(222)
plt.plot(x, y2, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.setp(plt.gca(), xticklabels=[], yticks=(4, 8, 12), yticklabels=[], xticks=(0, 10, 20))
plt.ylabel('II', fontsize=20)

plt.subplot(223)
plt.plot(x, y3, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.ylabel('III', fontsize=20)
plt.setp(plt.gca(), yticks=(4, 8, 12), xticks=(0, 10, 20))

plt.subplot(224)

xfit = np.array([np.amin(x4), np.amax(x4)])
plt.plot(x4, y4, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.setp(plt.gca(), yticklabels=[], yticks=(4, 8, 12), xticks=(0, 10, 20))
plt.ylabel('IV', fontsize=20)

# We create the figure in matplotlib and then we "pass it" to Bokeh

show(mpl.to_bokeh(name="subplots"))
Beispiel #41
0
numpoly, numverts = 100, 4
centers = 100 * (np.random.random((numpoly, 2)) - 0.5)
offsets = 10 * (np.random.random((numverts, numpoly, 2)) - 0.5)
verts = centers + offsets
verts = np.swapaxes(verts, 0, 1)

# In your case, "verts" might be something like:
# verts = zip(zip(lon1, lat1), zip(lon2, lat2), ...)
# If "data" in your case is a numpy array, there are cleaner ways to reorder
# things to suit.

facecolors = ['red', 'green', 'blue', 'cyan', 'yellow', 'magenta', 'black']

edgecolors = ['cyan', 'yellow', 'magenta', 'black', 'red', 'green', 'blue']

widths = [5, 10, 20, 10, 5]

ax = plt.axes()

# Make the collection and add it to the plot.
col = PolyCollection(verts, facecolor=facecolors, edgecolor=edgecolors,
                     linewidth=widths, linestyle='--', alpha=0.5)
ax.add_collection(col)

plt.xlim([-60, 60])
plt.ylim([-60, 60])

plt.title("MPL-PolyCollection support in Bokeh")

mpl.to_bokeh(name="polycollection")
Beispiel #42
0
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib as mplc
import matplotlib.pyplot as plt
from bokeh import mpl
from bokeh.plotting import show

# Generate the pandas dataframe
data = np.random.multivariate_normal([0, 0], [[1, 2], [2, 20]], size=100)
data = pd.DataFrame(data, columns=["X", "Y"])
mplc.rc("figure", figsize=(6, 6))

# Just plot seaborn kde
sns.kdeplot(data, cmap="BuGn_d")

plt.title("Seaborn kdeplot in bokeh.")

show(mpl.to_bokeh(name="kde"))
Beispiel #43
0
 def update_frame(self, key, ranges=None):
     if key in self.hmap:
         self.mplplot.update_frame(key, ranges)
         self.handles['plot'] = mpl.to_bokeh(self.mplplot.state)
Beispiel #44
0
# a "waterfall" plot or a "stagger" plot.

nverts = 60
ncurves = 20
offs = (0.1, 0.0)

rs = np.random.RandomState([12345678])
yy = np.linspace(0, 2 * np.pi, nverts)
ym = np.amax(yy)
xx = (0.2 + (ym - yy) / ym) ** 2 * np.cos(yy - 0.4) * 0.5
segs = []
for i in range(ncurves):
    xxx = xx + 0.02 * rs.randn(nverts)
    curve = list(zip(xxx, yy * 100))
    segs.append(curve)

colors = [(1.0, 0.0, 0.0, 1.0), (0.0, 0.5, 0.0, 1.0), (0.0, 0.0, 1.0, 1.0),
          (0.0, 0.75, 0.75, 1.0), (0.75, 0.75, 0, 1.0), (0.75, 0, 0.75, 1.0),
          (0.0, 0.0, 0.0, 1.0)]

col = LineCollection(segs, linewidth=5, offsets=offs)

ax = plt.axes()
ax.add_collection(col, autolim=True)
col.set_color(colors)
ax.set_title('Successive data offsets')

fig = plt.gcf()

mpl.to_bokeh(name="lc_offsets")
Beispiel #45
0
import numpy as np
import pandas as pd
from bokeh import mpl

ts = pd.Series(np.random.randn(1000),
               index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()
p = ts.plot()

mpl.to_bokeh(name="series")
Beispiel #46
0
from ggplot import *
from bokeh import mpl
from bokeh.plotting import show
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "x": range(100),
    "y": np.random.choice([-1, 1], 100)
})

df.y = df.y.cumsum()

g = ggplot(aes(x='x', y='y'), data=df) + \
    geom_step()
g.draw()

plt.title("Step ggplot-based plot in Bokeh.")

show(mpl.to_bokeh(name="step"))
Beispiel #47
0
 def update_frame(self, key, ranges=None):
     if key in self.hmap:
         self.mplplot.update_frame(key, ranges)
         self.handles['plot'] = mpl.to_bokeh(self.mplplot.state)
rs = np.random.RandomState([12345678])
yy = np.linspace(0, 2 * np.pi, nverts)
ym = np.amax(yy)
xx = (0.2 + (ym - yy) / ym) ** 2 * np.cos(yy - 0.4) * 0.5
segs = []
for i in range(ncurves):
    xxx = xx + 0.02 * rs.randn(nverts)
    curve = list(zip(xxx, yy * 100))
    segs.append(curve)

colors = [
    (1.0, 0.0, 0.0, 1.0),
    (0.0, 0.5, 0.0, 1.0),
    (0.0, 0.0, 1.0, 1.0),
    (0.0, 0.75, 0.75, 1.0),
    (0.75, 0.75, 0, 1.0),
    (0.75, 0, 0.75, 1.0),
    (0.0, 0.0, 0.0, 1.0),
]

col = LineCollection(segs, linewidth=5, offsets=offs)

ax = plt.axes()
ax.add_collection(col, autolim=True)
col.set_color(colors)
ax.set_title("Successive data offsets")

fig = plt.gcf()

show(mpl.to_bokeh(name="lc_offsets"))
Beispiel #49
0
plt.setp(plt.gca(), xticklabels=[], yticks=(4, 8, 12), xticks=(0, 10, 20))
plt.ylabel('I', fontsize=20)

plt.subplot(222)
plt.plot(x, y2, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.setp(plt.gca(),
         xticklabels=[],
         yticks=(4, 8, 12),
         yticklabels=[],
         xticks=(0, 10, 20))
plt.ylabel('II', fontsize=20)

plt.subplot(223)
plt.plot(x, y3, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.ylabel('III', fontsize=20)
plt.setp(plt.gca(), yticks=(4, 8, 12), xticks=(0, 10, 20))

plt.subplot(224)

xfit = np.array([np.amin(x4), np.amax(x4)])
plt.plot(x4, y4, 'ks', xfit, fit(xfit), 'r-', lw=2)
plt.axis([2, 20, 2, 14])
plt.setp(plt.gca(), yticklabels=[], yticks=(4, 8, 12), xticks=(0, 10, 20))
plt.ylabel('IV', fontsize=20)

# We create the figure in matplotlib and then we "pass it" to Bokeh

show(mpl.to_bokeh(name="subplots"))
    def plot_2d_graph(self, data_frame, gp, chart_type):

        if gp is None: gp = GraphProperties()
        if gp.chart_type is None and chart_type is None: chart_type = 'line'

        if gp.resample is not None: data_frame = data_frame.asfreq(gp.resample)

        self.apply_style_sheet(gp)

        # create figure & add a subplot
        fig = plt.figure(figsize=((gp.width * gp.scale_factor) / gp.dpi,
                                  (gp.height * gp.scale_factor) / gp.dpi),
                         dpi=gp.dpi)
        ax = fig.add_subplot(111)

        if gp.x_title != '': ax.set_xlabel(gp.x_title)
        if gp.y_title != '': ax.set_ylabel(gp.y_title)

        plt.xlabel(gp.x_title)
        plt.ylabel(gp.y_title)

        fig.suptitle(gp.title, fontsize=14 * gp.scale_factor)

        # format Y axis
        y_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
        ax.yaxis.set_major_formatter(y_formatter)

        # create a second y axis if necessary
        ax2 = []

        if gp.y_axis_2_series != []:
            ax2 = ax.twinx()

            # do not use a grid with multiple y axes
            ax.yaxis.grid(False)
            ax2.yaxis.grid(False)

        # matplotlib 1.5
        try:
            cyc = matplotlib.rcParams['axes.prop_cycle']
            color_cycle = [x['color'] for x in cyc]
        except KeyError:
            # pre 1.5
            pass
            # color_cycle =  matplotlib.rcParams['axes.color_cycle']

        bar_ind = np.arange(0, len(data_frame.index))

        # for bar charts, create a proxy x-axis (then relabel)
        xd, bar_ind, has_bar, no_of_bars = self.get_bar_indices(
            data_frame, gp, chart_type, bar_ind)

        # plot the lines (using custom palettes as appropriate)
        try:
            # get all the correct colors (and construct gradients if necessary eg. from 'blues')
            color_spec = self.create_color_list(gp, data_frame)

            # for stacked bar
            yoff_pos = np.zeros(len(data_frame.index.values)
                                )  # the bottom values for stacked bar chart
            yoff_neg = np.zeros(len(data_frame.index.values)
                                )  # the bottom values for stacked bar chart

            zeros = np.zeros(len(data_frame.index.values))

            # for bar chart
            bar_space = 0.2
            bar_width = (1 - bar_space) / (no_of_bars)
            bar_index = 0

            has_matrix = False

            # some lines we should exclude from the color and use the default palette
            for i in range(0, len(data_frame.columns.values)):

                if gp.chart_type is not None:
                    if isinstance(gp.chart_type, list):
                        chart_type = gp.chart_type[i]
                    else:
                        chart_type = gp.chart_type

                if chart_type == 'heatmap':
                    # TODO experimental!
                    # ax.set_frame_on(False)
                    ax.pcolor(data_frame, cmap=plt.cm.Blues, alpha=0.8)
                    # plt.colorbar()
                    has_matrix = True
                    break

                label = str(data_frame.columns[i])

                ax_temp = self.get_axis(ax, ax2, label, gp.y_axis_2_series)

                yd = data_frame.ix[:, i]

                if color_spec[i] is None:
                    color_spec[i] = color_cycle[i % len(color_cycle)]

                if (chart_type == 'line'):
                    linewidth_t = self.get_linewidth(label, gp.linewidth,
                                                     gp.linewidth_2,
                                                     gp.linewidth_2_series)

                    if linewidth_t is None:
                        linewidth_t = matplotlib.rcParams['axes.linewidth']

                    ax_temp.plot(xd,
                                 yd,
                                 label=label,
                                 color=color_spec[i],
                                 linewidth=linewidth_t)

                elif (chart_type == 'bar'):
                    # for multiple bars we need to allocate space properly
                    bar_pos = [
                        k - (1 - bar_space) / 2. + bar_index * bar_width
                        for k in range(0, len(bar_ind))
                    ]

                    ax_temp.bar(bar_pos,
                                yd,
                                bar_width,
                                label=label,
                                color=color_spec[i])

                    bar_index = bar_index + 1

                elif (chart_type == 'stacked'):
                    bar_pos = [
                        k - (1 - bar_space) / 2. + bar_index * bar_width
                        for k in range(0, len(bar_ind))
                    ]

                    yoff = np.where(yd > 0, yoff_pos, yoff_neg)

                    ax_temp.bar(bar_pos,
                                yd,
                                label=label,
                                color=color_spec[i],
                                bottom=yoff)

                    yoff_pos = yoff_pos + np.maximum(yd, zeros)
                    yoff_neg = yoff_neg + np.minimum(yd, zeros)

                    # bar_index = bar_index + 1

                elif (chart_type == 'scatter'):
                    ax_temp.scatter(xd, yd, label=label, color=color_spec[i])

                    if gp.line_of_best_fit is True:
                        self.trendline(ax_temp,
                                       xd.values,
                                       yd.values,
                                       order=1,
                                       color=color_spec[i],
                                       alpha=1,
                                       scale_factor=gp.scale_factor)

            # format X axis
            self.format_x_axis(ax, data_frame, gp, has_bar, bar_ind,
                               has_matrix)

        except:
            pass

        if gp.display_source_label == True:
            ax.annotate('Source: ' + gp.source,
                        xy=(1, 0),
                        xycoords='axes fraction',
                        fontsize=7 * gp.scale_factor,
                        xytext=(-5 * gp.scale_factor, 10 * gp.scale_factor),
                        textcoords='offset points',
                        ha='right',
                        va='top',
                        color=gp.source_color)

        if gp.display_brand_label == True:
            self.create_brand_label(ax,
                                    anno=gp.brand_label,
                                    scale_factor=gp.scale_factor)

        leg = []
        leg2 = []

        loc = 'best'

        # if we have two y-axis then make sure legends are in opposite corners
        if ax2 != []: loc = 2

        try:
            leg = ax.legend(loc=loc, prop={'size': 10 * gp.scale_factor})
            leg.get_frame().set_linewidth(0.0)
            leg.get_frame().set_alpha(0)

            if ax2 != []:
                leg2 = ax2.legend(loc=1, prop={'size': 10 * gp.scale_factor})
                leg2.get_frame().set_linewidth(0.0)
                leg2.get_frame().set_alpha(0)
        except:
            pass

        try:
            if gp.display_legend is False:
                if leg != []: leg.remove()
                if leg2 != []: leg.remove()
        except:
            pass

        try:
            plt.savefig(gp.file_output, transparent=False)
        except:
            pass

        ####### various matplotlib converters are unstable
        # convert to D3 format with mpld3
        try:
            # output matplotlib charts externally to D3 based libraries
            import mpld3

            if gp.display_mpld3 == True:
                mpld3.save_d3_html(fig, gp.html_file_output)
                mpld3.show(fig)
        except:
            pass

        # FRAGILE! convert to Bokeh format
        # better to use direct Bokeh renderer
        try:
            if (gp.convert_matplotlib_to_bokeh == True):
                from bokeh.plotting import output_file, show
                from bokeh import mpl

                output_file(gp.html_file_output)
                show(mpl.to_bokeh())
        except:
            pass

        # FRAGILE! convert matplotlib chart to Plotly format
        # recommend using AdapterCufflinks instead to directly plot to Plotly
        try:
            import plotly.plotly as py
            import plotly
            import plotly.tools as tls

            if gp.convert_matplotlib_to_plotly == True:
                plotly.tools.set_credentials_file(username=gp.plotly_username,
                                                  api_key=gp.plotly_api_key)

                py_fig = tls.mpl_to_plotly(fig, strip_style=True)
                plot_url = py.plot_mpl(py_fig, filename=gp.plotly_url)
        except:
            pass

        # display in matplotlib window
        try:
            if Constants.plotfactory_silent_display == True:
                pass
            elif gp.silent_display == False:
                plt.show()

        except:
            pass
Beispiel #51
0
def load_spectra():
	#'/Users/guillaumeshippee/Desktop/splat-master/reference/Spectra/10001_10443.fits' #change
	if request.method == 'GET':
		return render_template('input.html', error='')
	else:
#		for k in list(request.form.keys()):
#			print(k,request.form[k])

# search by file "upload"	
		if request.form['submit'] == 'Load File':
			try:
				path = request.form['path']
				sp = splat.Spectrum(file=str(path))
				sp = [sp]
			except:
				return render_template('input.html',  error = "\n\nProblem with file upload button")
		
# search by file path specification	
		if request.form['submit'] == 'Load File ':
			try:
				path = request.form['path']
				sp = splat.Spectrum(file=str(path))
				sp = [sp]
			except:
				return render_template('input.html',  error = "\n\nProblem with file path specification")
		
# search by spectrum key	
		if request.form['submit'] == 'Load by ID':
			try:
				sp = splat.Spectrum(int(str(request.form['key'])))
				sp = [sp]
			except:
				return render_template('input.html',  error = "\n\nProblem with key specification")
		
# search by date observed	
		if request.form['submit'] == 'Load by Date':
			try:
				sp = splat.getSpectrum(date = str(request.form['date']))
			except:
				return render_template('input.html',  error = "\n\nProblem with key specification")
		
# search by shortname	
		elif request.form['submit'] == 'Load by Shortname':
			try:
				sp = splat.getSpectrum(shortname = str(request.form['shortname']))
			except:
				return render_template('input.html',  error = "\n\nProblem with specifying file by shortname")
	
# search by name	
		elif request.form['submit'] == 'Load by Name':
			try:
				sp = splat.getSpectrum(name = str(request.form['name']))
			except:
				return render_template('input.html',  error = "\n\nProblem with specifying file by name")
	
			
# search by options
		elif request.form['submit'] == 'Load by Options':
			sp1 = request.form['sp1']
			sp2 = request.form['sp2']
			mag1 = request.form['mag1']
			mag2 =  request.form['mag2']


			if sp2 == '':
				sp = sp1
			elif sp1 == '':
				sp2 = sp1
			elif sp1 == '' and sp2 == '':
				sp = ''
			else:
				sp = [sp1, sp2]

			if mag2 == '':
				mag = mag1
			elif sp1 == '':
				mag2 = mag1
			elif sp1 == '' and sp2 == '':
				mag = ''
			else:
				mag = [mag1, mag2]

			kwargs = {'spt': sp, 'jmag' : mag, 'snr' : request.form['snr'], 'date' : request.form['date'] }
			kwargs = {k: v for k, v in kwargs.items() if v}

			try:
				sp = splat.getSpectrum(**kwargs)
			except:
				return render_template('input.html', error = "\n\nProblem with option search")
			
# lucky pull	
		elif request.form['submit'] == 'Get Lucky!':
			sp = splat.getSpectrum(lucky=True)

		if len(sp) == 0:
			return render_template('input.html', error = "\n\nNo spectra matched search constratins")

		try:
			tab = []

			for s in sp:
				spectral_type = splat.classifyByStandard(s)[0]
				mpl_fig = splat.plotSpectrum(s, web=True, uncertainty = True, mdwarf=True)[0]
				bokehfig = mpl.to_bokeh(fig=mpl_fig)
				bokehfig.set(x_range=Range1d(.8,2.4),y_range=Range1d(0,s.fluxMax().value*1.2))
#				sys.stdout = open("out1.txt", "w") 
#				sys.stdout = sys.__stdout__
#				with open("out1.txt", "r") as f:
#					content = f.read() 
				content = s.info(printout=False)
#				print(content)
				p = Paragraph(text=content)
				widget = VBox(bokehfig, p)
				tab.append(Panel(child=widget, title=str(s.name)))
#				tab.append(Panel(child=widget, title=str(spectral_type)+ " Star"))
				
			plottabs = Tabs(tabs= tab)
			script, div_dict = components({"plot" : plottabs})
		except:
				return render_template('input.html', error = "\n\nProblem Plotting Spectra")
		
		return render_template('out.html', star_type = spectral_type, script=script,  div=div_dict)	
Beispiel #52
0
def make_violin_plot(x,
                     y,
                     hue,
                     data,
                     plot_type="factor",
                     palette="GnBu",
                     width=750,
                     height=500):
    data = data[[x, y, hue]]
    sns_palette = sns.color_palette(palette, 2)
    sns.set_style("whitegrid")
    if plot_type == "factor":
        violin_plot_sns = sns.factorplot(x=x,
                                         y=y,
                                         hue=hue,
                                         data=data,
                                         kind="violin",
                                         palette=sns_palette)
    else:
        violin_plot_sns = sns.violinplot(x=x,
                                         y=y,
                                         hue=hue,
                                         data=data,
                                         palette=sns_palette,
                                         split=True,
                                         scale="area",
                                         inner="box",
                                         orient="v",
                                         bw=.15,
                                         responsive=True)
    violin_plot = mpl.to_bokeh()
    violin_plot.toolbar_location = "above"
    violin_plot.toolbar_sticky = False
    violin_plot.grid.grid_line_color = "SlateGray"
    violin_plot.grid.grid_line_alpha = .5
    violin_plot.grid.minor_grid_line_color = "SlateGray"
    violin_plot.grid.minor_grid_line_alpha = .2
    violin_plot.plot_height = height
    violin_plot.plot_width = width
    if "amount" in y:
        violin_plot.title.text = "Fare Violin Plot"
        violin_plot.yaxis[0].formatter = NumeralTickFormatter(format="$ 0.00")
    if "distance" in y:
        violin_plot.title.text = "Distance Violin Plot"
        violin_plot.yaxis[0].formatter = PrintfTickFormatter(
            format="%5.2f miles")

    def day_ticker():
        days = [
            "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
            "Sunday"
        ]
        if abs(int(round(tick)) - tick) < .05:
            return days[int(round(tick))]
        else:
            return ""

    def month_ticker():
        months = [
            "January", "February", "March", "April", "May", "June", "July"
        ]
        if abs(int(round(tick)) - tick) < .05:
            return months[int(round(tick))]
        else:
            return ""

    if "day" in x:
        violin_plot.xaxis[0].formatter = FuncTickFormatter.from_py_func(
            day_ticker)
    if "month" in x:
        violin_plot.xaxis[0].formatter = FuncTickFormatter.from_py_func(
            month_ticker)
    return violin_plot
Beispiel #53
0
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.collections import LineCollection
from bokeh import mpl
from bokeh.plotting import show

# In order to efficiently plot many lines in a single set of axes,
# add the lines all at once. Here is a simple example showing how it is done.

N = 50
x = np.arange(N)
# Here are many sets of y to plot vs x
ys = [x + i for i in x]

colors = ['#ff0000', '#008000', '#0000ff', '#00bfbf', '#bfbf00', '#bf00bf', '#000000']

line_segments = LineCollection([list(zip(x, y)) for y in ys], color=colors,
                                linewidth=(0.5, 1, 1.5, 2), linestyle='dashed')

ax = plt.axes()

ax.add_collection(line_segments)
ax.set_title('Line Collection with dashed colors')

show(mpl.to_bokeh(name="lc_dashed"))
Beispiel #54
0
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from bokeh import mpl
from bokeh.plotting import show

# We generated random data
data = 1 + np.random.randn(20, 6)

# And then just call the violinplot from Seaborn
sns.violinplot(data, color="Set3")

plt.title("Seaborn violin plot in bokeh.")

show(mpl.to_bokeh(name="violin"))
Beispiel #55
0
from ggplot import *
from bokeh import mpl
import matplotlib.pyplot as plt

g = ggplot(diamonds, aes(x='price', color='cut')) + \
    geom_density()

g.draw()

plt.title("Density ggplot-based plot in Bokeh.")

mpl.to_bokeh(name="density")
Beispiel #56
0
from ggplot import *
from bokeh import mpl
import matplotlib.pyplot as plt

g = ggplot(diamonds, aes(x='price', color='cut')) + \
    geom_density()

g.draw()

plt.title("xkcd-ggplot-mpl based plot in Bokeh.")

mpl.to_bokeh(name="xkcd_density", xkcd=True)
    def plot_2d_graph(self, data_frame, gp, chart_type):
        if gp.resample is not None: data_frame = data_frame.asfreq(gp.resample)

        # set the matplotlib style sheet & defaults
        matplotlib.rcdefaults()

        # first search PyThalesians styles, then try matplotlib
        try:
            plt.style.use(Constants().plotfactory_pythalesians_style_sheet[gp.style_sheet])
        except:
            plt.style.use(gp.style_sheet)

        matplotlib.rcParams.update({'font.size': matplotlib.rcParams['font.size'] * gp.scale_factor})

        # create figure & add a subplot
        fig = plt.figure(figsize = ((gp.width * gp.scale_factor)/gp.dpi,
                                    (gp.height * gp.scale_factor)/gp.dpi), dpi = gp.dpi)
        ax = fig.add_subplot(111)

        # format Y axis
        y_formatter = matplotlib.ticker.ScalarFormatter(useOffset = False)
        ax.yaxis.set_major_formatter(y_formatter)

        if gp.x_title != '': ax.set_xlabel(gp.x_title)
        if gp.y_title != '': ax.set_ylabel(gp.y_title)

        # create a second y axis if necessary
        ax2 = []

        if gp.y_axis_2_series != []:
            ax2 = ax.twinx()

            # do not use a grid with multiple y axes
            ax.yaxis.grid(False)
            ax2.yaxis.grid(False)

        color_cycle = matplotlib.rcParams['axes.color_cycle']

        bar_ind = np.arange(0, len(data_frame.index))

        xd, bar_ind, has_bar, no_of_bars = self.get_bar_indices(data_frame, gp, chart_type, bar_ind)

        # plot the lines (using custom palettes as appropriate)
        try:
            # get all the correct colors (and construct gradients if necessary eg. from 'blues')
            color_spec = self.create_color_list(gp, data_frame)

            # for stacked bar
            yoff = np.zeros(len(data_frame.index.values)) # the bottom values for stacked bar chart

            # for bar chart
            # bar_ind = np.arange(len(data_frame.index))
            # has_bar = False

            bar_space = 0.2
            bar_width = (1 - bar_space) / (no_of_bars)
            bar_index = 0

            # some lines we should exclude from the color and use the default palette
            for i in range(0, len(data_frame.columns.values)):

                if chart_type is not None:
                    if gp.chart_type is not None:
                        if isinstance(gp.chart_type, list):
                            chart_type = gp.chart_type[i]
                        else:
                            chart_type = gp.chart_type

                label = str(data_frame.columns[i])

                ax_temp = self.get_axis(ax, ax2, label, gp.y_axis_2_series)

                yd = data_frame.ix[:,i]

                if (chart_type == 'line'):
                    linewidth_t = self.get_linewidth(label,
                                                     gp.linewidth, gp.linewidth_2, gp.linewidth_2_series)

                    if linewidth_t is None: linewidth_t = matplotlib.rcParams['axes.linewidth']

                    ax_temp.plot(xd, yd, label = label, color = color_spec[i],
                                     linewidth = linewidth_t)

                elif(chart_type == 'bar'):
                    bar_pos = [k - (1 - bar_space) / 2. + bar_index * bar_width for k in range(0,len(bar_ind))]

                    if color_spec[i] is not None:
                        ax_temp.bar(bar_pos, yd, bar_width, label = label,
                                        color = color_spec[i])
                    else:
                        ax_temp.bar(bar_pos, yd, bar_width, label = label,
                                        color = color_cycle[i % len(color_cycle)])

                    bar_index = bar_index + 1
                    # bar_ind = bar_ind + bar_width

                    has_bar = True

                elif(chart_type == 'stacked'):
                    ax_temp.bar(xd, yd, label = label, color = color_spec[i], bottom = yoff)
                    yoff = yoff + yd

                    has_bar = True

                elif(chart_type == 'scatter'):
                    ax_temp.scatter(xd, yd, label = label, color = color_spec[i])

                    if gp.line_of_best_fit is True:
                        self.trendline(ax_temp, xd.values, yd.values, order=1, color= color_spec[i], alpha=1,
                                           scale_factor = gp.scale_factor)

            # format X axis
            self.format_x_axis(ax, data_frame, gp, has_bar, bar_ind)

        except: pass

        plt.xlabel(gp.x_title)
        plt.ylabel(gp.y_title)

        fig.suptitle(gp.title, fontsize = 14 * gp.scale_factor)

        if gp.display_source_label == True:
            ax.annotate('Source: ' + gp.source, xy = (1, 0), xycoords='axes fraction', fontsize=7 * gp.scale_factor,
                        xytext=(-5 * gp.scale_factor, 10 * gp.scale_factor), textcoords='offset points',
                        ha='right', va='top', color = gp.source_color)

        if gp.display_brand_label == True:
            self.create_brand_label(ax, anno = gp.brand_label, scale_factor = gp.scale_factor)

        leg = []
        leg2 = []

        loc = 'best'

        # if we have two y-axis then make sure legends are in opposite corners
        if ax2 != []: loc = 2

        try:
            leg = ax.legend(loc = loc, prop={'size':10 * gp.scale_factor})
            leg.get_frame().set_linewidth(0.0)
            leg.get_frame().set_alpha(0)

            if ax2 != []:
                leg2 = ax2.legend(loc = 1, prop={'size':10 * gp.scale_factor})
                leg2.get_frame().set_linewidth(0.0)
                leg2.get_frame().set_alpha(0)
        except: pass

        try:
            if gp.display_legend is False:
                if leg != []: leg.remove()
                if leg2 != []: leg.remove()
        except: pass

        try:
            plt.savefig(gp.file_output, transparent=False)
        except: pass


        ####### various matplotlib converters are unstable
        # convert to D3 format with mpld3
        try:
            if gp.display_mpld3 == True:
                mpld3.save_d3_html(fig, gp.html_file_output)
                mpld3.show(fig)
        except: pass

        # FRAGILE! convert to Bokeh format
        # better to use direct Bokeh renderer
        try:
            if (gp.convert_matplotlib_to_bokeh == True):
                from bokeh.plotting import output_file, show
                from bokeh import mpl

                output_file(gp.html_file_output)
                show(mpl.to_bokeh())
        except: pass

        # FRAGILE! convert matplotlib chart to Plotly format
        # recommend using AdapterCufflinks instead to directly plot to Plotly
        try:
            if gp.convert_matplotlib_to_plotly == True:
                plotly.tools.set_credentials_file(username = gp.plotly_username,
                                                  api_key = gp.plotly_api_key)

                py_fig = tls.mpl_to_plotly(fig, strip_style = True)
                plot_url = py.plot_mpl(py_fig, filename = gp.plotly_url)
        except:
            pass

        # display in Matplotlib
        try:
            if gp.silent_display == False: plt.show()
        except:
            pass