Пример #1
0
    def bqstreamplot(self):
        Cxs = bq.DateScale()
        Cys = bq.LinearScale()
        Cx = self.CallIVtable.index.values
        Cy = self.CallIVtable.as_matrix().transpose()
        Ccol = self.CallIVtable.columns.tolist()

        self.Cline = bq.Lines(x=Cx, y=Cy, scales={'x': Cxs, 'y': Cys},
                        colors=[i.hex for i in list(Color(rgb=(0.95,0,0)).range_to(Color(rgb=(0.45,0.1,0)), len(Ccol)))],
                        labels=Ccol,
                        enable_hover=True,
                        display_legend=True)
        Cxax = bq.Axis(scale=Cxs, label='Datetime', grid_lines='solid')
        Cyax = bq.Axis(scale=Cys, orientation='vertical', tick_format='0.1f', label='CallIV', grid_lines='solid')
        figC = bq.Figure(marks=[self.Cline], axes=[Cxax, Cyax], animation_duration=1000)

        Pxs = bq.DateScale()
        Pys = bq.LinearScale()
        Px = self.PutIVtable.index.values
        Py = self.PutIVtable.as_matrix().transpose()
        Pcol = self.PutIVtable.columns.tolist()

        self.Pline = bq.Lines(x=Px, y=Py, scales={'x': Pxs, 'y': Pys},
                        colors=[i.hex for i in list(Color(rgb=(0,0.75,0)).range_to(Color(rgb=(0,0,0.45)), len(Pcol)))],
                        labels=Pcol,
                        enable_hover=True,
                        display_legend=True)
        Pxax = bq.Axis(scale=Pxs, label='Datetime', grid_lines='solid')
        Pyax = bq.Axis(scale=Pys, orientation='vertical', tick_format='0.1f', label='PutIV', grid_lines='solid')
        figP = bq.Figure(marks=[self.Pline], axes=[Pxax, Pyax], animation_duration=1000)
        display(HBox(([figC,figP])))
def plot_orbit(z0=0.5+0.5*1j, c=0+0*1j):
    sc_x = bqplot.LinearScale(min=-1.2, max=1.2)
    sc_y = bqplot.LinearScale(min=-1.2, max=1.2)

    c_point = bqplot.Scatter(x=[c.real], y=[c.imag], scales={'x': sc_x, 'y': sc_y}, colors=['red'],
                   enable_move=True, default_size=200)
    c_point.update_on_move = True

    z_point = bqplot.Scatter(x=[z0.real], y=[z0.imag], scales={'x': sc_x, 'y': sc_y}, colors=['green'],
                   enable_move=True, default_size=200)
    z_point.update_on_move = True

    c_label = bqplot.Label(x=[c.real+.05], y=[c.imag+.05], scales={'x': sc_x, 'y': sc_y}, colors=['red'],
                           text=['c'],
                           default_size=26, font_weight='bolder')

    z_label = bqplot.Label(x=[z0.real+.05], y=[z0.imag+.05], scales={'x': sc_x, 'y': sc_y}, colors=['green'],
                           text=['z0'],
                           default_size=26, font_weight='bolder')
    
    scatt = bqplot.Scatter(x=[], y=[], scales={'x': sc_x, 'y': sc_y}, colors=['black'], default_size=20)

    theta = np.linspace(0, 2.*np.pi, 1000)
    x = np.cos(theta)
    y = np.sin(theta)
    circle = bqplot.Lines(x=x, y=y, scales={'x': sc_x, 'y': sc_y}, colors=['black'])
    lin = bqplot.Lines(x=[], y=[], scales={'x': sc_x, 'y': sc_y}, colors=['black'], stroke_width=1)

    def update_line(change=None):
        out = orbit(z_point.x + 1j*z_point.y, c_point.x + 1j*c_point.y)
        c_label.x = c_point.x + 0.05
        c_label.y = c_point.y + 0.05
        z_label.x = z_point.x + 0.05
        z_label.y = z_point.y + 0.05
        lin.x = out.real
        lin.y = out.imag
        scatt.x = out.real.flatten()
        scatt.y = out.imag.flatten()

    update_line()
    # update line on change of x or y of scatter
    c_point.observe(update_line, names=['x'])
    c_point.observe(update_line, names=['y'])
    z_point.observe(update_line, names=['x'])
    z_point.observe(update_line, names=['y'])
    ax_x = bqplot.Axis(scale=sc_x, offset=dict(value=0.5), grid_lines='none')
    ax_y = bqplot.Axis(scale=sc_y, orientation='vertical', offset=dict(value=0.5), grid_lines='none')

    fig = bqplot.Figure(marks=[scatt, lin, circle, c_point, z_point, c_label, z_label], axes=[ax_x, ax_y],
                 min_aspect_ratio=1, max_aspect_ratio=1)
    fig.layout.height = '800px'
    return fig
