bokeh.models.FreehandDrawTool

Here are the examples of the python api bokeh.models.FreehandDrawTool taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1 Examples 7

0 Source : main.py
with MIT License
from Psy-Fer

def bkapp(doc):
    global signal
    global ut
    global lt
    global show_segs
    show_segs = False
    ut = 0
    lt = 0
    if signal.any():
        ut = max(signal)
        lt = min(signal)
        source = ColumnDataSource(data={
            'signal'    : signal,
            'position'  : list(range(0,len(signal)))
            })

        p = figure()

        p.line('position','signal', source=source)

        p.add_tools(HoverTool(
            tooltips=[
                ('signal', '@signal'),
                ('position', '@position'),
            ],
            formatters={
                'signal'    : 'printf',
                'position'    : 'printf'
            },
            mode='vline'
        ))

        renderer = p.multi_line([[1,1]], [[1,1]], line_width=4, alpha=0.5, color='green')
        draw_tool = FreehandDrawTool(renderers=[renderer])
        p.add_tools(draw_tool)

        src = ColumnDataSource({
            'x':[1,1,1], 'y':[1,1,1], 'width':[1,1,1], 'height':[1,1,1]
        })
        box_renderer = p.rect('x', 'y', 'width', 'height', fill_alpha=0.4, fill_color='orange', line_color='orange', source=src)
        box_draw_tool = BoxEditTool(renderers=[box_renderer], empty_value=1, num_objects = 5)
        p.add_tools(box_draw_tool)

        ut_slider = Slider(start=lt, end=max(signal), value=max(signal), name='upper_thresh', step=1, title="Upper Threshold")
        lt_slider = Slider(start=min(signal), end=ut, value=min(signal), name='lower_thresh', step=1, title="Lower Threshold")

        def ut_callback(attr, old, new):
            global signal
            global ut
            global lt
            ut = new
            new_signal = scale_outliers(signal, ut, lt)
            source.data = {
                        'signal'    : new_signal,
                        'position'  : list(range(0,len(new_signal)))
                        }
            update_segs()

        def lt_callback(attr, old, new):
            global signal
            global ut
            global lt
            lt = new
            new_signal = scale_outliers(signal, ut, lt)
            source.data = {
                        'signal'    : new_signal,
                        'position'  : list(range(0,len(new_signal)))
                        }
            update_segs()

        ut_slider.on_change('value', ut_callback)
        lt_slider.on_change('value', lt_callback)

        segments = ColumnDataSource(data={
            'top'     : [1,1],
            'bottom'  : [1,1],
            'left'    : [1,1],
            'right'   : [1,1]
            })

        button = Toggle(label="View Segments", sizing_mode="scale_width")

        def segment_handler(new):
            global show_segs
            show_segs = new
            if not new:
                segments.data = {
                    'top'     : [1,1],
                    'bottom'  : [1,1],
                    'left'    : [1,1],
                    'right'   : [1,1]
                            }
            update_segs()

        button.on_click(segment_handler)

        err_slider = Slider(start=0, end=20, value=5, name='error', step=1, title="Allowable Error")
        err_win_slider = Slider(start=0, end=100, value=50, name='err_win', step=1, title="Error Window Size")
        min_win_slider = Slider(start=0, end=500, value=150, name='min_win', step=1, title="Minimum Window Size")
        max_merge_slider = Slider(start=0, end=100, value=50, name='max_merge', step=1, title="Max Merge Distance")
        stdev_scale_slider = Slider(start=0, end=5, value=0.75, name='stdev_scale', step=0.01, title="Standard Deviation Scale Factor")
        stall_len_slider = Slider(start=0, end=5, value=0.25, name='stall_len', step=0.01, title="Stall Length")

        p.quad(top='top',bottom='bottom',left='left',right='right',source=segments,fill_alpha=0.5,fill_color='pink',line_color='pink')

        def err_callback(atrr, old, new):
            global err
            err = new
            update_segs()

        def err_win_callback(atrr, old, new):
            global err_win
            err_win = new
            update_segs()

        def min_win_callback(atrr, old, new):
            global min_win
            min_win = new
            update_segs()

        def max_merge_callback(atrr, old, new):
            global max_merge
            max_merge = new
            update_segs()

        def stdev_scale_callback(atrr, old, new):
            global stdev_scale
            stdev_scale = new
            update_segs()

        def stall_len_callback(atrr, old, new):
            global stall_len
            stall_len = new
            update_segs()

        def update_segs():
            #need to take into account the modified signal- somehow access it?
            global err
            global err_win
            global min_win
            global max_merge
            global stdev_scale
            global stall_len
            global ut
            global lt
            global show_segs
            left = None
            right = None
            if show_segs:
                sig = scale_outliers(signal, ut, lt)
                if sig.any():
                    left, right = get_segs(sig, err, err_win, min_win, max_merge, stdev_scale, stall_len)
                if left is not None and right is not None:
                    segments.data = {
                                'top'     :  np.full(len(left),1000),
                                'bottom'  :  np.full(len(left),0),
                                'left'    :  left,
                                'right'   :  right
                                }
                else:
                    segments.data = {
                        'top'     : [1,1],
                        'bottom'  : [1,1],
                        'left'    : [1,1],
                        'right'   : [1,1]
                                }


        err_slider.on_change('value', err_callback)
        err_win_slider.on_change('value', err_win_callback)
        min_win_slider.on_change('value', min_win_callback)
        max_merge_slider.on_change('value', max_merge_callback)
        stdev_scale_slider.on_change('value', stdev_scale_callback)
        stall_len_slider.on_change('value', stall_len_callback)

        doc.add_root(row(column(Spacer(height=10), ut_slider, lt_slider, Spacer(height=10), button, err_slider, err_win_slider, min_win_slider, max_merge_slider, stdev_scale_slider, stall_len_slider, Spacer(height=10), sizing_mode="stretch_height"), p, sizing_mode="stretch_both"))
        doc.theme = Theme(filename="theme.yaml")

def bk_worker():