Esempio n. 1
0
 def term_sheet_to_db(self,
                      window=30,
                      windows=[30, 60, 90, 120],
                      quantiles=[0.25, 0.75],
                      bins=100,
                      normed=True,
                      bench='SPY',
                      open=False):
     ext = '.json'
     cones_fig, cones_plt = self.cones(windows=windows, quantiles=quantiles)
     rolling_quantiles_fig, rolling_quantiles_plt = self.rolling_quantiles(
         window=window, quantiles=quantiles)
     rolling_extremes_fig, rolling_extremes_plt = self.rolling_extremes(
         window=window)
     rolling_descriptives_fig, rolling_descriptives_plt = self.rolling_descriptives(
         window=window)
     histogram_fig, histogram_plt = self.histogram(window=window,
                                                   bins=bins,
                                                   normed=normed)
     cones_fig_dict = mpld3.fig_to_dict(cones_fig)
     rolling_quantiles_fig_dict = mpld3.fig_to_dict(rolling_quantiles_fig)
     rolling_extremes_fig_dict = mpld3.fig_to_dict(rolling_extremes_fig)
     rolling_descriptives_fig_dict = mpld3.fig_to_dict(
         rolling_descriptives_fig)
     histogram_fig_dict = mpld3.fig_to_dict(histogram_fig)
     pyplt.close(cones_fig)
     pyplt.close(rolling_quantiles_fig)
     pyplt.close(rolling_extremes_fig)
     pyplt.close(rolling_descriptives_fig)
     pyplt.close(histogram_fig)
Esempio n. 2
0
def show_total(values, options, toSend={}, show=True):
    values = np.real(values)
    total_trans = (values[:, 0].sum(axis=1) + values[:, 1].sum(axis=1)) / 2
    total_ref = (values[:, 2].sum(axis=1) + values[:, 3].sum(axis=1)) / 2

    points = np.linspace(options['divisions_start'], options['divisions_end'], options['divisions'])

    fig3 = plt.figure(3, figsize=(6.75, 5.55))
    plt.title("Total transmission and reflection")
    plt.plot(points, total_trans, 'r-', label='Total transmission')
    plt.plot(points, total_ref, 'b-', label='Total reflection ')
    plt.xlabel(options['dependence']['label'])
    max = np.array([total_trans, total_ref]).max()
    plt.axis([options['divisions_start'], options['divisions_end'], 0, 1.4 * max])
    plt.legend(loc='upper right')
    plt.grid(True)
    plt.tight_layout()
    if show:
        plt.show()

    fig4 = plt.figure(4, figsize=(6.75, 5.55))
    plt.title("Total transmission and reflection and absorbance")
    plt.plot(points, total_ref + total_trans, 'g-', label='Total transmission + reflection')
    plt.plot(points, 1 - total_ref - total_trans, 'y-', label='Absorbance')
    plt.xlabel(options['dependence']['label'])
    plt.axis([options['divisions_start'], options['divisions_end'], 0, 1.4])
    plt.legend(loc='upper right')
    plt.grid(True)
    plt.tight_layout()
    if show:
        plt.show()

    toSend.graphs['total_trans_ref'] = mpld3.fig_to_dict(fig3)
    toSend.graphs['total_abs'] = mpld3.fig_to_dict(fig4)
Esempio n. 3
0
    def plot_data_join_metrics(self, num_buckets=30):
        res = es.query_data_join_metrics(self._job.name, num_buckets)
        if not res['aggregations']['OVERALL']['buckets']:
            raise NotFoundException()

        metrics = []

        # plot pie chart for overall join rate

        overall = res['aggregations']['OVERALL']['buckets'][0]
        labels = ['joined', 'fake', 'unjoined']
        sizes = [
            overall['JOINED']['doc_count'], overall['FAKE']['doc_count'],
            overall['UNJOINED']['value']
        ]
        fig = Figure()
        ax = fig.add_subplot(111)
        ax.pie(sizes, labels=labels, autopct='%1.1f%%')
        metrics.append(mpld3.fig_to_dict(fig))

        # plot stackplot for event time
        by_et = res['aggregations']['EVENT_TIME']['buckets']
        et_index = [self._to_datetime(buck['key']) for buck in by_et]
        et_joined = [buck['JOINED']['doc_count'] for buck in by_et]
        et_faked = [buck['FAKE']['doc_count'] for buck in by_et]
        et_unjoined = [buck['UNJOINED']['value'] for buck in by_et]
        fig = Figure()
        ax = fig.add_subplot(111)
        ax.stackplot(et_index, et_joined, et_faked, et_unjoined, labels=labels)

        twin_ax = ax.twinx()
        twin_ax.patch.set_alpha(0.0)
        et_rate = [buck['JOIN_RATE']['value'] for buck in by_et]
        twin_ax.plot(et_index, et_rate, label='join rate', color='black')

        ax.xaxis_date()
        ax.legend()
        metrics.append(mpld3.fig_to_dict(fig))

        # plot processing time vs event time
        by_pt = res['aggregations']['PROCESS_TIME']['buckets']
        pt_index = [self._to_datetime(buck['key']) for buck in by_pt]
        pt_min = [
            self._to_datetime(buck['MIN_EVENT_TIME']['value']) \
                for buck in by_pt]
        pt_max = [
            self._to_datetime(buck['MAX_EVENT_TIME']['value']) \
                for buck in by_pt]
        fig = Figure()
        ax = fig.add_subplot(111)
        ax.plot(pt_index, pt_min, label='min event time')
        ax.plot(pt_index, pt_max, label='max event time')

        ax.xaxis_date()
        ax.yaxis_date()
        ax.legend()
        metrics.append(mpld3.fig_to_dict(fig))

        return metrics
Esempio n. 4
0
def show_comprehensive(values, options, toSend={}, show=True):
    values = np.real(values)
    points = np.linspace(options['divisions_start'], options['divisions_end'], options['divisions'])

    fig1 = plt.figure(10, figsize=(6.75, 5.55))
    plt.title("Zero orders - Reflection")
    plt.plot(points, values[:, 0, 0], 'r-', label='Rs')
    plt.plot(points, values[:, 1, 0], 'b-', label='Rp')
    plt.xlabel(options['dependence']['label'])
    max = np.array([values[:, 0, 0], values[:, 1, 0]]).max()
    plt.axis([options['divisions_start'], options['divisions_end'], 0, 1.4 * max])
    plt.legend(loc='upper right')
    plt.grid(True)
    plt.tight_layout()
    if show:
        plt.show()

    fig2 = plt.figure(11, figsize=(6.75, 5.55))
    plt.title("Negative orders - Reflection")
    plt.plot(points, values[:, 0, 2], 'r-', label='Rs -1')
    plt.plot(points, values[:, 0, 4], 'r--', label='Rs -2')
    plt.plot(points, values[:, 0, 6], 'r-.', label='Rs -3')
    plt.plot(points, values[:, 1, 2], 'b-', label='Rp -1')
    plt.plot(points, values[:, 1, 4], 'b--', label='Rp -2')
    plt.plot(points, values[:, 1, 6], 'b-.', label='Rp -3')
    plt.xlabel(options['dependence']['label'])
    max = np.array(
        [values[:, 0, 2], values[:, 0, 4], values[:, 0, 6], values[:, 1, 2], values[:, 1, 4], values[:, 1, 6]]).max()
    plt.axis([options['divisions_start'], options['divisions_end'], 0, 1.4 * max])
    plt.legend(loc='upper right')
    plt.grid(True)
    plt.tight_layout()
    if show:
        plt.show()

    fig3 = plt.figure(12, figsize=(6.75, 5.55))
    plt.title("Positive orders - Reflection")
    plt.plot(points, values[:, 0, 1], 'r-', label='Rs 1')
    plt.plot(points, values[:, 0, 3], 'r--', label='Rs 2')
    plt.plot(points, values[:, 0, 5], 'r-.', label='Rs 3')
    plt.plot(points, values[:, 1, 1], 'b-', label='Rp 1')
    plt.plot(points, values[:, 1, 3], 'b--', label='Rp 2')
    plt.plot(points, values[:, 1, 5], 'b-.', label='Rp 3')
    plt.xlabel(options['dependence']['label'])
    max = np.array(
        [values[:, 0, 1], values[:, 0, 3], values[:, 0, 5], values[:, 1, 1], values[:, 1, 3], values[:, 1, 5]]).max()
    plt.axis([options['divisions_start'], options['divisions_end'], 0, 1.4 * max])
    plt.legend(loc='upper right')
    plt.grid(True)
    plt.tight_layout()
    if show:
        plt.show()

    toSend.graphs['comp_zero'] = mpld3.fig_to_dict(fig1)
    toSend.graphs['comp_neg'] = mpld3.fig_to_dict(fig2)
    toSend.graphs['comp_pos'] = mpld3.fig_to_dict(fig3)