Пример #3
0
def test_lines(scales):
    # since lines can have 2d data, with irregularly shaped data, binary serialization
    # doesn't work or is trickier
    with pytest.raises(TraitError, match='.*type object.*'):
        lines = bqplot.Lines(x=[[0, 1], [0, 1, 2]], y=[[0, 1], [1, 0, -1]], scales=scales)

    lines = bqplot.Lines(x=[[0, 1], [0, 1]], y=[[0, 1], [1, 0]], scales=scales)
    state = lines.get_state()

    lines2 = bqplot.Lines(scales=scales)
    lines2.set_state(state)
    assert lines.x[0][0] == 0
    assert lines.x[0][1] == 1
    assert lines.x[1][1] == 1
Пример #4
0
def draw_graph(graph, pos=None):
    from numpy import array
    import networkx as nx
    import bqplot as bq

    if pos is None:
        pos = nx.spring_layout(graph)
    nodes = graph.nodes()
    x = [pos[n][0] for n in nodes]
    y = [pos[n][1] for n in nodes]
    lines_x = []
    lines_y = []
    for k, v in graph.edges():
        i1 = graph.nodes().index(k)
        i2 = graph.nodes().index(v)
        lines_x.append([x[i1], x[i2]])
        lines_y.append([y[i1], y[i2]])
    lines_x = array(lines_x)
    lines_y = array(lines_y)

    x_sc = bq.LinearScale()
    y_sc = bq.LinearScale()
    points = bq.Scatter(x=x, y=y, scales={'x': x_sc, 'y': y_sc})
    lines = bq.Lines(x=lines_x,
                     y=lines_y,
                     scales={
                         'x': x_sc,
                         'y': y_sc
                     },
                     colors=['red'])
    ax_x = bq.Axis(scale=x_sc)
    ax_y = bq.Axis(scale=y_sc, orientation='vertical')
    fig = bq.Figure(marks=[lines, points], axes=[ax_x, ax_y])
    return fig
Пример #5
0
    def init_elements(self):
        self.xscale = bq.LinearScale(
            min=np.min(self.xvals),
            max=np.max(self.xvals)
        )
        self.yscale = bq.LinearScale(
            min=self.ylim[0],
            max=self.ylim[1]
        )
        self.xax = bq.Axis(
            scale=self.xscale,
            label=self.labels['xlabel'],
            grid_lines='none'
        )
        self.yax = bq.Axis(
            scale=self.yscale,
            label=self.labels['ylabel'],
            orientation='vertical',
            grid_lines='none'
        )
        self.line = bq.Lines(
            x=self.xvals,
            y=self.yvals,
            scales={'x': self.xscale, 'y': self.yscale},
            colors=[self.color],
            interpolation='cardinal'
        )
        self.handdraw = bqi.HandDraw(lines=self.line)

        super().__init__(
            marks=[self.line],
            axes=[self.xax, self.yax],
            interaction=self.handdraw
        )
