def snap_click(self, b=None): w = self.widget cy = self.cy json = self.to_json_value() snap = js_proxy.ProxyWidget() self.configure_widget(snap, layout="preset", descriptor=json) snap.embed(True, await=["cytoscape"])
def __init__(self, target): self.target = target w = self.widget = js_proxy.ProxyWidget() e = self.element = w.element() # Create JS/python parallel mapping for finding elements. self.displays = {} self.expanded = {} w(e._set("DISPLAYS", {})) self.displays_reference = e.DISPLAYS self.jQuery = w.window().jQuery self.display_object(None, target, expanded=True, top=True)
def __init__(self, width=500, height=500, autoRotate=False, center=(0,0,0), offset=100): init() w = self.w = js_proxy.ProxyWidget() element = self.element = w.element() window = self.window = w.window() THREE = self.THREE = window.THREE self.center = center self.offset = offset self.autoRotate = autoRotate scene = self.scene = w.save_new("scene", THREE.Scene, []) renderer = self.renderer = w.save_new("renderer", THREE.WebGLRenderer, []) w(renderer.setSize(width, height)) w(renderer.setClearColor( 0xffffff, 1)) w(element.append(renderer.domElement))
def canvas(self, width=None, height=None, entropy=True): """ Make a jsproxy canvas widget which draws the motif using sequence_motif.js. """ from jp_gene_viz import js_proxy js_proxy.load_javascript_support() w = js_proxy.ProxyWidget() elt = w.element() return self.add_canvas(w, elt, width=width, height=height, entropy=entropy, x=5, y=5)
def explore_directory(directory): from jp_gene_viz import js_proxy from IPython.display import display, HTML js_proxy.load_javascript_support() load_highcharts = """ <script src="https://code.highcharts.com/highcharts.js"></script> """ display(HTML(load_highcharts)) widget = js_proxy.ProxyWidget() elt = widget.element() # create a chart element look up table #widget(elt._set("PieCharts", {})) # attach a pie chart for directory chart = DirectoryPieChart(directory, widget, elt) widget.flush() display(widget) return widget
def __init__(self, message="Choose file", root=".", files=True, folders=False, upload=False, dialog=True, width=500, *args, **kwargs): """ FileChooser constructor. Parameters ---------- message : str Message near the top of the widget as a prompt. root : str The root path for the top folder to display. files : bool Make non-folders selectable iff true. folders : bool Show folders iff true. upload : bool Enable file upload iff true. dialog : bool Show in a jQueryUI dialog iff true, else inline. width : int Width of widget in pixels. """ super(FileChooser, self).__init__(*args, **kwargs) js_context.load_if_not_loaded(["simple_upload_button.js"]) js_context.load_if_not_loaded(["server_file_chooser.js"]) self.root = root self.upload = upload self.files = files self.folders = folders self.dialog = dialog self.message = message self.width = width self.widget = js_proxy.ProxyWidget() self.layout([self.root])
def test_plot(with_box=False, with_rotator=True): from IPython import display import math sp = ScatterPlot3D() points1 = [(400 + math.sin(i * 2), math.cos(i * 3) * 1.5, math.sin(i * 0.5)) for i in range(150)] sp.add_series("star", 0xff0000, points1) points2 = [(401 + math.sin(i), math.cos(i * 2), math.sin(i * 1.5) * 1.7) for i in range(150)] sp.add_series("openCube", 0xffff00, points2) w = js_proxy.ProxyWidget() window = w.window() element = w.element() THREE = window.THREE new = w.save_new scene = new("scene", THREE.Scene, []) camera = new("camera", THREE.PerspectiveCamera, [75, 1.0, 1, 10000]) w(camera.position._set("z", 500)) # plot the scatter points sp.plot(300, w, scene, 10) if with_box: geometry = new("geometry", THREE.BoxGeometry, [200, 200, 200]) #geometry = new("geometry", THREE.TetrahedronGeometry, []) material = new("material", THREE.MeshBasicMaterial, [{ "color": 0xff00ee, "wireframe": True }]) mesh = new("mesh", THREE.Mesh, [geometry, material]) w(scene.add(mesh)) renderer = new("renderer", THREE.WebGLRenderer, []) w(renderer.setSize(800, 800)) w(element.append(renderer.domElement)) do_render = w(renderer.render(scene, camera)) if with_rotator: gamma = xyz_dict(0, 0, 1) delta = xyz_dict(1, 0, 0) radius = 300 w(THREE.rotator(gamma, delta, radius, camera, renderer, scene)) json_sent = w.flush() display.display(w) return w
def __init__(self, *args, **kwargs): super(Diagram, self).__init__(*args, **kwargs) initialize() mx = self.max_angle * 2 d = self.diagram = js_proxy.ProxyWidget() xy = self.xy_slider = widgets.FloatSlider(description="XY rotation", min=-mx, max=mx) xz = self.xy_slider = widgets.FloatSlider(description="XZ rotation", min=-mx, max=mx) yz = self.xy_slider = widgets.FloatSlider(description="YZ rotation", min=-mx, max=mx) traitlets.link((self, "xy_rotation"), (xy, "value")) traitlets.link((self, "xz_rotation"), (xz, "value")) traitlets.link((self, "yz_rotation"), (yz, "value")) self.on_trait_change(self.draw_diagram, "xy_rotation") self.on_trait_change(self.draw_diagram, "xz_rotation") self.on_trait_change(self.draw_diagram, "yz_rotation") self.assembly = widgets.VBox(children=[xy, xz, yz, d])
def __init__(self, dataset, *args, **kwargs): super(Nearest, self).__init__(*args, **kwargs) initialize() self.dataset = dataset feature_names = list(dataset.feature_names) self.x_name = feature_names[0] self.y_name = feature_names[1] self.z_name = feature_names[2] sc = self.scatter_plot = js_proxy.ProxyWidget() xd = self.x_dropdown = widgets.Dropdown( options=list(feature_names), value=self.x_name) yd = self.y_dropdown = widgets.Dropdown( options=list(feature_names), value=self.y_name) zd = self.z_dropdown = widgets.Dropdown( options=list(feature_names), value=self.z_name) bc = self.border_checkbox = widgets.Checkbox(description="border", value=True) tc = self.training_checkbox = widgets.Checkbox(description="training", value=True) tstc = self.test_checkbox = widgets.Checkbox(description="test", value=True) ns = self.n_slider = widgets.IntSlider(value=self.n_neighbors, min=1, max=20, description="neighbors", width="50px") ss = self.n_slider = widgets.FloatSlider(value=self.n_neighbors, min=0.2, max=0.5, description="test size", width="50px", step=0.1) traitlets.directional_link((ss, "value"), (self, "test_size")) traitlets.directional_link((xd, "value"), (self, "x_name")) traitlets.directional_link((yd, "value"), (self, "y_name")) traitlets.directional_link((zd, "value"), (self, "z_name")) traitlets.directional_link((bc, "value"), (self, "show_borders")) traitlets.directional_link((ns, "value"), (self, "n_neighbors")) traitlets.directional_link((tc, "value"), (self, "show_training")) traitlets.directional_link((tstc, "value"), (self, "show_test")) xd.on_trait_change(self.redraw, "value") ss.on_trait_change(self.redraw, "value") yd.on_trait_change(self.redraw, "value") zd.on_trait_change(self.redraw, "value") bc.on_trait_change(self.redraw, "value") tc.on_trait_change(self.redraw, "value") tstc.on_trait_change(self.redraw, "value") ns.on_trait_change(self.redraw, "value") controls = widgets.VBox(children=[xd, yd, zd, bc, tc, tstc, ns, ss]) self.assembly = widgets.HBox(children=[controls, sc])
def __init__(self, viewBox="0 0 500 500", dimension=SIDE_DEFAULT, *pargs, **kwargs): super(HTML5CanvasProxy, self).__init__(*pargs, **kwargs) self.viewBox = viewBox self.svg_width = dimension self.svg_height = dimension self.on_trait_change(self.change_dimensions, "svg_width") self.on_trait_change(self.change_dimensions, "svg_height") self.on_trait_change(self.start_watch_event, "watch_event") self.on_trait_change(self.stop_watch_event, "unwatch_event") self.font = "Arial" # default self.font_size = 10 self.font_style = "" self.font_weight = "normal" self.operations = [] self.assignments = {} w = self.widget = js_proxy.ProxyWidget() self.element = w.element() self.empty()
def decrypt_widget(): import time import threading from jp_gene_viz import js_proxy js_proxy.load_javascript_support() # wait for the js to compile... time.sleep(0.5) from IPython.display import display d = js_proxy.ProxyWidget() elt = d.element() #display(d) window = d.window() jQuery = window.jQuery d(elt.width("400px").height("100px")) d( elt.html( """<input type="password" id="pw000"/> <input id="b000" type="button" value="decrypt files"/> """ )) def click_handler(id, args): print "click" t = threading.Timer(0.1, extract) t.start() def extract(): print "extracting password..." print d.send(jQuery("#pw000").val(), pw_callback) def pw_callback(arg): print "... password extracted" password = arg[0] # print("pw="+repr(password)) decrypt(password) callback = d.callback(click_handler, None) d(jQuery("#b000").click(callback)) d.flush() #display(d) return d
def show(self): ls = self.label_selection = self.label_selector() sd = self.spot_display = self.display_spot_canvas() #detail = self.detail_display = self.display_spot_canvas(width=2*self.radius, height=2*self.radius) im_detail = self.image_detail = js_proxy.ProxyWidget() #self.assembly = self.label_selection # testing only info = self.info_area = widgets.Textarea(description="status") filename = self.file_name_text = widgets.Text( value=self.annotation_path) savebutton = self.save_button = widgets.Button(description="save") savebutton.on_click(self.save_click) restorebutton = self.restore_button = widgets.Button( description="restore") restorebutton.on_click(self.restore_click) nearbybutton = self.nearby_button = widgets.Button( description="x: nearby") nearbybutton.on_click(self.nearby_click) file_save_widgets = [filename, savebutton, restorebutton] if self.spots_href is not None: spots_checkbox = self.spots_checkbox = widgets.Checkbox( description="spots") file_save_widgets.append(spots_checkbox) spots_checkbox.on_trait_change(self.redraw, "value") file_save_widgets.append(nearbybutton) file_save = widgets.HBox(children=file_save_widgets) work_area = widgets.HBox(children=[sd.target, ls, im_detail]) self.assembly = widgets.VBox(children=[work_area, file_save, info]) #self.assembly = widgets.HBox(children=[ls]) display(self.assembly) self.configure_label_selector() self.configure_image_detail() self.add_key_bindings() self.label_selection.flush() if os.path.exists(self.annotation_path): self.restore_click() else: self.draw_spots()
def __init__(self, data=None, slide_columns=8): self.row_size = slide_columns if data is None: data = Data() self.data = data slides = data.slides slide_displays = [] slide_name_to_controller = {} slide_controllers = [] slide_rows = int(len(slides) / slide_columns) if slide_rows * slide_columns < len(slides): slide_rows += 1 self.slide_margin = margin = 5 row_size = 2*margin + slide_rows * (data.slide_height + margin) col_size = 2*margin + (slide_columns) * (data.slide_width + margin) slides_width = 2 * self.big_width #slide_drawing = cartesian_svg.doodle(-1, -1, col_size+1, row_size+1, slides_width, margin=2) #print "rows, cols", slide_rows, slide_columns #print "slides dimensions", len(slides), col_size, row_size, "html width", slides_width slide_drawing = canvas_doodle(-1, -1, col_size+1, row_size+1, slides_width, margin=2) self.slide_drawing = slide_drawing #slide_drawing.enable_events("click", self.slide_drawing_click) count = 0 for slide_name in slides: count += 1 #if count > 30: # break controller = Slide(slide_name, data, slide_drawing) slide_controllers.append(controller) assert slide_name not in slide_name_to_controller slide_name_to_controller[slide_name] = controller self.slide_controllers = slide_controllers controller_rows = [] available_controllers = list(slide_controllers) while available_controllers: row_list = available_controllers[:self.row_size] available_controllers = available_controllers[self.row_size:] controller_rows.append(row_list) self.controller_rows = controller_rows self.slide_name_to_controller = slide_name_to_controller #tsne_drawing = cartesian_svg.doodle(-TSNE_RADIUS-1, -TSNE_RADIUS-1, TSNE_RADIUS+1, TSNE_RADIUS+1, self.big_width, margin=4) tsne_drawing = canvas_doodle(-TSNE_RADIUS-1, -TSNE_RADIUS-1, TSNE_RADIUS+1, TSNE_RADIUS+1, self.big_width, margin=4) self.tsne_drawing = tsne_drawing #tsne_events = "click mouseover mouseout" #tsne_events = "click" #print "enabling tsne events", tsne_events #tsne_drawing.enable_events(tsne_events, self.tsne_event_callback) #big_slide_drawing = cartesian_svg.doodle(-1, -1, data.slide_width+1, data.slide_height+1, self.big_width, margin=4) big_slide_drawing = canvas_doodle(-1, -1, data.slide_width+1, data.slide_height+1, self.big_width, margin=4) self.big_slide_drawing = big_slide_drawing # make dialog w = js_proxy.ProxyWidget() e = w.element() w(e.html("Temporary content for dialog").dialog()) w(e.dialog("close")) w.flush() self.dialog = w big_assembly = widgets.HBox(children=[tsne_drawing.target.widget, big_slide_drawing.target.widget]) self.assembly = widgets.VBox(children=[big_assembly, slide_drawing.target.widget, self.dialog]) self.tsne_controller = TSNE(data, tsne_drawing) self.slide_controller_rows = slide_controllers self.chosen_slide = slides[0] self.chosen_indicator = None self.events_enabled = False self.reset_bookkeeping()
def label_selector(self): w = js_proxy.ProxyWidget() return w
def configure_widget(self, w=None, layout="cose", descriptor=None): if w is None: self.widget = js_proxy.ProxyWidget() w = self.widget element = w.element() w(element.empty()) # set up an event callback helper w.save_function( "event_cb", ["callback"], """ //debugger; return function(evt) { //debugger; var cyTarget = evt.cyTarget; if (cyTarget && cyTarget.data) { var result = evt.cyTarget.data(); if (result) { result.type = evt.type; result.shiftKey = evt.originalEvent.shiftKey; result.isNode = cyTarget.isNode(); result.isEdge = cyTarget.isEdge(); return callback(result); } } return callback({}); } """) self.element = element = w.element() window = w.window() cytoscape = window.cytoscape jQuery = window.jQuery w( element._set( "target", jQuery("<div></div>").height("600px").width("800px"). #html("cytoscape target div"). appendTo(element))) #nodes = [{"data": {"id": "n", "label": "cytoscape"}}] if descriptor is None: nodes = [] edges = [] elements = {"nodes": nodes, "edges": edges} descriptor = { "container": element.target._get(0), "style": STYLE, "elements": elements, "layout": { "name": layout, "padding": 5 } } else: descriptor = copy.deepcopy(descriptor) descriptor["container"] = element.target._get(0) descriptor["layout"]["name"] = layout w(element._set("cy_container", cytoscape(descriptor))) w(element.height("600px").width("800px")) self.cy = cy = element.cy_container clickcallback = element.event_cb( w.callback(self.clickhandler, data="click", level=3)) self.getter = cy._get("$") # only add events in live mode if w == self.widget: w(cy.on('click', clickcallback)) return w