Esempio n. 5
0
def plot_test():
    db=get_db()
    username=session['username']
    print username
    data_raw=get_db_user_data_dic(username,db)
    data=data_pack_hist(data_raw)
    fig=plt.figure()
    plt.hist(data)
    json01 = json.dumps(mpld3.fig_to_dict(fig))
    json02 = json.dumps(mpld3.fig_to_dict(fig))
    json03 = json.dumps(mpld3.fig_to_dict(fig))
    return render_template('page_mld3.html',json1=json01,json2=json02,json3=json03)
Esempio n. 6
0
    def plot_data_join_metrics(self, num_buckets=30):
        res = es.query_data_join_metrics(self._job.name, num_buckets)
        time_res = es.query_time_metrics(self._job.name,
                                         num_buckets,
                                         index='data_join*')
        metrics = []
        if not res['aggregations']['OVERALL']['buckets']:
            return metrics

        # plot pie chart for overall join rate
        overall = res['aggregations']['OVERALL']['buckets'][0]
        labels = ['joined', 'fake', 'unjoined']
        sizes = [
            overall['JOINED']['doc_count'], overall['FAKE']['doc_count'],
            overall['UNJOINED']['doc_count']
        ]
        fig = Figure()
        ax = fig.add_subplot(111)
        ax.pie(sizes, labels=labels, autopct='%1.1f%%')
        metrics.append(mpld3.fig_to_dict(fig))

        # plot stackplot for event time
        by_et = res['aggregations']['EVENT_TIME']['buckets']
        et_index = [self._to_datetime(buck['key']) for buck in by_et]
        et_joined = [buck['JOINED']['doc_count'] for buck in by_et]
        et_faked = [buck['FAKE']['doc_count'] for buck in by_et]
        et_unjoined = [buck['UNJOINED']['doc_count'] for buck in by_et]
        fig = Figure()
        ax = fig.add_subplot(111)
        ax.stackplot(et_index, et_joined, et_faked, et_unjoined, labels=labels)

        twin_ax = ax.twinx()
        twin_ax.patch.set_alpha(0.0)
        et_rate = [buck['JOIN_RATE']['value'] for buck in by_et]
        et_rate_fake = [buck['JOIN_RATE_WITH_FAKE']['value'] for buck in by_et]
        twin_ax.plot(et_index, et_rate, label='join rate', color='black')
        twin_ax.plot(et_index,
                     et_rate_fake,
                     label='join rate w/ fake',
                     color='#8f8f8f')  # grey color

        ax.xaxis_date()
        ax.legend()
        metrics.append(mpld3.fig_to_dict(fig))

        # plot processing time vs event time
        fig_dict = self._plot_pt_vs_et(time_res)
        metrics.append(fig_dict)

        return metrics
Esempio n. 7
0
 def plot_dashboard(self, opt_dash_df, delta_sat, plot_type='show'):
     """
     Args:
         opt_dash_df (dataframe): this is the optimization dash df
         delta_sat (float): this is the change in SAT
         plot_type (str): this is the nature of the plot which is going to
         have the following possible outputs:
              - 'show': will show the plot
              - 'html': will return html as a string
              - 'json': will return the plot as json
              - 'mpld3': will show the plot in the browser
     Returns:
         plot_output (any of {str, dict}): returns an html string, None,
         or a, plot dict, depending on the requested output
     """
     fig = plt.figure()
     ax = fig.add_subplot(111)
     title = 'Quarterly Cost Avoidance '
     title += 'when Delta SAT = {} degC'.format(delta_sat)
     plt.title(title)
     opt_dash_df['cap'].plot.barh(ax=ax)
     plt.ylabel('CRAH Unit')
     plt.xlabel('Amount in CAD')
     if plot_type == 'show':
         plt.show()
     elif plot_type == 'html':
         plot_output = mpld3.fig_to_html(fig)
         return plot_output
     elif plot_type == 'json':
         plot_output = mpld3.fig_to_dict(fig)
         return plot_output
     elif plot_type == 'mpld3':
         mpld3.show()
Esempio n. 8
0
def ReuseRecycledrawfigs(data):
        fig, ax = plt.subplots()
        with open('neighhydro.csv', 'wb') as f:  
            w = csv.DictWriter(f, data.keys())
            w.writeheader()
            w.writerow(data)
        print data
	model = pysd.read_vensim ('IWRET_13.mdl')
        for k,v in data.items():
            if v == 'on' or k=='undefined' or k=='formId':
               del data[k]
        modeldata=model.run(params=data, return_columns=['RH Total Water Harvested'])
        glist = ['RH Total Water Harvested','IA Runoff Daily','IA Runoff Total',
             'GWS Tank Inflow','Water Reuse Daily','Result RR LCC',
             'Result RR GHG Emissions','Result RR Energy']
        dict_of_plots=list()
        x1 = range(7301)
	y1 = modeldata['LU Sum']
        indata=pd.DataFrame(x1,y1)
        indata.plot(ax=ax)
        single_chart=dict()
        single_chart['id']="NeighHyd1"
        single_chart['json']=json.dumps(mpld3.fig_to_dict(fig))
        dict_of_plots.append(single_chart)    
        return render_template("results.html", dict_of_plots=dict_of_plots)#snippet=plot_snippet)
Esempio n. 9
0
def delete(id):
    point_to_delete = Data.query.get_or_404(id)

    try:
        db.session.delete(point_to_delete)
        db.session.commit()
        #return redirect('/')
    except:
        return 'There was a problem deleting that point'
    global reg
    points = Data.query.order_by(Data.date_created).all()
    try:
        g, f, r = prepare_graph(reg)
        json1 = json.dumps(mpld3.fig_to_dict(g))
    except:
        return render_template('index.html',
                               points=points,
                               json1=None,
                               regstatus=reg)
    print(f)
    print(r)
    return render_template('index.html',
                           points=points,
                           json1=json1,
                           regstatus=reg,
                           function=f,
                           r2=r)
Esempio n. 10
0
def mpld3ify(fig, sanitize=True, jsonify=True):
    ''' Do all the processing steps that might be necessary to render a figure displayable '''

    import mpld3  # Do this here since currently a bug that sets the wrong backend

    # Nothing to do if already a string
    if sc.isstring(fig):
        return fig

    # If it's empty or null, make a small figure
    if not fig:
        fig = pl.figure(figsize=(1, 1))  # Make a dummy plot since no legend
        fig.add_subplot(111)  # So axis commands work
        fig.get_axes()[0].set_visible(False)  # Turn off axes

    # Convert to mpld3 -- this is the big step
    if isinstance(fig, pl.Figure):
        fig = mpld3.fig_to_dict(fig)

    # Optionally do additional sanitization
    if sanitize: fig = sc.sanitizejson(fig)
    if jsonify and not sc.isstring(fig):
        fig = json.dumps(fig)  # Could cause problems to jsonify a string

    return fig
Esempio n. 11
0
def main():
    #get our data as an array from read_in()
    coords = read_in()

    x = list()
    y = list()
    z = list()

    i = 0
    while i < len(coords):
        x.append(coords[i]['coords']['x'])
        y.append(coords[i]['coords']['y'])
        z.append(coords[i]['coords']['z'])
        i += 1

    mynegy = [-coord for coord in y]

    im = plt.imread("./public/assets/miramar.png")
    fig, ax = plt.subplots()
    ax.imshow(im, extent=[0, 820000, -820000, 0], alpha=1, zorder=1)
    # ax.scatter(x, mynegy, c=z, alpha=1, zorder=2)
    ax.plot(x, mynegy, c='b', alpha=1, zorder=3)
    axes = plt.gca()
    axes.set_xlim([-200000, 1000000])
    axes.set_ylim([-1000000, 200000])
    print(json.dumps(mpld3.fig_to_dict(fig)))
Esempio n. 12
0
def makeHMIGraph(noaaNmbr):
    fig, ax = plt.subplots(figsize=(6,6))

    for i in range(len(dateAndTimeHMI)):
        xStart = lonMin[i]
        yStart = latMin[i]
        
        xLength = lonMax[i] - lonMin[i]
        yLength = latMax[i] - latMin[i]
        
        ax.add_patch(Rectangle((xStart, yStart), xLength, yLength, edgecolor = 'blue', facecolor='none'))

    ax.add_patch(Circle((0, 0), 980 , facecolor='none', edgecolor=(0, 0.8, 0.8), linewidth=3, alpha=0.5))
    ax.set_xlabel('X-Cen (HPC Arcseconds)')
    ax.set_ylabel('Y-Cen (HPC Arcseconds)')

    plt.axis('equal')

    ax.grid(True)
    plt.gca().set_aspect('equal', adjustable='box')

    ax.set_title("HMI Dataseries:", size=30)
    
    js_data = json.dumps(mpld3.fig_to_dict(fig))

    return js_data