Пример #6
0
def make_bq_plot(plot_type,
                 x,
                 y,
                 scales,
                 size,
                 interactions,
                 selected_style,
                 unselected_style,
                 display_legend=False,
                 labels=[''],
                 colors=['#43a2ca'],
                 stroke_width=3,
                 marker='circle'):

    if plot_type == 'scatter':
        chart = bqplot.Scatter(x=x,
                               y=y,
                               scales=scales,
                               size=size,
                               interactions=interactions,
                               selected_style=selected_style,
                               unselected_style=unselected_style,
                               display_legend=display_legend,
                               labels=labels,
                               marker=marker,
                               colors=colors)
    elif plot_type == 'lines':
        chart = bqplot.Lines(x=x,
                             y=y,
                             colors=colors,
                             stroke_width=stroke_width,
                             scales=scales,
                             size=size)

    return chart
    def make_pixel_intensities_pane(self):
        FULL_HEIGHT = 800

        scales = {
            'x': bq.LinearScale(min=0),
            'y': bq.LinearScale(min=0, max=255)
        }

        self.pixel_intensities_mark = bq.Lines(scales=scales,
                                               colors=['blue', 'green', 'red'],
                                               display_legend=True,
                                               opacities=[0.7] * 3)

        axes = [bq.Axis(scale=scales['y'], orientation='vertical')]

        self.pixel_intensities_fig = bq.Figure(
            marks=[self.pixel_intensities_mark], axes=axes)
        self.pixel_intensities_fig.layout.width = '100%'
        self.pixel_intensities_fig.layout.height = str(
            self.display_pane.size * FULL_HEIGHT) + 'px'
        self.pixel_intensities_fig.layout.margin = '0'
        self.pixel_intensities_fig.title = 'Pixel Intensities Along Segment'

        self.update_pixel_intensities_mark()

        return ipy.VBox([
            self.pixel_intensities_fig,
            bq.toolbar.Toolbar(figure=self.pixel_intensities_fig)
        ])
Пример #8
0
def scatter_drag(x_points: 'Array', y_points: 'Array', *, show_eqn=True,
                 options={}):
    """
    Generates an interactive scatter plot with the best fit line plotted over
    the points. The points can be dragged by the user and the line will
    automatically update.

    Args:
        x_points (Array Number): x-values of points to plot

        y_points (Array Number): y-values of points to plot

    Kwargs:
        show_eqn (bool): If True (default), displays the best fit line's
            equation above the scatterplot.

        {options}

    Returns:
        None

    >>> xs = np.arange(10)
    >>> ys = np.arange(10) + np.random.rand(10)
    >>> scatter_drag(xs, ys)
    VBox(...)
    """
    params = {
        'mark': {
            'x': x_points,
            'y': y_points,
            'enable_move': True,
        }
    }

    scat, fig = _create_plot(mark=bq.Scatter, options=options, params=params)

    # Add line to figure
    lin = bq.Lines(scales=scat.scales,
                   animation_duration=5000,
                   colors=[GOLDENROD])
    fig.marks = [scat, lin]

    # equation label
    label = widgets.Label()

    # create line fit to data and display equation
    def update_line(change=None):
        x_sc = scat.scales['x']
        lin.x = [x_sc.min if x_sc.min is not None else np.min(scat.x),
                 x_sc.max if x_sc.max is not None else np.max(scat.x)]
        poly = np.polyfit(scat.x, scat.y, deg=1)
        lin.y = np.polyval(poly, lin.x)
        if show_eqn:
            label.value = 'y = {:.2f} + {:.2f}x'.format(poly[1], poly[0])
    update_line()

    scat.observe(update_line, names=['x', 'y'])

    layout = widgets.VBox([label, fig])
    display(layout)
Пример #9
0
    def __init__(self, model=None, *args, **kwargs):

        super(GeneratorCostView, self).__init__(*args, **kwargs)

        if model is not None:
            self.model = model
        else:
            self.model = Generator()

        self._scale_x = bq.LinearScale(min=self.model.minimum_real_power,
                                       max=self.model.maximum_real_power)

        self._scale_y = bq.LinearScale(
            min=0, max=(max(self.model.cost_curve_values) * 1.5 + 50))

        self._scales = {
            'x': self._scale_x,
            'y': self._scale_y,
        }

        self._scatter = bq.Scatter(x=self.model.cost_curve_points,
                                   y=self.model.cost_curve_values,
                                   scales=self._scales)

        self._lines = bq.Lines(x=self.model.cost_curve_points,
                               y=self.model.cost_curve_values,
                               scales=self._scales)

        self._axes_x = bq.Axis(scale=self._scale_x)
        self._axes_y = bq.Axis(scale=self._scale_y,
                               orientation='vertical',
                               padding_x=0.025)

        f = bq.Figure(marks=[
            self._lines,
            self._scatter,
        ],
                      axes=[
                          self._axes_x,
                          self._axes_y,
                      ])

        children = [f]

        self.children = children

        t.link((self.model, 'maximum_real_power'), (self._scale_x, 'max'))
        t.link((self.model, 'cost_curve_points'), (self._scatter, 'x'))
        t.link((self.model, 'cost_curve_values'), (self._scatter, 'y'))

        t.link((self._lines, 'x'), (self._scatter, 'x'))
        t.link((self._lines, 'y'), (self._scatter, 'y'))

        # self._scatter.observe(self._callback_ydata, names=['y'])

        with self._scatter.hold_sync():
            self._scatter.enable_move = True
            self._scatter.update_on_move = True
            self._scatter.interactions = {'click': None}
