diff options
Diffstat (limited to 'doc/source/Tutorials/Image.ipynb')
| -rw-r--r-- | doc/source/Tutorials/Image.ipynb | 1873 |
1 files changed, 1873 insertions, 0 deletions
diff --git a/doc/source/Tutorials/Image.ipynb b/doc/source/Tutorials/Image.ipynb new file mode 100644 index 0000000..5ddab38 --- /dev/null +++ b/doc/source/Tutorials/Image.ipynb @@ -0,0 +1,1873 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image processing performance optimisation\n", + "\n", + "The idea of this tutorial is to give some suggestion how optimise image processing.\n", + "In the following example we decompress a CBF image from a Pilatus 6M, take the log-scale and calculate the histogram of pixel intensities before plotting. \n", + "This very simple operation takes >300ms, what makes it unpractical for live display of images coming from a detector. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab nbagg" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using silx version 0.7.0-dev0\n", + "filename powder_200_2_0001.cbf\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/users/kieffer/VirtualEnvs/py3/lib/python3.5/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", + " from ._conv import register_converters as _register_converters\n" + ] + } + ], + "source": [ + "import time, os\n", + "start_time = time.time()\n", + "import silx\n", + "print(\"Using silx version \",silx.version)\n", + "from silx.resources import ExternalResources\n", + "downloader = ExternalResources(\"pyFAI\", \"http://www.silx.org/pub/pyFAI/testimages\", \"PYFAI_DATA\")\n", + "fname = downloader.getfile(\"powder_200_2_0001.cbf\")\n", + "print(\"filename\", os.path.basename(fname))\n", + "import fabio\n", + "nbins = 1000" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 252 ms, sys: 32 ms, total: 284 ms\n", + "Wall time: 280 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "#Display an image and the histogram of values (in log scale)\n", + "img = fabio.open(fname).data\n", + "log_img = numpy.arcsinh(img) # arcsinh is well behaved log-like function\n", + "his, edges = numpy.histogram(log_img, nbins)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"639.8333142648146\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x7fdf03bb7cf8>]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = subplots(1,2,)\n", + "center = (edges[1:] + edges[:-1])/2.0 # this is the center of the bins \n", + "ax[1].imshow(log_img, cmap=\"inferno\")\n", + "ax[0].plot(center,his)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimised GPU code\n", + "\n", + "The code below prepares a GPU to be able to perform the same calculation as in the previous example.\n", + "\n", + "3 operations have to be carried out:\n", + "\n", + "* Decompress the CBF image\n", + "* Calculate the log scale (arcsinh values)\n", + "* Calculate the histogram\n", + "\n", + "Both can be performed on the GPU without additional memory transfer" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#switch this to \"CPU\" to have a fail safe \n", + "devicetype = \"GPU\"\n", + "from silx.opencl.codec.byte_offset import ByteOffset\n", + "from silx.opencl.image import ImageProcessing\n", + "import pyopencl, pyopencl.array, pyopencl.elementwise\n", + "cbf = fabio.cbfimage.CbfImage()\n", + "bo = ByteOffset(os.path.getsize(fname), img.size, devicetype=devicetype)\n", + "ash = pyopencl.elementwise.ElementwiseKernel(bo.ctx, \n", + " arguments=\"float* data, float* res\", \n", + " operation=\"res[i] = asinh(data[i])\", \n", + " name='arcsinh_kernel')\n", + "ip = ImageProcessing(template=img, ctx=bo.ctx)\n", + "res = pyopencl.array.empty(bo.queue, img.shape, dtype=float32)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 16 ms, sys: 16 ms, total: 32 ms\n", + "Wall time: 28.8 ms\n" + ] + } + ], + "source": [ + "%%time \n", + "raw = cbf.read(fname, only_raw=True)\n", + "dec = bo(raw, as_float=True)\n", + "ash(dec, res)\n", + "his, edges = ip.histogram(res, nbins, copy=False)\n", + "log_img = res.get()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"639.8333142648146\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x7fdebd059390>]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = subplots(1,2,)\n", + "center = (edges[1:] + edges[:-1])/2.0 # this is the center of the bins \n", + "ax[1].imshow(log_img, cmap=\"inferno\")\n", + "ax[0].plot(center,his)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The results are the same and the processing time is 6x faster. Hence, one can envisage realtime visualisation of images coming from detectors.\n", + "\n", + "## Investigation of the timings" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Profiling info for OpenCL ByteOffset\n", + " copy raw H -> D:\t0.972ms\n", + " memset mask:\t0.091ms\n", + " memset counter:\t0.005ms\n", + " mark exceptions:\t0.092ms\n", + " copy counter D -> H:\t0.002ms\n", + " treat_exceptions:\t0.027ms\n", + " double scan:\t0.200ms\n", + " copy_results:\t0.141ms\n", + "________________________________________________________________________________\n", + " Total execution time:\t1.530ms\n", + "\n", + "Profiling info for OpenCL ImageProcessing\n", + " copy D->D :\t0.104ms\n", + " max_min_stage1:\t0.069ms\n", + " max_min_stage2:\t0.009ms\n", + " histogram:\t0.098ms\n", + "________________________________________________________________________________\n", + " Total execution time:\t0.281ms\n" + ] + } + ], + "source": [ + "ip.set_profiling(True)\n", + "bo.set_profiling(True)\n", + "ip.reset_log()\n", + "bo.reset_log()\n", + "raw = cbf.read(fname, only_raw=True)\n", + "dec = bo(raw, as_float=True)\n", + "ash(dec, res)\n", + "his, edges = ip.histogram(res, nbins, copy=False)\n", + "log_img = res.get()\n", + "import os\n", + "print(os.linesep.join(bo.log_profile()))\n", + "print(os.linesep.join(ip.log_profile()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "This notebook explains how to optimise some heavy numerical processing up to 10x speed-up for realtime image processing using GPU." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.4.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} |