Esempio n. 13
0
    def update_figure(self, rnd_draws):
        # regenerate matplotlib plot
        self.ax1.cla()
        self.ax1.set_xlabel('r1')
        self.ax1.set_ylabel('Normalized Distribtuion')
        self.ax1.set_xlim(0, 1)
        self.ax1.set_ylim(0, 1.5)
        self.ax1.grid(True)
        self.ax1.hist(
            [r[0] for r in rnd_draws], 50,
            normed=1, facecolor='green', alpha=0.75
        )
        self.ax2.cla()
        self.ax2.set_xlabel('r2')
        self.ax2.set_ylabel('Normalized Distribtuion')
        self.ax2.set_xlim(0, 1)
        self.ax2.set_ylim(0, 1.5)
        self.ax2.grid(True)
        self.ax2.hist(
            [r[1] for r in rnd_draws], 50,
            normed=1, facecolor='blue', alpha=0.75
        )

        # send new matplotlib plots to frontend
        self.emit('mpld3canvas', mpld3.fig_to_dict(self.fig))
Esempio n. 14
0
def comp_outcome(outcome):
    fig, ax = plt.subplots()
    fig.set_size_inches(8, 6)
    labels_new = []
    if outcome == "WON":
        points = ax.plot(winner_list, 'or', alpha=1,markersize=12, markeredgewidth=1, color = 'red')
        for i in range(len(df)):
            if df.iloc[i]["Outcome of Bid"] == "Won Tender Bid":
                label = df.iloc[[i], :].T
                label.columns = ['Project {0}'.format(i)]
                labels_new.append(str(label.to_html()))
    elif outcome == "LOST":
        points = ax.plot(losing_list, 'or', alpha=1,markersize=12, markeredgewidth=1, color = 'black')
        for i in range(len(df)):
            if df.iloc[i]["Outcome of Bid"] == "Lost Tender Bid":
                label = df.iloc[[i], :].T
                label.columns = ['Project {0}'.format(i)]
                labels_new.append(str(label.to_html()))
    elif outcome == 'ALL':

        points = ax.plot(y, 'or', alpha=0.7,markersize=12, markeredgewidth=1, color = 'orange')

        labels_new = labels


    tooltip = plugins.PointHTMLTooltip(points[0], labels_new, voffset=10, hoffset=10, css=css)
    plugins.connect(fig, tooltip)
    plugins.connect(fig, DragPlugin(points[0]))
    json01 = json.dumps(mpld3.fig_to_dict(fig))


    return(json01)
Esempio n. 15
0
def draw_spectrum(spectrum, dummy=False):

    rmf = pf.open('rmf_62bands.fits')
    src_spectrum = spectrum[8].data
    E_min = rmf[3].data['E_min']
    E_max = rmf[3].data['E_max']

    msk = src_spectrum['RATE'] > 0.

    y = src_spectrum['RATE'] / (E_max - E_min)

    x = (E_max + E_min)
    dx = np.log10(np.e) * (E_max - E_min) / x
    x = np.log10(x)

    dy = src_spectrum['STAT_ERR'] / (E_max - E_min)
    dy = np.log10(np.e) * dy / y
    y = np.log10(y)

    fig, ax = plt.subplots(figsize=(4, 2.8))

    ax.set_xlabel('log(E)  keV')
    ax.set_ylabel('log(counts/s/keV)')

    ax.errorbar(x[msk],
                y[msk],
                yerr=dy[msk] * 0.5,
                xerr=dx[msk] * 0.5,
                fmt='o')
    #print (x,y,dy)
    plugins.connect(fig, plugins.MousePosition(fontsize=14))

    return mpld3.fig_to_dict(fig)
Esempio n. 16
0
def filesize_plot(filesizes):
    # Pull all filesizes
    sizes = []
    while True:
        size = yield marv.pull(filesizes)
        if size is None:
            break
        sizes.append(size)

    # plot
    fig = plt.figure()
    axis = fig.add_subplot(1, 1, 1)
    axis.plot(sizes, 'bo')

    # EE: save figure to file
    plotfile = yield marv.make_file('filesizes.json')
    with open(plotfile.path, 'w') as f:
        json.dump(mpld3.fig_to_dict(fig), f)

    # EE: create plot widget referencing file
    widget = {
        'title': 'Filesizes',
        'mpld3': 'marv-partial:{}'.format(plotfile.relpath),
    }

    # Alternative code for community edition
    #plotfile = yield marv.make_file('filesizes.jpg')
    #fig.savefig(plotfile.path)
    #widget = {
    #    'title': 'Filesizes',
    #    'image': {'src': plotfile.relpath},
    #}

    yield marv.push(widget)
Esempio n. 17
0
def get_daily_data(company):
    '''Data retrieval from the stock market using Alpha Vantage API for intraday and daily time series'''
    plt.close()
    # ts = TimeSeries(key='EZ3UZE4SWE1JI2A9', output_format='pandas')
    # data, meta_data = ts.get_daily(symbol="NSE:"+company, outputsize="compact")
    data = quandl.get("NSE/" + company)
    data = data.dropna(axis=0, how='any')
    # print(data)
    fig_size = plt.rcParams["figure.figsize"]
    fig_size[0] = 12
    fig_size[1] = 7
    plt.rcParams["figure.figsize"] = fig_size
    # print(data.index)
    fig, ax = plt.subplots()
    ax.plot(data.index, data['Close'])
    # ax.plot(data.index, data['close'])
    # data['close'].plot()
    ax.set_title('Daily Times Series for the ' + company + ' stock')
    ax.set_xticklabels(data.index, rotation=90, ha='left', fontsize=10)
    # fig.autofmt_xdate()
    # ax.fmt_xdata = mdates.DateFormatter('%Y-%m-%d')
    # plt.savefig("/Users/rjmac/Desktop/SahanaMD_Project/FrontEnd/src/assets/"+company+"_daily.png", dpi = 1000)
    # mpld3.save_html(fig, company+'_daily_mpld3.html')
    # html_string_daily = mpld3.fig_to_html(fig)
    dictionary_rep = mpld3.fig_to_dict(fig)
    # mpld3.save_json(fig,company+'_daily_mpld3_json.json')
    # print(dictionary_rep)
    plt.close()
    # plt.show()
    '''Data retrieval complete'''
    return data, dictionary_rep
Esempio n. 18
0
def mdsGraph():
    json = request.get_json()
    # lists=[]
    # for row in json:
    #     aa=[row["Open"],row["Close"],row["Change"],row["Volume"]]
    #     #print aa
    #     lists.append(aa)
    # x =[]
    # clusters=json["clusters"]
    # tmp=[0]*clusters[0]
    # x.extend(tmp)
    # tmp=[50]*clusters[1]
    # x.extend(tmp)
    # tmp=[100]*clusters[2]
    # x.extend(tmp)
    # x=np.array(x)
    x = colorArray(json["clusters"])
    a = np.array(json["result"]).astype(np.float)

    Y = manifold.MDS(2, max_iter=100, n_init=4).fit_transform(a)
    fig = plt.figure()
    plt.scatter(Y[:, 0], Y[:, 1], c=x)

    plt.xlabel('x_values')
    plt.ylabel('y_values')
    plt.xlim([-4, 4])
    plt.ylim([-4, 4])
    plt.title('MDS Graph')

    # X_iso = manifold.Isomap(10, n_components=2).fit_transform(mlab_pca.Y)

    # #mpld3.show()
    # print mpld3.fig_to_dict(fig)
    return jsonify(result=mpld3.fig_to_dict(fig))
Esempio n. 19
0
def pcaPlot():
    print 1
    json = request.get_json()
    # lists=[]
    # for row in json:
    #     aa=[row["Open"],row["Close"],row["Change"],row["Volume"]]
    #     #print aa
    #     lists.append(aa)
    print 2
    x = colorArray(json["clusters"])

    a = np.array(json["result"]).astype(np.float)
    fig = plt.figure()

    dims = random.sample(range(0, 3), 2)

    plt.scatter(a[:, dims[0]], a[:, dims[1]], c=x)

    plt.xlabel('x_values')
    plt.ylabel('y_values')
    plt.xlim([-4, 4])
    plt.ylim([-4, 4])
    plt.title('Scree Plot of PCA')

    # X_iso = manifold.Isomap(10, n_components=2).fit_transform(mlab_pca.Y)

    # #mpld3.show()
    # print mpld3.fig_to_dict(fig)
    return jsonify(result=mpld3.fig_to_dict(fig))