Пример #10
0
    def get_input_form(self, figure_title, no_users=100):
        if self.fig:
            return self.fig

        self.figure_title = figure_title
        max_hours = 24 + 1
        max_users = no_users

        # Define scales
        x_scale = bqplot.LinearScale(min=0, max=max_hours)
        y_scale = bqplot.LinearScale(min=0, max=max_users)

        # Initialize data for our line
        line = bqplot.Lines(
            x=np.arange(0, max_hours),
            y=np.zeros(max_hours),
            scales={"x": x_scale, "y": y_scale},
            fill="bottom",
            fill_opacities=[0.5],
        )

        # Layout only - axes (plural of axis)
        x_axis = bqplot.Axis(scale=x_scale, label="Hour", grid_lines="none")
        y_axis = bqplot.Axis(
            scale=y_scale,
            label="Number of Users",
            grid_lines="none",
            orientation="vertical",
        )

        def _fix_input_callback(change):
            # ensures we draw integer values 0 or greater and that
            # 00:00 [0] and 24:00 [24] represent the same value.
            with line.hold_sync():

                if change["old"][-1] != change["new"][-1]:
                    line.y[0] = line.y[-1]
                elif change["old"][0] != change["new"][0]:
                    line.y[-1] = line.y[0]

                line.y = np.fmax(0, np.rint(line.y))

        line.observe(_fix_input_callback, names=["y"])

        handdraw_interaction = bqplot.interacts.HandDraw(lines=line)
        self.fig = bqplot.Figure(
            marks=[line],
            axes=[x_axis, y_axis],
            interaction=handdraw_interaction,
            animation_duration=150,
            title=self.figure_title,
        )

        return self.fig
Пример #11
0
def test_bars(scales):
    with pytest.raises(TraitError, match='.*type object.*'):
        lines = bqplot.Bars(x=[0, 1], y=[[0, 1], [1, 0, -1]], scales=scales)

    lines = bqplot.Bars(x=[0, 1], y=[[1, 2], [3, 4]], scales=scales)
    state = lines.get_state()

    lines2 = bqplot.Lines(scales=scales)
    lines2.set_state(state)
    assert lines.x[0] == 0
    assert lines.x[1] == 1
    assert lines.y[0][0] == 1
    assert lines.y[0][1] == 2
    assert lines.y[1][0] == 3
    assert lines.y[1][1] == 4
Пример #12
0
def create_plot():
    index = pd.date_range(start='2000-06-01', end='2001-06-01',
                          freq='30min') + timedelta(minutes=15)
    s = pd.Series(np.full(len(index), np.nan), index=index)

    x = index.values
    y = s

    x_sc = bq.DateScale()
    y_sc = bq.LinearScale(min=0)

    line = bq.Lines(
        x=x,
        y=y,
        scales={
            'x': x_sc,
            'y': y_sc
        },
        #display_legend=True, labels=["line 1"],
        #fill='bottom', # opacity does work with this option
        #fill_opacities = [0.5] *len(x)
    )

    panzoom = bq.PanZoom(scales={'x': [x_sc], 'y': [y_sc]})
    #p = bq.Scatter(x=x, y=y, scales= {'x': x_sc, 'y': y_sc})
    ax_x = bq.Axis(scale=x_sc)
    ax_y = bq.Axis(scale=y_sc, orientation='vertical', tick_format='0.2f')

    #fig = bq.Figure(marks=[line, p], axes=[ax_x, ax_y])
    fig = bq.Figure(marks=[line], axes=[ax_x, ax_y], interaction=panzoom)
    fig.layout.width = '95%'

    #p.interactions = {'click': 'select', 'hover': 'tooltip'}
    #p.selected_style = {'opacity': 1.0, 'fill': 'DarkOrange', 'stroke': 'Red'}
    #p.unselected_style = {'opacity': 0.5}
    #p.tooltip = bq.Tooltip(fields=['x', 'y'], formats=['', '.2f'])

    #sel = bq.interacts.IndexSelector(scale=p.scales['x'])
    #
    #def update_range(*args):
    #    if sel.selected:
    #        print(sel.selected[0])
    #
    #sel.observe(update_range, 'selected')
    #fig.interaction = sel

    return fig, line