Esempio n. 20
0
def pcaGraph():
    json = request.get_json()
    # lists=[]
    # for row in json:
    #     aa=[row["Open"],row["Close"],row["Change"],row["Volume"]]
    #     #print aa
    #     lists.append(aa)

    x = colorArray(json["clusters"])

    a = np.array(json["result"]).astype(np.float)
    # print a
    fig = plt.figure()
    plt.scatter(a[:, 0], a[:, 1], c=x)

    plt.xlabel('x_values')
    plt.ylabel('y_values')
    plt.xlim([-4, 4])
    plt.ylim([-4, 4])
    plt.title('PCA Graph')

    # X_iso = manifold.Isomap(10, n_components=2).fit_transform(mlab_pca.Y)

    # mpld3.show()
    # print mpld3.fig_to_dict(fig)
    return jsonify(result=mpld3.fig_to_dict(fig))
Esempio n. 21
0
    def _plot_pt_vs_et(self, res):
        # plot process time vs event time
        by_pt = res['aggregations']['PROCESS_TIME']['buckets']
        pt_index = [self._to_datetime(buck['key']) for buck in by_pt]
        pt_min = [
            self._to_datetime(buck['MIN_EVENT_TIME']['value']) \
            for buck in by_pt]
        pt_max = [
            self._to_datetime(buck['MAX_EVENT_TIME']['value']) \
            for buck in by_pt]
        fig = Figure()
        ax = fig.add_subplot(111)
        pt_index = [
            idx for idx, time in zip(pt_index, pt_min) if time is not None
        ]
        ax.plot(pt_index,
                list(filter(lambda x: x is not None, pt_min)),
                label='min event time')
        ax.plot(pt_index,
                list(filter(lambda x: x is not None, pt_max)),
                label='max event time')

        ax.xaxis_date()
        ax.yaxis_date()
        ax.legend()
        return mpld3.fig_to_dict(fig)
    def run(self):

        # Pass DataFrame itself into task?
        # Pointless to read url, write to csv, then read csv

        alertsdata = pandas.read_csv(self.input().path)

        alertsdata.columns = [x.replace('#','').strip().lower() for x in alertsdata.columns.values.tolist()]

        ra = np.array(alertsdata['radeg'])
        dec = np.array(alertsdata['decdeg'])
        mag = np.array(alertsdata['alertmag'])
        alclass = np.array(alertsdata['class'])

        cmap = mpl.cm.rainbow
        classes = list(set(alclass))
        colours = {classes[i]: cmap(i / float(len(classes))) for i in range(len(classes))}

        fig = plt.figure()
        for i in range(len(ra)):
            plt.plot(ra[i], dec[i], 'o', ms=self.magtopoint(mag[i], mag), color=colours[alclass[i]])
        plt.xlabel('Right Ascension')
        plt.ylabel('Declination')

        with open(self.output().path, 'w') as out:
            json.dump(mpld3.fig_to_dict(fig), out)
Esempio n. 23
0
 def plot_tree_metrics(self):
     metric_list = [
         'acc', 'auc', 'precision', 'recall', 'f1', 'ks', 'mse', 'msre',
         'abs'
     ]
     metrics = []
     aggregations = es.query_tree_metrics(self._job.name, metric_list)
     for name in metric_list:
         train_ = aggregations[name.upper()]['TRAIN']['TOP']['hits']['hits']
         eval_ = aggregations[name.upper()]['EVAL']['TOP']['hits']['hits']
         if len(train_) == 0 and len(eval_) == 0:
             continue
         fig = Figure()
         ax = fig.add_subplot(111)
         if len(train_) > 0:
             train_metric = [(item['_source']['tags']['iteration'],
                              item['_source']['value']) for item in train_]
             ax.plot(*zip(*train_metric), label='train', color='blue')
         if len(eval_) > 0:
             eval_metric = [(item['_source']['tags']['iteration'],
                             item['_source']['value']) for item in eval_]
             ax.plot(*zip(*eval_metric), label='eval', color='red')
         ax.legend()
         ax.set_title(name)
         ax.set_xlabel('iteration')
         ax.set_ylabel('value')
         metrics.append(mpld3.fig_to_dict(fig))
     return metrics
Esempio n. 24
0
    def _figure_data(self, plot, fmt='png', bbox_inches='tight', **kwargs):
        """
        Render matplotlib figure object and return the corresponding data.

        Similar to IPython.core.pylabtools.print_figure but without
        any IPython dependency.
        """
        fig = plot.state
        if self.mode == 'nbagg':
            manager = plot.comm.get_figure_manager()
            if manager is None: return ''
            self.counter += 1
            manager.show()
            return ''
        elif self.mode == 'mpld3':
            import mpld3
            fig.dpi = self.dpi
            mpld3.plugins.connect(fig,
                                  mpld3.plugins.MousePosition(fontsize=14))
            if fmt == 'json':
                return mpld3.fig_to_dict(fig)
            else:
                figid = "fig_el" + plot.comm.id if plot.comm else None
                html = mpld3.fig_to_html(fig, figid=figid)
                html = "<center>" + html + "<center/>"
                if plot.comm:
                    comm, msg_handler = self.comms[self.mode]
                    msg_handler = msg_handler.format(comm_id=plot.comm.id)
                    return comm.template.format(init_frame=html,
                                                msg_handler=msg_handler,
                                                comm_id=plot.comm.id)
                return html

        traverse_fn = lambda x: x.handles.get('bbox_extra_artists', None)
        extra_artists = list(
            chain(*[
                artists for artists in plot.traverse(traverse_fn)
                if artists is not None
            ]))

        kw = dict(format=fmt,
                  facecolor=fig.get_facecolor(),
                  edgecolor=fig.get_edgecolor(),
                  dpi=self.dpi,
                  bbox_inches=bbox_inches,
                  bbox_extra_artists=extra_artists)
        kw.update(kwargs)

        # Attempts to precompute the tight bounding box
        try:
            kw = self._compute_bbox(fig, kw)
        except:
            pass

        bytes_io = BytesIO()
        fig.canvas.print_figure(bytes_io, **kw)
        data = bytes_io.getvalue()
        if fmt == 'svg':
            data = data.decode('utf-8')
        return data
Esempio n. 25
0
def filesize_plot(filesizes):
    # Pull all filesizes
    sizes = []
    while True:
        size = yield marv.pull(filesizes)
        if size is None:
            break
        sizes.append(size)

    # plot with plotly
    fig = go.Figure(data=go.Scatter(y=sizes))

    # save plotly figure to file
    plotfile = yield marv.make_file('filesizes_plotly.json')
    Path(plotfile.path).write_text(fig.to_json())

    # create plotly widget referencing file
    widget_plotly = {
        'title': 'Filesizes (plotly)',
        'plotly': f'marv-partial:{plotfile.relpath}',
    }

    # plot with matplotlib
    fig = plt.figure()
    axis = fig.add_subplot(1, 1, 1)
    axis.plot(sizes, 'bo')

    # save mpld3 figure to file
    plotfile = yield marv.make_file('filesizes_mpld3.json')
    Path(plotfile.path).write_text(json.dumps(mpld3.fig_to_dict(fig)))

    # create mpld3 plot widget referencing file
    widget_mpld3 = {
        'title': 'Filesizes (mpld3)',
        'mpld3': f'marv-partial:{plotfile.relpath}',
    }

    # save plot as image
    plotfile = yield marv.make_file('filesizes.jpg')
    fig.savefig(plotfile.path)

    # create image widget referencing file
    widget_image = {
        'title': 'Filesizes (image)',
        'image': {
            'src': plotfile.relpath
        },
    }

    # Let the user choose which widget to show with a dropdown
    yield marv.push({
        'title': 'Filesize plots',
        'dropdown': {
            'widgets': [
                widget_plotly,
                widget_mpld3,
                widget_image,
            ],
        },
    })
Esempio n. 26
0
def chart_template_direct(request, disease_id, state_id):

    return HttpResponse(request_url)


    js_data = json.dumps(mpld3.fig_to_dict(fig))
    return render_to_response('direct_plot.html', {"my_data": js_data})
Esempio n. 27
0
def filesize_plot_fixed(filesizes):
    # set_header() helps marv to schedule nodes
    yield marv.set_header()

    # Pull all filesizes
    sizes = []
    while True:
        size = yield marv.pull(filesizes)
        if size is None:
            break
        sizes.append(size)

    # plot
    fig = plt.figure()
    axis = fig.add_subplot(1, 1, 1)
    axis.plot(sizes, 'bo')
    # axis.set_xlabel('foo')
    # axis.set_ylabel('bat')

    # save figure to file
    plotfile = yield marv.make_file('filesizes.json')
    with open(plotfile.path, 'w') as f:
        json.dump(mpld3.fig_to_dict(fig), f)

    # create plot widget referencing file
    widget = {
        'title': 'Filesizes',
        'mpld3': f'marv-partial:{plotfile.relpath}',
    }
    yield marv.push(widget)
Esempio n. 28
0
def pcaPlot():
    print 1
    json = request.get_json()
    # lists=[]
    # for row in json:
    #     aa=[row["Open"],row["Close"],row["Change"],row["Volume"]]
    #     #print aa
    #     lists.append(aa)
    print 2
    x=colorArray(json["clusters"])
    
    a= np.array(json["result"]).astype(np.float)
    fig=plt.figure()

    dims=random.sample(range(0, 3), 2)

    plt.scatter(a[:,dims[0]],a[:,dims[1]], c=x)

    plt.xlabel('x_values')
    plt.ylabel('y_values')
    plt.xlim([-4,4])
    plt.ylim([-4,4])
    plt.title('Scree Plot of PCA')


    # X_iso = manifold.Isomap(10, n_components=2).fit_transform(mlab_pca.Y)
    
    # #mpld3.show()
    # print mpld3.fig_to_dict(fig)
    return jsonify(result=mpld3.fig_to_dict(fig))
Esempio n. 29
0
  def network_delay_histogram(self, app, butler, alg_label):
    """
    Description: returns the data to network delay histogram of the time it takes to getQuery+processAnswer for each algorithm

    Expected input:
      (string) alg_label : must be a valid alg_label contained in alg_list list of dicts

    Expected output (in dict):
      (dict) MPLD3 plot dictionary
    """
    list_of_query_dict,didSucceed,message = self.db.get_docs_with_filter(app.app_id+':queries',{'exp_uid':app.exp_uid,'alg_label':alg_label})

    t = []
    for item in list_of_query_dict:
      try:
        t.append(item['network_delay'])
      except:
        pass

    fig, ax = plt.subplots(subplot_kw=dict(axisbg='#FFFFFF'))
    ax.hist(t,MAX_SAMPLES_PER_PLOT,range=(0,5),alpha=0.5,color='black')
    ax.set_xlim(0, 5)
    ax.set_axis_off()
    ax.set_xlabel('Durations (s)')
    ax.set_ylabel('Count')
    ax.set_title(alg_label + " - network delay", size=14)
    plot_dict = mpld3.fig_to_dict(fig)
    plt.close()

    return plot_dict
Esempio n. 30
0
def pcaGraph():
    json = request.get_json()
    # lists=[]
    # for row in json:
    #     aa=[row["Open"],row["Close"],row["Change"],row["Volume"]]
    #     #print aa
    #     lists.append(aa)

    x=colorArray(json["clusters"])
    
    a= np.array(json["result"]).astype(np.float)
    # print a
    fig=plt.figure()
    plt.scatter(a[:,0],a[:,1], c=x)

    plt.xlabel('x_values')
    plt.ylabel('y_values')
    plt.xlim([-4,4])
    plt.ylim([-4,4])
    plt.title('PCA Graph')


    # X_iso = manifold.Isomap(10, n_components=2).fit_transform(mlab_pca.Y)
    
    # mpld3.show()
    # print mpld3.fig_to_dict(fig)
    return jsonify(result=mpld3.fig_to_dict(fig))
Esempio n. 31
0
def mdsGraph():
    json = request.get_json()
    # lists=[]
    # for row in json:
    #     aa=[row["Open"],row["Close"],row["Change"],row["Volume"]]
    #     #print aa
    #     lists.append(aa)
    # x =[]
    # clusters=json["clusters"]
    # tmp=[0]*clusters[0]
    # x.extend(tmp)
    # tmp=[50]*clusters[1]
    # x.extend(tmp)
    # tmp=[100]*clusters[2]
    # x.extend(tmp)
    # x=np.array(x)
    x=colorArray(json["clusters"])
    a= np.array(json["result"]).astype(np.float)

    Y = manifold.MDS(2 , max_iter=100, n_init=4).fit_transform(a)
    fig=plt.figure()
    plt.scatter(Y[:,0],Y[:,1],c=x)

    plt.xlabel('x_values')
    plt.ylabel('y_values')
    plt.xlim([-4,4])
    plt.ylim([-4,4])
    plt.title('MDS Graph')


    # X_iso = manifold.Isomap(10, n_components=2).fit_transform(mlab_pca.Y)
    
    # #mpld3.show()
    # print mpld3.fig_to_dict(fig)
    return jsonify(result=mpld3.fig_to_dict(fig))
Esempio n. 32
0
def plot_grid_3d(X_range, Y_range, Z, X_label='X', Y_label='Y', Z_label='Z', json_data=False):
  fig = plt.figure(figsize=(18,6))
  ax = fig.add_subplot(1, 1, 1, projection='3d')

  X, Y = np.meshgrid(X_range, Y_range)
  Zm = Z #zip(*Z)
  # print "[plot_check]", np.shape(X_range), np.shape(Y_range), np.shape(X), np.shape(Y), np.shape(Z)
  p = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)
  x_offset = (max(X_range) - min(X_range))*0.2
  y_offset = (max(Y_range) - min(Y_range))*0.2
  Zmax = max(max(Zm))
  Zmin = min(min(Zm))
  z_offset = (Zmax - Zmin)*0.2
  cset = ax.contour(X, Y, Z, zdir='x', offset=X_range[0]-x_offset, cmap=cm.coolwarm)
  cset = ax.contour(X, Y, Z, zdir='y', offset=Y_range[-1]+y_offset, cmap=cm.coolwarm)
  cset = ax.contour(X, Y, Z, zdir='z', offset=Zmin-z_offset, cmap=cm.coolwarm)
  ax.set_xlabel(X_label)
  ax.set_ylabel(Y_label)
  ax.set_zlabel(Z_label)
  ax.set_xlim(X_range[0]-x_offset, X_range[-1])
  ax.set_ylim(Y_range[0], Y_range[-1]+y_offset)
  ax.set_zlim(Zmin-z_offset, Zmax+z_offset)
  cb = fig.colorbar(p, shrink=0.5)
  # print "[mpld3] before json serialize."
  if json_data: return mpld3.fig_to_dict(fig)
Esempio n. 33
0
  def api_activity_histogram(self,app_id,exp_uid,task):
    """
    Description: returns the data to plot all API activity (for all algorithms) in a histogram with respect to time for any task in {getQuery,processAnswer,predict} 

    Expected input:
      (string) task :  must be in {'getQuery','processAnswer','predict'}

    Expected output (in dict):
      (dict) MPLD3 plot dictionary
    """


    list_of_log_dict,didSucceed,message = self.ell.get_logs_with_filter(app_id+':APP-CALL',{'exp_uid':exp_uid,'task':task})

    from datetime import datetime
    from datetime import timedelta
    start_date_str,didSucceed,message = self.db.get('experiments_admin',exp_uid,'start_date')
    start_date = utils.str2datetime(start_date_str)
    numerical_timestamps = [ ( utils.str2datetime(item['timestamp'])-start_date).total_seconds() for item in list_of_log_dict]

    import matplotlib.pyplot as plt
    import mpld3
    fig, ax = plt.subplots(subplot_kw=dict(axisbg='#FFFFFF'),figsize=(12,1.5))
    ax.hist(numerical_timestamps,int(1+4*numpy.sqrt(len(numerical_timestamps))),alpha=0.5,color='black')
    ax.set_frame_on(False)
    ax.get_xaxis().set_ticks([])
    ax.get_yaxis().set_ticks([])
    ax.get_yaxis().set_visible(False)
    ax.set_xlim(0, max(numerical_timestamps))
    plot_dict = mpld3.fig_to_dict(fig)

    
    return plot_dict
Esempio n. 34
0
    def update_figure(self, rnd_draws):
        # regenerate matplotlib plot
        self.ax1.cla()
        self.ax1.set_xlabel('r1')
        self.ax1.set_ylabel('Normalized Distribtuion')
        self.ax1.set_xlim(0, 1)
        self.ax1.set_ylim(0, 1.5)
        self.ax1.grid(True)
        self.ax1.hist([r[0] for r in rnd_draws],
                      50,
                      normed=1,
                      facecolor='green',
                      alpha=0.75)
        self.ax2.cla()
        self.ax2.set_xlabel('r2')
        self.ax2.set_ylabel('Normalized Distribtuion')
        self.ax2.set_xlim(0, 1)
        self.ax2.set_ylim(0, 1.5)
        self.ax2.grid(True)
        self.ax2.hist([r[1] for r in rnd_draws],
                      50,
                      normed=1,
                      facecolor='blue',
                      alpha=0.75)

        # send new matplotlib plots to frontend
        self.emit('mpld3canvas', mpld3.fig_to_dict(self.fig))