Пример #13
0
 def get_marks(self):
     marks = []
     data = self.datafunction()
     for d, c in zip(data, self.colors):
         marks.append(
             bq.Lines(
                 x=[],
                 y=[],
                 icon="line-chart",
                 scales=self.scales,
                 stroke_width=2,
                 fill='bottom',
                 fill_opacities=[0.2],
                 colors=[c],
                 labels=d["labels"],
                 display_legend=True,
             ))
     return marks
Пример #14
0
def make_pred_bqplot():
    x_sc = bq.LinearScale()
    y_sc = bq.LinearScale()

    ax_x = bq.Axis(label="Feature", scale=x_sc)  # , tick_format="0.0f"
    ax_y = bq.Axis(
        label="Target",
        scale=y_sc,
        orientation="vertical"  # , tick_format="0.0e"
    )

    line = bq.Lines(
        x=[0],
        y=[0],
        scales={
            "x": x_sc,
            "y": y_sc
        },
        colors=["darkblue"],
        opacities=[1],
    )

    scatter = bq.Scatter(
        x=[0],
        y=[0],
        scales={
            "x": x_sc,
            "y": y_sc
        },
        colors=["red"],
        opacities=[1],
    )
    out_plot = bq.Figure(
        axes=[ax_x, ax_y],
        marks=[line, scatter],
        #     interaction=interval_selector,
        # animation_duration=100,
    )

    out_plot.legend_style = {"stroke-width": 0}
    out_plot.layout.width = "flex"
    return {k: v for k, v in locals().items()}
Пример #15
0
def plot():
    co2_conc = in_dd1.value
    key_x = in_dd2.value
    key_y = in_dd3.value

    dir_name = Path(co2_dict[co2_conc])
    df = get_df(dir_name)

    sc_x = bq.LinearScale(min=5, max=25)
    sc_y = bq.LinearScale()

    da_x = df[key_x]
    da_y = df[key_y]

    ax_x = bq.Axis(scale=sc_x, grid_lines='solid', label=key_x)
    ax_y = bq.Axis(scale=sc_y, orientation='vertical', label=key_y)

    lines = bq.Lines(x=da_x,
                     y=da_y,
                     scales={
                         'x': sc_x,
                         'y': sc_y
                     },
                     stroke_width=3,
                     colors=['blue'])

    #ax.plot('wavlen_um','total_trans',data=df)
    #ax.set_title(key)
    #ax.set_xlim([5,25])
    grid[:, 1:2] = bq.Figure(marks=[lines],
                             axes=[ax_x, ax_y],
                             layout=Layout(width='auto', height='auto'),
                             fig_margin=dict(top=60,
                                             bottom=40,
                                             left=40,
                                             right=0),
                             title=key_x + ' vs ' + key_y +
                             ' with CO2 conc. = ' + co2_conc)
Пример #16
0
    def make_segment_mark_and_drawer(self):
        mark = bq.Lines(scales=self.display_pane.image_plot_scales,
                        x=[0.45, 0.55],
                        y=[0.45, 0.55])

        drawer = bq.interacts.BrushSelector(
            x_scale=self.display_pane.image_plot_scales['x'],
            y_scale=self.display_pane.image_plot_scales['y'],
            color='blue')

        def on_interaction(change):
            if change['name'] == 'selected_x':
                mark.x = change['new']
            elif change['name'] == 'selected_y':
                if self.segment_draw_diagonal:
                    mark.y = list(reversed(change['new']))
                else:
                    mark.y = change['new']
            self.update_observers()

        drawer.observe(on_interaction, ['selected_x', 'selected_y'])

        return mark, drawer