Esempio n. 35
0
def makeIRISGraph(noaaNmbr):
    fig, ax = plt.subplots(figsize = (6,6))

    HEKgraph = ax.scatter(xcen, ycen, s=25, alpha = 1.0)
    
    HEKcoordinates = []
    for i in range(len(xcen)):
        HEKcoordinates.append(str(xcen[i]) + ", " + str(ycen[i]))
        plt.plot(xcen, ycen, linestyle="dashed", color="red")
    
    tooltip = mpld3.plugins.PointLabelTooltip(HEKgraph, labels=HEKcoordinates)
    mpld3.plugins.connect(fig,tooltip)

    ax.add_patch(Circle((0, 0), 980 , facecolor='none', edgecolor=(0, 0.8, 0.8), linewidth=3, alpha=0.5))
    ax.set_xlabel('X-Cen (HPC Arcseconds)')
    ax.set_ylabel('Y-Cen (HPC Arcseconds)')

    plt.axis('equal')

    ax.grid(True)
    plt.gca().set_aspect('equal', adjustable='box')

    ax.set_title("IRIS Observations:", size=30)
    
    js_data = json.dumps(mpld3.fig_to_dict(fig))

    return js_data
Esempio n. 36
0
    def api_activity_histogram(self, app, butler):
        """
    Description: returns the data to plot all API activity (for all algorithms) in a histogram with respect to time for any task in {getQuery,processAnswer,predict}

    Expected output (in dict):
      (dict) MPLD3 plot dictionary
    """
        queries = butler.queries.get(pattern={'exp_uid': app.exp_uid})
        #self.db.get_docs_with_filter(app_id+':queries',{'exp_uid':exp_uid})
        start_date = utils.str2datetime(
            butler.admin.get(uid=app.exp_uid)['start_date'])
        numerical_timestamps = [
            (utils.str2datetime(item['timestamp_query_generated']) -
             start_date).total_seconds() for item in queries
        ]
        fig, ax = plt.subplots(subplot_kw=dict(axisbg='#FFFFFF'),
                               figsize=(12, 1.5))
        ax.hist(numerical_timestamps,
                min(int(1 + 4 * numpy.sqrt(len(numerical_timestamps))), 300),
                alpha=0.5,
                color='black')
        ax.set_frame_on(False)
        ax.get_xaxis().set_ticks([])
        ax.get_yaxis().set_ticks([])
        ax.get_yaxis().set_visible(False)
        ax.set_xlim(0, max(numerical_timestamps))
        plot_dict = mpld3.fig_to_dict(fig)
        plt.close()
        return plot_dict
Esempio n. 37
0
def get_intraday(company):
    '''Data retrieval from the stock market using Alpha Vantage API for intraday and daily time series'''
    plt.close()
    ts = TimeSeries(key='EZ3UZE4SWE1JI2A9', output_format='pandas')
    data, meta_data = ts.get_intraday(symbol=company,
                                      interval="1min",
                                      outputsize="full")
    fig_size = plt.rcParams["figure.figsize"]
    fig_size[0] = 12
    fig_size[1] = 5
    plt.rcParams["figure.figsize"] = fig_size
    fig, ax = plt.subplots()
    ax.plot(data.index, data['close'])
    # data['close'].plot()
    ax.set_title('Intraday Times Series for the ' + company +
                 ' stock (15 min)')
    ax.set_xticklabels(data.index, rotation=90, ha='left', fontsize=10)
    # dictionary_rep = mpld3.fig_to_dict(fig)
    # data['close'].plot()
    # plt.title('Intraday Times Series for the ' + company + ' stock (1 min)')
    dictionary_rep = mpld3.fig_to_dict(fig)
    # fig.autofmt_xdate()
    # ax.fmt_xdata = mdates.DateFormatter('%Y-%m-%d')
    # plt.savefig("/Users/rjmac/Desktop/SahanaMD_Project/FrontEnd/src/assets/"+company+ "_intraday.png", dpi=1000)
    plt.close()
    # plt.show()
    '''Data retrieval complete'''
    return dictionary_rep
Esempio n. 38
0
def getPayoffProfile(request):
    strategyName = request.args['strategyName']

    s = getStrategy(strategyName, request)

    fig, ax = plt.subplots()
    s.CalcPayoffProfile()
    return mpld3.fig_to_dict(fig)
Esempio n. 39
0
 def _plot_figure(self, idx):
     from .display_hooks import display_figure
     fig = self.plot[idx]
     if OutputMagic.options['backend'] == 'd3':
         import mpld3
         mpld3.plugins.connect(fig, mpld3.plugins.MousePosition(fontsize=14))
         return mpld3.fig_to_dict(fig)
     return display_figure(fig)
Esempio n. 40
0
 def _plot_figure(self, idx):
     from .display_hooks import display_frame
     self.plot.update(idx)
     if OutputMagic.options['backend'] == 'd3':
         import mpld3
         mpld3.plugins.connect(fig, mpld3.plugins.MousePosition(fontsize=14))
         return mpld3.fig_to_dict(self.plot.state)
     return display_frame(self.plot, **self.display_options)
def get_statistics_rasterplot(videoname, runname):
    with Run(videoname, runname) as run:
        run['time_per_bin'] = float(request.form['time_per_bin'])

        fig_raster = analyzer.plot.plot_rasterplot(run['statistics']['spikes'],
                                                   run['exposure_time'],
                                                   run['time_per_bin'])
    rasterplot = mpld3.fig_to_dict(fig_raster)
    return jsonify(rasterplot=rasterplot)
Esempio n. 42
0
    def on_run(self):
        """Run when button is pressed."""
        self.emit('log', 'Hi. The run button was pressed. Going to sleep.')
        time.sleep(self.sleep_duration)
        self.emit('log', 'Waking up again. Run is done.')

        # draw something on self.fig
        # regenerate matplotlib plot
        self.ax.cla()
        self.ax.set_xlabel('output of random.random()')
        self.ax.set_ylabel('normalized distribtuion of 100 trials')
        self.ax.set_xlim(0, 1)
        self.ax.set_ylim(0, 1.5)
        self.ax.grid(True)
        self.ax.hist(
            [random.random() for i in xrange(100)], 5,
            normed=1, facecolor='green', alpha=0.75
        )
        self.emit('mpld3canvas', mpld3.fig_to_dict(self.fig))

        # create the data for the Basic d3.js part
        data = [
            {'id': 1, 'x1': 0.1, 'y1': 0.1, 'x2': 0.8, 'y2': 0.5,
             'width': 0.05, 'color': 0.5},
            {'id': 2, 'x1': 0.1, 'y1': 0.3, 'x2': 0.8, 'y2': 0.7,
             'width': 0.05, 'color': 0.7},
            {'id': 3, 'x1': 0.1, 'y1': 0.5, 'x2': 0.8, 'y2': 0.9,
             'width': 0.05, 'color': 0.9},
        ]
        self.emit('update_basic', data)
        # update with some new data after a short wait
        time.sleep(1)
        data2 = [
            {'id': 1, 'x1': 0.1, 'y1': 0.1, 'x2': 0.8, 'y2': 0.5,
             'width': 0.2, 'color': 0.5},
            {'id': 2, 'x1': 0.1, 'y1': 0.3, 'x2': 0.8, 'y2': 0.7,
             'width': 0.2, 'color': 0.7},
            {'id': 3, 'x1': 0.1, 'y1': 0.5, 'x2': 0.8, 'y2': 0.9,
             'width': 0.2, 'color': 0.9},
        ]
        self.emit('update_basic', data2)

        # create and send data for the d3.js plot
        self.emit('log', 'Increasing numbers.')
        self.emit('update_plot', [0.1, 0.3, 0.5, 0.7, 0.9])
        time.sleep(1)
        self.emit('log', 'Random numbers.')
        self.emit('update_plot', [random.random() for i in xrange(5)])
        time.sleep(1)
        # Animation of a sin wave. Use numpy.
        self.emit('log', 'Animate a sin wave.')
        x = numpy.linspace(0, numpy.pi, 5)
        for t in xrange(50):
            numpy_data = 0.5 + 0.4*numpy.sin(x + t/3.0)
            self.emit('update_plot', numpy_data.tolist())
            time.sleep(0.25)
Esempio n. 43
0
def plot_grid_2d(X, Z, X_label='X', Z_label='Z', json_data=False):
  fig = plt.figure(figsize=(6,2.5))
  ax = fig.add_subplot(1, 1, 1)
  p = ax.plot(X, Z)
  ax.set_xlabel(X_label)
  ax.set_ylabel(Z_label)
  if json_data:
    chart_data = mpld3.fig_to_dict(fig)
    plt.close()
    return chart_data
Esempio n. 44
0
def viz_content():
    params = get_params(request)
    df = get_events_by_content(g.db_engine, params)
    ax = df.plot(x='loaded', y='played', kind='scatter', figsize=(12, 8))
    mpld3_data = mpld3.fig_to_dict(ax.get_figure())
    url_format = lambda x: '<a href="%s">%s</a>' % (x, x)
    table_html = df.head(20).to_html(classes=['table'], formatters={'content_url': url_format})
    return render_template('base_viz.html', \
        clients=get_clients(), content_hosts=get_content_hosts(), params=params, \
        data_table=table_html, mpld3_data=json.dumps(mpld3_data))
Esempio n. 45
0
def home(request):
	context = {}
	context['requestMethod'] = request.META['REQUEST_METHOD']

	if request.method == 'GET' :

		if request.GET.__contains__('hidden') :
			#if 'name' in context and 'end_date' in context and 'start_date' in context:
			context['name'] = request.GET['name']
			context['start_date'] = request.GET['start_date']
			context['end_date'] = request.GET['end_date']
	
	print context
				
	requestContext = RequestContext(request, context)

	templateIndex = loader.get_template('index.html')

	renderedTemplate = templateIndex.render(requestContext)

	response = HttpResponse()

	response['Age'] = 120

	response.write(renderedTemplate)
	
	if 'name' in context:# and 'end_date' in context and 'start_date' in context:
		company = context['name'].encode('ascii','ignore')
		start_date = context['start_date'].encode('ascii','ignore')
		end_date = context['end_date'].encode('ascii','ignore')
		a = request.GET.get('name')
		start_date = start_date.split('-')
		end_date = end_date.split('-')
		
		start = datetime.datetime(int(start_date[0]),int(start_date[1]),int(start_date[2]))
		end = datetime.datetime(int(end_date[0]),int(end_date[1]),int(end_date[2]))
		
		f = web.DataReader(company,'yahoo',start,end)
		a = f['Close']
		b = a.index.tolist()
		array = []
		for i in range(b.__len__()):
			c = b[i]
			s = str(c)[:10]
			d = a.tolist()
			e = round(d[i],2)
			array.append(e)
		#print f
        fig = figure(1)
        plot([3,1,2,4,1])
        js_data = json.dumps(mpld3.fig_to_dict(fig))

        return render_to_response('index.html',{'array':json.dumps(array), 'start_date':json.dumps(start_date), 'end_date':json.dumps(end_date), 'js_data': js_data})
	return render_to_response('index.html',{})
Esempio n. 46
0
def viz_date():
    params = get_params(request)
    df = get_events_date_df(g.db_engine, params)
    df = df.unstack(1)
    ax = df.plot(legend=['load', 'play'], figsize=(12, 8))
    ax.set_xlabel('Date')
    mpld3_data = mpld3.fig_to_dict(ax.get_figure())
    table_df = get_events_by_source_df(g.db_engine, params)
    ratio_format = lambda x: '<span class="significant"><bold>%f</bold></span>' % x
    table_html = table_df.head(20).to_html(classes=['table'], formatters={'ratio': ratio_format})
    return render_template('base_viz.html', \
        clients=get_clients(), content_hosts=get_content_hosts(), params=params, \
        data_table=table_html, mpld3_data=json.dumps(mpld3_data))
Esempio n. 47
0
def vis_rec(data, fig_id, title=None):
    data = data.copy()
    data -= data.min()
    data /= data.max()

    plt.figure()
    plt.xticks(np.arange(0, 10, 1.0))
    plt.yticks([])
    plt.imshow(data)
    if title:
        plt.title(title)
    plt.tight_layout()

    return {'id': fig_id, 'json': json.dumps(mpld3.fig_to_dict(plt.gcf()))}
Esempio n. 48
0
    def _figure_data(self, plot, fmt='png', bbox_inches='tight', **kwargs):
        """
        Render matplotlib figure object and return the corresponding data.

        Similar to IPython.core.pylabtools.print_figure but without
        any IPython dependency.
        """
        fig = plot.state
        if self.mode == 'nbagg':
            manager = self.get_figure_manager(plot.state)
            if manager is None: return ''
            self.counter += 1
            manager.show()
            return ''
        elif self.mode == 'mpld3':
            import mpld3
            fig.dpi = self.dpi
            mpld3.plugins.connect(fig, mpld3.plugins.MousePosition(fontsize=14))
            if fmt == 'json':
                return mpld3.fig_to_dict(fig)
            else:
                return "<center>" + mpld3.fig_to_html(fig) + "<center/>"

        traverse_fn = lambda x: x.handles.get('bbox_extra_artists', None)
        extra_artists = list(chain(*[artists for artists in plot.traverse(traverse_fn)
                                     if artists is not None]))

        kw = dict(
            format=fmt,
            facecolor=fig.get_facecolor(),
            edgecolor=fig.get_edgecolor(),
            dpi=self.dpi,
            bbox_inches=bbox_inches,
            bbox_extra_artists=extra_artists
        )
        kw.update(kwargs)

        # Attempts to precompute the tight bounding box
        try:
            kw = self._compute_bbox(fig, kw)
        except:
            pass

        bytes_io = BytesIO()
        fig.canvas.print_figure(bytes_io, **kw)
        data = bytes_io.getvalue()
        if fmt == 'svg':
            data = data.decode('utf-8')
        return data
Esempio n. 49
0
def show_plot_shear(span_length, x_loc, feet_or_frac, max_shear_loc):

    axle_pos = max_shear_loc
    x_loc = x_loc * span_length if feet_or_frac == 'frac' else x_loc


    # Plot span
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    span = ax.plot([0, span_length], [0, 0], 'b')

    # Add boundaries to span
    # tri_width = (span_length*1.2+20)/120
    # bound1 = plt.plot([0, -tri_width, tri_width, 0], [0, -2, -2, 0])
    bound1 = ax.plot(0, -0.7, 'b^')
    bound2 = ax.plot(span_length, -0.7, 'bo')

    axle_pos += span_length

    # Cooper E-80 Axle Layout
    axle_loads = [40, 80, 80, 80, 80, 52, 52, 52, 52,
                  40, 80, 80, 80, 80, 52, 52, 52, 52,
                  8]

    axle_spaces = [0, 8, 5, 5, 5, 9, 5, 6, 5,
                   8, 8, 5, 5, 5, 9, 5, 6, 5,
                   5.5]

    train_len = sum(axle_spaces)
    while (sum(axle_spaces) - train_len) < span_length:
        axle_spaces.append(1)
        axle_loads.append(8)

    for pos, spac in enumerate(axle_spaces):
        axle_pos = axle_pos - spac
        axle_load = 1 + axle_loads[pos] / 4
        axle = ax.plot([axle_pos, axle_pos], [1, axle_load], 'r')
        axle_label = ax.text(axle_pos - 1.5,
                             axle_load + 2,
                             str(axle_loads[pos]) + 'k',
                             fontsize=8,
                             color='r')
        axle_end = ax.plot(axle_pos, 1, 'rv')
    xplot = ax.plot([x_loc, x_loc], [-1, -5], 'y')
    xplotarr = ax.plot(x_loc, -1 ,'y^')
    ax.set_xlim(-20, span_length + 20)
    ax.set_ylim(-30, 60)
    ax.set_title('Train Position for Max Shear')
    return mpld3.fig_to_dict(fig)
Esempio n. 50
0
    def test_extra_contour(self):
        """ Create an empty line collection by requesting invalid contours, and
        check that a collection with length(paths) === 0 is not passed to the
        JavaScript.
        """
        fig, ax = plt.subplots()
        X, Y = np.mgrid[0:5, 0:5]
        Z = X**2 - Y**2
        ax.contour(X, Y, Z, range(-15, 18, 2))  # last contour level is 17
                                                # but Z.max() is 16
        jsondict = mpld3.fig_to_dict(fig)

        for collection in jsondict["axes"][0]["collections"]:
            self.assertTrue(len(collection["paths"]) != 0)
        return
def star_param_scatterplot():

	# Create star population
	# starpop = vespa.MultipleStarPopulation(1)
	# return starpop.prophist2d('distmod','distmod')
	# x = starpop['H_mag']
	# y = starpop['distmod']
	x = np.random.randint(200, size=100)
	y = np.random.randint(200, size=100)
	fig = plt.figure()
	ax = fig.add_subplot(111) #, xlabel='$distance$', ylabel='$distmod$')

	the_plot = ax.plot(x,y,marker='.',lw=0)
	f = open("mpld3_product.txt","w")
	json01 = json.dumps(mpld3.fig_to_dict(fig))
	return render_template('test.html', testvar=json01)
Esempio n. 52
0
    def _figure_data(self, plot, fmt="png", bbox_inches="tight", **kwargs):
        """
        Render matplotlib figure object and return the corresponding data.

        Similar to IPython.core.pylabtools.print_figure but without
        any IPython dependency.
        """
        fig = plot.state
        if self.mode == "nbagg":
            manager = self.get_figure_manager(plot)
            if manager is None:
                return ""
            self.counter += 1
            manager.show()
            return ""
        elif self.mode == "mpld3":
            import mpld3

            fig.dpi = self.dpi
            mpld3.plugins.connect(fig, mpld3.plugins.MousePosition(fontsize=14))
            if fmt == "json":
                return mpld3.fig_to_dict(fig)
            else:
                return "<center>" + mpld3.fig_to_html(fig) + "<center/>"

        kw = dict(
            format=fmt,
            facecolor=fig.get_facecolor(),
            edgecolor=fig.get_edgecolor(),
            dpi=self.dpi,
            bbox_inches=bbox_inches,
        )
        kw.update(kwargs)

        # Attempts to precompute the tight bounding box
        try:
            kw = self._compute_bbox(fig, kw)
        except:
            pass

        bytes_io = BytesIO()
        fig.canvas.print_figure(bytes_io, **kw)
        data = bytes_io.getvalue()
        if fmt == "svg":
            data = data.decode("utf-8")
        return data
Esempio n. 53
0
def plot_experiment(gene_data):
    gene_data.sort(key=operator.itemgetter(1))
    filtered_genes = [gene_tuple[0] for gene_tuple in gene_data]
    filtered_values = [gene_tuple[1] for gene_tuple in gene_data]
    filtered_values.reverse()
    filtered_genes.reverse()
    
    fig, ax = plt.subplots(1)
    scatter = ax.scatter(range(len(gene_data)), filtered_values, edgecolor='none', facecolor='#ff69b4')
    
    tooltip = mpld3.plugins.PointLabelTooltip(scatter, labels=filtered_genes)
    mpld3.plugins.connect(fig, tooltip)

    # When you've made your plot, convert it with the mpld3 library like so:
    mpld3_dict = mpld3.fig_to_dict(fig)

    return mpld3_dict
Esempio n. 54
0
    def update_plot(self, path_data):
        codes, verts = zip(*path_data)
        path = mpl.path.Path(verts, codes)
        patch = mpl.patches.PathPatch(path, facecolor='r', alpha=0.5)
        self.ax.add_patch(patch)

        # plot control points and connecting lines
        x, y = zip(*path.vertices[:-1])
        points = self.ax.plot(x, y, 'go', ms=10)
        line = self.ax.plot(x, y, '-k')

        self.ax.grid(True, color='gray', alpha=0.5)
        self.ax.axis('equal')
        self.ax.set_title("Drag Points to Change Path", fontsize=18)

        # enable custom plugin
        mpld3.plugins.connect(self.fig,
                              LinkedDragPlugin(points[0], line[0], patch))
        # send plot to frontend
        self.emit('mpld3canvas', mpld3.fig_to_dict(self.fig))
Esempio n. 55
0
  def response_time_histogram(self,app_id,exp_uid,alg_label):
    """
    Description: returns the data to plot response time histogram of processAnswer for each algorithm  

    Expected input:
      (string) alg_label : must be a valid alg_label contained in alg_list list of dicts 

    Expected output (in dict):
      (dict) MPLD3 plot dictionary
    """

    alg_list,didSucceed,message = self.db.get(app_id+':experiments',exp_uid,'alg_list')

    for algorithm in alg_list:
      if algorithm['alg_label'] == alg_label:
        alg_id = algorithm['alg_id']
        alg_uid = algorithm['alg_uid']

    list_of_query_dict,didSucceed,message = self.db.get_docs_with_filter(app_id+':queries',{'exp_uid':exp_uid,'alg_uid':alg_uid})


    t = []
    for item in list_of_query_dict:
      try:
        t.append(item['response_time'])
      except:
        pass

    import matplotlib.pyplot as plt
    import mpld3
    fig, ax = plt.subplots(subplot_kw=dict(axisbg='#FFFFFF'))
    ax.hist(t,MAX_SAMPLES_PER_PLOT,range=(0,30),alpha=0.5,color='black')
    ax.set_xlim(0, 30)
    ax.set_axis_off()
    ax.set_xlabel('Durations (s)')
    ax.set_ylabel('Count')
    ax.set_title(alg_label + " - response time", size=14)
    plot_dict = mpld3.fig_to_dict(fig)
    plt.close()

    return plot_dict
def onconnect():
    """Run as soon as a browser connects to this."""

    fig, ax = plt.subplots()
    points = ax.scatter(
        np.random.rand(40),
        np.random.rand(40),
        s=300,
        alpha=0.3,
    )

    # use the mpld3 tooltop plugin
    labels = ["Point {0}".format(i) for i in range(40)]
    tooltip = mpld3.plugins.PointLabelTooltip(points, labels)
    mpld3.plugins.connect(fig, tooltip)

    # send the plot to the frontend
    ANALYSIS.signals.emit('mpld3canvas', mpld3.fig_to_dict(fig))

    # done
    ANALYSIS.signals.emit('log', {'action': 'done'})
Esempio n. 57
0
  def api_activity_histogram(self, app, butler):
    """
    Description: returns the data to plot all API activity (for all algorithms) in a histogram with respect to time for any task in {getQuery,processAnswer,predict}

    Expected output (in dict):
      (dict) MPLD3 plot dictionary
    """
    queries = butler.queries.get(pattern={'exp_uid':app.exp_uid})
    #self.db.get_docs_with_filter(app_id+':queries',{'exp_uid':exp_uid})
    start_date = utils.str2datetime(butler.admin.get(uid=app.exp_uid)['start_date'])
    numerical_timestamps = [(utils.str2datetime(item['timestamp_query_generated'])-start_date).total_seconds() 
                                for item in queries]
    fig, ax = plt.subplots(subplot_kw=dict(axisbg='#FFFFFF'),figsize=(12,1.5))
    ax.hist(numerical_timestamps,min(int(1+4*numpy.sqrt(len(numerical_timestamps))),300),alpha=0.5,color='black')
    ax.set_frame_on(False)
    ax.get_xaxis().set_ticks([])
    ax.get_yaxis().set_ticks([])
    ax.get_yaxis().set_visible(False)
    ax.set_xlim(0, max(numerical_timestamps))
    plot_dict = mpld3.fig_to_dict(fig)
    plt.close()
    return plot_dict
Esempio n. 58
0
def onconnect():
    """Run as soon as a browser connects to this."""

    # initialize plot
    fig, ax = mpl.pyplot.subplots()

    # create plot elements
    path_data = [
        (mpl.path.Path.MOVETO, (1.58, -2.57)),
        (mpl.path.Path.CURVE4, (0.35, -1.1)),
        (mpl.path.Path.CURVE4, (-1.75, 2.0)),
        (mpl.path.Path.CURVE4, (0.375, 2.0)),
        (mpl.path.Path.LINETO, (0.85, 1.15)),
        (mpl.path.Path.CURVE4, (2.2, 3.2)),
        (mpl.path.Path.CURVE4, (3, 0.05)),
        (mpl.path.Path.CURVE4, (2.0, -0.5)),
        (mpl.path.Path.CLOSEPOLY, (1.58, -2.57)),
    ]
    codes, verts = zip(*path_data)
    path = mpl.path.Path(verts, codes)
    patch = mpl.patches.PathPatch(path, facecolor='r', alpha=0.5)
    ax.add_patch(patch)

    # plot control points and connecting lines
    x, y = zip(*path.vertices[:-1])
    points = ax.plot(x, y, 'go', ms=10)
    line = ax.plot(x, y, '-k')

    ax.grid(True, color='gray', alpha=0.5)
    ax.axis('equal')
    ax.set_title("Drag Points to Change Path", fontsize=18)

    # enable custom plugin
    mpld3.plugins.connect(fig, LinkedDragPlugin(points[0], line[0], patch))
    # send plot to frontend
    ANALYSIS.signals.emit('mpld3canvas', mpld3.fig_to_dict(fig))

    ANALYSIS.signals.emit('log', {'action': 'done'})
Esempio n. 59
0
def vis_square(data, fig_id, padsize=1, padval=0, title=None):
    data = data.copy()
    data -= data.min()
    data /= data.max()

    # force the number of filters to be square
    n = int(np.ceil(np.sqrt(data.shape[0])))
    padding = ((0, n ** 2 - data.shape[0]), (0, padsize), (0, padsize)) + ((0, 0),) * (data.ndim - 3)
    data = np.pad(data, padding, mode='constant', constant_values=(padval, padval))

    # tile the filters into an image
    data = data.reshape((n, n) + data.shape[1:]).transpose((0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))
    data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:])
    data = data.squeeze()

    plt.figure()
    plt.xticks([])
    plt.yticks([])
    plt.imshow(data)
    if title:
        plt.title(title)
    plt.tight_layout()

    return {'id': fig_id, 'json': json.dumps(mpld3.fig_to_dict(plt.gcf()))}